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

Array operations

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.arrayOperations calls the array operations 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).

Array operation [push]

Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "push",
            path: "attributes.color",
            dataToPush: [
                "YELLOW",
                "SKY_BLUE"
            ]
        }
    ]
});
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'push',
            'attributes.color',
            data_to_push=[
                'YELLOW',
                'SKY_BLUE',
            ],
        ),
    ],
)
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'push',
            'attributes.color',
            dataToPush: [
                'YELLOW',
                'SKY_BLUE',
            ],
        ),
    ],
);
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("push", "attributes.color")
        {
            DataToPush = [
                "YELLOW",
                "SKY_BLUE",
            ],
        },
    ],
});
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "push",
            Path:      "attributes.color",
            DataToPush: []any{
                "YELLOW",
                "SKY_BLUE",
            },
        },
    },
}); err != nil {
    return nil, err
}
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("push", "attributes.color")
                .data_to_push([
                    "YELLOW",
                    "SKY_BLUE",
                ]),
        ]),
)?;
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("push", "attributes.color")
            .dataToPush(
                "YELLOW",
                "SKY_BLUE"
            )
    ));
Array operation push
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("push", "attributes.color")
                .dataToPush(
                    "YELLOW",
                    "SKY_BLUE",
                ),
        ),
)

Array operation [pull]

Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "pull",
            path: "ages",
            queryToRemove: {
                "age": 2,
                "birth_year": 1989,
                "country_id": 1
            }
        }
    ]
});
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'pull',
            'ages',
            query_to_remove={
                'age': 2,
                'birth_year': 1989,
                'country_id': 1,
            },
        ),
    ],
)
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'pull',
            'ages',
            queryToRemove: [
                'age' => 2,
                'birth_year' => 1989,
                'country_id' => 1,
            ],
        ),
    ],
);
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("pull", "ages")
        {
            QueryToRemove = new JsonObject
            {
                ["age"] = 2,
                ["birth_year"] = 1989,
                ["country_id"] = 1,
            },
        },
    ],
});
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "pull",
            Path:      "ages",
            QueryToRemove: am.M{
                "age":        2,
                "birth_year": 1989,
                "country_id": 1,
            },
        },
    },
}); err != nil {
    return nil, err
}
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("pull", "ages")
                .query_to_remove(json!({
                    "age": 2,
                    "birth_year": 1989,
                    "country_id": 1,
                })),
        ]),
)?;
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("pull", "ages")
            .queryToRemove(Map.of(
                "age", 2,
                "birth_year", 1989,
                "country_id", 1
            ))
    ));
Array operation pull
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("pull", "ages")
                .queryToRemove(mapOf(
                    "age" to 2,
                    "birth_year" to 1989,
                    "country_id" to 1,
                )),
        ),
)

Array operation [pullAll]

Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "pullAll",
            path: "attributes.size",
            dataToPull: [
                3.5
            ]
        }
    ]
});
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'pullAll',
            'attributes.size',
            data_to_pull=[
                3.5,
            ],
        ),
    ],
)
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'pullAll',
            'attributes.size',
            dataToPull: [
                3.5,
            ],
        ),
    ],
);
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("pullAll", "attributes.size")
        {
            DataToPull = [
                3.5,
            ],
        },
    ],
});
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "pullAll",
            Path:      "attributes.size",
            DataToPull: []any{
                3.5,
            },
        },
    },
}); err != nil {
    return nil, err
}
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("pullAll", "attributes.size")
                .data_to_pull([
                    json!(3.5),
                ]),
        ]),
)?;
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("pullAll", "attributes.size")
            .dataToPull(
                3.5
            )
    ));
Array operation pullAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("pullAll", "attributes.size")
                .dataToPull(
                    3.5,
                ),
        ),
)

Array operation [pop]

Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "pop",
            path: "attributes.color",
            direction: 1
        }
    ]
});
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'pop',
            'attributes.color',
            direction=1,
        ),
    ],
)
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'pop',
            'attributes.color',
            direction: 1,
        ),
    ],
);
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("pop", "attributes.color")
        {
            Direction = 1,
        },
    ],
});
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "pop",
            Path:      "attributes.color",
            Direction: 1,
        },
    },
}); err != nil {
    return nil, err
}
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("pop", "attributes.color")
                .direction(1),
        ]),
)?;
Array operation pop
1
2
3
4
5
6
7
8
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("pop", "attributes.color")
            .direction(1)
    ));
Array operation pop
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("pop", "attributes.color")
                .direction(1),
        ),
)

Array operation [set]

Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "set",
            dataToSet: {
                'ages.birth_year': 1890,
            },
            arrayFilters: [
                {
                    'item.age': 4,
                },
            ],
        }
    ]
});
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'set',
            data_to_set={
                'ages.birth_year': 1890,
            },
            array_filters=[
                {
                    'item.age': 4,
                },
            ],
        ),
    ],
)
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'set',
            dataToSet: [
                'ages.birth_year' => 1890,
            ],
            arrayFilters: [
                [
                    'item.age' => 4,
                ],
            ],
        ),
    ],
);
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation
        {
            Operation = "set",
            DataToSet = new JsonObject
            {
                ["ages.birth_year"] = 1890,
            },
            ArrayFilters = [
                new JsonObject
                {
                    ["item.age"] = 4,
                },
            ],
        },
    ],
});
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "set",
            DataToSet: am.M{
                "ages.birth_year": 1890,
            },
            ArrayFilters: []any{
                am.M{
                    "item.age": 4,
                },
            },
        },
    },
}); err != nil {
    return nil, err
}
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::default()
                .operation("set")
                .data_to_set(json!({
                    "ages.birth_year": 1890,
                }))
                .array_filters([
                    json!({
                        "item.age": 4,
                    }),
                ]),
        ]),
)?;
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation()
            .operation("set")
            .dataToSet(Map.of(
                "ages.birth_year", 1890
            ))
            .arrayFilters(
                Map.of(
                    "item.age", 4
                )
            )
    ));
Array operation set
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation()
                .operation("set")
                .dataToSet(mapOf(
                    "ages.birth_year" to 1890,
                ))
                .arrayFilters(
                    mapOf(
                        "item.age" to 4,
                    ),
                ),
        ),
)

Array operation [addToSet]

Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
await g.sys.db.arrayOperations({
    instance: "mongodb", database: "inventory", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "addToSet",
            dataToSet: {
                'ages.birth_year': 1890,
            },
            arrayFilters: [
                {
                    'item.age': 4,
                },
            ],
        }
    ]
});
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
await g.sys.db.array_operations(
    'mongodb', 'inventory', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'addToSet',
            data_to_set={
                'ages.birth_year': 1890,
            },
            array_filters=[
                {
                    'item.age': 4,
                },
            ],
        ),
    ],
)
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
$g->sys->db->arrayOperations(
    'mongodb', 'inventory', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'addToSet',
            dataToSet: [
                'ages.birth_year' => 1890,
            ],
            arrayFilters: [
                [
                    'item.age' => 4,
                ],
            ],
        ),
    ],
);
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
await g.Sys.Db.ArrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation
        {
            Operation = "addToSet",
            DataToSet = new JsonObject
            {
                ["ages.birth_year"] = 1890,
            },
            ArrayFilters = [
                new JsonObject
                {
                    ["item.age"] = 4,
                },
            ],
        },
    ],
});
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "mongodb", Database: "inventory", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "addToSet",
            DataToSet: am.M{
                "ages.birth_year": 1890,
            },
            ArrayFilters: []any{
                am.M{
                    "item.age": 4,
                },
            },
        },
    },
}); err != nil {
    return nil, err
}
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
g.sys.db.array_operations(
    ArrayOperations::new("mongodb", "inventory", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::default()
                .operation("addToSet")
                .data_to_set(json!({
                    "ages.birth_year": 1890,
                }))
                .array_filters([
                    json!({
                        "item.age": 4,
                    }),
                ]),
        ]),
)?;
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
g.sys.db.arrayOperations(new ArrayOperations("mongodb", "inventory", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation()
            .operation("addToSet")
            .dataToSet(Map.of(
                "ages.birth_year", 1890
            ))
            .arrayFilters(
                Map.of(
                    "item.age", 4
                )
            )
    ));
Array operation addToSet
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
g.sys.db.arrayOperations(
    ArrayOperations("mongodb", "inventory", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation()
                .operation("addToSet")
                .dataToSet(mapOf(
                    "ages.birth_year" to 1890,
                ))
                .arrayFilters(
                    mapOf(
                        "item.age" to 4,
                    ),
                ),
        ),
)

Structure

Array operations
 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
34
35
36
37
38
39
40
41
42
43
44
45
await g.sys.db.arrayOperations({
    instance: "INSTANCE_NAME", database: 'DB_NAME', collection: "COLLECTION_NAME",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "push", // push | addToSet | pull | pullAll | pop | set
            path: "attributes.color",
            dataToPush: [
                "YELLOW",
                "SKY_BLUE"
            ]
        },
        {
            operation: "pull", // push | addToSet | pull | pullAll | pop | set
            path: "attributes.color",
            dataToPull: [
                "SKY_BLUE"
            ]
        }
    ],
    select: "COMMA_SEPARATED_COLUMN_NAMES",
    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",
    },
});
Array operations
 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
34
35
36
37
38
39
40
41
42
43
44
45
await g.sys.db.array_operations(
    'INSTANCE_NAME', 'DB_NAME', 'COLLECTION_NAME',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'push',  # push | addToSet | pull | pullAll | pop | set
            'attributes.color',
            data_to_push=[
                'YELLOW',
                'SKY_BLUE',
            ],
        ),
        ArrayOperation(
            'pull',  # push | addToSet | pull | pullAll | pop | set
            'attributes.color',
            data_to_pull=[
                'SKY_BLUE',
            ],
        ),
    ],
    select='COMMA_SEPARATED_COLUMN_NAMES',
    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',
    },
)
Array operations
 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
34
35
36
37
38
39
40
41
42
43
44
45
$g->sys->db->arrayOperations(
    'INSTANCE_NAME', 'DB_NAME', 'COLLECTION_NAME',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'push', // push | addToSet | pull | pullAll | pop | set
            'attributes.color',
            dataToPush: [
                'YELLOW',
                'SKY_BLUE',
            ],
        ),
        new ArrayOperation(
            'pull', // push | addToSet | pull | pullAll | pop | set
            'attributes.color',
            dataToPull: [
                'SKY_BLUE',
            ],
        ),
    ],
    select: 'COMMA_SEPARATED_COLUMN_NAMES',
    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',
    ],
);
Array operations
 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
34
35
36
37
38
39
40
41
42
43
44
45
await g.Sys.Db.ArrayOperations(new ArrayOperations("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("push", "attributes.color")
        {
            DataToPush = [
                "YELLOW",
                "SKY_BLUE",
            ],
        },
        new ArrayOperation("pull", "attributes.color")
        {
            DataToPull = [
                "SKY_BLUE",
            ],
        },
    ],
    Select = "COMMA_SEPARATED_COLUMN_NAMES",
    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",
    },
});
Array operations
 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
if _, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "INSTANCE_NAME", Database: "DB_NAME", Collection: "COLLECTION_NAME",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation: "push", // push | addToSet | pull | pullAll | pop | set
            Path:      "attributes.color",
            DataToPush: []any{
                "YELLOW",
                "SKY_BLUE",
            },
        },
        {
            Operation: "pull", // push | addToSet | pull | pullAll | pop | set
            Path:      "attributes.color",
            DataToPull: []any{
                "SKY_BLUE",
            },
        },
    },
    Select: "COMMA_SEPARATED_COLUMN_NAMES",
    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",
    },
}); err != nil {
    return nil, err
}
Array operations
 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
34
35
36
37
38
39
g.sys.db.array_operations(
    ArrayOperations::new("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("push", "attributes.color")
                .data_to_push([
                    "YELLOW",
                    "SKY_BLUE",
                ]),
            ArrayOperation::new("pull", "attributes.color")
                .data_to_pull([
                    "SKY_BLUE",
                ]),
        ])
        .select("COMMA_SEPARATED_COLUMN_NAMES")
        .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",
        })),
)?;
Array operations
 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
34
35
36
37
g.sys.db.arrayOperations(new ArrayOperations("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("push", "attributes.color")
            .dataToPush(
                "YELLOW",
                "SKY_BLUE"
            ),
        new ArrayOperation("pull", "attributes.color")
            .dataToPull(
                "SKY_BLUE"
            )
    )
    .select("COMMA_SEPARATED_COLUMN_NAMES")
    .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"
    )));
Array operations
 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
34
35
36
37
38
39
g.sys.db.arrayOperations(
    ArrayOperations("INSTANCE_NAME", "DB_NAME", "COLLECTION_NAME")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("push", "attributes.color")
                .dataToPush(
                    "YELLOW",
                    "SKY_BLUE",
                ),
            ArrayOperation("pull", "attributes.color")
                .dataToPull(
                    "SKY_BLUE",
                ),
        )
        .select("COMMA_SEPARATED_COLUMN_NAMES")
        .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.
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
let arrayOperations = await g.sys.db.arrayOperations({
    instance: "crm::acme", database: "crm", collection: "customers",
    find: {
        "customer_id": 1
    },
    operations: [
        {
            operation: "push",
            path: "tags",
            dataToPush: ["vip"]
        }
    ]
});
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
array_operations = await g.sys.db.array_operations(
    'crm::acme', 'crm', 'customers',
    find={
        'customer_id': 1,
    },
    operations=[
        ArrayOperation(
            'push',
            'tags',
            data_to_push=['vip'],
        ),
    ],
)
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
$arrayOperations = $g->sys->db->arrayOperations(
    'crm::acme', 'crm', 'customers',
    find: [
        'customer_id' => 1,
    ],
    operations: [
        new ArrayOperation(
            'push',
            'tags',
            dataToPush: ['vip'],
        ),
    ],
);
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var arrayOperations = await g.Sys.Db.ArrayOperations(new ArrayOperations("crm::acme", "crm", "customers")
{
    Find = new JsonObject
    {
        ["customer_id"] = 1,
    },
    Operations = [
        new ArrayOperation("push", "tags")
        {
            DataToPush = ["vip"],
        },
    ],
});
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
arrayOperations, err := g.Sys.Db.ArrayOperations(am.ArrayOperations{
    Instance: "crm::acme", Database: "crm", Collection: "customers",
    Find: am.M{
        "customer_id": 1,
    },
    Operations: []am.ArrayOperation{
        {
            Operation:  "push",
            Path:       "tags",
            DataToPush: []any{"vip"},
        },
    },
})
if err != nil {
    return nil, err
}
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let array_operations = g.sys.db.array_operations(
    ArrayOperations::new("crm::acme", "crm", "customers")
        .find(json!({
            "customer_id": 1,
        }))
        .operations([
            ArrayOperation::new("push", "tags")
                .data_to_push(["vip"]),
        ]),
)?;
Array operations on a customer of the tenant acme
1
2
3
4
5
6
7
8
var arrayOperations = g.sys.db.arrayOperations(new ArrayOperations("crm::acme", "crm", "customers")
    .find(Map.of(
        "customer_id", 1
    ))
    .operations(
        new ArrayOperation("push", "tags")
            .dataToPush("vip")
    ));
Array operations on a customer of the tenant acme
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
val arrayOperations = g.sys.db.arrayOperations(
    ArrayOperations("crm::acme", "crm", "customers")
        .find(mapOf(
            "customer_id" to 1,
        ))
        .operations(
            ArrayOperation("push", "tags")
                .dataToPush("vip"),
        ),
)

Without a schema

g.sys.db.gen.arrayOperationsGen takes the same arguments and calls the array operations 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.arrayOperationsGen(…)
Python g.sys.db.gen.array_operations_gen(…)
PHP $g->sys->db->gen->arrayOperationsGen(…)
C#, Go g.Sys.Db.Gen.ArrayOperationsGen(…)
Rust g.sys.db.array_operations_gen(ArrayOperations::new(…))
Java, Kotlin g.sys.db.gen.arrayOperationsGen(…)