Skip to content
This page View Markdown Open in ChatGPT Open in Claude

Query for get data by stream

g.sys.db.gen.queryByStreamGen calls the query for get data by stream generated API from your code : no schema, the data as it is in the table.

Structure

Query by stream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
let response = [];
await g.sys.db.gen.queryByStreamGen({
    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"
}, (obj) => {
    response.push(obj);
});

Simple queryByStream

Simple queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    }
}, (obj) => {
    response.push(obj);
});

Simple [headers]

headers
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    },
    headers: {
        "x-am-response-case": "capitalCase"
    }
}, (obj) => {
    response.push(obj);
});

Simple [select]

select
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    },
    select: "first_name"
}, (obj) => {
    response.push(obj);
});

Simple [limit]

limit
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    },
    limit: 2
}, (obj) => {
    response.push(obj);
});

Simple [skip]

skip
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    },
    skip: 1
}, (obj) => {
    response.push(obj);
});

Simple [sort]

sort
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": "Bob"
    },
    sort: "first_name"
}, (obj) => {
    response.push(obj);
});

Simple [deep]

deep
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let response = [];
await g.sys.db.gen.queryByStreamGen({
    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"
        }
    ]
}, (obj) => {
    response.push(obj);
});

$lt queryByStream

$lt queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$lt": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$lte queryByStream

$lte queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$lte": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$gt queryByStream

$gt queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$gt": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$gte queryByStream

$gte queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$gte": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$eq queryByStream

$eq queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$eq": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$ne queryByStream

$ne queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$ne": 2
        }
    }
}, (obj) => {
    response.push(obj);
});

$not queryByStream

$not queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        customer_id: {
            "$not": {
                "$in": [1, 2, 3, 4]
            }
        }
    }
}, (obj) => {
    response.push(obj);
});

$and queryByStream

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

$or queryByStream

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

$in queryByStream

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

$nin queryByStream

$nin queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "customer_id": {
            "$nin": [1, 2]
        }
    }
}, (obj) => {
    response.push(obj);
});

$like queryByStream

$like queryByStream
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "first_name": {
            "$like": "Bob%"
        }
    }
}, (obj) => {
    response.push(obj);
});

MongoDB $in operator in nested find

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

MongoDB $nin operator in nested find

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

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
16
17
18
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$and": [
            {
                "eventListeners.versions.name": "Original"
            },
            {
                "eventListeners.versions.version": "-1"
            }
        ]
    }
}, (obj) => {
    response.push(obj);
});

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
16
17
18
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "mysql_8",
    database: "inventory",
    collection: "customers",
    find: {
        "$or": [
            {
                "eventListeners.versions.name": "Original"
            },
            {
                "eventListeners.versions.version": "-1"
            }
        ]
    }
}, (obj) => {
    response.push(obj);
});

Multi-tenant

  • instance: "crm::acme" works on the database of the tenant acme of the multi-tenant instance crm.
  • With instance: "crm", the call works on the database of the tenant of the request: a custom API called with the x-am-tenant-username header passes it on to the APIs it calls. A request without a tenant works on the structure database.
Query the customers of the tenant acme by stream
1
2
3
4
5
6
7
8
9
let response = [];
await g.sys.db.gen.queryByStreamGen({
    instance: "crm::acme", database: "crm", collection: "customers",
    find: {
        "first_name": "Bob"
    }
}, (obj) => {
    response.push(obj);
});