Database Management

 1package main
 2
 3import (
 4	"context"
 5	"log"
 6
 7	"github.com/codenotary/immudb/pkg/api/schema"
 8	immudb "github.com/codenotary/immudb/pkg/client"
 9)
10
11func main() {
12	client := immudb.NewClient()
13	ctx := context.Background()
14
15	err := client.OpenSession(ctx,
16		[]byte(`immudb`),
17		[]byte(`immudb`),
18		"defaultdb",
19	)
20	if err != nil {
21		log.Fatal(err)
22	}
23
24	defer client.CloseSession(ctx)
25
26	res, err := client.CreateDatabaseV2(
27		ctx,
28		"mydb",
29		&schema.DatabaseNullableSettings{
30			// this setting determines how many
31			// transactions can be handled concurrently
32			MaxConcurrency: &schema.NullableUint32{Value: 10},
33		},
34	)
35	if err != nil {
36		log.Fatal(err)
37	}
38	log.Print("Database created, server response: ", res)
39}

 1package io.codenotary.immudb.helloworld;
 2
 3import io.codenotary.immudb4j.*;
 4
 5public class App {
 6
 7    public static void main(String[] args) {
 8        FileImmuStateHolder stateHolder = FileImmuStateHolder.newBuilder()
 9                    .withStatesFolder("./immudb_states")
10                    .build();
11
12        ImmuClient client = ImmuClient.newBuilder()
13                    .withServerUrl("127.0.0.1")
14                    .withServerPort(3322)
15                    .withStateHolder(stateHolder)
16                    .build();
17
18        client.login("immudb", "immudb");
19    
20        client.createDatabase("db1");
21    }
22
23}

 1from immudb import ImmudbClient
 2
 3URL = "localhost:3322"  # immudb running on your machine
 4LOGIN = "immudb"        # Default username
 5PASSWORD = "immudb"     # Default password
 6DB = b"defaultdb"       # Default database name (must be in bytes)
 7
 8def main():
 9    client = ImmudbClient(URL)
10    client.login(LOGIN, PASSWORD, database = DB)
11
12    client.createDatabase("db1")
13
14if __name__ == "__main__":
15    main()

 1import ImmudbClient from 'immudb-node'
 2import Parameters from 'immudb-node/types/parameters'
 3
 4const IMMUDB_HOST = '127.0.0.1'
 5const IMMUDB_PORT = '3322'
 6const IMMUDB_USER = 'immudb'
 7const IMMUDB_PWD = 'immudb'
 8
 9const cl = new ImmudbClient({ host: IMMUDB_HOST, port: IMMUDB_PORT });
10
11(async () => {
12    await cl.login({ user: IMMUDB_USER, password: IMMUDB_PWD })
13
14    const createDatabaseReq: Parameters.CreateDatabase = {
15        databasename: 'myimmutabledb'
16    }
17
18    const createDatabaseRes = await cl.createDatabase(createDatabaseReq)
19    console.log('success: createDatabase', createDatabaseRes)
20})()

1var client = new ImmuClient();
2await client.Open("immudb", "immudb", "defaultdb");
3
4var dbName = "mydatabase";
5await client.CreateDatabase(dbName);
6await client.UseDatabase(dbName);
7
8await client.Close();

 1package main
 2
 3import (
 4	"context"
 5	"log"
 6
 7	immudb "github.com/codenotary/immudb/pkg/client"
 8)
 9
10func main() {
11	client := immudb.NewClient()
12	ctx := context.Background()
13
14	err := client.OpenSession(
15		ctx,
16		[]byte(`immudb`),
17		[]byte(`immudb`),
18		"defaultdb",
19	)
20	if err != nil {
21		log.Fatal(err)
22	}
23
24	defer client.CloseSession(ctx)
25
26	res, err := client.DatabaseListV2(ctx)
27	if err != nil {
28		log.Fatal(err)
29	}
30
31	for _, db := range res.Databases {
32		log.Printf(
33			"database: %s, loaded: %v",
34			db.Name,
35			db.Loaded,
36		)
37	}
38}

 1package io.codenotary.immudb.helloworld;
 2
 3import io.codenotary.immudb4j.*;
 4
 5public class App {
 6
 7    public static void main(String[] args) {
 8        FileImmuStateHolder stateHolder = FileImmuStateHolder.newBuilder()
 9                    .withStatesFolder("./immudb_states")
10                    .build();
11
12        ImmuClient client = ImmuClient.newBuilder()
13                    .withServerUrl("127.0.0.1")
14                    .withServerPort(3322)
15                    .withStateHolder(stateHolder)
16                    .build();
17
18        client.login("immudb", "immudb");
19
20        List<String> dbs = client.databases();
21        // List of database names
22    }
23
24}

 1var client = new ImmuClient();
 2await client.Open("immudb", "immudb", "defaultdb");
 3
 4var databases = await client.Databases();
 5foreach(var database in databases)
 6{
 7    Console.WriteLine(database);
 8}
 9
10await client.Close();

 1package main
 2
 3import (
 4	"context"
 5	"log"
 6
 7	"github.com/codenotary/immudb/pkg/api/schema"
 8	immudb "github.com/codenotary/immudb/pkg/client"
 9)
10
11func main() {
12	client := immudb.NewClient()
13	ctx := context.Background()
14
15	err := client.OpenSession(
16		ctx,
17		[]byte(`immudb`),
18		[]byte(`immudb`),
19		"defaultdb",
20	)
21	if err != nil {
22		log.Fatal(err)
23	}
24	defer client.CloseSession(ctx)
25
26	unloadRes, err := client.UnloadDatabase(
27		ctx,
28		&schema.UnloadDatabaseRequest{
29			Database: "mydb",
30		},
31	)
32	if err != nil {
33		log.Fatal(err)
34	}
35
36	log.Print("Database unloaded, server response: ", unloadRes)
37
38	// Do db maintenance - e.g. backup physical files from disk
39
40	loadRes, err := client.LoadDatabase(
41		ctx,
42		&schema.LoadDatabaseRequest{
43			Database: "mydb",
44		},
45	)
46	if err != nil {
47		log.Fatal(err)
48	}
49
50	log.Print("Database loaded, server response: ", loadRes)
51}

 1package main
 2
 3import (
 4	"context"
 5	"fmt"
 6	"log"
 7
 8	"github.com/codenotary/immudb/pkg/api/schema"
 9	immudb "github.com/codenotary/immudb/pkg/client"
10)
11
12func main() {
13	client := immudb.NewClient()
14	ctx := context.Background()
15
16	err := client.OpenSession(
17		ctx,
18		[]byte(`immudb`),
19		[]byte(`immudb`),
20		"defaultdb",
21	)
22	if err != nil {
23		log.Fatal(err)
24	}
25
26	defer client.CloseSession(ctx)
27
28	res, err := client.UpdateDatabaseV2(
29		ctx,
30		"mydb",
31		&schema.DatabaseNullableSettings{
32			TxLogCacheSize: &schema.NullableUint32{Value: 1000},
33		},
34	)
35	if err != nil {
36		log.Fatal(err)
37	}
38
39	fmt.Println("Database settings updated, server response: ", res)
40}