com.foursquare.rogue.QueryField.scala Maven / Gradle / Ivy
The newest version!
// Copyright 2011 Foursquare Labs Inc. All Rights Reserved.
package com.foursquare.rogue
import com.mongodb.DBObject
import java.util.Calendar
import java.util.regex.Pattern
import net.liftweb.common.{Box, Full, Empty}
import net.liftweb.json.JsonAST.{JInt, JValue, JArray}
import net.liftweb.mongodb.record.{BsonRecord, MongoId, MongoRecord}
import net.liftweb.mongodb.record.field.{BsonRecordField, BsonRecordListField, MongoCaseClassField, MongoCaseClassListField}
import net.liftweb.record.{Field, MandatoryTypedField, OptionalTypedField}
import net.liftweb.record.field.EnumField
import org.bson.types.ObjectId
import org.joda.time.DateTime
import scala.util.matching.Regex
object CondOps extends Enumeration(0, "$ne", "$lt", "$gt", "$lte", "$gte",
"$in", "$nin", "$near", "$all", "$size",
"$exists", "$type", "$mod") {
type Op = Value
val Ne, Lt, Gt, LtEq, GtEq, In, Nin, Near, All, Size, Exists, Type, Mod = Value
}
object ModOps extends Enumeration(0, "$inc", "$set", "$unset", "$push", "$pushAll",
"$addToSet", "$pop", "$pull", "$pullAll", "$bit",
"$rename") {
type Op = Value
val Inc, Set, Unset, Push, PushAll, AddToSet, Pop, Pull, PullAll, Bit, Rename = Value
}
object MongoType extends Enumeration {
type MongoType = Value
val Double = Value(1)
val String = Value(2)
val Object = Value(3)
val Array = Value(4)
val Binary = Value(5)
val ObjectId = Value(7)
val Boolean = Value(8)
val Date = Value(9)
val Null = Value(10)
val RegEx = Value(11)
val JavaScript = Value(13)
val Symbol = Value(15)
val Int32 = Value(16)
val Timestamp = Value(17)
val Int64 = Value(18)
val MaxKey = Value(127)
val MinKey = Value(255)
}
// ********************************************************************************
// *** Query fields
// ********************************************************************************
//
// The types of fields that can be queried, and the particular query operations that each supports
// are defined below.
abstract class AbstractQueryField[V, DB, M <: BsonRecord[M]](val field: Field[V, M]) {
def valueToDB(v: V): DB
def valuesToDB(vs: Traversable[V]) = vs.map(valueToDB _)
def eqs(v: V) = EqClause(field.name, valueToDB(v))
def neqs(v: V) = new NeQueryClause(field.name, valueToDB(v))
def in[L <% Traversable[V]](vs: L) = QueryHelpers.inListClause(field.name, valuesToDB(vs))
def nin[L <% Traversable[V]](vs: L) = new NinQueryClause(field.name, QueryHelpers.validatedList(valuesToDB(vs)))
def lt(v: V) = new LtQueryClause(field.name, valueToDB(v))
def gt(v: V) = new GtQueryClause(field.name, valueToDB(v))
def lte(v: V) = new LtEqQueryClause(field.name, valueToDB(v))
def gte(v: V) = new GtEqQueryClause(field.name, valueToDB(v))
def <(v: V) = lt(v)
def <=(v: V) = lte(v)
def >(v: V) = gt(v)
def >=(v: V) = gte(v)
def between(v1: V, v2: V) =
new BetweenQueryClause(field.name, valueToDB(v1), valueToDB(v2))
}
class QueryField[V, M <: BsonRecord[M]](field: Field[V, M])
extends AbstractQueryField[V, V, M](field) {
override def valueToDB(v: V) = v
def exists(b: Boolean) = new ExistsQueryClause(field.name, b)
def hastype(t: MongoType.Value) = new TypeQueryClause(field.name, t)
}
class CalendarQueryField[M <: BsonRecord[M]](val field: Field[java.util.Calendar, M]) {
def before(d: DateTime) = new LtQueryClause(field.name, d.toDate)
def after(d: DateTime) = new GtQueryClause(field.name, d.toDate)
def between(d1: DateTime, d2: DateTime) = new StrictBetweenQueryClause(field.name, d1.toDate, d2.toDate)
def between(range: (DateTime, DateTime)) = new StrictBetweenQueryClause(field.name, range._1.toDate, range._2.toDate)
}
class EnumNameQueryField[M <: BsonRecord[M], E <: Enumeration#Value](field: Field[E, M])
extends AbstractQueryField[E, String, M](field) {
override def valueToDB(e: E) = e.toString
}
class EnumIdQueryField[M <: BsonRecord[M], E <: Enumeration](field: EnumField[M, E])
extends AbstractQueryField[E#Value, Int, M](field) {
override def valueToDB(e: E#Value) = e.id
}
class GeoQueryField[M <: BsonRecord[M]](field: Field[LatLong, M])
extends AbstractQueryField[LatLong, java.util.List[Double], M](field) {
override def valueToDB(ll: LatLong) =
QueryHelpers.list(List(ll.lat, ll.long))
def eqs(lat: Double, lng: Double) =
EqClause(field.name, QueryHelpers.list(List(lat, lng)))
def neqs(lat: Double, lng: Double) =
new NeQueryClause(field.name, QueryHelpers.list(List(lat, lng)))
def near(lat: Double, lng: Double, radius: Degrees) =
new NearQueryClause(field.name, QueryHelpers.list(List(lat, lng, QueryHelpers.radius(radius))))
def withinCircle(lat: Double, lng: Double, radius: Degrees) =
new WithinCircleClause(field.name, lat, lng, QueryHelpers.radius(radius))
def withinBox(lat1: Double, lng1: Double, lat2: Double, lng2: Double) =
new WithinBoxClause(field.name, lat1, lng1, lat2, lng2)
}
abstract class AbstractNumericQueryField[V, DB, M <: BsonRecord[M]](field: Field[V, M])
extends AbstractQueryField[V, DB, M](field) {
def mod(by: Int, eq: Int) =
new ModQueryClause(field.name, QueryHelpers.list(List(by, eq)))
}
class NumericQueryField[V, M <: BsonRecord[M]](field: Field[V, M])
extends AbstractNumericQueryField[V, V, M](field) {
override def valueToDB(v: V) = v
}
class ObjectIdQueryField[M <: BsonRecord[M]](override val field: Field[ObjectId, M])
extends NumericQueryField(field) {
def before(d: DateTime) =
new LtQueryClause(field.name, new ObjectId(d.toDate, 0, 0))
def after(d: DateTime) =
new GtQueryClause(field.name, new ObjectId(d.toDate, 0, 0))
def between(d1: DateTime, d2: DateTime) =
new StrictBetweenQueryClause(field.name, new ObjectId(d1.toDate, 0, 0), new ObjectId(d2.toDate, 0, 0))
def between(range: (DateTime, DateTime)) =
new StrictBetweenQueryClause(field.name, new ObjectId(range._1.toDate, 0, 0), new ObjectId(range._2.toDate, 0, 0))
}
class ForeignObjectIdQueryField[M <: BsonRecord[M], T <: MongoRecord[T]
with MongoId[T]](override val field: Field[ObjectId, M]
with HasMongoForeignObjectId[T])
extends ObjectIdQueryField[M](field) {
def eqs(obj: T) =
EqClause(field.name, obj.id)
def neqs(obj: T) =
new NeQueryClause(field.name, obj.id)
def in(objs: Traversable[T]) =
QueryHelpers.inListClause(field.name, objs.map(_.id))
def nin(objs: Traversable[T]) =
new NinQueryClause(field.name, QueryHelpers.validatedList(objs.map(_.id)))
}
class StringQueryField[M <: BsonRecord[M]](val field: Field[String, M]) {
def startsWith(s: String): RegexQueryClause[PartialIndexScan] =
new RegexQueryClause[PartialIndexScan](field.name, PartialIndexScan, Pattern.compile("^" + Pattern.quote(s)))
def matches(p: Pattern): RegexQueryClause[DocumentScan] =
new RegexQueryClause[DocumentScan](field.name, DocumentScan, p)
def matches(r: Regex): RegexQueryClause[DocumentScan] =
matches(r.pattern)
def regexWarningNotIndexed(p: Pattern) =
matches(p)
}
class CaseClassQueryField[V, M <: BsonRecord[M]](val field: MongoCaseClassField[M, V]) {
def unsafeField[F](name: String): SelectableDummyField[F, M] =
new SelectableDummyField[F, M](field.owner, field.name + "." + name)
}
class BsonRecordQueryField[M <: BsonRecord[M], B <: BsonRecord[B]](field: BsonRecordField[M, B])
extends AbstractNumericQueryField[B, DBObject, M](field) {
override def valueToDB(b: B) = b.asDBObject
def subfield[V](subfield: B => Field[V, B]): SelectableDummyField[V, M] = {
val rec = field.defaultValue // a hack to get at the embedded record
new SelectableDummyField[V, M](field.owner, field.name + "." + subfield(rec).name)
}
def subselect[V](f: B => Field[V, B]): SelectableDummyField[V, M] = subfield(f)
def unsafeField[F](name: String): DummyField[F, M] = {
new DummyField[F, M](field.owner, field.name + "." + name)
}
}
// This class is a hack to get $pull working for lists of objects. In that case,
// the $pull should look like:
// "$pull" : { "field" : { "subfield" : { "$gt" : 3 }}}
// whereas for normal queries, the same query would look like:
// { "field.subfield" : { "$gt" : 3 }}
// So, normally, we need to just have one level of nesting, but here we want two.
class BsonRecordQueryFieldInPullContext[M <: BsonRecord[M], B <: BsonRecord[B]]
(field: Field[B, M] with MandatoryTypedField[B])
extends AbstractNumericQueryField[B, DBObject, M](field) {
override def valueToDB(b: B) = b.asDBObject
def subfield[V](subfield: B => Field[V, B]): SelectableDummyField[V, M] = {
val rec = field.defaultValue // a hack to get at the embedded record
new SelectableDummyField[V, M](field.owner, subfield(rec).name)
}
}
abstract class AbstractListQueryField[V, DB, M <: BsonRecord[M]](val field: Field[List[V], M]) {
def valueToDB(v: V): DB
def valuesToDB(vs: Traversable[V]) = vs.map(valueToDB _)
def all(vs: Traversable[V]) =
QueryHelpers.allListClause(field.name, valuesToDB(vs))
def in(vs: Traversable[V]) =
QueryHelpers.inListClause(field.name, valuesToDB(vs))
def nin(vs: Traversable[V]) =
new NinQueryClause(field.name, QueryHelpers.validatedList(valuesToDB(vs)))
def size(s: Int) =
new SizeQueryClause(field.name, s)
def contains(v: V) =
EqClause(field.name, valueToDB(v))
def notcontains(v: V) =
new NeQueryClause(field.name, valueToDB(v))
def at(i: Int): DummyField[V, M] =
new DummyField[V, M](field.owner, field.name + "." + i.toString)
def idx(i: Int): DummyField[V, M] = at(i)
}
class ListQueryField[V, M <: BsonRecord[M]](field: Field[List[V], M])
extends AbstractListQueryField[V, V, M](field) {
override def valueToDB(v: V) = v
}
class CaseClassListQueryField[V, M <: BsonRecord[M]](field: MongoCaseClassListField[M, V])
extends AbstractListQueryField[V, DBObject, M](field) {
override def valueToDB(v: V) = QueryHelpers.asDBObject(v)
def unsafeField[F](name: String): SelectableDummyField[List[F], M] =
new SelectableDummyField[List[F], M](field.owner, field.name + "." + name)
}
class BsonRecordListQueryField[M <: BsonRecord[M], B <: BsonRecord[B]](field: BsonRecordListField[M, B])
extends AbstractListQueryField[B, DBObject, M](field) {
override def valueToDB(b: B) = b.asDBObject
def subfield[V, V1](subfield: B => Field[V, B])(implicit ev: Rogue.Flattened[V, V1]): SelectableDummyField[List[V1], M] = {
val rec = field.setFromJValue(JArray(JInt(0) :: Nil)).open_!.head // a gross hack to get at the embedded record
new SelectableDummyField[List[V1], M](field.owner, field.name + "." + subfield(rec).name)
}
def subselect[V, V1](f: B => Field[V, B])(implicit ev: Rogue.Flattened[V, V1]): SelectField[Box[List[V1]], M] = {
Rogue.optionalFieldToSelectField(subfield(f))
}
def unsafeField[F](name: String): DummyField[F, M] = {
new DummyField[F, M](field.owner, field.name + "." + name)
}
}
class MapQueryField[V, M <: BsonRecord[M]](val field: Field[Map[String, V], M]) {
def at(key: String): SelectableDummyField[V, M] =
new SelectableDummyField[V, M](field.owner, field.name + "." + key)
}
class EnumerationListQueryField[V <: Enumeration#Value, M <: BsonRecord[M]](field: Field[List[V], M])
extends AbstractListQueryField[V, String, M](field) {
override def valueToDB(v: V) = v.toString
}
// ********************************************************************************
// *** Modify fields
// ********************************************************************************
abstract class AbstractModifyField[V, DB, M <: BsonRecord[M]](val field: Field[V, M]) {
def valueToDB(v: V): DB
def setTo(v: V) = new ModifyClause(ModOps.Set, field.name -> valueToDB(v))
def unset = new ModifyClause(ModOps.Unset, field.name -> 1)
def rename(newName: String) = new ModifyClause(ModOps.Rename, field.name -> newName)
}
class ModifyField[V, M <: BsonRecord[M]](field: Field[V, M])
extends AbstractModifyField[V, V, M](field) {
def valueToDB(v: V) = v
}
class CalendarModifyField[M <: BsonRecord[M]](field: Field[Calendar, M])
extends AbstractModifyField[Calendar, java.util.Date, M](field) {
override def valueToDB(c: Calendar) = c.getTime
def setTo(d: DateTime) = new ModifyClause(ModOps.Set, field.name -> d.toDate)
}
class EnumerationModifyField[M <: BsonRecord[M], E <: Enumeration#Value](field: Field[E, M])
extends AbstractModifyField[E, String, M](field) {
override def valueToDB(e: E) = e.toString
}
class GeoModifyField[M <: BsonRecord[M]](field: Field[LatLong, M])
extends AbstractModifyField[LatLong, java.util.List[Double], M](field) {
override def valueToDB(ll: LatLong) =
QueryHelpers.list(List(ll.lat, ll.long))
def setTo(lat: Double, long: Double) =
new ModifyClause(ModOps.Set,
field.name -> QueryHelpers.list(List(lat, long)))
}
class NumericModifyField[V, M <: BsonRecord[M]](val field: Field[V, M]) {
def inc(v: V) = new ModifyClause(ModOps.Inc, field.name -> v)
def bitAnd(v: V) = new ModifyBitAndClause(field.name, v)
def bitOr(v: V) = new ModifyBitOrClause(field.name, v)
}
class BsonRecordModifyField[M <: BsonRecord[M], B <: BsonRecord[B]](field: Field[B, M])
extends AbstractModifyField[B, DBObject, M](field) {
override def valueToDB(b: B) = b.asDBObject
}
class MapModifyField[V, M <: BsonRecord[M]](field: Field[Map[String, V], M])
extends AbstractModifyField[Map[String, V], java.util.Map[String, V], M](field) {
override def valueToDB(m: Map[String, V]) = QueryHelpers.makeJavaMap(m)
}
abstract class AbstractListModifyField[V, DB, M <: BsonRecord[M]](val field: Field[List[V], M]) {
def valueToDB(v: V): DB
def valuesToDB(vs: Traversable[V]) = vs.map(valueToDB _)
def setTo(vs: Traversable[V]) =
new ModifyClause(ModOps.Set,
field.name -> QueryHelpers.list(valuesToDB(vs)))
def push(v: V) =
new ModifyClause(ModOps.Push,
field.name -> valueToDB(v))
def pushAll(vs: Traversable[V]) =
new ModifyClause(ModOps.PushAll,
field.name -> QueryHelpers.list(valuesToDB(vs)))
def addToSet(v: V) =
new ModifyClause(ModOps.AddToSet,
field.name -> valueToDB(v))
def addToSet(vs: Traversable[V]) =
new ModifyAddEachClause(field.name, valuesToDB(vs))
def popFirst =
new ModifyClause(ModOps.Pop, field.name -> -1)
def popLast =
new ModifyClause(ModOps.Pop, field.name -> 1)
def pull(v: V) =
new ModifyClause(ModOps.Pull,
field.name -> valueToDB(v))
def pullAll(vs: Traversable[V]) =
new ModifyClause(ModOps.PullAll,
field.name -> QueryHelpers.list(valuesToDB(vs)))
def $: Field[V, M] = new DummyField[V, M](field.owner, field.name + ".$")
def pullWhere(clauseFuncs: (Field[V, M] => QueryClause[_])*) =
new ModifyPullWithPredicateClause(field.name,
clauseFuncs.map(cf => cf(new DummyField[V, M](field.owner, field.name))): _*)
}
class ListModifyField[V, M <: BsonRecord[M]](field: Field[List[V], M])
extends AbstractListModifyField[V, V, M](field) {
override def valueToDB(v: V) = v
}
class CaseClassListModifyField[V, M <: BsonRecord[M]](field: MongoCaseClassListField[M, V])
extends AbstractListModifyField[V, DBObject, M](field) {
override def valueToDB(v: V) = QueryHelpers.asDBObject(v)
}
class EnumerationListModifyField[V <: Enumeration#Value, M <: BsonRecord[M]](field: Field[List[V], M])
extends AbstractListModifyField[V, String, M](field) {
override def valueToDB(v: V) = v.toString
}
class BsonRecordListModifyField[M <: BsonRecord[M], B <: BsonRecord[B]](field: Field[List[B], M])(implicit mf: Manifest[B])
extends AbstractListModifyField[B, DBObject, M](field) {
override def valueToDB(b: B) = b.asDBObject
override def $: BsonRecordField[M, B] = {
val rec = field.setFromJValue(JArray(JInt(0) :: Nil)).open_!.head // a gross hack to get at the embedded record
new BsonRecordField[M, B](field.owner, rec.meta)(mf) {
override def name = field.name + ".$"
}
}
def pullObjectWhere[V](clauseFuncs: BsonRecordQueryFieldInPullContext[M, B] => QueryClause[_]*) = {
val rec = field.setFromJValue(JArray(JInt(0) :: Nil)).open_!.head // a gross hack to get at the embedded record
new ModifyPullObjWithPredicateClause(
field.name,
clauseFuncs.map(cf => cf(
new BsonRecordQueryFieldInPullContext(
new MandatoryDummyField[B, M](field.owner, field.name, rec)))): _*)
}
}
// ********************************************************************************
// *** Select fields
// ********************************************************************************
abstract class SelectField[V, M <: BsonRecord[M]](val field: Field[_, M]) {
// Input will be a Box of the value, and output will either be a Box of the value or the value itself
def apply(v: Any): Any
}
class MandatorySelectField[V, M <: BsonRecord[M]](override val field: Field[V, M] with MandatoryTypedField[V])
extends SelectField[V, M](field) {
override def apply(v: Any): Any = v.asInstanceOf[Box[V]].openOr(field.defaultValue)
}
class OptionalSelectField[V, M <: BsonRecord[M]](override val field: Field[V, M] with OptionalTypedField[V])
extends SelectField[Box[V], M](field) {
override def apply(v: Any): Any = v.asInstanceOf[Box[V]]
}
// ********************************************************************************
// *** Dummy field
// ********************************************************************************
trait AbstractDummyField[V, M <: BsonRecord[M]] extends Field[V, M] {
override val asJValue = null
override val asJs = null
override val toForm = Empty
override def toBoxMyType(v: ValueType): Box[V] = Empty
override def toValueType(v: Box[MyType]) = null.asInstanceOf[ValueType]
override def defaultValueBox = Empty
override def set(v: ValueType) = v
override def get = null.asInstanceOf[ValueType]
override def is = get
override def apply(v: V) = owner
override def setFromAny(a: Any) = Empty
override def setFromString(s: String) = Empty
override def setFromJValue(jv: JValue) = Empty
override def liftSetFilterToBox(in: Box[MyType]): Box[MyType] = Empty
}
class DummyField[V, M <: BsonRecord[M]](override val owner: M, override val name: String)
extends AbstractDummyField[V, M]
class SelectableDummyField[V, M <: BsonRecord[M]](override val owner: M, override val name: String)
extends OptionalTypedField[V]
with AbstractDummyField[V, M]
class MandatoryDummyField[V, M <: BsonRecord[M]](override val owner: M,
override val name: String,
override val defaultValue: V)
extends MandatoryTypedField[V] with AbstractDummyField[V, M] {
override def set(v: MyType) = v
override def toBoxMyType(v: ValueType): Full[V] = Full(v)
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy