MongoDocumentMeta

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit lazy val _formats: Formats

lazy val allFormats: Formats

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def codecRegistry: CodecRegistry

def collectionName: String

The name of the database collection.

def connectionIdentifier: ConnectionIdentifier

Override this to specify a ConnectionIdentifier.

def count(qry: JObject): Box[Long]

Count documents by JObject query

def count(qry: Bson): Box[Long]

Count documents by Bson query

def count: Box[Long]

Count all documents

def countDistinct(key: String, query: Bson): Box[Long]

Count distinct records on a given field.

def create(dbo: Bson): BaseDocument

def create(in: JObject)(implicit formats: Formats): BaseDocument

def createIndex(keys: JObject, uniq: Boolean = false): Box[String]

def createIndex(keys: JObject): Box[String]

def createIndex(keys: JObject, opts: IndexOptions): Box[String]

def createIndex(keys: Bson, uniq: Boolean): Box[String]

def createIndex(keys: Bson): Box[String]

def createIndex(keys: Bson, opts: IndexOptions): Box[String]

def deleteMany(qry: JObject, opts: DeleteOptions): Box[DeleteResult]

Delete many documents by a JObject query with the given DeleteOptions

def deleteMany(qry: JObject): Box[DeleteResult]

Delete many documents by a JObject query

def deleteMany(qry: Bson, opts: DeleteOptions): Box[DeleteResult]

Delete many documents by a Bson query with the given DeleteOptions

def deleteMany(qry: Bson): Box[DeleteResult]

Delete many documents by a Bson query

def deleteOne(k: String, v: Any, opts: DeleteOptions = new DeleteOptions): Box[DeleteResult]

Delete a single document by a key-value pair query

def deleteOne(qry: JObject, opts: DeleteOptions): Box[DeleteResult]

Delete a single document by a JObject query with the given DeleteOptions

def deleteOne(qry: JObject): Box[DeleteResult]

Delete a single document by a JObject query

def deleteOne(qry: Bson, opts: DeleteOptions): Box[DeleteResult]

Delete a single document by a Bson query with the given DeleteOptions

def deleteOne(qry: Bson): Box[DeleteResult]

Delete a single document by a Bson query

def drop: Box[Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def find(json: JObject): Option[BaseDocument]

Find a single document by a qry using a json query

def find(k: String, v: Any): Option[BaseDocument]

Find a single document by a qry using String, Any inputs

def find(uuid: UUID): Option[BaseDocument]

Find a single document by _id using a UUID.

def find(oid: ObjectId): Option[BaseDocument]

Find a single document by _id using an ObjectId.

def find(s: String): Option[BaseDocument]

Find a single document by _id using a String.

def find(qry: Bson): Option[BaseDocument]

Find a single row by a qry, using a Bson.

def findAll(k: String, o: Any, sort: JObject, opts: FindOption*): List[BaseDocument]

Find all documents using a k, v query with JObject sort

def findAll(k: String, o: Any, opts: FindOption*): List[BaseDocument]

Find all documents using a k, v query

def findAll(qry: JObject, sort: JObject, opts: FindOption*): List[BaseDocument]

Find all documents using a JObject query with sort

def findAll(qry: JObject, opts: FindOption*): List[BaseDocument]

Find all documents using a JObject query

def findAll(qry: Bson, sort: Bson, opts: FindOption*): List[BaseDocument]

Find all documents using a Bson query with sort

def findAll(qry: Bson, opts: FindOption*): List[BaseDocument]

Find all documents using a Bson query.

def findAll(qry: Bson, sort: Option[Bson], opts: FindOption*): List[BaseDocument]

Find all documents using a Bson query.

def findAll: List[BaseDocument]

Find all documents in this collection

def fixCollectionName: String

Collection names should begin with letters or an underscore and may include numbers; $ is reserved.

def formats: Formats

final def getClass(): Class[_]

def hashCode(): Int

def insertOne(inst: BaseDocument, opts: InsertOneOptions = new InsertOneOptions): Box[BaseDocument]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def replaceOne(qry: JObject, inst: BaseDocument): Box[UpdateResult]

def replaceOne(qry: JObject, inst: BaseDocument, opts: ReplaceOptions): Box[UpdateResult]

def replaceOne(qry: Bson, inst: BaseDocument): Box[UpdateResult]

def replaceOne(qry: Bson, inst: BaseDocument, opts: ReplaceOptions): Box[UpdateResult]

def replaceOne(inst: BaseDocument, opts: ReplaceOptions = new ReplaceOptions): Box[UpdateResult]

def save(inst: BaseDocument): UpdateResult

Save a document to the db

final def synchronized[T0](arg0: ⇒ T0): T0

def toJObject(in: BaseDocument)(implicit formats: Formats): JObject

def toString(): String

def updateMany(qry: JObject, update: JObject, opts: UpdateOptions): Box[UpdateResult]

Update many documents with a JObject query with the given UpdateOptions

def updateMany(qry: JObject, update: JObject): Box[UpdateResult]

Update many documents with a JObject query

def updateMany(qry: Bson, update: Bson, opts: UpdateOptions): Box[UpdateResult]

Update many documents with a Bson query with the given UpdateOptions

def updateMany(qry: Bson, update: Bson): Box[UpdateResult]

Update many documents with a Bson query

def updateOne(qry: JObject, update: JObject, opts: UpdateOptions): Box[UpdateResult]

Update a single document with a JObject query with the given UpdateOptions

def updateOne(qry: JObject, update: JObject): Box[UpdateResult]

Update a single document with a JObject query

def updateOne(qry: Bson, update: Bson, opts: UpdateOptions): Box[UpdateResult]

Update a single document with a Bson query with the given UpdateOptions

def updateOne(qry: Bson, update: Bson): Box[UpdateResult]

Update a single document with a Bson query

def useCollection[T](db: MongoDatabase)(f: (MongoCollection[BsonDocument]) ⇒ T): T

def useCollection[T](f: (MongoCollection[BsonDocument]) ⇒ T): T

Use the collection associated with this Meta.

def useDatabase[T](f: (MongoDatabase) ⇒ T): T

Use the db associated with this Meta.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writeConcern: WriteConcern

This will be used if set to Some, otherwise the WriteConcern set in MongoClientOptions will be used.

def createIndex(keys: JObject, opts: JObject): Unit

def delete(qry: JObject): Unit

Delete documents by a JObject query

def delete(k: String, v: Any): Unit

def delete(qry: DBObject): Unit

Delete documents by a DBObject query

def save(in: BaseDocument, db: DB): Unit

def update(qry: JObject, newbd: BaseDocument, opts: UpdateOption*): Unit

def update(qry: JObject, newbd: BaseDocument, db: DB, opts: UpdateOption*): Unit

def update(qry: JObject, newobj: JObject, opts: UpdateOption*): Unit

def update(qry: JObject, newobj: JObject, db: DB, opts: UpdateOption*): Unit

def update(qry: DBObject, newobj: DBObject, db: DB, opts: UpdateOption*): Unit

def useColl[T](f: (DBCollection) ⇒ T): T

def useDb[T](f: (DB) ⇒ T): T