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

Remove by query

g.sys.db.removeByQuery calls the remove by query schema API of any table from your code, with the same headers and query parameters as over HTTP. It returns the data, or the whole envelope when true is passed as the second argument.

Simple removeByQuery

Remove by query
1
2
3
4
5
6
let updateById = await g.sys.db.removeByQuery({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "first_name": "Bob"
    }
});

removeByQuery with headers

Remove by query with headers
1
2
3
4
5
6
7
8
9
let updateById = await g.sys.db.removeByQuery({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "first_name": "Bob"
    },
    headers: {
        "x-am-response-case": "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    },
});

$lt removeByQuery

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

$lte removeByQuery

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

$gt removeByQuery

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

$gte removeByQuery

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

$eq removeByQuery

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

$ne removeByQuery

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

$not removeByQuery

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

$and removeByQuery

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

$or removeByQuery

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

$in removeByQuery

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

$nin removeByQuery

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

$like removeByQuery

$nin Remove by query
1
2
3
4
5
6
7
8
let updateById = await g.sys.db.removeByQuery({
    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
let updateById = await g.sys.db.removeByQuery({
    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
let updateById = await g.sys.db.removeByQuery({
    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
let updateById = await g.sys.db.removeByQuery({
    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
let updateById = await g.sys.db.removeByQuery({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "$or": [
            {
                "eventListeners.versions.name": "Original"
            },
            {
                "eventListeners.versions.version": "-1"
            }
        ]
    }
});

Structure

Remove by query
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
let updateById = await g.sys.db.removeByQuery({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    find: {
        "COLUMN_NAME": "VALUE"
    },
    headers: {
        "x-am-response-case": "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
        "x-am-response-object-type": "make_flat", // no_action | make_flat
        "x-am-meta": "true", // true, false
        "x-am-internationalization": "USER_I18N_ID",
        "x-am-run-in-sandbox": "2",
        "x-am-content-type-response": "text/xml", // application/json | text/xml | text/yaml | text/plain | text/html | application/octet-stream
        "x-am-cache-control": "reset_cache", // no_action | reset_cache
        "x-am-get-encrypted-data": "get_only_encryption", // no_encryption | get_only_encryption | get_data_and_encryption
        "x-am-sandbox-timeout": "13000",
        "x-no-compression": "true", // true | false
        "x-am-encrypted-payload": "true", // user will send 'true', when payload is encrypted for transfer
        // Multi-tenant : the tenant of the request, each instance finds it in its own tenants table
        "x-am-tenant-username": "TENANT_USERNAME", // ex: acme
        // Authorization headers
        "x-am-authorization": "AUTHORIZATION_TOKEN",
        "x-am-user-authorization": "API_USER_TOKEN",
        "x-aws-authorization": "AWS_TOKEN",
        "x-google-authorization": "GOOGLE_TOKEN",
        "x-azure-authorization": "AZURE_TOKEN",
    },
});

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.
Remove customers of the tenant acme by query
1
2
3
4
5
6
let removeByQuery = await g.sys.db.removeByQuery({
    instance: "crm::acme", database: "crm", collection: "customers",
    find: {
        "first_name": "Bob"
    }
});