Mongo

deleteOne(), updateOne() and replaceOne() affect a single matching document; deleteMany() and updateMany() affect all matches.

A replacement document (no $-prefixed keys) fully replaces the matched document’s fields, but keeps its _id. The _id is immutable: an update or replacement that changes or removes it is refused (error 66).

The supported update operators are $set, $unset and $inc. They accept dotted paths ({ $set: { "addr.city": "Rome" } }): the embedded document is updated and missing levels are created. Writing below a value that is not a document (for example a string) is refused.

With upsert: true, when no document matches a new one is inserted, seeded from the filter’s equality conditions plus the update. If the filter includes an _id, that _id is used for the new document; otherwise one is generated. Either way, the resulting _id is returned.

$ne, $nin, $in (with null) and $not also match documents whose field is null or missing, like MongoDB. For example { age: { $ne: 30 } } returns documents with no age.

Filters follow MongoDB’s rules for types and arrays, in find, count, update and delete. A number never equals a string or a boolean ({ n: 5 } does not match "5"), and $gt/$lt compare within one type only. A filter on an array field tests its elements: { tags: "a" } matches ["a", "b"], { tags: { $ne: "a" } } does not, and $all, $elemMatch, $size and tags.0 work. $exists works on dotted paths ({ "a.b": { $exists: false } }), and collection names with dots (fs.files) can be read like any other.

A filter on _id (equality or $in) uses the unique _id index. A filter on any other field is tested on the documents with MongoDB’s own rules, and an index narrows which documents are tested only for a field that an index starts with and whose type is declared in the schema as a scalar (STRING, BOOLEAN, BYTE, SHORT, INTEGER, LONG or DOUBLE; for example CREATE PROPERTY products.sku STRING followed by CREATE INDEX ON products (sku) UNIQUE). Equality and $in use the index, and so does a range ($gt, $gte, $lt, $lte) on an integer field, when the operand is of the kind of the field (a string for a STRING, an integer for an INTEGER). Lookups, updates, deletes and bulk upserts by such a field do not read the whole collection. A field the schema does not declare is never narrowed by its index, because an array can be stored in it and an index does not see the elements of an array: filters on it, and on dotted paths, negations, regular expressions and temporal values, read every document of the collection and are slower on large ones. The declared type is relied upon: when you declare a property on a collection that already holds data, records stored before the declaration are not converted, so rewrite them if they hold an array or a value of another kind in that field.

A top-level $not, $expr and a $regex directly inside $elemMatch are refused with an error. Regular expressions are time-bounded by arcadedb.command.regexTimeout, shared by all the documents one command scans: raise it if a big scan with a regular expression times out. The same bound applies to the $match stages of an aggregation, including countDocuments() with a filter, and to the $match stages nested in $facet, $lookup and $unionWith. A non-regex $expr works inside an aggregation $match.

Aggregating or counting a collection that does not exist returns an empty result, and the first insert creates the collection.

find() honors the projection ({ name: 1 }, { _id: 0 }, { age: 0 }, dotted paths). Inclusion and exclusion cannot be mixed, except for _id. Projection operators ($slice, $elemMatch, $meta) are not supported and return an error. Documents never contain ArcadeDB’s @rid, @type or @cat.

Regular expressions work as literals (/^a/i) and with $regex and $options (i, m, s, x), also under $not. An invalid pattern returns an error.

_id is unique: inserting an existing _id fails with E11000. In a batch, ordered: true (the default) stops at the first duplicate, ordered: false inserts the others. The first insert creates the collection and a unique index on _id; on a big existing collection that first insert builds the index and other writes to it wait until it is done.

The _id index keys follow the _id type (integers, doubles, strings or ObjectIds), so range queries and sorts on numeric ids are numeric. If a collection mixes kinds of _id, the index uses string keys: 1 and "1" are then the same key, and ordering is textual.

Decimal128 is stored as an exact decimal. A decimal with more than 34 digits, written through SQL, is returned as a double.

An ObjectId outside _id is stored as the text $oid:<24 hex digits> and returned as an ObjectId. Filters (eq, $ne, $in) also match the plain hex text stored by older versions. _id keeps the plain hex form.

Binary, timestamp, regular expression, MinKey, MaxKey and JavaScript values are stored as a small document with the reserved field $bson. Equality and $in work on them, but range queries and sorting do not follow BSON order.

Reserved names: a field called $bson is refused, and a text starting with $oid: or $str: is escaped on write, so it comes back unchanged.

The Symbol type and binary subtypes other than 0 and 4 are not supported by the bundled MongoDB library.