This content is for SDK V4. For the latest version, see the V5 documentation.

See Document Model for more information on documents in Ditto.

Creating Documents

To insert a document, call the EXECUTE API method against the ditto.store object and include an INSERT INTO query that specifies the document to be inserted.

Embed related data within a single document — typically as a map keyed by ID — for atomic single-document sync. See Denormalized Documents for the recommended pattern, or use a foreign-key relationship across collections when sub-entities need their own permission scope or independent access.

For example, the following snippet demonstrates how to insert a new document with a single field “color” set to “blue”:

await ditto.store.execute(
    query: "INSERT INTO cars DOCUMENTS (:newCar)",
    arguments: ["newCar": ["color": "blue"]]);

ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    mapOf("newCar" to mapOf("color" to "blue")))

await ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    { newCar: { color: "blue" } }
);

interface Car {
  color: string;
}

await ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    { newCar: { color: "blue" } as Car }
);

ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    Collections.singletonMap("newCar", Collections.singletonMap("color", "blue")));

var args = new Dictionary<string, object>();
args.Add("newCar", new { color = "blue" });

await ditto.Store.ExecuteAsync(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    args);

std::map<std::string, std::map<std::string, std::string>> args;

args["newCar"] = {{"color", "blue"}};

ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

ditto
  .store()
  .execute_v2((
    "INSERT INTO cars DOCUMENTS (:newCar)",
    serde_json::json!({
        "newCar": {
            "color": "blue"
        }
    }),
  )).await?;

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: {"newCar": {"color": "blue"}},
);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:newCar)",
	ditto.QueryArguments{
		"newCar": ditto.Document{
			"color": "blue",
		},
	},
)
if err != nil {
    return err
}
defer result.Close()  // cleanup

If desired, supply a document ID in your creation request; otherwise, Ditto automatically generates and assigns one.

Inserting Multiple Documents

To efficiently create multiple documents, use the INSERT INTO operation and specify multiple query parameters, as follows:

await ditto.store.execute(
  query: "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  arguments: [
    "doc1": ["color": "blue"],
    "doc2": ["color": "red"]
  ]);

ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  mapOf(
    "doc1" to mapOf("color" to "blue"),
    "doc2" to mapOf("color" to "red"),
    ))

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  {
    doc1: { color: 'blue' },
    doc2: { color: 'red' }
  });

interface Car {
  color: string;
}

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  {
    doc1: { color: 'blue' },
    doc2: { color: 'red' }
  });

var args = new HashMap<String, HashMap<String, String>>();
args.put("doc1", Collections.singletonMap("color", "blue"));
args.put("doc2", Collections.singletonMap("color", "red"));

ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  args);

var args = new Dictionary<string, object>();
args.Add("doc1", new { color = "blue" });
args.Add("doc2", new { color = "red" });

await ditto.Store.ExecuteAsync(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  args);

std::map<std::string, std::map<std::string, std::string>> args;
args["doc1"] = {{"color", "blue"}};
args["doc2"] = {{"color", "red"}};

ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
  args);

ditto
  .store()
  .execute_v2((
    "INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
    serde_json::json!({
        "doc1": {
            "color": "blue"
        },
        "doc2": {
            "color": "red"
        }
    }),
  )).await?;

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:doc1),(:doc2)",
  arguments: {
    "doc1": {"color": 'blue'},
    "doc2": {"color": 'red'},
  },
);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:doc1), (:doc2)",
	ditto.QueryArguments{
		"doc1": ditto.Document{
			"color": "blue",
		},
		"doc2": ditto.Document{
			"color": "red",
		},
	},
)
if err != nil {
    return err
}
defer result.Close()  // cleanup

Identifying Documents

Unless manually supplied, Ditto automatically generates and assigns the new document a 128‑bit Universally Unique Identifier (UUID). The document identifier is represented as _id and serves as the primary key for the document.

Retrieving Document IDs

To access the IDs of the documents affected by the INSERT INTO operation, call the mutatedDocumentIDs method on the result object after the insertion like this:

let result = await ditto.store.execute(
  query: "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: [
    newCar: ["color": "blue"]
  ]);

// "507f191e810c19729de860ea"
print(result.mutatedDocumentIDs()[0])

ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  mapOf("newCar" to mapOf("color" to "blue"))).use { result ->
    // "507f191e810c19729de860ea"
    println(result.mutatedDocumentIds().first())
}

const result = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  { newCar: { color: 'blue' } }
);

// "507f191e810c19729de860ea"
console.log(result.mutatedDocumentIDs()[0].value)

import { QueryResult } from '@dittolive/ditto';

interface Car {
  color: string;
}

const result: QueryResult = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  { newCar: { color: 'blue' } as Car }
);

// "507f191e810c19729de860ea"
console.log(result.mutatedDocumentIDs()[0].value);

try (DittoQueryResult result = (DittoQueryResult) ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  Collections.singletonMap("newCar", Collections.singletonMap("color", "blue")))) {
    // "507f191e810c19729de860ea"
    System.out.println(result.mutatedDocumentIds().stream().findFirst().get());
}

var args = new Dictionary<string, object>();
args.Add("newCar", new { color = "blue" });

using var result = await ditto.Store.ExecuteAsync(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

// "507f191e810c19729de860ea"
result.MutatedDocumentIds.ForEach(id => Console.WriteLine(id));

std::map<std::string, std::map<std::string, std::string>> args;
args["newCar"] = {{"color", "blue"}};

auto result = ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

// "507f191e810c19729de860ea"
std::cout << result.mutated_document_ids()[0].to_string();

let result = ditto
  .store()
  .execute_v2((
    "INSERT INTO cars DOCUMENTS (:newCar)",
    serde_json::json!({
        "newCar": {
            "color": "blue"
        }
    }),
  )).await?;

// "507f191e810c19729de860ea"
println!("{}", result.mutated_document_ids()[0].to_string())

final result = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: {
    "newCar": {"color": 'blue'},
  },
);

// "507f191e810c19729de860ea"
print(result.mutatedDocumentIDs.first);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:newCar)",
	ditto.QueryArguments{
		"newCar": ditto.Document{"color": "blue"},
	})
if err != nil {
	return err
}
defer result.Close() // cleanup

// "507f191e810c19729de860ea"
log.Printf("%v", result.MutatedDocumentIDs()[0])

Supplying String IDs

When creating a document, you can assign it a custom ID. This custom ID can be generated using a single string value or a combination of two or more string values. This flexibility in structuring document identifiers allows you to customize document IDs to your specific requirements, use cases, or standard naming conventions. The following snippet demonstrates a new document assigned the custom ID “123”.

let result = await ditto.store.execute(
  query: "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: [
    newCar: ["_id": "123", "color": "blue"]
  ]);

// "123"
println(result.mutatedDocumentIDs().first())

ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  mapOf("newCar" to mapOf("_id" to "123", "color" to "blue")))
.use { result ->
    // "123"
    println(result.mutatedDocumentIds().first())
}

const result = await ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    { newCar: { "_id": "123", color: "blue" } }
);

// "123"
console.log(result.mutatedDocumentIDs()[0].value)

import { QueryResult } from '@dittolive/ditto';

interface Car {
  _id: string;
  color: string;
}

const result: QueryResult = await ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    { newCar: { _id: "123", color: "blue" } as Car }
);

// "123"
console.log(result.mutatedDocumentIDs()[0].value);

Map<String, String> newCar = new HashMap<>();
newCar.put("_id", "123");
newCar.put("color", "blue");

try (DittoQueryResult result = (DittoQueryResult) ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  Collections.singletonMap("newCar", newCar)
)) {
    // "123"
    System.out.println(result.mutatedDocumentIds().stream().findFirst().get());
}

var args = new Dictionary<string, object>();
args.Add("newCar", new { _id = "123", color = "blue" });

using var result = await ditto.Store.ExecuteAsync(
  "INSERT INTO your_collection_name DOCUMENTS (:newCar)",
  args);

// "123"
result.MutatedDocumentIds.ForEach(id => Console.WriteLine(id));

std::map<std::string, std::map<std::string, std::string>> args;
args["newCar"] = {{"_id", "123"},{"color", "blue"}};

auto result = ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

// "123"
std::cout << result.mutated_document_ids()[0].to_string();

let result = ditto
  .store()
  .execute_v2((
    "INSERT INTO cars DOCUMENTS (:newCar)",
    serde_json::json!({
        "newCar": {
            "_id": "123",
            "color": "blue"
        }
    }),
  )).await?;

// "123"
println!("{}", result.mutated_document_ids()[0].to_string())

final result = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: {
    "newCar": {"_id":"123","color": 'blue'},
  },
);

// "123"
print(result.mutatedDocumentIDs.first);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:newCar)",
	ditto.QueryArguments{
		"newCar": ditto.Document{
			"_id":   "123",
			"color": "blue",
		},
	})
if err != nil {
    return err
}
defer result.Close()  // cleanup

// "123"
log.Printf("%v", result.MutatedDocumentIDs()[0])

Following is the new 123 document that results:

{
  "_id": "123",
  "color": "blue"
}

Forming Composite Keys

The following demonstrates combining the vin and make fields to form a composite key:

let arguments = [
  newCar: [ "_id": [vin: "123", make: "Toyota"], "color": "blue"]
];

let result = await ditto.store.execute(
  query: "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: arguments);

// "{vin: "123", make: "Toyota"}"
print(result.mutatedDocumentIDs()[0])

val arguments = mapOf(
    "newCar" to mapOf(
        "_id" to mapOf("vin" to "123", "make" to "Toyota"),
        "color" to "blue"
    )
)
ditto.store.execute(
    "INSERT INTO cars DOCUMENTS (:newCar)",
    arguments
).use { result ->
    println(result.mutatedDocumentIDs()[0])
}

const newCar = {
  "_id": {
    vin: "123",
    make: "Toyota"
  },
  color: "blue"
};

const result = await ditto.store.execute(`
  INSERT INTO cars DOCUMENTS (:newCar)`,
  { newCar });

// { vin: "123", make: "Toyota" }
console.log(result.mutatedDocumentIDs()[0].value)

import { QueryResult } from '@dittolive/ditto';

interface CarId {
  vin: string;
  make: string;
}

interface Car {
  _id: CarId;
  color: string;
}

const newCar: Car = {
  _id: {
    vin: "123",
    make: "Toyota"
  },
  color: "blue"
};

const result: QueryResult = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  { newCar });

// { vin: "123", make: "Toyota" }
console.log(result.mutatedDocumentIDs()[0].value);

Map<String, String> newCarId = new HashMap<>();
newCarId.put("vin", "123");
newCarId.put("make", "Toyota");
Map<String, Object> newCar = new HashMap<>();
newCar.put("_id", newCarId);
newCar.put("color", "blue");

try (DittoQueryResult result = (DittoQueryResult) ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  Collections.singletonMap("newCar", newCar),
)) {
  // "{vin: "123", make: "Toyota"}"
  System.out.println(result.mutatedDocumentIDs().stream().findFirst().get());
}

var newId = new { vin: "123", make: "Toyota"};
var args = new Dictionary<string, object>();
args.Add("newCar", new { "_id" = newId, color = "blue" });

using var result = await ditto.Store.ExecuteAsync(
  "INSERT INTO your_collection_name DOCUMENTS (:newCar)",
  args);

// "{vin: "123", make: "Toyota"}"
result.MutatedDocumentIds.ForEach(id => Console.WriteLine(
  System.Text.Json.JsonSerializer.Serialize(id))
);

struct CarId {
  std::string vin;
  std::string make;
};

struct Car {
  CarId _id;
  std::string color;
};

std::map<std::string, Car> args;
args["newCar"] = {{"123", "Toyota"}, "blue"};

auto result = ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

// "{vin: "123", make: "Toyota"}"
std::cout << result.mutated_document_ids()[0].to_string();

let result = ditto
  .store()
  .execute_v2((
    "INSERT INTO cars DOCUMENTS (:newCar)",
    serde_json::json!({
        "newCar": {
            "_id": {
              "vin": "123",
              "make": "Toyota"
            },
            "color": "blue"
        }
    }),
  )).await?;

// "{vin: "123", make: "Toyota"}"
println!("{}", result.mutated_document_ids()[0].to_string())

final result = await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: {
    "newCar": {
      "_id": {"vin": "123", "make": "Toyota"},
      "color": 'blue',
    },
  },
);

// "{vin: "123", make: "Toyota"}"
print(result.mutatedDocumentIDs.first);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:newCar)",
	ditto.QueryArguments{
		"newCar": ditto.Document{
			"_id": map[string]any{
				"vin":  "123",
				"make": "Toyota",
			},
			"color": "blue",
		},
	})
if err != nil {
	return err
}
defer result.Close()  // cleanup

// "{vin: "123", make: "Toyota"}"
log.Printf("%v", result.MutatedDocumentIDs()[0])

Creating MAPs

There are two ways to create a MAP structure within a document:

In an INSERT operation — Create a new document and nest it with this set of fields.
In an UPDATE operation — If the MAP does not exist, create it. (See UPDATE)

To represent a highly complex data structure in a MAP, consider embedding it with an additional MAP. Embedding a MAP within a MAP establishes an additional hierarchy. The decision to use deeply embedded MAPS in a single document or opt for a flat model depends on your requirements, relationships between data, and tolerance for certain tradeoffs.

The flat model is a simple, non‑embedded structure in which you spread your data across multiple, separate documents.

Inserting to Create a MAP

Disable Strict Mode

In 4.11+ and DQL_STRICT_MODE=false, collection definitions are no longer required.Read more

When inserting a new document in Ditto, you can define a field as a MAP and include the structure of key-value pairs nested within it — a two-in-one approach. To do this, first disable strict mode before starting synchronization. Read more

let arguments: [String: Any] = [
  "newCar": [
    "_id": "123",
    "properties": [
      "color": "blue",
      "mileage": 3000
    ]
  }
];

await ditto.store.execute(
  query: "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: arguments);

val arguments = mapOf(
  "newCar" to mapOf(
    "_id" to "123",
    "properties" to mapOf(
      "color" to "blue",
      "mileage" to 3000
    )
  )
)

ditto.store.execute(
  "INSERT INTO cars  DOCUMENTS (:newCar)",
  arguments)

const newCar = {
  "_id": "123",
  properties: {
    color: 'blue',
    mileage: 3000
  }
};

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  { newCar }
);

interface CarProperties {
  color: string;
  mileage: number;
}

interface Car {
  _id: string;
  properties: CarProperties;
}

const newCar: Car = {
  _id: "123",
  properties: {
    color: 'blue',
    mileage: 3000
  }
};

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  { newCar }
);

Map<String, Object> properties = new HashMap<>();
properties.put("color", "blue");
properties.put("mileage", 3000);

Map<String, Object> newCar = new HashMap<>();
newCar.put("_id", "123");
newCar.put("properties", properties);

ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  Collections.singletonMap("newCar", newCar));

var subMap = new {
  color = "blue",
  mileage = 3000
};

var insertArgs = new Dictionary<string, object>();
insertArgs.Add("newCar", new { "_id" = newId, properties = subMap })

using var result = await ditto.Store.ExecuteAsync(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  insertArgs);

struct Properties {
  std::string color;
  int mileage;
};

struct Car {
  std::string _id;
  Properties properties;
};

std::map<std::string, Car> args;
args["newCar"] = {"123", {"blue", 3000}};

ditto.get_store().execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args);

#[derive(Serialize)]
struct Properties {
  color: String,
  mileage: i32
}

#[derive(Serialize)]
struct Car {
  _id: String,
  properties: Properties
}

#[derive(Serialize)]
struct Args {
  newCar: Car
}

let args = Args {
  newCar: Cat {
    _id: "123".to_string(),
    properties: Properties {
      color: "blue".to_string(),
      mileage: 3000
    }
  }
};

await ditto.store().execute_v2((
  "INSERT INTO cars DOCUMENTS (:newCar)",
  args,
));

final newCar = {
  "_id": "123",
  "properties": {
    "color": 'blue',
    "mileage": 3000,
  },
};

await ditto.store.execute(
  "INSERT INTO cars DOCUMENTS (:newCar)",
  arguments: {"newCar": newCar},
);

result, err := dit.Store().Execute(
	"INSERT INTO cars DOCUMENTS (:newCar)",
	ditto.QueryArguments{
		"newCar": ditto.Document{
			"_id": "123",
			"properties": map[string]any{
				"color":   "blue",
				"mileage": 3000,
			},
		},
	})
if err != nil {
    return err
}
defer result.Close()  // cleanup

You can also create MAPs within a document after the fact using an UPDATE operation. In the UPDATE approach, you set the structure of key-value pairs and specify the document ID to update. For example, this statement creates a MAP structure, adding key-value pair of “color is red” to the properties MAP for the document with the ID 123 in the cars collection:

DQl

UPDATE cars
   SET properties.color = 'red'
 WHERE _id = '123'

Overview & Setup

Accessing Data

Syncing Data

Authentication and Authorization

Managing the Mesh

Deploying your App

Reference

Preview Features

Creating Documents

Creating Documents

Inserting Multiple Documents

Identifying Documents

Retrieving Document IDs

Supplying String IDs

Forming Composite Keys

Creating MAPs

Inserting to Create a MAP

Disable Strict Mode

​Creating Documents

​Inserting Multiple Documents

​Identifying Documents

​Retrieving Document IDs

​Supplying String IDs

​Forming Composite Keys

​Creating MAPs

​Inserting to Create a MAP

​Disable Strict Mode

Creating Documents

Inserting Multiple Documents

Identifying Documents

Retrieving Document IDs

Supplying String IDs

Forming Composite Keys

Creating MAPs

Inserting to Create a MAP

Disable Strict Mode