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

Type Members

  1. type ResultSet = Stream[Row]

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  6. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  7. 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)
  8. 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)
  9. 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)
  10. 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)
  11. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. 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)
  13. 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)
  14. 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)
  15. 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)
  16. final def eq(arg0: AnyRef): Boolean

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

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

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  19. 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)
  20. 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)
  21. 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)
  22. 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)
      } *)
  23. 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)
  24. def getAliased[T](aliasName: String)(implicit extractor: Column[T]): RowParser[T]

  25. final def getClass(): Class[_]

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

    Definition Classes
    AnyRef → Any
  27. 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)
  28. 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)
  29. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  30. 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)
  31. 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)
  32. 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

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

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

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

    Definition Classes
    AnyRef
  36. 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)
  37. 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)
  38. 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)
  39. 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)
  40. 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)
  41. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  42. def toString(): String

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

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  45. 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

Inherited from AnyRef

Inherited from Any

Ungrouped