DB - datomiscadao.DB

Abstract Value Members

implicit abstract val reader: EntityReader[T]
implicit abstract val writer: PartialAddEntityWriter[T]

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def execute0(myQuery: AbstractQuery)(implicit conn: Connection): Iterable[Any]
def execute1(myQuery: AbstractQuery, param: Long)(implicit conn: Connection): Iterable[Any]
def execute1(myQuery: AbstractQuery, param: String)(implicit conn: Connection): Iterable[Any]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(ref: LookupRef)(implicit conn: Connection, reader: EntityReader[T]): Option[T]
def find(ref: LookupRef, db: Database)(implicit reader: EntityReader[T]): Option[T]

Similar to get(id: Long) except this method will not throw an exception of the entity with the specified ID exists, instead, it simply returns a None.
Similar to get(id: Long) except this method will not throw an exception of the entity with the specified ID exists, instead, it simply returns a None. This is useful for when you are not sure whether or not an entity has been retracted.
ref
the LookupRef for the entity you wish to find
db
the database to search in
reader
the reader which converts the Entity to our native entity type T
returns
Some[T] if the entity exists, None otherwise
def find[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Option[T]
def find[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Option[T]
def get[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): T
def get[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): T

Gets an entity by ID, where the ID can either be a Long or a LookupRef.
Gets an entity by ID, where the ID can either be a Long or a LookupRef. This method will throw an UnresolvedLookupRefException if the ID does not map to an existing entity. this should never be the case for a Long ID, but can potentially be possible when using a LookupRef. If you are not certain that a LookupRef points to an existing entity, call find instead
I
the type of the ID, can either be a Long or a LookupRef
id
the ID of the entity you with to select
db
the database to look in
reader
the reader that converts the entity into the proper case class
idConv
the converter that converts the OD from type I to the Long that it eventually needs to be
returns
the entity, or an UnresolvedLookupRefException if no entity can be found
def getAsJson[I](id: I, db: Database, depth: Int = 10)(implicit idConv: AsPermanentEntityId[I]): JsValue

Gets an entity in JSON format.
Gets an entity in JSON format. This is done directly on the Datomic map, so calling this method is an optimization that saves on having to serialize and deserialize from a case class.
I
the type of the ID, can either be a Long or a LookupRef
id
the ID of the entity
db
the database to use
depth
the depth to recursively expand. After you reach this depth, you will only get entity IDs instead of the fully expanded entities.
returns
the JSON
def getAsTry[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Try[T]
def getAsTry[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Try[T]

Similar to get(id: Long) all excpetions are caught and wrapped in a Try.
Similar to get(id: Long) all excpetions are caught and wrapped in a Try. This is useful in circumstances where perhaps the entity in question was not fully entered into the DB, so while something is there with that ID, there isn't enough to fully inflate the case class.
id
the ID of the entity that you want to select
db
the database to search in
reader
the reader which converts the Entity to our native entity type T
idConv
the converter that converts the OD from type I to the Long that it eventually needs to be
returns
Some[T] if the entity exists, None otherwise
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def headOption(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): Option[T]

Attributes
protected
def headOption(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): Option[T]

Returns a single entity (the first entity if there are many that match the query) as an option or None if there are no results matching the query
Returns a single entity (the first entity if there are many that match the query) as an option or None if there are no results matching the query
query
the executed query
db
the database - Required to convert the entity ID to the full entity. For consistency, This should be the same database that you used to execute the query.
reader
the reader to convert to the specified entity type
returns
Some(entity) of there is at lease one result where entity is the first entity found, or None if there are no results

Attributes
protected
def headOptionWithId(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): Option[(Long, T)]

Attributes
protected
def headOptionWithId(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): Option[(Long, T)]

Attributes
protected
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def list(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): List[T]

Attributes
protected
def list(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): List[T]

Returns the list of entities chosen by the query tupled with its ID.
Returns the list of entities chosen by the query tupled with its ID.
query
the Datomic Query
db
the database - Required to convert the entity ID to the full entity. For consistency, This should be the same database that you used to execute the query.
reader
the reader for the entity

Attributes
protected
def listWithId(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): List[(Long, T)]

Attributes
protected
def listWithId(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): List[(Long, T)]

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def page(query: Iterable[Any], filter: PageFilter)(implicit db: Database, reader: EntityReader[T]): Page[T]

Runs a query and pulls a single page worth of values out.
Runs a query and pulls a single page worth of values out.
query
the query
filter
the filter
db
the database - Required to convert the entity ID to the full entity. For consistency, This should be the same database that you used to execute the query.
reader
the entity reader
returns
the Page

Attributes
protected
def pageWithSort(query: Iterable[(Any, Any)], filter: PageFilter, sort: SortOrder = Asc)(implicit db: Database, reader: EntityReader[T]): Page[T]

Attributes
protected
def retractEntity[I](id: I)(implicit conn: Connection, ex: ExecutionContext, idConv: AsPermanentEntityId[I]): Future[TxReport]

This is the Datomic equivalent of a delete, except in Datomic, nothing ever gets deleted.
This is the Datomic equivalent of a delete, except in Datomic, nothing ever gets deleted. You can only insert a retraction, that flags the specified entity as ignored.
I
the type of the ID, can either be a Long or a LookupRef
id
the ID of the entity to retract
ex
the ExecutionContext
returns
the transaction record specifying whether or not the transaction succeeded or failed
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

DB

Related Docs: object DB | package datomiscadao

trait DB[T] extends AnyRef

Abstract Value Members

implicit abstract val reader: EntityReader[T]

implicit abstract val writer: PartialAddEntityWriter[T]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute0(myQuery: AbstractQuery)(implicit conn: Connection): Iterable[Any]

def execute1(myQuery: AbstractQuery, param: Long)(implicit conn: Connection): Iterable[Any]

def execute1(myQuery: AbstractQuery, param: String)(implicit conn: Connection): Iterable[Any]

def finalize(): Unit

def find(ref: LookupRef)(implicit conn: Connection, reader: EntityReader[T]): Option[T]

def find(ref: LookupRef, db: Database)(implicit reader: EntityReader[T]): Option[T]

def find[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Option[T]

def find[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Option[T]

def get[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): T

def get[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): T

def getAsJson[I](id: I, db: Database, depth: Int = 10)(implicit idConv: AsPermanentEntityId[I]): JsValue

def getAsTry[I](id: I)(implicit conn: Connection, reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Try[T]

def getAsTry[I](id: I, db: Database)(implicit reader: EntityReader[T], idConv: AsPermanentEntityId[I]): Try[T]

final def getClass(): Class[_]

def hashCode(): Int

def headOption(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): Option[T]

def headOption(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): Option[T]

def headOptionWithId(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): Option[(Long, T)]

def headOptionWithId(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): Option[(Long, T)]

final def isInstanceOf[T0]: Boolean

def list(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): List[T]

def list(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): List[T]

def listWithId(query: Iterable[Any])(implicit conn: Connection, reader: EntityReader[T]): List[(Long, T)]

def listWithId(query: Iterable[Any], db: Database)(implicit reader: EntityReader[T]): List[(Long, T)]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def page(query: Iterable[Any], filter: PageFilter)(implicit db: Database, reader: EntityReader[T]): Page[T]

def pageWithSort(query: Iterable[(Any, Any)], filter: PageFilter, sort: SortOrder = Asc)(implicit db: Database, reader: EntityReader[T]): Page[T]

def retractEntity[I](id: I)(implicit conn: Connection, ex: ExecutionContext, idConv: AsPermanentEntityId[I]): Future[TxReport]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped