Sql

Type Members

class BaseStatement extends AnyRef

Attributes
protected[com.lucidchart.relate]

Abstract Value Members

abstract def applyParams(stmt: PreparedStatement): Unit

Attributes
protected
abstract val parsedQuery: String

Attributes
protected

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
def as[A]()(implicit arg0: RowParser[A], connection: Connection): A
def asCollection[U, T[_]]()(implicit arg0: RowParser[U], cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]
def asCollection[U, T[_]](parser: (SqlRow) ⇒ U)(implicit cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

Execute this query and get back the result as an arbitrary collection of records
Execute this query and get back the result as an arbitrary collection of records
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as an arbitrary collection of records
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asIterable[A]()(implicit arg0: RowParser[A], connection: Connection): Iterable[A]
def asIterable[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Iterable[A]

Execute this query and get back the result as an iterable of records
Execute this query and get back the result as an iterable of records
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as an iterable of records
def asIterator[A](parser: (SqlRow) ⇒ A, fetchSize: Int = 100)(implicit connection: Connection): Iterator[A]

The asIterator method returns an Iterator that will stream data out of the database.
The asIterator method returns an Iterator that will stream data out of the database. This avoids an OutOfMemoryError when dealing with large datasets. Bear in mind that many JDBC implementations will not allow additional queries to the connection before all records in the Iterator have been retrieved.
parser
the RowParser to parse rows with
fetchSize
the number of rows to fetch at a time, defaults to 100. If the JDBC Driver is MySQL, the fetchSize will always default to Int.MinValue, as MySQL's JDBC implementation ignores all other fetchSize values and only streams if fetchSize is Int.MinValue
def asList[A]()(implicit arg0: RowParser[A], connection: Connection): List[A]
def asList[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): List[A]

Execute this query and get back the result as a List of records
Execute this query and get back the result as a List of records
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as a List of records
def asMap[U, V]()(implicit connection: Connection, p: RowParser[(U, V)]): Map[U, V]
def asMap[U, V](parser: (SqlRow) ⇒ (U, V))(implicit connection: Connection): Map[U, V]

Execute this query and get back the result as a Map of records
Execute this query and get back the result as a Map of records
parser
the RowParser to use when parsing the result set. The RowParser should return a Tuple of size 2 containing the key and value
connection
the connection to use when executing the query
returns
the results as a Map of records
def asMultiMap[U, V]()(implicit connection: Connection, p: RowParser[(U, V)]): Map[U, Set[V]]
def asMultiMap[U, V](parser: (SqlRow) ⇒ (U, V))(implicit connection: Connection): Map[U, Set[V]]
def asPairCollection[U, V, T[_, _]]()(implicit cbf: CanBuildFrom[T[U, V], (U, V), T[U, V]], connection: Connection, p: RowParser[(U, V)]): T[U, V]
def asPairCollection[U, V, T[_, _]](parser: (SqlRow) ⇒ (U, V))(implicit cbf: CanBuildFrom[T[U, V], (U, V), T[U, V]], connection: Connection): T[U, V]

Execute this query and get back the result as an arbitrary collection of key value pairs
Execute this query and get back the result as an arbitrary collection of key value pairs
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as an arbitrary collection of key value pairs
def asScalar[A]()(implicit connection: Connection): A

Execute this query and get back the result as a single value.
Execute this query and get back the result as a single value. Assumes that there is only one row and one value in the result set.
connection
the connection to use when executing the query
returns
the results as a single value
def asScalarOption[A]()(implicit connection: Connection): Option[A]

Execute this query and get back the result as an optional single value.
Execute this query and get back the result as an optional single value. Assumes that there is only one row and one value in the result set.
connection
the connection to use when executing the query
returns
the results as an optional single value
def asSeq[A]()(implicit arg0: RowParser[A], connection: Connection): Seq[A]
def asSeq[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Seq[A]

Execute this query and get back the result as a sequence of records
Execute this query and get back the result as a sequence of records
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as a sequence of records
def asSet[A]()(implicit arg0: RowParser[A], connection: Connection): Set[A]
def asSet[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Set[A]

Execute this query and get back the result as a Set of records
Execute this query and get back the result as a Set of records
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as a Set of records
def asSingle[A]()(implicit arg0: RowParser[A], connection: Connection): A
def asSingle[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): A

Execute this query and get back the result as a single record
Execute this query and get back the result as a single record
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as a single record
def asSingleOption[A]()(implicit arg0: RowParser[A], connection: Connection): Option[A]
def asSingleOption[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Option[A]

Execute this query and get back the result as an optional single record
Execute this query and get back the result as an optional single record
parser
the RowParser to use when parsing the result set
connection
the connection to use when executing the query
returns
the results as an optional single record
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 execute()(implicit connection: Connection): Boolean

Execute a statement
Execute a statement
connection
the db connection to use when executing the query
returns
whether the query succeeded in its execution
def executeInsertCollection[U, T[_]](parser: (SqlRow) ⇒ U)(implicit cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

Execute the query and get the auto-incremented keys using a RowParser.
Execute the query and get the auto-incremented keys using a RowParser. Provided for the case that a primary key is not an Int or BigInt
parser
the RowParser that can parse the returned keys
connection
the connection to use when executing the query
returns
the auto-incremented keys
def executeInsertInt()(implicit connection: Connection): Int

Execute the query and get the auto-incremented key as an Int
Execute the query and get the auto-incremented key as an Int
connection
the connection to use when executing the query
returns
the auto-incremented key as an Int
def executeInsertInts()(implicit connection: Connection): List[Int]

Execute the query and get the auto-incremented keys as a List of Ints
Execute the query and get the auto-incremented keys as a List of Ints
connection
the connection to use when executing the query
returns
the auto-incremented keys as a List of Ints
def executeInsertLong()(implicit connection: Connection): Long

Execute the query and get the auto-incremented key as a Long
Execute the query and get the auto-incremented key as a Long
connection
the connection to use when executing the query
returns
the auto-incremented key as a Long
def executeInsertLongs()(implicit connection: Connection): List[Long]

Execute the query and get the auto-incremented keys as a a List of Longs
Execute the query and get the auto-incremented keys as a a List of Longs
connection
the connection to use when executing the query
returns
the auto-incremented keys as a a List of Longs
def executeInsertSingle[U](parser: (SqlRow) ⇒ U)(implicit connection: Connection): U

Execute the query and get the auto-incremented key using a RowParser.
Execute the query and get the auto-incremented key using a RowParser. Provided for the case that a primary key is not an Int or BigInt
parser
the RowParser that can parse the returned key
connection
the connection to use when executing the query
returns
the auto-incremented key
def executeUpdate()(implicit connection: Connection): Int

Execute an update
Execute an update
connection
the db connection to use when executing the query
returns
the number of rows update by the query
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def insertionStatement(implicit connection: Connection): BaseStatement with InsertionStatementPreparer

Attributes
protected
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normalStatement(implicit connection: Connection): BaseStatement with NormalStatementPreparer

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def results()(implicit connection: Connection): ResultSet

Provides direct access to the underlying java.sql.ResultSet.
Provides direct access to the underlying java.sql.ResultSet. Note that this ResultSet must be closed manually or by wrapping it in SqlResult.
```
val results = SQL(query).results()
. . .
SqlResult(results).asList[A](parser)
// or
results.close()
```
returns
java.sql.ResultSet
def statementString(implicit connection: Connection): String

Calls PreparedStatement#toString, which for many JDBC implementations is the SQL query after parameter substitution.
Calls PreparedStatement#toString, which for many JDBC implementations is the SQL query after parameter substitution. This is intended primarily for ad-hoc debugging.
For more routine logging, consider other solutions, such as log4jdbc.
def streamedStatement(fetchSize: Int)(implicit connection: Connection): BaseStatement with StreamedStatementPreparer

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

Definition Classes
AnyRef
def toString(): String

Returns the SQL query, before parameter substitution.
Returns the SQL query, before parameter substitution.

Definition Classes
Sql → 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( ... )

Related Doc: package relate

trait Sql extends AnyRef

Type Members

class BaseStatement extends AnyRef

Abstract Value Members

abstract def applyParams(stmt: PreparedStatement): Unit

abstract val parsedQuery: String

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def as[A]()(implicit arg0: RowParser[A], connection: Connection): A

def asCollection[U, T[_]]()(implicit arg0: RowParser[U], cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

def asCollection[U, T[_]](parser: (SqlRow) ⇒ U)(implicit cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

final def asInstanceOf[T0]: T0

def asIterable[A]()(implicit arg0: RowParser[A], connection: Connection): Iterable[A]

def asIterable[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Iterable[A]

def asIterator[A](parser: (SqlRow) ⇒ A, fetchSize: Int = 100)(implicit connection: Connection): Iterator[A]

def asList[A]()(implicit arg0: RowParser[A], connection: Connection): List[A]

def asList[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): List[A]

def asMap[U, V]()(implicit connection: Connection, p: RowParser[(U, V)]): Map[U, V]

def asMap[U, V](parser: (SqlRow) ⇒ (U, V))(implicit connection: Connection): Map[U, V]

def asMultiMap[U, V]()(implicit connection: Connection, p: RowParser[(U, V)]): Map[U, Set[V]]

def asMultiMap[U, V](parser: (SqlRow) ⇒ (U, V))(implicit connection: Connection): Map[U, Set[V]]

def asPairCollection[U, V, T[_, _]]()(implicit cbf: CanBuildFrom[T[U, V], (U, V), T[U, V]], connection: Connection, p: RowParser[(U, V)]): T[U, V]

def asPairCollection[U, V, T[_, _]](parser: (SqlRow) ⇒ (U, V))(implicit cbf: CanBuildFrom[T[U, V], (U, V), T[U, V]], connection: Connection): T[U, V]

def asScalar[A]()(implicit connection: Connection): A

def asScalarOption[A]()(implicit connection: Connection): Option[A]

def asSeq[A]()(implicit arg0: RowParser[A], connection: Connection): Seq[A]

def asSeq[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Seq[A]

def asSet[A]()(implicit arg0: RowParser[A], connection: Connection): Set[A]

def asSet[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Set[A]

def asSingle[A]()(implicit arg0: RowParser[A], connection: Connection): A

def asSingle[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): A

def asSingleOption[A]()(implicit arg0: RowParser[A], connection: Connection): Option[A]

def asSingleOption[A](parser: (SqlRow) ⇒ A)(implicit connection: Connection): Option[A]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute()(implicit connection: Connection): Boolean

def executeInsertCollection[U, T[_]](parser: (SqlRow) ⇒ U)(implicit cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

def executeInsertInt()(implicit connection: Connection): Int

def executeInsertInts()(implicit connection: Connection): List[Int]

def executeInsertLong()(implicit connection: Connection): Long

def executeInsertLongs()(implicit connection: Connection): List[Long]

def executeInsertSingle[U](parser: (SqlRow) ⇒ U)(implicit connection: Connection): U

def executeUpdate()(implicit connection: Connection): Int

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def insertionStatement(implicit connection: Connection): BaseStatement with InsertionStatementPreparer

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def normalStatement(implicit connection: Connection): BaseStatement with NormalStatementPreparer

final def notify(): Unit

final def notifyAll(): Unit

def results()(implicit connection: Connection): ResultSet

def statementString(implicit connection: Connection): String

def streamedStatement(fetchSize: Int)(implicit connection: Connection): BaseStatement with StreamedStatementPreparer

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