class CompoundSelect[Q, R] extends Proxy[Q, R]
A SQL SELECT
query, with
ORDER BY
, LIMIT
, OFFSET
, or UNION
clauses
- Alphabetic
- By Inheritance
- CompoundSelect
- Proxy
- Select
- Wrapped
- DelegateQueryable
- Query
- JoinOps
- Joinable
- Aggregatable
- WithSqlExpr
- Renderable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new CompoundSelect(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)
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: (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
Combined with sortBy to make the sort order ascending, translates into SQL
ASC
- Definition Classes
- CompoundSelect → Proxy → Select
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
- def compound0(op: String, other: Select[Q, R]): CompoundSelect[Q, R]
- Definition Classes
- CompoundSelect → Proxy → Select
- val compoundOps: Seq[Op[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 copy[Q, R](lhs: SimpleSelect[Q, R] = this.lhs, compoundOps: Seq[Op[Q, R]] = this.compoundOps, orderBy: Seq[OrderBy] = this.orderBy, limit: Option[Int] = this.limit, offset: Option[Int] = this.offset)(implicit qr: Row[Q, R]): CompoundSelect[Q, R]
- Attributes
- protected
- 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
Combined with sortBy to make the sort order descending, translates into SQL
DESC
- Definition Classes
- CompoundSelect → Proxy → Select
- implicit val dialect: DialectTypeMappers
- Definition Classes
- CompoundSelect → Select
- 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.
Drops the first n rows from this Select. Like when used in Scala collections, if called multiple times the dropped rows add up
- Definition Classes
- CompoundSelect → Proxy → 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
- CompoundSelect → Proxy → WithSqlExpr
- def filter(f: (Q) => Expr[Boolean]): Select[Q, R]
Filters this Select with the given predicate, translates into a SQL
WHERE
clauseFilters this Select with the given predicate, translates into a SQL
WHERE
clause- Definition Classes
- CompoundSelect → Proxy → Select
- def filterIf(cond: Boolean)(f: (Q) => Expr[Boolean]): Select[Q, R]
Filters this Select with the given predicate, if cond evaluates to true
- def filterOpt[T](option: Option[T])(f: (Q, T) => Expr[Boolean]): Select[Q, R]
Filters this Select with the given predicate consuming provided option as a part of predicate's input, if this option is Some[T]
- 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
- @HotSpotIntrinsicCandidate() @native()
- def groupBy[K, V, R2, R3](groupKey: (Q) => K)(groupAggregate: (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
- @HotSpotIntrinsicCandidate() @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
- val lhs: SimpleSelect[Q, R]
- val limit: Option[Int]
- def map[Q2, R2](f: (Q) => Q2)(implicit qr2: Row[Q2, R2]): Select[Q2, R2]
Transforms the return value of this Select with the given function
Transforms the return value of this Select with the given function
- Definition Classes
- CompoundSelect → Proxy → Select
- def mapAggregate[Q2, R2](f: (Q, 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], exprSuffix: 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
- @HotSpotIntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def nullsFirst: Select[Q, R]
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS FIRST
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS FIRST
- Definition Classes
- CompoundSelect → Proxy → Select
- def nullsLast: Select[Q, R]
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS LAST
Combined with sortBy to configure handling of nulls, translates into SQL
NULLS LAST
- Definition Classes
- CompoundSelect → Proxy → Select
- val offset: Option[Int]
- val orderBy: Seq[OrderBy]
- 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. - implicit val qr: Row[Q, R]
- Definition Classes
- CompoundSelect → Proxy → Select → DelegateQueryable
- def queryConstruct(args: ResultSetIterator): Seq[R]
- def queryGetGeneratedKeys: Option[Row[_, _]]
- Attributes
- protected
- Definition Classes
- Query
- 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 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)]
- Attributes
- protected
- Definition Classes
- CompoundSelect → Proxy → Wrapped
- def selectRenderer(prevContext: Context): Renderer
- Attributes
- protected
- Definition Classes
- CompoundSelect → Proxy → Wrapped
- def selectToSimpleSelect(): SimpleSelect[Q, R]
- Attributes
- protected
- Definition Classes
- CompoundSelect → Proxy → Select
- def selectWithExprPrefix(preserveAll: Boolean, s: (Context) => SqlStr): Select[Q, R]
- def selectWithExprSuffix(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.
Sorts this Select via the given expression. Translates into a SQL
ORDER BY
clause. Can be called more than once to sort on multiple columns, with the last call to sortBy taking priority. Can be followed by asc, desc, nullsFirst or nullsLast to configure the sort order- Definition Classes
- CompoundSelect → Proxy → Select
- 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.
Only returns the first n rows from this Select. Like when used in Scala collections, if called multiple times only the smallest value of n takes effect
- Definition Classes
- CompoundSelect → Proxy → 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(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()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def withFilter(f: (Q) => Expr[Boolean]): Select[Q, R]
Alias for filter
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
(Since version 9)