anorm

SqlParser

object SqlParser

Source
SqlParser.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. SqlParser
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

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 array[T](columnPosition: Int)(implicit c: Column[Array[T]]): RowParser[Array[T]]

    Parses specified array column.

    Parses specified array column.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (String, Array[String]) = SQL"SELECT a, sqlArrayOfString FROM test"
      .as(SqlParser.str("a") ~ SqlParser.array[String](2) map (
        SqlParser.flatten) single)
  5. def array[T](columnName: String)(implicit c: Column[Array[T]]): RowParser[Array[T]]

    Parses specified array column.

    Parses specified array column.

    import anorm.{ SQL, SqlParser }
    
    val t: (String, Array[String]) = SQL"SELECT a, sqlArrayOfString FROM test"
      .as(SqlParser.str("a") ~
    SqlParser.array[String]("sqlArrayOfString") map (
        SqlParser.flatten) single)
  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. def binaryStream(columnPosition: Int)(implicit c: Column[InputStream]): RowParser[InputStream]

    Parses specified column as binary stream.

    Parses specified column as binary stream.

    import java.io.InputStream
    import anorm.{ SQL, SqlParser }
    
    val parser = SqlParser.str(1) ~ SqlParser.binaryStream(2)
    val file: (String, InputStream) = SQL("SELECT name, data FROM files").
      as(parser.single)
  8. def binaryStream(columnName: String)(implicit c: Column[InputStream]): RowParser[InputStream]

    Parses specified column as binary stream.

    Parses specified column as binary stream.

    import java.io.InputStream
    import anorm.{ SQL, SqlParser }
    
    val parser = SqlParser.str("name") ~ SqlParser.binaryStream("data")
    val file: (String, InputStream) = SQL("SELECT name, data FROM files").
      as(parser.single)
  9. def bool(columnPosition: Int)(implicit c: Column[Boolean]): RowParser[Boolean]

    Parses specified column as boolean.

    Parses specified column as boolean.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Boolean, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.bool(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  10. def bool(columnName: String)(implicit c: Column[Boolean]): RowParser[Boolean]

    Parses specified column as boolean.

    Parses specified column as boolean.

    import anorm.{ SQL, SqlParser }
    
    val t: (Boolean, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.bool("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  11. def byte(columnPosition: Int)(implicit c: Column[Byte]): RowParser[Byte]

    Parses specified column as byte.

    Parses specified column as byte.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Byte, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.byte(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  12. def byte(columnName: String)(implicit c: Column[Byte]): RowParser[Byte]

    Parses specified column as byte.

    Parses specified column as byte.

    import anorm.{ SQL, SqlParser }
    
    val t: (Byte, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.byte("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  13. def byteArray(columnPosition: Int)(implicit c: Column[Array[Byte]]): RowParser[Array[Byte]]

    Parses specified column as binary stream.

    Parses specified column as binary stream.

    import anorm.{ SQL, SqlParser }
    
    val parser = SqlParser.str(1) ~ SqlParser.byteArray(2)
    val file: (String, Array[Byte]) = SQL("SELECT name, data FROM files").
      as(parser.single)
  14. def byteArray(columnName: String)(implicit c: Column[Array[Byte]]): RowParser[Array[Byte]]

    Parses specified column as binary stream.

    Parses specified column as binary stream.

    import anorm.{ SQL, SqlParser }
    
    val parser = SqlParser.str("name") ~ SqlParser.byteArray("data")
    val file: (String, Array[Byte]) = SQL("SELECT name, data FROM files").
      as(parser.single)
  15. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  16. def date(columnPosition: Int)(implicit c: Column[Date]): RowParser[Date]

    Parses specified column as date.

    Parses specified column as date.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Date, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.date(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  17. def date(columnName: String)(implicit c: Column[Date]): RowParser[Date]

    Parses specified column as date.

    Parses specified column as date.

    import anorm.{ SQL, SqlParser }
    
    val t: (Date, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.date("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  18. def double(columnPosition: Int)(implicit c: Column[Double]): RowParser[Double]

    Parses specified column as double.

    Parses specified column as double.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Double, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.double(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  19. def double(columnName: String)(implicit c: Column[Double]): RowParser[Double]

    Parses specified column as double.

    Parses specified column as double.

    import anorm.{ SQL, SqlParser }
    
    val t: (Double, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.double("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  20. final def eq(arg0: AnyRef): Boolean

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

    Definition Classes
    AnyRef → Any
  22. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  23. def flatten[T1, T2, R](implicit f: TupleFlattener[(~[T1, T2]) ⇒ R]): (~[T1, T2]) ⇒ R

    Flatten columns tuple-like.

    Flatten columns tuple-like.

    import anorm.SQL
    import anorm.SqlParser.{ long, str, int }
    
    val tuple: (Long, String, Int) = SQL("SELECT a, b, c FROM Test").
      as(long("a") ~ str("b") ~ int("c") map (SqlParser.flatten) single)
  24. def float(columnPosition: Int)(implicit c: Column[Float]): RowParser[Float]

    Parses specified column as float.

    Parses specified column as float.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Float, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.float(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  25. def float(columnName: String)(implicit c: Column[Float]): RowParser[Float]

    Parses specified column as float.

    Parses specified column as float.

    import anorm.{ SQL, SqlParser }
    
    val t: (Float, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.float("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  26. def get[T](position: Int)(implicit extractor: Column[T]): RowParser[T]

    Returns row parser for column at given position.

    Returns row parser for column at given position.

    position

    Column position, from 1 to n

    import anorm.SQL
    import anorm.SqlParser.get
    
    val res: (Float, String) = // parsing columns #1 & #3
      SQL("SELECT * FROM Test").as(get[String](1) ~ get[Float](3) map {
        case str ~ f => (f -> str)
      } *)
  27. def get[T](name: String)(implicit extractor: Column[T]): RowParser[T]

    Returns row parser for column with given name.

    Returns row parser for column with given name.

    name

    Column name

    import anorm.SQL
    import anorm.SqlParser.get
    
    val title: String = SQL("SELECT title FROM Books").
      as(get[String]("title").single)
  28. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  29. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  30. def int(columnPosition: Int)(implicit c: Column[Int]): RowParser[Int]

    Parses specified column as integer.

    Parses specified column as integer.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Int, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.int(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  31. def int(columnName: String)(implicit c: Column[Int]): RowParser[Int]

    Parses specified column as integer.

    Parses specified column as integer.

    import anorm.{ SQL, SqlParser }
    
    val t: (Int, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.int("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  32. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  33. def list[T](columnPosition: Int)(implicit c: Column[List[T]]): RowParser[List[T]]

    Parses specified array column as list.

    Parses specified array column as list.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (String, List[String]) = SQL("SELECT a, sqlArrayOfString FROM test")
      .as(SqlParser.str("a") ~ SqlParser.list(2) map (
        SqlParser.flatten) single)
  34. def list[T](columnName: String)(implicit c: Column[List[T]]): RowParser[List[T]]

    Parses specified array column as list.

    Parses specified array column as list.

    import anorm.{ SQL, SqlParser }
    
    val t: (String, List[String]) = SQL("SELECT a, sqlArrayOfString FROM test")
      .as(SqlParser.str("a") ~ SqlParser.list("sqlArrayOfString") map (
        SqlParser.flatten) single)
  35. def long(columnPosition: Int)(implicit c: Column[Long]): RowParser[Long]

    Parses specified column as long.

    Parses specified column as long.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Long, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.long(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  36. def long(columnName: String)(implicit c: Column[Long]): RowParser[Long]

    Parses specified column as long.

    Parses specified column as long.

    import anorm.{ SQL, SqlParser }
    
    val t: (Long, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.long("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  37. def matches[TT, T <: TT](column: String, value: T)(implicit arg0: Column[TT], c: Column[TT]): RowParser[Boolean]

    Returns row parser which true if specified column is found and matching expected value.

    Returns row parser which true if specified column is found and matching expected value.

    import anorm.SQL
    import anorm.SqlParser.matches
    
    val m: Boolean = SQL("SELECT * FROM table").as(matches("a", 1.2f).single)
    // true if column |a| is found and matching 1.2f, otherwise false
    returns

    true if matches, or false if not

  38. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  39. final def notify(): Unit

    Definition Classes
    AnyRef
  40. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  41. def scalar[T](implicit transformer: Column[T]): RowParser[T]

    Returns parser for a scalar not-null value.

    Returns parser for a scalar not-null value.

    val count = SQL("select count(*) from Country").as(scalar[Long].single)
  42. def short(columnPosition: Int)(implicit c: Column[Short]): RowParser[Short]

    Parses specified column as short.

    Parses specified column as short.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Short, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.short(1) ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  43. def short(columnName: String)(implicit c: Column[Short]): RowParser[Short]

    Parses specified column as short.

    Parses specified column as short.

    import anorm.{ SQL, SqlParser }
    
    val t: (Short, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.short("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  44. def str(columnPosition: Int)(implicit c: Column[String]): RowParser[String]

    Parses specified column as string.

    Parses specified column as string.

    columnPosition

    from 1 to n

    import anorm.{ SQL, SqlParser }
    
    val t: (Float, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.float("a") ~ SqlParser.str(1) map (
        SqlParser.flatten) single)
  45. def str(columnName: String)(implicit c: Column[String]): RowParser[String]

    Parses specified column as string.

    Parses specified column as string.

    import anorm.{ SQL, SqlParser }
    
    val t: (Float, String) = SQL("SELECT a, b FROM test")
      .as(SqlParser.float("a") ~ SqlParser.str("b") map (
        SqlParser.flatten) single)
  46. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  47. def toString(): String

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

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Deprecated Value Members

  1. def contains[TT, T <: TT](column: String, value: T)(implicit arg0: Column[TT]): RowParser[Unit]

    Returns row parser which throws exception if specified column is either missing or not matching expected value.

    Returns row parser which throws exception if specified column is either missing or not matching expected value. If row contains described column, do nothing (Unit).

    import anorm.SQL
    import anorm.SqlParser.{ contains, str }
    
    val parser = contains("a", true) ~ str("b") map {
      case () ~ str => str
    }
    
    SQL("SELECT * FROM table").as(parser.+)
    // Throws exception if there no |a| column or if |a| is not true,
    // otherwise parses as non-empty list of |b| strings.
    Annotations
    @throws( ... ) @deprecated
    Deprecated

    (Since version 2.3.0) Use matches

  2. def getAliased[T](aliasName: String)(implicit extractor: Column[T]): RowParser[T]

    Annotations
    @deprecated
    Deprecated

    (Since version 2.3.3) Use get with alias

Inherited from AnyRef

Inherited from Any

Ungrouped