Transactions

    • All the commands in a transaction are serialized and executed sequentially. No request issued by another client can ever interrupt the execution of a transaction. This guarantees that the commands are executed as a single isolated operation.
    • Either all of the commands are processed, or none are, so the transaction is also atomic.
    1. // Using getAll:
    2. List<String> keys = Arrays.asList("key1", "key2", "key3");
    3. List<KV> got = immuClient.getAll(keys);
    5. // Using execAll for setting multiple KVs at once:
    6. byte[] item1 = "execAll_key1".getBytes(StandardCharsets.UTF_8);
    7. byte[] item2 = "execAll_key2".getBytes(StandardCharsets.UTF_8);
    9. immuClient.execAll(
    10.         Arrays.asList(                  // Providing just a kvList, which is a List< Pair<byte[], byte[]> >.
    11.                 Pair.of(item1, item1),
    12.                 Pair.of(item2, item2)
    13.         ),
    14.         null,                          // No refList provided.
    15.         null                           // No zaddList provided.
    16. );
    18. // Using execAll for setting multiple references and doing zAdd(s):
    19. immuClient.execAll(
    20.         null,                          // No kvList provided.
    21.         Arrays.asList(                 // The refList.
    22.                 Pair.of("ref1".getBytes(StandardCharsets.UTF_8), item1),
    23.                 Pair.of("ref2".getBytes(StandardCharsets.UTF_8), item2)
    24.         ),
    25.         // The zaddList.
    26.         Collections.singletonList(Triple.of("set1", 1.0, "execAll_key1"))
    27. );

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on Python sdk github project (opens new window)

    1. import ImmudbClient from 'immudb-node'
    2. import Parameters from 'immudb-node/types/parameters'
    4. const IMMUDB_HOST = '127.0.0.1'
    5. const IMMUDB_PORT = '3322'
    6. const IMMUDB_USER = 'immudb'
    7. const IMMUDB_PWD = 'immudb'
    9. const cl = new ImmudbClient({ host: IMMUDB_HOST, port: IMMUDB_PORT });
    11. (async () => {
    12.     await cl.login({ user: IMMUDB_USER, password: IMMUDB_PWD })
    14.     const getAllReq: Parameters.GetAll = {
    15.         keysList: ['key1', 'key2', 'key3'],
    16.         sincetx: 0
    17.     }
    18.     const getAllRes = await cl.getAll(getAllReq)
    19.     console.log('success: getAll', getAllRes)
    20. })()

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on

    If you’re using another development language, please read up on our immugw (opens new window) option.

    A more versatile atomic multi set operation

    SetBatch and GetBatch example

    1.     kvList := &schema.KVList{KVs: []*schema.KeyValue{
    2.         {Key: []byte("1,2,3"), Value: []byte("3,2,1")},
    3.         {Key: []byte("4,5,6"), Value: []byte("6,5,4")},
    4.     }}
    6.     _, err = client.SetAll(ctx, kvList)

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on 

    1. import ImmudbClient from 'immudb-node'
    2. import Parameters from 'immudb-node/types/parameters'
    4. const IMMUDB_HOST = '127.0.0.1'
    5. const IMMUDB_PORT = '3322'
    6. const IMMUDB_USER = 'immudb'
    7. const IMMUDB_PWD = 'immudb'
    9. const cl = new ImmudbClient({ host: IMMUDB_HOST, port: IMMUDB_PORT });
    11. (async () => {
    12.     await cl.login({ user: IMMUDB_USER, password: IMMUDB_PWD })
    14.     const setAllReq: Parameters.SetAll = {
    15.             { key: '1,2,3', value: '3,2,1' },
    16.             { key: '4,5,6', value: '6,5,4' },
    17.         ]
    18.     }
    20.     console.log('success: setAll', setAllRes)
    21. })()

    If you’re using another development language, please read up on our immugw (opens new window) option.

    ExecAll permits many insertions at once. The difference is that is possible to specify a list of a mix of key value set, reference and zAdd insertions. The argument of a ExecAll is an array of the following types:

    • Op_Kv: ordinary key value item
    • Op_ZAdd: option element
    • Op_Ref: Reference option element

    It’s possible to persist and reference items that are already persisted on disk. In that case is mandatory to provide the index of the referenced item. This has to be done for:

    • Op_ZAdd
    • Op_Ref If zAdd or reference is not yet persisted on disk it’s possible to add it as a regular key value and the reference is done onFly. In that case if BoundRef is true the reference is bounded to the current transaction values.
    1.         aOps := &schema.ExecAllRequest{
    2.             Operations: []*schema.Op{
    3.                 {
    4.                     Operation: &schema.Op_Kv{
    5.                         Kv: &schema.KeyValue{
    6.                             Key:   []byte(`notPersistedKey`),
    7.                             Value: []byte(`notPersistedVal`),
    8.                         },
    9.                     },
    10.                 },
    11.                 {
    12.                     Operation: &schema.Op_ZAdd{
    13.                         ZAdd: &schema.ZAddRequest{
    14.                             Set:   []byte(`mySet`),
    15.                             Score: 0.4,
    16.                             Key:   []byte(`notPersistedKey`)},
    17.                     },
    18.                 },
    19.                 {
    20.                     Operation: &schema.Op_ZAdd{
    21.                         ZAdd: &schema.ZAddRequest{
    22.                             Set:      []byte(`mySet`),
    23.                             Score:    0.6,
    24.                             Key:      []byte(`persistedKey`),
    25.                             AtTx:     idx.Id,
    26.                             BoundRef: true,
    27.                         },
    28.                     },
    29.                 },
    30.             },
    31.         }
    33.         idx , err = client.ExecAll(ctx, aOps)
    34.         if err != nil {
    35.             log.Fatal(err)
    36.         }
    37.         zscanOpts1 := &schema.ZScanRequest{
    38.             Set:     []byte(`mySet`),
    39.             SinceTx: math.MaxUint64,
    40.             NoWait: true,
    41.         }
    43.         list, err := client.ZScan(ctx, zscanOpts1)
    44.         if err != nil{
    45.             log.Fatal(err)
    46.         }
    47.         s, _ := json.MarshalIndent(list, "", "\t")
    48.         fmt.Print(string(s))
    1. byte[] item1 = "execAll_key1".getBytes(StandardCharsets.UTF_8);
    2. byte[] item2 = "execAll_key2".getBytes(StandardCharsets.UTF_8);
    4. // Using execAll just for setting multiple KVs:
    5. TxMetadata txMd = immuClient.execAll(
    6.         Arrays.asList(                 // The kvList.
    7.                 Pair.of(item1, item1),
    8.                 Pair.of(item2, item2)
    9.         ),
    10.         null,                         // No refList provided.
    11.         null                          // No zaddList provided.
    12. );
    14.         null,                         // No kvList provided.
    16.                 Pair.of("ref1".getBytes(StandardCharsets.UTF_8), item1),
    17.                 Pair.of("ref2".getBytes(StandardCharsets.UTF_8), item2)
    18.         ),
    19.         // The zaddList (even if it has one single entry).
    20.         Collections.singletonList(Triple.of("set1", 1.0, "execAll_key1"))
    21. );

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on .Net sdk github project (opens new window)

    If you’re using another development language, please read up on our option.

    The argument of a TxScan is an array of the following types:

    • InitialTx: initial transaction id
    • Limit: number of transactions returned
    • Desc: order of returned transacations
    1.     _, err = client.Set(ctx, []byte("key1"), []byte("val1"))
    2.     if err != nil {
    3.         log.Fatal(err)
    4.     }
    5.     _, err = client.Set(ctx, []byte("key2"), []byte("val2"))
    6.     if err != nil {
    7.         log.Fatal(err)
    8.     }
    9.     _, err = client.Set(ctx, []byte("key3"), []byte("val3"))
    10.     if err != nil {
    11.         log.Fatal(err)
    12.     }
    14.     txRequest := &schema.TxScanRequest{
    15.         InitialTx: 2,
    16.         Limit:     3,
    17.         Desc:      false,
    18.     }
    20.     txs , err := client.TxScan(ctx, txRequest)
    21.     if err != nil {
    22.         log.Fatal(err)
    23.     }
    25.     for _, tx := range txs.GetTxs() {
    26.         fmt.Printf("retrieved in ASC tx %d \n", tx.Metadata.Id )
    27.     }
    28.     txRequest = &schema.TxScanRequest{
    29.         InitialTx: 2,
    30.         Limit:     3,
    31.         Desc:      true,
    32.     }
    34.     txs , err = client.TxScan(ctx, txRequest)
    35.     if err != nil {
    36.         log.Fatal(err)
    37.     }

    Then it’s possible to retrieve entries of every transactions:

    1.     for _, tx := range txs.GetTxs() {
    2.         for _, entry := range tx.Entries {
    3.             item, err := client.GetAt(ctx, entry.Key[1:], tx.Metadata.Id)
    4.             if err != nil {
    5.                 log.Fatal(err)
    6.             }
    7.             fmt.Printf("retrieved key %s and val %s\n", item.Key, item.Value)
    8.         }
    9.     }
    1. String key = "txtest-t2";
    2. byte[] val1 = "immuRocks!".getBytes(StandardCharsets.UTF_8);
    3. byte[] val2 = "immuRocks! Again!".getBytes(StandardCharsets.UTF_8);
    5. long initialTxId = 1;
    6. try {
    7.     TxMetadata txMd = immuClient.set(key, val1);
    8.     initialTxId = txMd.id;
    9.     txMd = immuClient.set(key, val2);
    10. } catch (CorruptedDataException e) {
    11.     Assert.fail("Failed at set.", e);
    12. }
    13.             // This is a .txScan(initialTxId, limit, desc)
    14. List<Tx> txs = immuClient.txScan(initialTxId, 1, false);
    15. // We expect one Tx entry in this list.

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on Python sdk github project (opens new window)

    This feature is not yet supported or not documented. Do you want to make a feature request or help out? Open an issue on

    If you’re using another development language, please read up on our immugw (opens new window) option.