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

Query for get data by stream

The body of query for get data with the answer of get all by stream : rows are sent as the database produces them.
Method POST
URL /api/schema/admin/mysql8/inventory/customers/query-stream
Body { find, select, sort, skip, limit, deep, getTotalCount }
Query params none
Answer data : an array of rows, streamed
Databases MongoDB, MySQL, MariaDB, PostgreSQL, SQL Server, Oracle, TiDB, Percona
Cached no : streams always come from the database
From code g.sys.db.queryByStream
API id SCHEMA_POST_QUERY_STREAM (groups, settings, hooks, WebSocket subscriptions)
Without a schema /api/gen/admin/mysql8/inventory/customers/query-stream : below

Generated (/api/gen) or schema (/api/schema) ?

Both families offer the same operations on the same URL pattern. The schema APIs read the schema of the table : values are converted to their types, validated, encrypted, defaulted and numbered before they reach the database. The generated APIs are schemaless : they pass your data as it is, so a number sent as "22" stays a string. Use the schema APIs for the tables your application writes to, and the generated APIs for quick reads and for tables without a schema.

The URL

/api/schema/admin/mysql8/inventory/customers/query-stream : replace admin with the user path of your account, mysql8 with your instance, inventory with the database and customers with the table. The examples use this table :

customer_id first_name last_name last_update pincode isActive
1 Bob lin 2022-11-14 04: 34: 58 382345 1
2 Alice Page 2022-10-15 02: 10: 40 382346 1
3 Mallory Brown 2022-09-13 03: 44: 05 382347 1
4 Eve Mathly 2022-11-12 01: 59: 33 382348 1
5 Eve Page 2022-11-12 01: 59: 33 382349 1

The call

POST /api/schema/admin/mysql8/inventory/customers/query-stream
Body
{ "find": { "isActive": 1 }, "sort": "customer_id", "select": "customer_id,first_name" }
Answer, written in chunks
{ "data": [ { "customer_id": 1, "first_name": "Bob" }, { "customer_id": 2, "first_name": "Alice" } ], "success": true, "statusCode": 200, "meta": {} }
  • Same keys and operators as the query API, find and join and deep included. Read success at the end : an error after the first rows closes the answer with "success": false and the errors.
  • Never cached ; post hooks can not change what was sent.

From your code

1
2
3
4
5
const rows: any[] = [];
await g.sys.db.queryByStream({
    instance: 'mysql8', database: 'inventory', collection: 'customers',
    find: { isActive: 1 }, select: 'customer_id,first_name',
}, (row) => rows.push(row));

1
2
3
4
5
6
7
8
rows = []
await g.sys.db.query_by_stream(
    Query(
        'mysql8', 'inventory', 'customers',
        find={'isActive': 1}, select='customer_id,first_name',
    ),
    rows.append,
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
$rows = [];
$g->sys->db->queryByStream(
    new Query(
        'mysql8', 'inventory', 'customers',
        find: ['isActive' => 1], select: 'customer_id,first_name',
    ),
    function ($row) use (&$rows) {
        $rows[] = $row;
    },
);

1
2
3
4
5
var rows = new List<JsonObject>();
await g.Sys.Db.QueryByStream(new Query("mysql8", "inventory", "customers")
{
    Find = new JsonObject { ["isActive"] = 1 }, Select = "customer_id,first_name",
}, row => rows.Add(row));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
rows := []am.M{}
if err := g.Sys.Db.QueryByStream(am.Query{
    Instance: "mysql8", Database: "inventory", Collection: "customers",
    Find: am.M{"isActive": 1}, Select: "customer_id,first_name",
}, func(row am.M) error {
    rows = append(rows, row)
    return nil
}); err != nil {
    return nil, err
}

1
2
3
4
5
6
7
8
9
let mut rows = Vec::new();
g.sys.db.query_by_stream(
    Query::new("mysql8", "inventory", "customers")
        .find(json!({ "isActive": 1 })).select("customer_id,first_name"),
    |row| {
        rows.push(row.clone());
        Ok(())
    },
)?;

1
2
3
var rows = new ArrayList<JsonObject>();
g.sys.db.queryByStream(new Query("mysql8", "inventory", "customers")
    .find(Map.of("isActive", 1)).select("customer_id,first_name"), row -> rows.add(row));

1
2
3
4
5
val rows = mutableListOf<JsonObject>()
g.sys.db.queryByStream(
    Query("mysql8", "inventory", "customers")
        .find(mapOf("isActive" to 1)).select("customer_id,first_name"),
) { row -> rows.add(row) }

Without a schema : /api/gen

Every table also answers this operation under /api/gen, with or without a schema :
URL /api/gen/admin/mysql8/inventory/customers/query-stream
API id GEN_POST_QUERY_STREAM (groups, settings, hooks, WebSocket subscriptions)
From code g.sys.db.gen.queryByStreamGen

The data passes as it is : nothing is converted, validated, defaulted, encrypted or numbered, and a filter matches the type you send ("22" does not match the number 22). On MongoDB, strings which look like ObjectIds are converted. The query params, headers and errors are the ones of this page.

Headers

Every call takes the request headers : the tokens, x-am-response-case, x-am-content-type-response (JSON, XML, YAML…), x-am-response-object-type: make_flat, x-am-cache-control, x-am-get-encrypted-data, x-am-internationalization, x-am-tenant-username, x-am-meta.

Errors

Code When
401 The token in x-am-authorization is missing or invalid.
403 No group of the API user grants this API of this table, or a field of the request.
404 The instance, database or table of the URL does not exist, or the table has no schema (use /api/gen).
400 The query or the body is wrong : the error messages say which key and why.