trait Proxy[Q, R] extends Select[Q, R]
- Alphabetic
- By Inheritance
- Proxy
- Select
- Wrapped
- DelegateQueryable
- Query
- JoinOps
- Joinable
- Aggregatable
- WithSqlExpr
- Renderable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def dialect: DialectTypeMappers
- Attributes
- protected
- Definition Classes
- Select
- abstract def qr: Row[Q, R]
- Definition Classes
- Proxy → Select → DelegateQueryable
- abstract def selectToSimpleSelect(): SimpleSelect[Q, R]
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 aggregate[E, V](f: (core.Aggregatable.Proxy[Q]) => E)(implicit qr: Row[E, V]): Aggregate[E, V]
Performs one or more aggregates in a single Select
- def aggregateExpr[V](f: (Q) => (Context) => SqlStr)(implicit arg0: TypeMapper[V], qr: Row[Expr[V], V]): Expr[V]
- Definition Classes
- Proxy → Aggregatable
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asc: Select[Q, R]
Combined with sortBy to make the sort order ascending, translates into SQL
ASC
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compound0(op: String, other: Select[Q, R]): CompoundSelect[Q, R]
- def contains(other: Q): Expr[Boolean]
Returns whether or not the Select on the left contains the other value on the right
- def crossJoin[Q2, R2, QF, RF](other: Joinable[Q2, R2])(implicit ja: JoinAppend[Q, Q2, QF, RF]): Select[QF, RF]
Performs a
CROSS JOIN
, which is anINNER JOIN
but without theON
clausePerforms a
CROSS JOIN
, which is anINNER JOIN
but without theON
clause- Definition Classes
- JoinOps
- def crossJoin[Q2, R2](): Mapper[Q, Q2, R, R2]
Version of
crossJoin
meant for usage infor
-comprehensionsVersion of
crossJoin
meant for usage infor
-comprehensions- Definition Classes
- Joinable
- def desc: Select[Q, R]
Combined with sortBy to make the sort order descending, translates into SQL
DESC
- def distinct: Select[Q, R]
Causes this Select to ignore duplicate rows, translates into SQL
SELECT DISTINCT
- def drop(n: Int): Select[Q, R]
Drops the first n rows from this Select.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def except(other: Select[Q, R]): Select[Q, R]
Subtracts the other from this Select, returning only rows present this but absent in other, and removing duplicates.
- def expr: Q
- Attributes
- protected
- Definition Classes
- Proxy → WithSqlExpr
- def filter(f: (Q) => Expr[Boolean]): Select[Q, R]
Filters this Select with the given predicate, translates into a SQL
WHERE
clause - def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMap[Q2, R2](f: (Q) => Rhs[Q2, R2])(implicit qr: Row[Q2, R2]): Select[Q2, R2]
Performs an implicit
JOIN
between this Select and the one returned by the callback function f - final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def groupBy[K, V, R2, R3](groupKey: (Q) => K)(groupAggregate: (core.Aggregatable.Proxy[Q]) => V)(implicit qrk: Row[K, R2], qrv: Row[V, R3]): Select[(K, V), (R2, R3)]
Translates into a SQL
GROUP BY
, takes a function specifying the group-key and a function specifying the group-aggregate. - def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def head: Single[R]
Shorthand for
.take(1).single
:Shorthand for
.take(1).single
:1. If the query returns a single row, this returns it as a single value of type R 2. If the query returns multiple rows, returns the first as a single value of type R and discards the rest 3. If the query returns zero rows, throws an exception.
- Definition Classes
- Select
- def intersect(other: Select[Q, R]): Select[Q, R]
Intersects the result rows of this Select with another, preserving only rows present in both this and the other and removing duplicates.
- def isEmpty: Expr[Boolean]
Returns whether or not the Select on the left is empty with zero elements
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[Q2, R2, QF, RF](other: Joinable[Q2, R2])(on: (Q, Q2) => Expr[Boolean])(implicit ja: JoinAppend[Q, Q2, QF, RF]): Select[QF, RF]
Performs a
JOIN
/INNER JOIN
on the given other, typically a Table or Select. - def join[Q2, R2](on: (Q) => Expr[Boolean]): Mapper[Q, Q2, R, R2]
Version of
join
meant for usage infor
-comprehensionsVersion of
join
meant for usage infor
-comprehensions- Definition Classes
- Joinable
- def join0[Q2, R2, QF, RF](prefix: String, other: Joinable[Q2, R2], on: Option[(Q, Q2) => Expr[Boolean]])(implicit ja: JoinAppend[Q, Q2, QF, RF]): Select[QF, RF]
- def joinInfo[Q2, R2](joinPrefix: String, other: Joinable[Q2, R2], on: Option[(Q, Q2) => Expr[Boolean]]): (Seq[Join], Q2)
- Attributes
- protected
- Definition Classes
- JoinOps
- def joinableToFromExpr: (From, Q)
- def leftJoin[Q2, R2](other: Joinable[Q2, R2])(on: (Q, Q2) => Expr[Boolean])(implicit joinQr: Row[Q2, R2]): Select[(Q, JoinNullable[Q2]), (R, Option[R2])]
Performs a
LEFT JOIN
on the given other, typically a Table or Select. - def leftJoin[Q2, R2](on: (Q) => Expr[Boolean]): NullableMapper[Q, Q2, R, R2]
Version of
leftJoin
meant for usage infor
-comprehensionsVersion of
leftJoin
meant for usage infor
-comprehensions- Definition Classes
- Joinable
- def map[Q2, R2](f: (Q) => Q2)(implicit qr: Row[Q2, R2]): Select[Q2, R2]
Transforms the return value of this Select with the given function
- def mapAggregate[Q2, R2](f: (Q, core.Aggregatable.Proxy[Q]) => Q2)(implicit qr: Row[Q2, R2]): Select[Q2, R2]
Performs a
.map
which additionally provides a Aggregatable.Proxy that allows you to perform aggregate functions. - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newCompoundSelect[Q, R](lhs: SimpleSelect[Q, R], compoundOps: Seq[Op[Q, R]], orderBy: Seq[OrderBy], limit: Option[Int], offset: Option[Int])(implicit qr: Row[Q, R], dialect: DialectTypeMappers): CompoundSelect[Q, R]
- Attributes
- protected
- Definition Classes
- Select
- def newSimpleSelect[Q, R](expr: Q, exprPrefix: Option[(Context) => SqlStr], preserveAll: Boolean, from: Seq[From], joins: Seq[Join], where: Seq[Expr[_]], groupBy0: Option[GroupBy])(implicit qr: Row[Q, R], dialect: DialectTypeMappers): SimpleSelect[Q, R]
- Attributes
- protected
- Definition Classes
- Select
- def nonEmpty: Expr[Boolean]
Returns whether or not the Select on the left is nonempty with one or more elements
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def nullsFirst: Select[Q, R]
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS FIRST
- def nullsLast: Select[Q, R]
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS LAST
- def outerJoin[Q2, R2](other: Joinable[Q2, R2])(on: (Q, Q2) => Expr[Boolean])(implicit joinQr: Row[Q2, R2]): Select[(JoinNullable[Q], JoinNullable[Q2]), (Option[R], Option[R2])]
Performs a
OUTER JOIN
on the given other, typically a Table or Select. - def queryConstruct(args: ResultSetIterator): Seq[R]
- def queryIsExecuteUpdate: Boolean
- Attributes
- protected
- Definition Classes
- DelegateQueryable → Query
- def queryIsSingleRow: Boolean
- Attributes
- protected
- Definition Classes
- Select → DelegateQueryable → Query
- def queryWalkExprs(): Seq[Expr[_]]
- Attributes
- protected
- Definition Classes
- DelegateQueryable → Query
- def queryWalkLabels(): Seq[List[String]]
- Attributes
- protected
- Definition Classes
- DelegateQueryable → Query
- def renderSql(ctx: Context): SqlStr
- Attributes
- protected
- Definition Classes
- Select → Renderable
- def rightJoin[Q2, R2](other: Joinable[Q2, R2])(on: (Q, Q2) => Expr[Boolean])(implicit joinQr: Row[Q2, R2]): Select[(JoinNullable[Q], Q2), (Option[R], R2)]
Performs a
RIGHT JOIN
on the given other, typically a Table or Select. - def selectExprAliases(prevContext: Context): Seq[(Identity, SqlStr)]
- def selectRenderer(prevContext: Context): Renderer
- def selectWithExprPrefix(preserveAll: Boolean, s: (Context) => SqlStr): Select[Q, R]
- def single: Single[R]
Asserts that this query returns exactly one row, and returns a single value of type R rather than a
Seq[R]
.Asserts that this query returns exactly one row, and returns a single value of type R rather than a
Seq[R]
. Throws an exception if zero or multiple rows are returned.- Definition Classes
- Select
- def sortBy(f: (Q) => Expr[_]): Select[Q, R]
Sorts this Select via the given expression.
- def subquery: SimpleSelect[Q, R]
Forces this Select to be treated as a subquery that any further operations will operate on, rather than having some operations flattened out into clauses in this Select
- def subqueryRef(implicit qr: Row[Q, R]): SubqueryRef
- Attributes
- protected
- Definition Classes
- Select
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def take(n: Int): Select[Q, R]
Only returns the first n rows from this Select.
- def toExpr(implicit mt: TypeMapper[R]): Expr[R]
Converts this Select into an Expr, assuming it returns a single row and a single column.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def union(other: Select[Q, R]): Select[Q, R]
Concatenates the result rows of this Select with another and removes duplicate rows; translates into SQL
UNION
- def unionAll(other: Select[Q, R]): Select[Q, R]
Concatenates the result rows of this Select with another; translates into SQL
UNION ALL
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def withFilter(f: (Q) => Expr[Boolean]): Select[Q, R]
Alias for filter