# ~~~json
# {field: {$<name>: <value>} }
# ~~~
- fun op(name: String, field: nullable String, value: nullable Jsonable): MongoMatch do
+ fun op(name: String, field: nullable String, value: nullable Serializable): MongoMatch do
if field != null then
var q = new JsonObject
q["${name}"] = value
self[field] = q
else
- self[name] = value
+ self["${name}"] = value
end
return self
end
# ~~~json
# {field: {$eq: value} }
# ~~~
- fun eq(field: String, value: nullable Jsonable): MongoMatch do
+ fun eq(field: String, value: nullable Serializable): MongoMatch do
self[field] = value
return self
end
# ~~~json
# {field: {$ne: value} }
# ~~~
- fun ne(field: String, value: nullable Jsonable): MongoMatch do
+ fun ne(field: String, value: nullable Serializable): MongoMatch do
op("ne", field, value)
return self
end
# ~~~json
# {field: {$gt: value} }
# ~~~
- fun gt(field: String, value: nullable Jsonable): MongoMatch do
+ fun gt(field: String, value: nullable Serializable): MongoMatch do
op("gt", field, value)
return self
end
# ~~~json
# {field: {$gte: value} }
# ~~~
- fun gte(field: String, value: nullable Jsonable): MongoMatch do
+ fun gte(field: String, value: nullable Serializable): MongoMatch do
op("gte", field, value)
return self
end
# ~~~json
# {field: {$lt: value} }
# ~~~
- fun lt(field: String, value: nullable Jsonable): MongoMatch do
+ fun lt(field: String, value: nullable Serializable): MongoMatch do
op("lt", field, value)
return self
end
# ~~~json
# {field: {$lte: value} }
# ~~~
- fun lte(field: String, value: nullable Jsonable): MongoMatch do
+ fun lte(field: String, value: nullable Serializable): MongoMatch do
op("lte", field, value)
return self
end
#
# `$in` selects the documents where the value of a field equals any value
# in the specified array.
- fun is_in(field: String, values: Array[nullable Jsonable]): MongoMatch do
- op("$in", field, new JsonArray.from(values))
+ fun is_in(field: String, values: Array[nullable Serializable]): MongoMatch do
+ op("in", field, new JsonArray.from(values))
return self
end
# `$nin` selects the documents where:
# * the field value is not in the specified array or
# * the field does not exist.
- fun is_nin(field: String, values: Array[nullable Jsonable]): MongoMatch do
- op("$nin", field, new JsonArray.from(values))
+ fun is_nin(field: String, values: Array[nullable Serializable]): MongoMatch do
+ op("nin", field, new JsonArray.from(values))
+ return self
+ end
+
+ # Logical `or`
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/or/#op._S_or
+ #
+ # The `$or` operator performs a logical OR operation on an array of two or
+ # more `expressions` and selects the documents that satisfy at least one of
+ # the `expressions`.
+ #
+ # The `$or` has the following syntax:
+ #
+ # ~~~json
+ # { field: { $or: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
+ # ~~~
+ fun lor(field: nullable String, expressions: Array[Serializable]): MongoMatch do
+ op("or", field, new JsonArray.from(expressions))
+ return self
+ end
+
+ # Logical `and`
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/and/#op._S_and
+ #
+ # The `$and` operator performs a logical AND operation on an array of two or
+ # more `expressions` and selects the documents that satisfy all of the `expressions`.
+ #
+ # The `$and` has the following syntax:
+ #
+ # ~~~json
+ # { field: { $and: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
+ # ~~~
+ fun land(field: nullable String, expressions: Array[Serializable]): MongoMatch do
+ op("and", field, new JsonArray.from(expressions))
+ return self
+ end
+
+ # Logical `not`
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/not/#op._S_not
+ #
+ # `$not` performs a logical NOT operation on the specified `expression` and
+ # selects the documents that do not match the `expression`.
+ # This includes documents that do not contain the field.
+ #
+ # The $not has the following syntax:
+ #
+ # ~~~json
+ # { field: { $not: { <expression> } } }
+ # ~~~
+ fun lnot(field: nullable String, expression: Serializable): MongoMatch do
+ op("not", field, expression)
+ return self
+ end
+
+ # Logical `nor`
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/nor/#op._S_nor
+ #
+ # `$nor` performs a logical NOR operation on an array of one or more query
+ # expression and selects the documents that fail all the query expressions
+ # in the array.
+ #
+ # The $nor has the following syntax:
+ #
+ # ~~~json
+ # { field: { $nor: [ { <expression1> }, { <expression2> }, ... , { <expressionN> } ] } }
+ # ~~~
+ fun lnor(field: nullable String, expressions: Array[Serializable]): MongoMatch do
+ op("nor", field, new JsonArray.from(expressions))
+ return self
+ end
+
+ # Array contains all
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/all/#op._S_all
+ #
+ # `$all` selects the documents where the value of a field is an array that
+ # contains all the specified elements.
+ #
+ # ~~~json
+ # { field: { $all: [ <value1>, <value2>, ... ] } }
+ # ~~~
+ fun all(field: nullable String, values: Array[Serializable]): MongoMatch do
+ op("all", field, new JsonArray.from(values))
+ return self
+ end
+
+ # Array element match
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/elemMatch/#op._S_elemMatch
+ #
+ # `$elemMatch` matches documents that contain an array field with at least
+ # one element that matches all the specified query criteria.
+ #
+ # ~~~json
+ # { field: { $elemMatch: <query> } }
+ # ~~~
+ fun elem_match(field: nullable String, query: Serializable): MongoMatch do
+ op("elemMatch", field, query)
+ return self
+ end
+
+ # Array size match
+ #
+ # https://docs.mongodb.com/manual/reference/operator/query/size/#op._S_size
+ #
+ # `$size` matches any array with the number of elements specified by the argument
+ #
+ # ~~~json
+ # { field: { $size: <size> } }
+ # ~~~
+ fun size(field: nullable String, size: Int): MongoMatch do
+ op("size", field, size)
return self
end
end
# ~~~json
# { $<stage>: <json> }
# ~~~
- fun add_stage(stage: String, json: Jsonable): MongoPipeline do
+ fun add_stage(stage: String, json: Serializable): MongoPipeline do
var obj = new JsonObject
obj["${stage}"] = json
add obj
# { $group: { <group> } }
# ~~~
fun group(group: MongoGroup): MongoPipeline do return add_stage("group", group)
+
+ # Apply unwind
+ #
+ # https://docs.mongodb.com/manual/reference/operator/aggregation/unwind/
+ #
+ # Deconstructs an array field from the input documents to output a document
+ # for each element.
+ # Each output document is the input document with the value of the array
+ # field replaced by the element.
+ #
+ # ~~~json
+ # { $unwind: <field path> }
+ # ~~~
+ fun unwind(path: String): MongoPipeline do return add_stage("unwind", path)
end
# Mongo pipeline group stage
# ~~~json
# <field>: { <accumulator> : <expression> }
# ~~~
- private fun acc(name: String, field: String, expression: nullable Jsonable): MongoGroup do
+ private fun acc(name: String, field: String, expression: nullable Serializable): MongoGroup do
var q = new JsonObject
q["${name}"] = expression
self[field] = q
# ~~~
#
# `$sum` ignores non-numeric values.
- fun sum(field: String, expression: Jsonable): MongoGroup do
+ fun sum(field: String, expression: Serializable): MongoGroup do
return acc("sum", field, expression)
end
# ~~~
#
# `$avg` ignores non-numeric values.
- fun avg(field: String, expression: Jsonable): MongoGroup do
+ fun avg(field: String, expression: Serializable): MongoGroup do
return acc("avg", field, expression)
end
#
# `$max` compares both value and type, using the specified BSON comparison
# order for values of different types.
- fun max(field: String, expression: Jsonable): MongoGroup do
+ fun max(field: String, expression: Serializable): MongoGroup do
return acc("max", field, expression)
end
#
# `$min` compares both value and type, using the specified BSON comparison
# order for values of different types.
- fun min(field: String, expression: Jsonable): MongoGroup do
+ fun min(field: String, expression: Serializable): MongoGroup do
return acc("min", field, expression)
end
# document in a group of documents that share the same group by key.
#
# Only meaningful when documents are in a defined order.
- fun first(field: String, expression: Jsonable): MongoGroup do
+ fun first(field: String, expression: Serializable): MongoGroup do
return acc("first", field, expression)
end
# document in a group of documents that share the same group by key.
#
# Only meaningful when documents are in a defined order.
- fun last(field: String, expression: Jsonable): MongoGroup do
+ fun last(field: String, expression: Serializable): MongoGroup do
return acc("last", field, expression)
end
#
# Returns an array of all values that result from applying an expression to
# each document in a group of documents that share the same group by key.
- fun push(field: String, expr: Jsonable): MongoGroup do
+ fun push(field: String, expr: Serializable): MongoGroup do
return acc("push", field, expr)
end
# group by key.
#
# Order of the elements in the output array is unspecified.
- fun addToSet(field: String, expr: Jsonable): MongoGroup do
+ fun addToSet(field: String, expr: Serializable): MongoGroup do
return acc("addToSet", field, expr)
end
end