Packages

case class SimpleSql[T](sql: SqlQuery, params: Map[String, ParameterValue], defaultParser: RowParser[T], resultSetOnFirstRow: Boolean = false) extends Sql with Product with Serializable

Simple/plain SQL.

Linear Supertypes
Serializable, Serializable, Product, Equals, Sql, WithResult, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SimpleSql
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. Sql
  7. WithResult
  8. AnyRef
  9. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new SimpleSql(sql: SqlQuery, params: Map[String, ParameterValue], defaultParser: RowParser[T], resultSetOnFirstRow: Boolean = false)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def as[T](parser: ResultSetParser[T])(implicit connection: Connection): T

    Converts this query result as T, using parser.

    Converts this query result as T, using parser.

    parser

    the result parser

    Definition Classes
    WithResult
    Annotations
    @SuppressWarnings()
    See also

    #asTry

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def asTry[T](parser: ResultSetParser[T], aliaser: ColumnAliaser = ColumnAliaser.empty)(implicit connection: Connection): Try[T]

    Converts this query result as T, using parser.

    Converts this query result as T, using parser.

    parser

    the result parser

    aliaser

    the column aliaser

    Definition Classes
    WithResult
  7. def bind[U](value: U)(implicit converter: ToParameterList[U]): SimpleSql[T]

    Returns the query prepared with the named parameters, provided by the appropriate converter.

    Returns the query prepared with the named parameters, provided by the appropriate converter.

    U

    the type of the value

    value

    the value to be converted as list of NamedParameter

    converter

    the function used to convert the value

  8. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  9. val defaultParser: RowParser[T]
  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def execute()(implicit connection: Connection): Boolean

    Executes this SQL statement.

    Executes this SQL statement.

    returns

    true if resultset was returned from execution (statement is query), or false if it executed update.

    val res: Boolean =
      SQL"""INSERT INTO Test(a, b) VALUES(\${"A"}, \${"B"}""".execute()
    Definition Classes
    Sql
  12. def executeInsert[A](generatedKeysParser: ResultSetParser[A] = SqlParser.scalar[Long].singleOpt)(implicit connection: Connection): A

    Executes this SQL as an insert statement.

    Executes this SQL as an insert statement.

    generatedKeysParser

    Parser for generated key (default: scalar long)

    returns

    Parsed generated keys

    import anorm.SqlParser.scalar
    
    val keys1 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert()
    
    val keys2 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert(scalar[String].singleOpt)
    // ... generated string key
    Definition Classes
    Sql
    Annotations
    @SuppressWarnings()
  13. def executeInsert1[A](generatedColumn: String, otherColumns: String*)(generatedKeysParser: ResultSetParser[A] = SqlParser.scalar[Long].singleOpt)(implicit connection: Connection): Try[A]

    Executes this SQL as an insert statement.

    Executes this SQL as an insert statement.

    generatedColumn

    the first (mandatory) column name to consider from the generated keys

    otherColumns

    the other (possibly none) column name(s) from the generated keys

    generatedKeysParser

    the parser for generated key (default: scalar long)

    returns

    Parsed generated keys

    import anorm.SqlParser.scalar
    
    val keys1 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert1("generatedCol", "colB")()
    
    val keys2 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert1("generatedCol")(scalar[String].singleOpt)
    // ... generated string key
    Definition Classes
    Sql
  14. def executeInsert2[A](generatedColumn: String, otherColumns: String*)(generatedKeysParser: ResultSetParser[A] = SqlParser.scalar[Long].singleOpt, aliaser: ColumnAliaser)(implicit connection: Connection): Try[A]

    Executes this SQL as an insert statement.

    Executes this SQL as an insert statement.

    generatedColumn

    the first (mandatory) column name to consider from the generated keys

    otherColumns

    the other (possibly none) column name(s) from the generated keys

    generatedKeysParser

    the parser for generated key (default: scalar long)

    aliaser

    the column aliaser

    returns

    Parsed generated keys

    import anorm.SqlParser.scalar
    
    val keys1 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert1("generatedCol", "colB")()
    
    val keys2 = SQL("INSERT INTO Test(x) VALUES ({x})").
      on("x" -> "y").executeInsert1("generatedCol")(scalar[String].singleOpt)
    // ... generated string key
    Definition Classes
    Sql
  15. def executeQuery()(implicit connection: Connection): SqlQueryResult

    Executes this SQL query, and returns its result.

    Executes this SQL query, and returns its result.

    implicit val conn: Connection = openConnection
    val res: SqlQueryResult =
      SQL("SELECT text_col FROM table WHERE id = {code}").
      on("code" -> code).executeQuery()
    // Check execution context; e.g. res.statementWarning
    val str = res as scalar[String].single // going with row parsing
    Definition Classes
    Sql
  16. def executeUpdate()(implicit connection: Connection): Int

    Executes this SQL as an update statement.

    Executes this SQL as an update statement.

    returns

    Count of updated row(s)

    Definition Classes
    Sql
    Annotations
    @throws( "If statement is query not update" )
  17. def fetchSize: Option[Int]

    Fetch size

  18. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  19. def fold[T](z: ⇒ T, aliaser: ColumnAliaser)(op: (T, Row) ⇒ T)(implicit connection: Connection): Either[List[Throwable], T]

    Aggregates over all rows using the specified operator.

    Aggregates over all rows using the specified operator.

    z

    the start value

    aliaser

    the column aliaser

    op

    Aggregate operator

    returns

    Either list of failures at left, or aggregated value

    Definition Classes
    WithResult
    See also

    #withResult

    #foldWhile

  20. def foldWhile[T](z: ⇒ T, aliaser: ColumnAliaser)(op: (T, Row) ⇒ (T, Boolean))(implicit connection: Connection): Either[List[Throwable], T]

    Aggregates over part of or the while row stream, using the specified operator.

    Aggregates over part of or the while row stream, using the specified operator.

    z

    the start value

    aliaser

    the column aliaser

    op

    Aggregate operator. Returns aggregated value along with true if aggregation must process next value, or false to stop with current value.

    returns

    Either list of failures at left, or aggregated value

    Definition Classes
    WithResult
    See also

    #withResult

  21. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  22. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  23. def map[A](f: (T) ⇒ A): SimpleSql[A]
  24. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  25. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  26. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  27. def on(args: NamedParameter*): SimpleSql[T]

    Returns the query prepared with named parameters.

    Returns the query prepared with named parameters.

    import anorm.toParameterValue
    
    val baseSql = SQL("SELECT * FROM table WHERE id = {id}") // one named param
    val preparedSql = baseSql.on("id" -> "value")
  28. def onParams(args: ParameterValue*): SimpleSql[T]

    Returns the query prepared with parameters using initial order of placeholder in statement.

    Returns the query prepared with parameters using initial order of placeholder in statement.

    import anorm.toParameterValue
    
    val baseSql =
      SQL("SELECT * FROM table WHERE name = {name} AND lang = {lang}")
    
    val preparedSql = baseSql.onParams("1st", "2nd")
    // 1st param = name, 2nd param = lang
  29. val params: Map[String, ParameterValue]
  30. final def preparedStatement(connection: Connection, generatedColumn: String, generatedColumns: Seq[String]): ManagedResource[PreparedStatement]
    Definition Classes
    Sql
  31. final def preparedStatement(connection: Connection, getGeneratedKeys: Boolean = false): ManagedResource[PreparedStatement]
    Attributes
    protected
    Definition Classes
    Sql
  32. def resultSet(connection: Connection): ManagedResource[ResultSet]

    Executes this statement as query (see executeQuery) and returns result.

    Executes this statement as query (see executeQuery) and returns result.

    Attributes
    protected
    Definition Classes
    Sql → WithResult
  33. val resultSetOnFirstRow: Boolean
    Definition Classes
    SimpleSql → WithResult
  34. val sql: SqlQuery
  35. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  36. def unsafeStatement(connection: Connection, generatedColumn: String, generatedColumns: Seq[String]): PreparedStatement
    Definition Classes
    SimpleSql → Sql
  37. def unsafeStatement(connection: Connection, getGeneratedKeys: Boolean = false): PreparedStatement
    Definition Classes
    SimpleSql → Sql
  38. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  39. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  40. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  41. def withFetchSize(count: Option[Int]): SimpleSql[T]

    Returns this query with the fetch suze updated to the row count.

    Returns this query with the fetch suze updated to the row count.

    See also

    SqlQuery.fetchSize

  42. def withQueryTimeout(seconds: Option[Int]): SimpleSql[T]

    Returns a copy with updated timeout.

  43. def withResult[T](op: (Option[Cursor]) ⇒ T, aliaser: ColumnAliaser)(implicit connection: Connection): Either[List[Throwable], T]

    Processes all or some rows from current result.

    Processes all or some rows from current result.

    op

    Operation applied with row cursor

    @annotation.tailrec
    def go(c: Option[Cursor], l: List[Row]): List[Row] = c match {
      case Some(cursor) => go(cursor.next, l :+ cursor.row)
      case _ => l
    }
    
    val l: Either[List[Throwable], List[Row]] =
      SQL"SELECT * FROM Test".withResult(go)
    Definition Classes
    WithResult
  44. def withResult[T](op: (Option[Cursor]) ⇒ T)(implicit connection: Connection): Either[List[Throwable], T]

    Processes all or some rows from current result.

    Processes all or some rows from current result.

    op

    Operation applied with row cursor

    Definition Classes
    WithResult
  45. def withResultSetOnFirstRow(onFirst: Boolean): SimpleSql[T]

    Returns a copy with updated flag.

Deprecated Value Members

  1. def fold[T](z: ⇒ T)(op: (T, Row) ⇒ T)(implicit connection: Connection): Either[List[Throwable], T]

    Aggregates over all rows using the specified operator.

    Aggregates over all rows using the specified operator.

    z

    the start value

    op

    Aggregate operator

    returns

    Either list of failures at left, or aggregated value

    Definition Classes
    WithResult
    Annotations
    @deprecated
    Deprecated

    (Since version 2.5.1) Use fold with empty ColumnAliaser

    See also

    #withResult

    #foldWhile

  2. def foldWhile[T](z: ⇒ T)(op: (T, Row) ⇒ (T, Boolean))(implicit connection: Connection): Either[List[Throwable], T]

    Aggregates over part of or the while row stream, using the specified operator.

    Aggregates over part of or the while row stream, using the specified operator.

    z

    the start value

    op

    Aggregate operator. Returns aggregated value along with true if aggregation must process next value, or false to stop with current value.

    returns

    Either list of failures at left, or aggregated value

    Definition Classes
    WithResult
    Annotations
    @deprecated
    Deprecated

    (Since version 2.5.1) Use foldWhile with empty ColumnAliaser

    See also

    #withResult

  3. def using[U](p: RowParser[U]): SimpleSql[U]

    Prepares query with given row parser.

    Prepares query with given row parser.

    import anorm.{ SQL, SqlParser }
    
    val res: Int = SQL("SELECT 1").using(SqlParser.scalar[Int]).single
    // Equivalent to: SQL("SELECT 1").as(SqlParser.scalar[Int].single)
    Annotations
    @deprecated
    Deprecated

    (Since version 2.5.1) Use as

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Sql

Inherited from WithResult

Inherited from AnyRef

Inherited from Any

Ungrouped