cmql-core.operators.operators — org.cmql/cmql-core 0.2.0-SNAPSHOT

* clj/s

(* & exprs)

$multiply Multiply numbers Call (* 1 2.3 5)

+ clj/s

(+ & es)

$add Add numbers or numbers(milliseconds) to dates Call (+_ 1 2) (+_ :adate (*_ 5 60 1000))

- clj/s

(- e-n)

(- e-n & es)

$substract Substract numbers or numbers(milliseconds) to dates Call (- 2 1) (- :adate (*_ 5 60 1000))

< clj/s

(< e1 e2)

$lt

<= clj/s

(<= e1 e2)

$lte

= clj/s

(= e1 e2 & es)

$eq Check for equality, works on all types

=sets clj/s

(=sets & args)

$setEquals

> clj/s

(> e1 e2)

$gt

>= clj/s

(>= e1 e2)

$gte

abs clj/s

(abs e-n)

$abs

all-true? clj/s

(all-true? e-array)

$allElementsTrue

and clj/s

(and & es)

$and Logical and,short circuit,false if one false/0/null/undefined

any-true? clj/s

(any-true? e-array)

$anyElementTrue

array? clj/s

(array? e-array)

$isArray

assoc clj/s

(assoc array-or-doc index value)

if the index/key is variable,i give it as {:key variable-e} or {:index variable-e}

assoc-in clj/s

(assoc-in array-or-doc indexes value)

assoc-object- clj/s

(assoc-object- doc key-e-string value-e)

avg clj/s

(avg group-or-array-e)

(avg e1 e2 & es)

$avg Can be used in $group $match if inside {$expr ...} $addFields=$set $project=$unset $replaceRoot=$replaceWith Ignores non numeric(doesnt count as members) if all non-numeric returns null Call (avg- e) ; the array is made from group 1e/member (avg- array) (avg- number1 number2 ...)

boolean clj/s

(boolean e)

$toBool

boolean? clj/s

(boolean? e)

bson-size clj/s

(bson-size e-doc)

ceil clj/s

(ceil e-n)

$ceil

cmp clj/s

(cmp e1 e2)

$cmp Compares value, works on all types Returns 1 if e1>e2 , -1 if e1<e2 , 0 if e1=e2

cmp-str-icase clj/s

(cmp-str-icase e1-string e2-string)

$strcasecmp string equality ignore case

compile-functions clj/s

(compile-functions f-name & f-names)

Compiles one cljs to one javascript function with the same name. The javascript function code,is saved in js/f-name.js The default location to look for js code

concat clj/s

(concat & e-arrays)

$concatArrays Concatenates arrays to return the concatenated array. If any of the argument is null returns null

cond clj/s

(cond & args)

$switch Call (cond- cond1 e1 ; cond1=boolean-e cond2 e2 ... :else en)

conj clj/s

(conj e-array e)

Like $push but implemented with concat- Not O(1) $push works only in group

conj-at clj/s

(conj-at ar index value)

conj-distinct clj/s

(conj-distinct e-array e)

Slow contains?- is not O(1) If order not important,add get distinct after

conj-each clj/s

(conj-each e)

$push Used only in $group Run 1 time/ member of the group Adds the member at the end of the acc array

conj-each-distinct clj/s

(conj-each-distinct e)

$addToSet Used only in $group Run 1 time/ member of the group Adds new member on the acc array only if not exists already

contains? clj/s

(contains? e-array e)

$in True is e is member(not index) of e-array

convert clj/s

(convert input-e e-type & args)

$convert Converts an expression to the type i specify using the type etype = double/string/objectId/bool/timestamp/date/int/long/decimal I can use the string representation of type or the number Call (convert- 1.99999 'bool') (convert- any-e 'bool' {:onError e1} {:onNull e2}) ;; optional

count clj/s

(count e-array)

$size

count-a clj/s

(count-a)

count-str clj/s

(count-str e-s)

$strLenCP

count-str-bytes clj/s

(count-str-bytes e-s)

date clj/s

(date e)

date-add clj/s

(date-add op-map)

$dateAdd

date-diff clj/s

(date-diff op-map)

$dateDiff

date-from-parts clj/s

(date-from-parts op-map)

$dateFromParts

date-from-string clj/s

(date-from-string date-str & options)

$dateFromString

date-hour clj/s

(date-hour e-date)

date-millisecond clj/s

(date-millisecond e-date)

date-minute clj/s

(date-minute e-date)

date-month clj/s

(date-month e-date)

date-second clj/s

(date-second e-date)

date-subtract clj/s

(date-subtract op-map)

$dateSubtract

date-to-parts clj/s

(date-to-parts op-map)

$dateToParts

date-to-string clj/s

(date-to-string op-map)

date-trunc clj/s

(date-trunc date-doc)

date-week clj/s

(date-week e-date)

date-year clj/s

(date-year e-date)

date? clj/s

(date? e)

day-of-month clj/s

(day-of-month e-date)

day-of-week clj/s

(day-of-week e-date)

day-of-year clj/s

(day-of-year e-date)

dec clj/s

(dec e)

decimal clj/s

(decimal e)

$toDecimal

decimal? clj/s

(decimal? e)

dense-rank clj/s

(dense-rank)

difference clj/s

(difference e-array1 e-array2)

$setDifference

disjoint? clj/s

(disjoint? e-array1 e-array2)

No common

dissoc clj/s

(dissoc array-or-doc index)

dissoc-in clj/s

(dissoc-in array-or-doc indexes)

div clj/s

(div e-n)

(div e-n & es)

$divide

double clj/s

(double e)

$toDouble

double? clj/s

(double? e)

ejs clj/s

(ejs njs-code)

(ejs f-name f-args & f-code)

Execute the javascript code,calls $function operator Used in 2 ways execute nested js => 1 argument execute code from file or argument => 2 or 3+ arguments

Call 1 argument

No wrappers 1 nested call (no need for njs use ejs with 3+ arguments directly) (ejs (njs f-name f-args f-code))

No wrappers 2 nested call (hard to read,use wrappers instead) (ejs :assoc_j [(njs :assoc_j [:myobject 'akey' 'avalue']) ;; doc after first call (nested) 'akey1' 'avalue1'])

Wrappers (here all functions use njs on their body)(usefull for nested calls) The prefered way,makes it look like regular MongoQL operator

(ejs (dissoc-j (assoc-j (assoc-j :mydoc 'e' 5) 'f' 6) 'f'))

assoc-j or dissoc-j wrapper uses njs (defn assoc-cj [doc k v] (njs :assoc_cj [doc k v]))

Call 2 arguments

Assumes that the js/fname.js already exists so no need for code (ejs :assoc_j [:myobject 'akey' 'avalue']

Call 3+ arguments

If javascript saves the code in js/fname.js If Clojurescript compiles and saves the code in js/fname.js Then execute the code,with $function (if code is given old-code is replaced if js/fname.js already existed)

fname(string/keyword),f-args vector,function-boy(each line can be 1 arg)

Javascript

(ejs :assoc_j [:myobject 'akey' 'avalue'] 'function assoc_j (a,k,v) {' ' a[k]=v; return a;}')

ClojureScript

(ejs :assoc_cj [:myobject 'akey' 'avalue'] '(defn assoc_cj [a k v] (do (aset a k v) a)))

empty? clj/s

(empty? e-array)

exists? clj/s

(exists? e)

$type True if field exists (not=_ (type- e) 'missing')

exp clj/s

(exp e-n)

$exp e(Euler’s number) pow e-n

expr clj/s

(expr aggregation-e)

$expr Converts an aggregate expression to a query expression For example i can use aggregate operators in a match stage Allows us to use aggregate operators instead of query operators

false? clj/s

(false? e)

filter clj/s

(filter cond-fn e-array)

$filter Call (filter (fn [:n.] (> :n. 0)) :myarray)

first clj/s

(first e-group)

$first Used only in $group Take the first member of the group. Only used at $group(in arrays i use (get- ar 0)) If data were sorted on the keys that i group by i take the smallest else random

floor clj/s

(floor e-n)

$floor

fn clj/s

(fn args body)

fn- like Clojure fn Used only in map/filter/reduce , only as argument Call (fn- [:avar.] ...) ; map/filter 1 arg (fn- [:avar. :bvar.] ...) ; reduce 2 args *if argument is :this. or :value. no let(reduce) and not :as(filter/map) , is used.

Reduce example (reduce (fn [:sum. :n.] (+ :sum. :n.)) [] :myarray)

get clj/s

(get array-or-doc index)

get-field clj/s

(get-field doc field)

get-in clj/s

(get-in array-or-doc indexes)

identity clj/s

(identity e)

returns its argument, useful when we want to use an array as argument

if- clj/s

(if- e-b e1 e2)

$cond Call (if- e-b e1 e2)

if-not clj/s

(if-not e-b e1 e2)

$cond e1 when e-b false Call (if-not e-b e1 e2)

if-not-value clj/s

(if-not-value e nill-e)

$ifNull Equivalent with (e nil or e not exist) (if- (not-value?- e) nill-e e)

inc clj/s

(inc e)

index-of clj/s

(index-of e-array e)

(index-of e-array e start)

(index-of e-array e start end)

$indexOfArray Returns the index of the matching member,or -1. I can search in a range only,of the array, for example from index=5 to index=10

index-of-in-bytes clj/s

(index-of-in-bytes e-s sub-e-s)

(index-of-in-bytes e-s sub-e-s start)

(index-of-in-bytes e-s sub-e-s start end)

$indexOfBytes UTF-8 byte index of the first occurrence or -1

index-of-str clj/s

(index-of-str e-s sub-e-s)

(index-of-str e-s sub-e-s start)

(index-of-str e-s sub-e-s start end)

$indexOfCP UTF-8 code point index of the first occurrence or -1

int clj/s

(int e)

$toInt

int? clj/s

(int? e)

intersection clj/s

(intersection & args)

$setIntersection

into clj/s

(into into-type array-or-doc-e)

iso-day-of-week clj/s

(iso-day-of-week e-date)

iso-week clj/s

(iso-week e-date)

iso-week-year clj/s

(iso-week-year e-date)

last clj/s

(last e-group)

$last Used only in $group Take the last member of the group. Only used at $group(in arrays i use (get- ar (-_ (count- ar) 1))) If data were sorted on the keys that i group by i take the largest else random

let clj/s

(let vars body)

$let Allows depended variables => generate minimun nested mongo $let Call (let- [:x- 2 :y- 1 :z- (+_ :y- :x-)] :z-)

leti clj/s

(leti vars body)

$let Not usefull,like let- but not allows dependent variables Call (leti- [:v1- e1 :v2- e2] e)

literal clj/s

(literal e)

$literal Used to show that it represents it self,without special MQL meaning. Call (literal- :a) => will mean a string '$a' not a field reference {$project {:myfield {$literal 1}}} => adds :myfield with value 1

ln clj/s

(ln e-n)

$ln

log clj/s

(log e-n)

(log e-n base)

$log log10 if no base

long clj/s

(long e)

$toLong

long? clj/s

(long? e)

lower-case clj/s

(lower-case e-s)

$toLower

map clj/s

(map map-fn e-array)

$map Call (map (fn [:n.] (+ :n. 1)) :myarray)

max clj/s

(max group-or-array-e)

(max e1 e2 & es)

$max Can be used in $group $match if inside {$expr ...} $addFields=$set $project=$unset $replaceRoot=$replaceWith Compares(using $cmp) and returns the max With 1 argument its always group or array, else >1 argument Call (max- e) ; the array is made from group 1e/member (max- array) (max- number1 number2 ...)

merge clj/s

(merge group-or-array-e)

(merge e1 e2 & es)

$mergeObjects

min clj/s

(min group-or-array-e)

(min e1 e2 & es)

$min Can be used in $group $match if inside {$expr ...} $addFields=$set $project=$unset $replaceRoot=$replaceWith Compares(using $cmp) and returns the min Call (min- e) ; the array is made from group 1e/member (min- array) (min- number1 number2 ...)

mod clj/s

(mod e1-n e2-n)

$mod

nil? clj/s

(nil? e)

njs clj/s

(njs f-name f-args & f-code)

Makes many nested javascirpt calls,1 javascript function => 1 $function call Its for optimization,and much faster. In MongoDB n nested calls => n $function calls Using njs it can be 1 $function call

Allows wrapping of js code,to make it look like MongoQL/Clojure code. The 3 nested calls will be 1 $function call,and looks like normal aggregation operators. (add 2 key-value pairs to a doc,and remove one)

(ejs (dissoc-j (assoc-j (assoc-j :mydoc 'e' 5) 'f' 6) 'f'))

After finishing with the nesting use ejs to execute the function. Call No wrapper,call it from query (ejs (njs f-name f-args f-code))

Wrapper call it on wrapper defn (here on njs no code is given assumes js/assoc_j.js exists) (defn assoc-j [doc k v] (njs :assoc_j [doc k v]))

Use the wrapper in the query (ejs (assoc-j :mydoc 'akey' 'avalue')

nor clj/s

(nor & es)

$not $or (not- (or- ...))

not clj/s

(not e)

$not Logical not,true if not (false/0/null/undefined)

not-disjoint? clj/s

(not-disjoint? e-array1 e-array2)

At least 1 common

not-empty? clj/s

(not-empty? e-array)

not-exists? clj/s

(not-exists? e)

True if field missing (=_ (type- e) 'missing')

not-value? clj/s

(not-value? e)

not= clj/s

(not= e1 e2)

(not= e1 e2 & es)

$ne

number? clj/s

(number? e)

object-id clj/s

(object-id e)

$toObjectId

object-id? clj/s

(object-id? e)

object? clj/s

(object? e)

operators-mappings clj/s

or clj/s

(or & es)

$or Logical or,short circuit,false all false/0/null/undefined

pow clj/s

(pow e1-n e2-n)

$pow

rand clj/s

(rand)

range clj/s

(range end-e-integer)

(range start-e-integer end-e-integer)

(range start-e-integer end-e-integer step-e-integer)

$range Produces array of integers range(start end step) step defaults to 1 start defaults to 0

rank clj/s

(rank)

re-find clj/s

(re-find pattern-expression string-s-expression)

(re-find pattern-expression string-s-expression options)

$regexFind

re-find? clj/s

(re-find? pattern-expression string-s-expression)

(re-find? pattern-expression string-s-expression options)

$regexMatch

re-seq clj/s

(re-seq pattern-expression string-s-expression)

(re-seq pattern-expression string-s-expression options)

$regexFindAll

reduce clj/s

(reduce in-rfn init-e input-e-array)

$reduce Call (reduce- (fn [:sum. :n.] (+ :sum. :n.)) [] :myarray)

regex? clj/s

(regex? e)

replace clj/s

(replace s str-e replacement)

$replaceOne match is string not pattern

replace-all clj/s

(replace-all s str-e replacement)

$replaceAll match is string not pattern

reverse clj/s

(reverse e-array)

$reverseArray reverses an array,if null => null

round clj/s

(round e-n)

(round e-n place-e-n)

$round e-n integer, double, decimal, or long place-e-n = -20 < e-n < 100 default=0 if missing

set-field clj/s

(set-field doc field value)

some? clj/s

(some? e)

True if not nil

split clj/s

(split e1-string e2-string)

$split splits on e2-string(no regex) returns array

sqrt clj/s

(sqrt e-n)

$sqrt

stdDevPop clj/s

(stdDevPop group-or-array-e)

(stdDevPop e1 e2 & es)

$stdDevPop

stdDevSamp clj/s

(stdDevSamp group-or-array-e)

(stdDevSamp e1 e2 & es)

$stdDevSamp

str clj/s

(str & es-s)

$concat Concatenates any number of strings,if 1 or more null => null

string clj/s

(string e)

$toString

string? clj/s

(string? e)

subs clj/s

(subs e-s start-e-n)

(subs e-s start-e-n end-e-n)

$substrCP Take the substring,starting from start to end UTF8 indexes Counts in UTF-8 code points,negatives indexes are not allowed Call like Clojure's subs (subs s start) ;; end=string size (subs s start end)

subs-bytes clj/s

(subs-bytes e-s start-e-n end-e-n)

$substrBytes Take the substring,starting from start to end BYTES indexes Counts in BYTES,negatives indexes are not allowed Call like Clojure's subs (subs s start) ;; end=string size (subs s start end)

subset? clj/s

(subset? subset-e-array1 e-array2)

$setIsSubset

subvec clj/s

(subvec e-array start-e-n)

(subvec e-array start-e-n end-e-n)

uses $slic but works like clojure subvec Call (subvec [1 2 3 4 5 6 7] 2 4) = 3,4 Limit cases start>count => empty array (slice do that alone) Doesn't do circles if index>count,just takes till the end cMQL's take works like slice,see take

sum clj/s

(sum group-or-array-e)

(sum e1 e2 & es)

$sum Can be used in $group $match if inside {$expr ...} $addFields=$set $project=$unset $replaceRoot=$replaceWith Ignores non numeric,if all non-numeric returns 0 Call (sum- e) ; the array is made from group 1e/member (sum- array) (sum- number1 number2 ...)

take clj/s

(take n e-array)

(take start-index n e-array)

$slice works like MQL slice,instead of indexes we give number of elements we want but different argument order

take-str clj/s

(take-str n e-str)

(take-str start-index n e-str)

$substrCP works like MQL substrCP, but different argument order

trim clj/s

(trim e-string)

(trim e-string trim-e-string)

$trim Deletes the characters ofr trim-e-string from the end and from start Character order in trim-e-string is ignored,its char1 or char2 ... and i can have multiple matches.Stop deleting when no match. for example gggddeee ged will reutrn '' delete all chars

triml clj/s

(triml e-string)

(triml e-string trim-e-string)

$ltrim Deletes the characters ofr trim-e-string from the start Character order in trim-e-string is ignored,its char1 or char2 ... and i can have multiple matches.Stop deleting when no match. for example gggddeee ged will reutrn '' delete all chars

trimr clj/s

(trimr e-string)

(trimr e-string trim-e-string)

$rtrim Deletes the characters ofr trim-e-string from the end Character order in trim-e-string is ignored,its char1 or char2 ... and i can have multiple matches.Stop deleting when no match. for example gggddeee ged will reutrn '' delete all chars

true? clj/s

(true? e)

trunc clj/s

(trunc e-n)

(trunc e-n place-e-n)

$trunc e-n integer, double, decimal, or long place-e-n = -20 < e-n < 100 default=0 if missing like round,but just removes,not round

type clj/s

(type e)

$type Returns a string representation of the argument type

union clj/s

(union & args)

$setUnion

unset-field clj/s

(unset-field doc field)

upper-case clj/s

(upper-case e-s)

$toUpper

value? clj/s

(value? e)

ziparray clj/s

(ziparray & args)

$zip Arguments are arrays. [[firsts of all arrays] [seconds of all arays] ...] if array not same sizes,the nth values dont added to result at all if useLongestLength (default is false) results = largest array size else results = smaller array size(if i dont have from not added in result) If not useLongestLength i always have elements to add from all arrays. If useLongestLength i give defaults,else defaults = [nil ...] defaults = defaults must have the same size as the number of arrays array that i take elements in order,to add to smaller arrays Call (ziparray- [a1 a2 a3] [b1 b2 b3] [c1 c2 c3]) => [[a1 b1 c1] [a2 b2 c2] [a3 b3 c3]