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

Update many

The code in every language

Each example is the inside of main, written in every language API Maker runs : pick yours in the tabs, and every page shows it from then on. The types a call takes (GetAll, DeepItem…) are those of am : from am import GetAll in Python, use am::GetAll; in Rust, import am.GetAll; in Java and Kotlin ; PHP and C# have them without an import, Go names them am.GetAll.

g.sys.db.updateMany calls the update many schema API of any table from your code, with the same headers and query parameters as over HTTP. It returns the data. The whole envelope (success, statusCode, data, totalCount, errors…) comes back when true is passed as the second argument in TypeScript, and through full in the other languages : g.sys.db.full (g.Sys.Db.Full in C# and Go, $g->sys->db->full in PHP).

Simple update-many

Update many
1
2
3
4
5
6
7
8
9
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "first_name": "Alice"
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
Update many
1
2
3
4
5
6
7
8
9
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'first_name': 'Alice',
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
Update many
1
2
3
4
5
6
7
8
9
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'first_name' => 'Alice',
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["first_name"] = "Alice",
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "first_name": "Alice",
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
Update many
1
2
3
4
5
6
7
8
9
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "first_name": "Alice",
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
Update many
1
2
3
4
5
6
7
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "first_name", "Alice"
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
Update many
1
2
3
4
5
6
7
8
9
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "first_name" to "Alice",
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

update-many with header

Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "first_name": "Alice"
    },
    updateData: {
        "first_name": "MALLORY"
    },
    headers: {
        "x-am-response-case": "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    },
});
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'first_name': 'Alice',
    },
    update_data={
        'first_name': 'MALLORY',
    },
    headers={
        'x-am-response-case': 'capitalCase',  # noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    },
)
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'first_name' => 'Alice',
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
    headers: [
        'x-am-response-case' => 'capitalCase', // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    ],
);
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["first_name"] = "Alice",
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
    Headers = new JsonObject
    {
        ["x-am-response-case"] = "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    },
});
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "first_name": "Alice",
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
    Headers: am.M{
        "x-am-response-case": "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    },
})
if err != nil {
    return nil, err
}
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "first_name": "Alice",
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        }))
        .headers(json!({
            "x-am-response-case": "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
        })),
)?;
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "first_name", "Alice"
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    ))
    .headers(Map.of(
        "x-am-response-case", "capitalCase" // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
    )));
Update many with header
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "first_name" to "Alice",
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        ))
        .headers(mapOf(
            "x-am-response-case" to "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
        )),
)

$in update-many

$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$in": [2, 3]
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$in': [2, 3],
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$in' => [2, 3],
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$in"] = new JsonArray { 2, 3 },
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$in": []any{2, 3},
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$in": [2, 3],
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$in Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$in", List.of(2, 3)
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$in Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$in" to listOf(2, 3),
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$nin update-many

$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$nin": [2, 3]
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$nin': [2, 3],
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$nin' => [2, 3],
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$nin"] = new JsonArray { 2, 3 },
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$nin": []any{2, 3},
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$nin": [2, 3],
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$nin Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$nin", List.of(2, 3)
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$nin Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$nin" to listOf(2, 3),
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$and update-many

$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        $and: [
            {
                "first_name": "Alice"
            },
            {
                "isActive": 1
            }
        ]
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        '$and': [
            {
                'first_name': 'Alice',
            },
            {
                'isActive': 1,
            },
        ],
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        '$and' => [
            [
                'first_name' => 'Alice',
            ],
            [
                'isActive' => 1,
            ],
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["$and"] = new JsonArray
        {
            new JsonObject
            {
                ["first_name"] = "Alice",
            },
            new JsonObject
            {
                ["isActive"] = 1,
            },
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "$and": []any{
            am.M{
                "first_name": "Alice",
            },
            am.M{
                "isActive": 1,
            },
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "$and": [
                {
                    "first_name": "Alice",
                },
                {
                    "isActive": 1,
                },
            ],
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "$and", List.of(
            Map.of(
                "first_name", "Alice"
            ),
            Map.of(
                "isActive", 1
            )
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$and Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "\$and" to listOf(
                mapOf(
                    "first_name" to "Alice",
                ),
                mapOf(
                    "isActive" to 1,
                ),
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$or update-many

$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        $or: [
            {
                "first_name": "Alice"
            },
            {
                "isActive": 1
            }
        ]
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        '$or': [
            {
                'first_name': 'Alice',
            },
            {
                'isActive': 1,
            },
        ],
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        '$or' => [
            [
                'first_name' => 'Alice',
            ],
            [
                'isActive' => 1,
            ],
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["$or"] = new JsonArray
        {
            new JsonObject
            {
                ["first_name"] = "Alice",
            },
            new JsonObject
            {
                ["isActive"] = 1,
            },
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "$or": []any{
            am.M{
                "first_name": "Alice",
            },
            am.M{
                "isActive": 1,
            },
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "$or": [
                {
                    "first_name": "Alice",
                },
                {
                    "isActive": 1,
                },
            ],
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "$or", List.of(
            Map.of(
                "first_name", "Alice"
            ),
            Map.of(
                "isActive", 1
            )
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$or Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "\$or" to listOf(
                mapOf(
                    "first_name" to "Alice",
                ),
                mapOf(
                    "isActive" to 1,
                ),
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$eq update-many

$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$eq": 2
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$eq': 2,
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$eq' => 2,
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$eq"] = 2,
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$eq": 2,
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$eq": 2,
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$eq Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$eq", 2
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$eq Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$eq" to 2,
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$gt update-many

$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$gt": 2
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$gt': 2,
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$gt' => 2,
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$gt"] = 2,
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$gt": 2,
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$gt": 2,
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$gt Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$gt", 2
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$gt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$gt" to 2,
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$gte update-many

$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$gte": 2
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$gte': 2,
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$gte' => 2,
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$gte"] = 2,
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$gte": 2,
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$gte": 2,
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$gte Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$gte", 2
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$gte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$gte" to 2,
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$lt update-many

$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$lt": 2
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$lt': 2,
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$lt' => 2,
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$lt"] = 2,
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$lt": 2,
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$lt": 2,
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$lt Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$lt", 2
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$lt Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$lt" to 2,
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

$lte update-many

$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": {
            "$lte": 2
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': {
            '$lte': 2,
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => [
            '$lte' => 2,
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = new JsonObject
        {
            ["$lte"] = 2,
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": am.M{
            "$lte": 2,
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": {
                "$lte": 2,
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$lte Update many
1
2
3
4
5
6
7
8
9
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", Map.of(
            "$lte", 2
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to mapOf(
                "\$lte" to 2,
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

[mongoDB] update-many

$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": 2,
        "ages.birth_year": "1889"
    },
    updateData: {
        "ages.$.age": "35"
    }
});
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': 2,
        'ages.birth_year': '1889',
    },
    update_data={
        'ages.$.age': '35',
    },
)
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => 2,
        'ages.birth_year' => '1889',
    ],
    updateData: [
        'ages.$.age' => '35',
    ],
);
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 2,
        ["ages.birth_year"] = "1889",
    },
    UpdateData = new JsonObject
    {
        ["ages.$.age"] = "35",
    },
});
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id":     2,
        "ages.birth_year": "1889",
    },
    UpdateData: am.M{
        "ages.$.age": "35",
    },
})
if err != nil {
    return nil, err
}
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": 2,
            "ages.birth_year": "1889",
        }))
        .update_data(json!({
            "ages.$.age": "35",
        })),
)?;
$mongoDB Update many
1
2
3
4
5
6
7
8
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", 2,
        "ages.birth_year", "1889"
    ))
    .updateData(Map.of(
        "ages.$.age", "35"
    )));
$mongoDB Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 2,
            "ages.birth_year" to "1889",
        ))
        .updateData(mapOf(
            "ages.\$.age" to "35",
        )),
)

[MongoDB] $elemMatch, $gte, $lte update-many

$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let updateMany = await g.sys.db.updateMany({
    instance: "mysql_8", database: "inventory", collection: "customers",
    find: {
        "customer_id": 2,
        "ages": {
            "$elemMatch": {
                "age": {
                    "$gte": 30
                },
                "birth_year": {
                    "$lte": 1900
                }
            }
        }
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
update_many = await g.sys.db.update_many(
    'mysql_8', 'inventory', 'customers',
    find={
        'customer_id': 2,
        'ages': {
            '$elemMatch': {
                'age': {
                    '$gte': 30,
                },
                'birth_year': {
                    '$lte': 1900,
                },
            },
        },
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
$updateMany = $g->sys->db->updateMany(
    'mysql_8', 'inventory', 'customers',
    find: [
        'customer_id' => 2,
        'ages' => [
            '$elemMatch' => [
                'age' => [
                    '$gte' => 30,
                ],
                'birth_year' => [
                    '$lte' => 1900,
                ],
            ],
        ],
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
$elemMatch, $gte, $lte Update many
 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
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("mysql_8", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 2,
        ["ages"] = new JsonObject
        {
            ["$elemMatch"] = new JsonObject
            {
                ["age"] = new JsonObject
                {
                    ["$gte"] = 30,
                },
                ["birth_year"] = new JsonObject
                {
                    ["$lte"] = 1900,
                },
            },
        },
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "mysql_8", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 2,
        "ages": am.M{
            "$elemMatch": am.M{
                "age": am.M{
                    "$gte": 30,
                },
                "birth_year": am.M{
                    "$lte": 1900,
                },
            },
        },
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let update_many = g.sys.db.update_many(
    UpdateMany::new("mysql_8", "inventory", "customers")
        .find(json!({
            "customer_id": 2,
            "ages": {
                "$elemMatch": {
                    "age": {
                        "$gte": 30,
                    },
                    "birth_year": {
                        "$lte": 1900,
                    },
                },
            },
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
var updateMany = g.sys.db.updateMany(new UpdateMany("mysql_8", "inventory", "customers")
    .find(Map.of(
        "customer_id", 2,
        "ages", Map.of(
            "$elemMatch", Map.of(
                "age", Map.of(
                    "$gte", 30
                ),
                "birth_year", Map.of(
                    "$lte", 1900
                )
            )
        )
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
$elemMatch, $gte, $lte Update many
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
val updateMany = g.sys.db.updateMany(
    UpdateMany("mysql_8", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 2,
            "ages" to mapOf(
                "\$elemMatch" to mapOf(
                    "age" to mapOf(
                        "\$gte" to 30,
                    ),
                    "birth_year" to mapOf(
                        "\$lte" to 1900,
                    ),
                ),
            ),
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

Structure

Update many
 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
28
29
30
let updateMany = await g.sys.db.updateMany({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    find: {
        "COLUMN_NAME": "VALUE",
    },
    updateData: {
        "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",
    },
});
Update many
 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
28
29
30
update_many = await g.sys.db.update_many(
    'INSTANCE_NAME', 'DB_NAME', 'COLLECTION_NAME',
    find={
        'COLUMN_NAME': 'VALUE',
    },
    update_data={
        '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',
    },
)
Update many
 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
28
29
30
$updateMany = $g->sys->db->updateMany(
    'INSTANCE_NAME', 'DB_NAME', 'COLLECTION_NAME',
    find: [
        'COLUMN_NAME' => 'VALUE',
    ],
    updateData: [
        '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',
    ],
);
Update many
 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
28
29
30
31
32
33
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
{
    Find = new JsonObject
    {
        ["COLUMN_NAME"] = "VALUE",
    },
    UpdateData = new JsonObject
    {
        ["COLUMN_NAME"] = "VALUE",
    },
    Headers = new JsonObject
    {
        ["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",
    },
});
Update many
 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
28
29
30
31
32
33
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "INSTANCE_NAME", Database: "DB_NAME", Collection: "COLLECTION_NAME",
    Find: am.M{
        "COLUMN_NAME": "VALUE",
    },
    UpdateData: am.M{
        "COLUMN_NAME": "VALUE",
    },
    Headers: am.M{
        "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",
    },
})
if err != nil {
    return nil, err
}
Update many
 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
28
29
30
let update_many = g.sys.db.update_many(
    UpdateMany::new("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
        .find(json!({
            "COLUMN_NAME": "VALUE",
        }))
        .update_data(json!({
            "COLUMN_NAME": "VALUE",
        }))
        .headers(json!({
            "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",
        })),
)?;
Update many
 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
28
var updateMany = g.sys.db.updateMany(new UpdateMany("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
    .find(Map.of(
        "COLUMN_NAME", "VALUE"
    ))
    .updateData(Map.of(
        "COLUMN_NAME", "VALUE"
    ))
    .headers(JsonObject.of(
        "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"
    )));
Update many
 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
28
29
30
val updateMany = g.sys.db.updateMany(
    UpdateMany("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
        .find(mapOf(
            "COLUMN_NAME" to "VALUE",
        ))
        .updateData(mapOf(
            "COLUMN_NAME" to "VALUE",
        ))
        .headers(mapOf(
            "x-am-response-case" to "capitalCase", // noChange | camelCase | capitalCase | constantCase | dotCase | headerCase | noCase | paramCase | pascalCase | pathCase | sentenceCase | snakeCase
            "x-am-response-object-type" to "make_flat", // no_action | make_flat
            "x-am-meta" to "true", // true, false
            "x-am-internationalization" to "USER_I18N_ID",
            "x-am-run-in-sandbox" to "2",
            "x-am-content-type-response" to "text/xml", // application/json | text/xml | text/yaml | text/plain | text/html | application/octet-stream
            "x-am-cache-control" to "reset_cache", // no_action | reset_cache
            "x-am-get-encrypted-data" to "get_only_encryption", // no_encryption | get_only_encryption | get_data_and_encryption
            "x-am-sandbox-timeout" to "13000",
            "x-no-compression" to "true", // true | false
            "x-am-encrypted-payload" to "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" to "TENANT_USERNAME", // ex: acme
            // Authorization headers
            "x-am-authorization" to "AUTHORIZATION_TOKEN",
            "x-am-user-authorization" to "API_USER_TOKEN",
            "x-aws-authorization" to "AWS_TOKEN",
            "x-google-authorization" to "GOOGLE_TOKEN",
            "x-azure-authorization" to "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.
Update many customers of the tenant acme
1
2
3
4
5
6
7
8
9
let updateMany = await g.sys.db.updateMany({
    instance: "crm::acme", database: "crm", collection: "customers",
    find: {
        "first_name": "Alice"
    },
    updateData: {
        "first_name": "MALLORY"
    }
});
Update many customers of the tenant acme
1
2
3
4
5
6
7
8
9
update_many = await g.sys.db.update_many(
    'crm::acme', 'crm', 'customers',
    find={
        'first_name': 'Alice',
    },
    update_data={
        'first_name': 'MALLORY',
    },
)
Update many customers of the tenant acme
1
2
3
4
5
6
7
8
9
$updateMany = $g->sys->db->updateMany(
    'crm::acme', 'crm', 'customers',
    find: [
        'first_name' => 'Alice',
    ],
    updateData: [
        'first_name' => 'MALLORY',
    ],
);
Update many customers of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var updateMany = await g.Sys.Db.UpdateMany(new UpdateMany("crm::acme", "crm", "customers")
{
    Find = new JsonObject
    {
        ["first_name"] = "Alice",
    },
    UpdateData = new JsonObject
    {
        ["first_name"] = "MALLORY",
    },
});
Update many customers of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
updateMany, err := g.Sys.Db.UpdateMany(am.UpdateMany{
    Instance: "crm::acme", Database: "crm", Collection: "customers",
    Find: am.M{
        "first_name": "Alice",
    },
    UpdateData: am.M{
        "first_name": "MALLORY",
    },
})
if err != nil {
    return nil, err
}
Update many customers of the tenant acme
1
2
3
4
5
6
7
8
9
let update_many = g.sys.db.update_many(
    UpdateMany::new("crm::acme", "crm", "customers")
        .find(json!({
            "first_name": "Alice",
        }))
        .update_data(json!({
            "first_name": "MALLORY",
        })),
)?;
Update many customers of the tenant acme
1
2
3
4
5
6
7
var updateMany = g.sys.db.updateMany(new UpdateMany("crm::acme", "crm", "customers")
    .find(Map.of(
        "first_name", "Alice"
    ))
    .updateData(Map.of(
        "first_name", "MALLORY"
    )));
Update many customers of the tenant acme
1
2
3
4
5
6
7
8
9
val updateMany = g.sys.db.updateMany(
    UpdateMany("crm::acme", "crm", "customers")
        .find(mapOf(
            "first_name" to "Alice",
        ))
        .updateData(mapOf(
            "first_name" to "MALLORY",
        )),
)

Without a schema

g.sys.db.gen.updateManyGen takes the same arguments and calls the update many generated API : no schema, so the data is read and written as it is in the table, without the conversions, validations and defaults of the schema.

Language The call
TypeScript g.sys.db.gen.updateManyGen(…)
Python g.sys.db.gen.update_many_gen(…)
PHP $g->sys->db->gen->updateManyGen(…)
C#, Go g.Sys.Db.Gen.UpdateManyGen(…)
Rust g.sys.db.update_many_gen(UpdateMany::new(…))
Java, Kotlin g.sys.db.gen.updateManyGen(…)