Skip to content

Query for get data

Structure

Query method
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
let query = await g.sys.db.gen.queryGen({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    find: {
        "pincode": 100050
    },
    limit: 1,
    select: "COLUMN_NAMES",
    deep: [{
        s_key: "SOURCE_COLLECTION_COLUMN_NAME",
        t_key: "TARGET_COLLECTION_COLUMN_NAME",
        t_col: "TARGET_COLLECTION_NAME",
        select: "COLUMN_NAMES"
    }],
    skip: 1,
    sort: "COLUMN_NAME",
    groupBy: "COLUMN_NAME"
});

Simple query

Simple query
1
2
3
4
5
6
7
8
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    }
});

Simple [headers]

headers
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    headers: {
        "x-am-response-case": "capitalCase"
    }
});

Simple [select]

select
1
2
3
4
5
6
7
8
9
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    select: "first_name"
});

Simple [limit]

limit
1
2
3
4
5
6
7
8
9
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    limit: 2
});

Simple [skip]

skip
1
2
3
4
5
6
7
8
9
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    skip: 1
});

Simple [sort]

sort
1
2
3
4
5
6
7
8
9
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    sort: "first_name"
});

Simple [deep]

deep
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find:{
        "first_name": "Bob"
    },
    deep: [
        {
            s_key: "customer_id",
            t_col: "products",
            t_key: "owner_id",
            select: "customer_id,first_name"
        }
    ]
});

$lt query

$lt query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$lt": 2
        }
    }
});

$lte query

$lte query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$lte": 2
        }
    }
});

$gt query

$gt query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$gt": 2
        }
    }
});

$gte query

$gte query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$gte": 2
        }
    }
});

$eq query

$eq query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$eq": 2
        }
    }
});

$ne query

$ne query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$ne": 2
        }
    }
});

$not query

$not query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$not": {
                "$in": [1, 2, 3, 4]
            }
        }
    }
});

$and query

$and query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$and": [
            {
                "customer_id": 2
            },
            {
                "pincode": 7171
            }
        ]
    }
});

$or query

$or query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$or": [
            {
                "customer_id": 2
            },
            {
                "pincode": 7171
            }
        ]
    }
});

$in query

$in query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "customer_id": {
            "$in": [1, 2]
        }
    }
});

$nin query

$nin query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "customer_id": {
            "$nin": [1, 2]
        }
    }
});

$like query

$like query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": {
            "$like": "Bob%"
        }
    }
});

MongoDB $in operator in nested find

$in operator in nested find
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "eventListeners.versions.name": {
            "$in": [
                "Original",
                "1"
            ]
        }
    }
});

MongoDB $nin operator in nested find

$nin operator in nested find
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "eventListeners.versions.name": {
            "$nin": [
                "Original",
                "1"
            ]
        }
    }
});

MongoDB $and operator in nested find

$and operator in nested find
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$and": [
            {
                "eventListeners.versions.name": "Original"
            },
            {
                "eventListeners.versions.version": "-1"
            }
        ]
    }
});

MongoDB $or operator in nested find

$or operator in nested find
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
let query = await g.sys.db.gen.queryGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$or": [
            {
                "eventListeners.versions.name": "Original"
            },
            {
                "eventListeners.versions.version": "-1"
            }
        ]
    }
});