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

Remove by query

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

Structure

Remove by query
1
2
3
4
5
6
let updateById = await g.sys.db.gen.removeByQueryGen({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    find: {
        "city_name": "LONDON"
    }
});

Simple removeByQuery

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

$lt removeByQuery

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

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.gen.removeByQueryGen({
    instance: "crm::acme", database: "crm", collection: "customers",
    find: {
        "first_name": "Bob"
    }
});