Below is a reference of the current query functions. The list is still evolving.

.rge(key)
Range greater or equal: Limits the collection to values having keys greater than or equal to the parameter. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The source result set limited to only values of the collection with keys greater than or equal to the given parameter.
Performs table scan: No

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":20 }, 
"2018-09-16" : { "Spent":30 } 
};
await db.aok();
let x = await db.o.rge("2018-09-14")
//x is now limited to :
{ 
"2018-09-15" : { "Spent":20 }, 
"2018-09-16" : { "Spent":30 } 
}

.rgt(key)
Range greater than: Limits the collection to values having keys greater than to the parameter. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The source result set limited to only values of the collection with keys greater than to the given parameter.
Performs table scan: No

.rle(key)
Range less than or equal: Limits the collection to values having keys less than or equal to the parameter. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The source result set limited to only values of the collection with keys less than or equal to the given parameter.
Performs table scan: No

.rlt(key)
Range less or than: Limits the collection to values having keys less than the parameter. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The source result set limited to only values of the collection with keys less than or the given parameter.
Performs table scan: No

.kge(key)
Key greater or equal: Returns the first key in the collection greater than or equal to the given key. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The value of the first key in the collection greater than or equal to the given parameter
Performs table scan: No

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":20 }, 
"2018-09-16" : { "Spent":30 } 
}
await db.aok();
let x = await db.o.kge("2018-09-14")
//x is now "2018-09-15"
let atx = await db.o[x];

.kgt(key)
Key greater than: Returns the first key in the collection greater than the given key. For objects that is key alphanumerically, and for arrays, index numerically. The parameter does not have to be an existing key.

Returns: The value of the first key in the collection greater than the given parameter
Performs table scan: No

.select(f)
select
Formats the result in a desired shape, as specified by the return value of the function parameter.
The select function parameter will be passed the object on which it is called. Note that it returns a new unbound object, thus no further query functions can be chained after select.
See examples below.

Returns: The return value of the select function.
Performs table scan: No

Example:

db.o = { 
    "a" : "hello",
    "b" : "world",
    "c" : { "x" : "!" }
}
await db.aok();

let sel = await db.o.select((o) => { return { a: o.a, "hey" : o.a + " " + o.b + o.c.x; } } );

//sel is now
{ "a" : "hello", "hey" : "hello world!" }

.where(f)
Filters the collection based on the filter function provided. The function will iterate over the collection and execute the filter function on each entry. The filter function will be passed two parameters, firstly the key (k), and secondly the collection (o) that where is called on. So the key is available in the function as k, and the value as o[k]. See examples below.

Returns: The collection containing only the values that passes the query function, that is, for which the query function returns true.
Performs table scan: Yes

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":20 }, 
"2018-09-16" : { "Spent":30 } 
}
await db.aok();

//filter using key only
let x = await db.o.where((k) => k.indexOf('15') == 8);
// or equivalent: where(function(k) { return k.indexOf('15') == 8 });
//x is now  
{ "2018-09-15" : { "Spent":20 } }

//filter using value
let y = await db.o.where((k, o) => o[k].Spent > 10);
// or equivalent: where(function(k, o) { return o[k].Spent > 10 });
//y is now 
{ "2018-09-15" : { "Spent":20 }, "2018-09-16" : { "Spent":30 } }

.asc(f)
Sort ascending.
Orders the values in the collection based on the order function provided, or if no parameter is provided, sorts ascending according to key. (Note that by default, collections are already sorted by by key ascending, unless previously reordered.) The function will be used to insert the element in the correct position in the result set. The filter function will be passed three parameters, the first key (k1), the second key, (k2), and lastly the collection (o) that the function is called on is called on. The function returns a positive number if the first is greater then the second, or a negative number if it is less, or zero if equal. See examples below.

Returns: The collection sorted ascending according to the query function.
Performs table scan: Yes

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let x = await db.o.asc((k1, k2, o) => o[k1].Spent - o[k2].Spent);

//x is now  
{ 
"2018-09-13" : { "Spent":10 }, 
"2018-09-16" : { "Spent":20 },
"2018-09-15" : { "Spent":30 }
}

.desc(f)
Sort descending.
Orders the values in the collection based on the order function provided, or if no parameter is provided, sorts descending according to key. (Note that by default, collections are sorted by by key ascending.) The function will be used to insert the element in the correct position in the result set. The filter function will be passed three parameters, the first key (k1), the second key, (k2), and lastly the collection (o) that the function is called on is called on. The function returns a positive number if the first is greater then the second, or a negative number if it is less, or zero if equal.

Returns: The collection sorted ascending according to the query function.
Performs table scan: Yes

.skip(n)
Skip the first number of entries of a result set. Useful for paging functionality.

Returns: The collection, excluding the fist n values
Performs table scan: Yes (scans n entries only)

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let x = await db.o.skip(1);
//x is now  
{ 
"2018-09-16" : { "Spent":20 },
"2018-09-15" : { "Spent":30 }
}

.limit(n)
limit the number of entries returned to the first n entries of a result set. Useful for paging functionality.

Returns: The the first n values of the collection.
Performs table scan: Yes (scans n entries only)

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let x = await db.o.skip(1).limit(1);
//x is now  
{ 
"2018-09-16" : { "Spent":20 }
}

.count()
counts the entries in the result set.

Returns: The number of entries in the reslt set.
Performs table scan: Yes

.dbmap(f)
map
Performs a mapping of each entry in the result set, and returns an array containing the return values of the mapping function for each entry in the result set The mapping function will be passed two parameters, firstly the key (k), and secondly the collection (o) that where is called on. So the key is available in the function as k, and the value as o[k]. See examples below.

Returns: An Array containing the return values of the mapping function for each entry in the result set
Performs table scan: Yes

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let spends = await db.o.dbmap((k, o) => o[k].Spent);

//spends is now  
[10, 30, 20]

.dbreduce(f)
reduce
Reduces the result set to a single value, by sequentially running the accumulation function on each value.
The accumulation function will be passed three parameters, firstly the key (k), secondly the collection (o) that where is called on, and lastly the current accumulation value (v), that is the value returned by the previous accumulator function call, or undefined for the first element. See examples below.

Returns: The accumulation value reached by runnnig the accumulation function on each value in the result set. Could be of any type (String/Number/Object/Array…), depending on accumulation function.
Performs table scan: Yes

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let totalspend = await db.o.dbreduce((k, o, v) => (v || 0) + o[k].Spent);

//totalspend is now  
60

.kat(n)
key at
Returns the key at position n in the result set.

Returns: The value of key at position n in the result set.
Performs table scan: Yes (scans n entries)

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let k = await db.o.kat(1);

//k is now  
"2018-09-15"

.vat(n)
value at
Returns the value at position n in the result set.

Returns: The value at position n in the result set.
Performs table scan: Yes (scans n entries)

Example:

db.o = { 
"2018-09-13" : { "Spent":10 }, 
"2018-09-15" : { "Spent":30 }, 
"2018-09-16" : { "Spent":20 } 
}
await db.aok();

let k = await db.o.vat(1);

//k is now  
{ "Spent":30 }

.tobj()
to object
Returns an array collection as an object collection. This is useful if the actual key index values are needed. Normally arrays are always returned as non sparse arrays, and so the key indexes are not necessarily preserved in the resultset if the resultset is a sparse Array. Add .tobj anywhere in the query chain will cause the resultset to take object form. See example below

Returns: The result set in object form
Performs table scan: No

Example:

db.a = [ 
 { "Date" : "2018-09-13", "Spent":10 }, 
 { "Date" : "2018-09-15", "Spent":30 }, 
 { "Date" : "2018-09-16", "Spent":20 } 
]
await db.aok();

let ra = await db.a.skip(1);
//ra is now
[ 
 { "Date" : "2018-09-15", "Spent":30 }, 
 { "Date" : "2018-09-16", "Spent":20 } 
] //Note result array indexes are 0 and 1

let ro = await db.a.skip(1).tobj();
//ro is now
{ 
 "1":{ "Date" : "2018-09-15", "Spent":30 }, 
 "2":{ "Date" : "2018-09-16", "Spent":20 } 
} // Note keys are original db.a array indexes, 1 and 2

.dbsetter(f)
Specify setter for a collection.
When a setter function is specified for a collection (object or array), then the function will be called whenever a property is assigned on the object, and the return value will be used as the value to which the property is assigned. The magic property .dbsetter must be assigned a function that takes 3 parameters, firstly the property key (k), secondly the value that is being assigned (v), and lastly the optional collection (o). The .dbsetter magic property will be hidden and will not be enumerated if the collection is iterated or queried, but it’s value can be viewed if referred to directly. A setter is useful to enforce schema or constrain or validate the type of value that may be added to a collection, or to modify the value, or perform any other action, like updating another associated collection (for example reciprocal links in graph db), or to prevent duplicates, etc. If the value is not valid the setter function should throw an exception, which will make the property assignment fail. Be very careful to not assign the same property within the setter, because that will cause the setter to be called from the setter, which will cause a loop. Also be aware that returning nothing from the function will result in undefined being assigned, which will cause the value associated with the key to be deleted!
See examples below.

Performs table scan: No

Example:

db.o = {
"2018-09-13" : { "Spent":10 },
"2018-09-15" : { "Spent":30 },
"2018-09-16" : { "Spent":20 }
}
await db.aok();

db.o.dbsetter = function(k,v) { if(v.Spent !== undefined) { v.ok = true;  return v; } else { throw 'Object must has property named Spent!' };
await db.aok();

db.o["2018-09-16"] = 1234; //Fails with exception, not valid value

db.o["2018-09-17"] = { "Spent":1234 }
//db.o["2018-09-17"] will have the value { "Spent":1234, ok: true }

db.dbsetter = function(k,v) { if(k =='o') { throw "Please don't overwrite my collection!"} return v; };
await db.aok();

db.o = "oops"; //Assignment will be rejected

.dbeq(o)
db object/array reference equality
Tests whether this object/array is the exact same object/array as the parameter, by checking for reference equality in the database. See examples below.

Returns: true if the same object else false.
Performs table scan: No

Example:

let a1 = db.a; let a2 = db.a; 
let r = a1.dbeq(a2); //true

let b1 = db.b; 
r = a1.dbeq(b1); //false

.dbcomp(o)
db object/array reference comparison
Useful for sorting elements by internal db id/reference.
See examples below.

Returns: 1 if this id greater than parameter’s id, 0 if equeal, and -1 if less than. Returns -2 if parameter is not db object.
Performs table scan: No

Example:

let a1 = db.a; let a2 = db.a; 
let r = a1.dbcomp(a2); //returns 0

let b1 = db.b; 
r = a1.dbcomp(b1); //returns -1 (assuming b1 was created after a1)

let ar = [a1,b1];
let sorted = ar.sort(function(a, b) { return a.dbcomp(b); });

.dbeach(f,p)
each
Perform the passed function for each element in the collection.

Returns: The original collection.
Performs table scan: Yes

db.o = {
"2018-09-13" : { "Spent":10 },
"2018-09-15" : { "Spent":30 },
"2018-09-16" : { "Spent":20 }
}

db.add10percent = function() {
 db.o.dbeach((k, o) => o[k].Spent *= 1.1 );
}

db.addCustomPercent = function() {
 db.o.dbeach(function(k, o, p) { return o[k].Spent *= p }, 1.1 );
}

db.add10percent();