InterpolatedQuery

Instance Constructors

new InterpolatedQuery(parsedQuery: String, params: Seq[Parameter])

Type Members

class BaseStatement extends AnyRef

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

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
def appendPlaceholders(stringBuilder: StringBuilder): Unit

Definition Classes
InterpolatedQuery → Parameter
def applyParams(stmt: PreparedStatement): Unit

Attributes
protected
Definition Classes
InterpolatedQuery → 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( ... )
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 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 parameterize(statement: PreparedStatement, i: Int): Int

Definition Classes
MultipleParameter → Parameter
val params: Seq[Parameter]

Attributes
protected
Definition Classes
InterpolatedQuery → MultipleParameter
val parsedQuery: String

Attributes
protected
Definition Classes
InterpolatedQuery → 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
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( ... )
def withTimeout(seconds: Int): InterpolatedQuery

Related Docs: object InterpolatedQuery | package interp

class InterpolatedQuery extends Sql with MultipleParameter

Instance Constructors

new InterpolatedQuery(parsedQuery: String, params: Seq[Parameter])

Type Members

class BaseStatement extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(query: InterpolatedQuery): InterpolatedQuery

final def ==(arg0: Any): Boolean

def appendPlaceholders(stringBuilder: StringBuilder): Unit

def applyParams(stmt: PreparedStatement): Unit

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

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 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 parameterize(statement: PreparedStatement, i: Int): Int

val params: Seq[Parameter]

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withTimeout(seconds: Int): InterpolatedQuery

Inherited from MultipleParameter

Inherited from Parameter

Inherited from Sql

Inherited from AnyRef

Inherited from Any

Ungrouped