Expandable

Type Members

class BaseStatement extends AnyRef

Attributes
protected[com.lucidchart.open.relate]
Definition Classes
Sql

Abstract Value Members

abstract def getCopy(params: List[(SqlStatement) ⇒ Unit]): ParameterizableSql

Classes that inherit the Sql trait will have to implement a method to copy themselves given just a different set of parameters.
Classes that inherit the Sql trait will have to implement a method to copy themselves given just a different set of parameters. HINT: Use a case class!

Attributes
protected
Definition Classes
ParameterizableSql
abstract val listParams: Map[String, ListParam]

The names of list params mapped to their size
abstract val params: List[(SqlStatement) ⇒ Unit]

A list of anonymous functions that insert parameters into a SqlStatement
A list of anonymous functions that insert parameters into a SqlStatement

Attributes
protected
Definition Classes
ParameterizableSql
abstract def queryParams: QueryParams

Attributes
protected[com.lucidchart.open.relate]
Definition Classes
ParameterizedSql

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 applyParams(stmt: PreparedStatement): Unit

Attributes
protected
Definition Classes
ParameterizedSql → Sql
def as[A]()(implicit arg0: Parseable[A], connection: Connection): A

Definition Classes
Sql
def asCollection[U, T[_]]()(implicit arg0: Parseable[U], cbf: CanBuildFrom[T[U], U, T[U]], connection: Connection): T[U]

Definition Classes
Sql
def asCollection[U, T[_]](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asIterable[A]()(implicit arg0: Parseable[A], connection: Connection): Iterable[A]

Definition Classes
Sql
def asIterable[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asIterator[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asList[A]()(implicit arg0: Parseable[A], connection: Connection): List[A]

Definition Classes
Sql
def asList[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asMap[U, V]()(implicit connection: Connection, p: Parseable[(U, V)]): Map[U, V]

Definition Classes
Sql
def asMap[U, V](parser: (SqlResult) ⇒ (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

Definition Classes
Sql
def asMultiMap[U, V]()(implicit connection: Connection, p: Parseable[(U, V)]): Map[U, Set[V]]

Definition Classes
Sql
def asMultiMap[U, V](parser: (SqlResult) ⇒ (U, V))(implicit connection: Connection): Map[U, Set[V]]

Definition Classes
Sql
def asPairCollection[U, V, T[_, _]]()(implicit cbf: CanBuildFrom[T[U, V], (U, V), T[U, V]], connection: Connection, p: Parseable[(U, V)]): T[U, V]

Definition Classes
Sql
def asPairCollection[U, V, T[_, _]](parser: (SqlResult) ⇒ (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

Definition Classes
Sql
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

Definition Classes
Sql
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

Definition Classes
Sql
def asSeq[A]()(implicit arg0: Parseable[A], connection: Connection): Seq[A]

Definition Classes
Sql
def asSeq[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asSet[A]()(implicit arg0: Parseable[A], connection: Connection): Set[A]

Definition Classes
Sql
def asSet[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asSingle[A]()(implicit arg0: Parseable[A], connection: Connection): A

Definition Classes
Sql
def asSingle[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def asSingleOption[A]()(implicit arg0: Parseable[A], connection: Connection): Option[A]

Definition Classes
Sql
def asSingleOption[A](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def commaSeparated(name: String, count: Int): Unit

Replace the provided identifier with a comma separated list of parameters WARNING: modifies this Expandable in place
Replace the provided identifier with a comma separated list of parameters WARNING: modifies this Expandable in place
name
the identifier for the parameter
count
the count of parameters in the list
def commas(name: String, count: Int): Expandable

Shorthand for calling commaSeparated within an expand block.
Shorthand for calling commaSeparated within an expand block.
```
SQL("SELECT * FROM users WHERE id IN ({ids})").commas("ids", 10)
```
is equivalent to
```
SQL("SELECT * FROM users WHERE id IN ({ids})").expand { implicit query =>
  commaSeparated("ids", 10)
}
```
WARNING: modifies this Expandable in place
name
the parameter name to expand
count
the number of items in the comma separated list
returns
this Expandable with the added list parameters
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

Definition Classes
Sql
def executeInsertCollection[U, T[_]](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
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

Definition Classes
Sql
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

Definition Classes
Sql
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

Definition Classes
Sql
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

Definition Classes
Sql
def executeInsertSingle[U](parser: (SqlResult) ⇒ 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

Definition Classes
Sql
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

Definition Classes
Sql
def expand(f: (Expandable) ⇒ Unit): Expandable

Expand out the query by turning an TraversableOnce into several parameters
Expand out the query by turning an TraversableOnce into several parameters
returns
a copy of this Expandable with the query expanded
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
Definition Classes
Sql
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
Definition Classes
Sql
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def on(f: (SqlStatement) ⇒ Unit): ParameterizableSql

Put in values for parameters in the query
Put in values for parameters in the query
f
a function that takes a SqlStatement and sets parameter values using its methods
returns
a copy of this Sql with the new params

Definition Classes
ParameterizableSql
def onTuples[A](name: String, tuples: TraversableOnce[A])(f: (A, TupleStatement) ⇒ Unit): ParameterizableSql

Put in values for tuple parameters in the query
Put in values for tuple parameters in the query
name
the tuple identifier in the query
tuples
the objects to loop over and use to insert data into the query
f
a function that takes a TupleStatement and sets parameter values using its methods
returns
a copy of this Sql with the new tuple params

Definition Classes
ParameterizableSql
val parsedParams: Map[String, List[Int]]

Attributes
protected
Definition Classes
ParameterizedSql
val parsedQuery: String

Attributes
protected
Definition Classes
ParameterizedSql → Sql
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

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

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

Attributes
protected
Definition Classes
Sql
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
def tupled(name: String, columns: Seq[String], numTuples: Int): Unit

Replace the provided identifier with a comma separated list of tuples WARNING: modifies this Expandable in place
Replace the provided identifier with a comma separated list of tuples WARNING: modifies this Expandable in place
name
the identifier for the tuples
columns
a list of the column names in the order they should be inserted into the tuples
numTuples
the number of tuples to insert
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

sealed trait Expandable extends ParameterizableSql

Type Members

class BaseStatement extends AnyRef

Abstract Value Members

abstract def getCopy(params: List[(SqlStatement) ⇒ Unit]): ParameterizableSql

abstract val listParams: Map[String, ListParam]

abstract val params: List[(SqlStatement) ⇒ Unit]

abstract def queryParams: QueryParams

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def applyParams(stmt: PreparedStatement): Unit

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

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

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

final def asInstanceOf[T0]: T0

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

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

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

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

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

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

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

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

def asMultiMap[U, V](parser: (SqlResult) ⇒ (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: Parseable[(U, V)]): T[U, V]

def asPairCollection[U, V, T[_, _]](parser: (SqlResult) ⇒ (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: Parseable[A], connection: Connection): Seq[A]

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

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

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

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

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

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

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

def clone(): AnyRef

def commaSeparated(name: String, count: Int): Unit

def commas(name: String, count: Int): Expandable

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def executeInsertCollection[U, T[_]](parser: (SqlResult) ⇒ 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: (SqlResult) ⇒ U)(implicit connection: Connection): U

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

def expand(f: (Expandable) ⇒ Unit): Expandable

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 on(f: (SqlStatement) ⇒ Unit): ParameterizableSql

def onTuples[A](name: String, tuples: TraversableOnce[A])(f: (A, TupleStatement) ⇒ Unit): ParameterizableSql

val parsedParams: Map[String, List[Int]]

val parsedQuery: String

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

def tupled(name: String, columns: Seq[String], numTuples: Int): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ParameterizableSql

Inherited from ParameterizedSql

Inherited from Sql

Inherited from AnyRef