package lifted
Lifted embedding: Stable query api based on implicits and overloading lifting Scala code into Slick ASTs
- Source
- package.scala
- Alphabetic
- By Inheritance
- lifted
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
abstract
class
AbstractTable[T] extends Rep[T]
The profile-independent superclass of all table row objects.
The profile-independent superclass of all table row objects.
- T
Row type for this table. Make sure it matches the type of your
*
projection.
- trait AbstractTableShapeImplicits extends RepShapeImplicits
-
trait
Aliases extends AnyRef
Aliases for lifted embedding features.
Aliases for lifted embedding features. This trait can be mixed into aliasing objects which simplify the use of the lifted embedding.
-
final
class
AnyExtensionMethods extends AnyVal
Extension methods for all columns and all primitive values that can be lifted to columns
-
final
class
AnyOptionExtensionMethods[O <: Rep[_], P] extends AnyVal
Extension methods for Options of single- and multi-column values
- class AppliedCompiledFunction[PU, R <: Rep[_], RU] extends RunnableCompiled[R, RU]
- final class BaseColumnExtensionMethods[P1] extends AnyVal with ColumnExtensionMethods[P1, P1] with BaseExtensionMethods[P1]
- trait BaseExtensionMethods[B1] extends ExtensionMethods[B1, B1]
- final class BaseJoinQuery[+E1, +E2, U1, U2, C[_], +B1, +B2] extends WrappingQuery[(E1, E2), (U1, U2), C]
- final class BaseNumericColumnExtensionMethods[P1] extends AnyVal with NumericColumnExtensionMethods[P1, P1] with BaseExtensionMethods[P1]
-
trait
BaseTag extends Tag
A Tag marking the base table instance itself
-
final
class
BooleanColumnExtensionMethods[P1] extends AnyVal with ExtensionMethods[Boolean, P1]
Extension methods for
Rep[Boolean]
andRep[Option[Boolean]]
-
trait
CanBeQueryCondition[-T] extends (T) ⇒ Rep[_]
A typeclass for types that can be used as predicates in
filter
calls.A typeclass for types that can be used as predicates in
filter
calls.- Annotations
- @implicitNotFound( ... )
-
class
CaseClassShape[P <: Product, LiftedTuple, LiftedCaseClass <: P, PlainTuple, PlainCaseClass <: P] extends MappedScalaProductShape[FlatShapeLevel, P, LiftedCaseClass, PlainCaseClass, LiftedCaseClass]
A generic case class shape that can be used to lift a case class of plain Scala types to a case class of lifted types.
A generic case class shape that can be used to lift a case class of plain Scala types to a case class of lifted types. This allows the type to be used as a record type (like tuples and HLists) in the Lifted Embedding.
Example:
case class C(a: Int, b: Option[String]) case class LiftedC(a: Column[Int], b: Column[Option[String]]) implicit object cShape extends CaseClassShape(LiftedC.tupled, C.tupled)
-
trait
ColumnExtensionMethods[B1, P1] extends ExtensionMethods[B1, P1]
Extension methods for all columns
-
case class
ColumnOrdered[T](column: Rep[T], ord: Ordering) extends Ordered with Product with Serializable
A
Column
with an associatedOrdering
. -
trait
ColumnsShapeLevel extends FlatShapeLevel
ShapeLevel that only allows records of individual columns.
ShapeLevel that only allows records of individual columns. This level is used for parameters of compiled queries.
-
trait
Compilable[T, C <: Compiled[T]] extends AnyRef
Typeclass for types that can be contained in a
Compiled
container.Typeclass for types that can be contained in a
Compiled
container. This includes allExecutable
types as well as functions (of any arity) from flat, fully packed parameter types to anExecutable
result type.- Annotations
- @implicitNotFound( ... )
- trait CompilableFunctions extends CompilableLowPriority
- trait CompilableLowPriority extends AnyRef
-
sealed
trait
Compiled[T] extends AnyRef
A possibly parameterized query that will be cached for repeated efficient execution without having to recompile it every time.
A possibly parameterized query that will be cached for repeated efficient execution without having to recompile it every time. The compiled state is computed on demand the first time a
Cached
value is executed. It is always tied to a specific profile.Cached
forms a limited monad which ensures that it can only contain values that areCompilable
. - abstract class CompiledExecutable[R, RU] extends RunnableCompiled[R, RU] with CompilersMixin
- class CompiledFunction[F, PT, PU, R <: Rep[_], RU] extends Compiled[F] with CompilersMixin
- abstract class CompiledStreamingExecutable[R, RU, EU] extends CompiledExecutable[R, RU] with StreamableCompiled[R, RU, EU]
- trait CompilersMixin extends AnyRef
-
class
ConstColumn[T] extends TypedRep[T]
A scalar value that is known at the client side at the time a query is executed.
A scalar value that is known at the client side at the time a query is executed. This is either a constant value (
LiteralColumn
) or a scalar parameter. - trait ConstColumnShapeImplicits extends RepShapeImplicits
-
trait
Constraint extends AnyRef
Marker trait for foreign key and primary key constraints.
-
trait
Executable[T, TU] extends AnyRef
Typeclass for types that can be executed as queries.
Typeclass for types that can be executed as queries. This encompasses collection-valued (
Query[_, _, _[_] ]
), scalar and record types.- Annotations
- @implicitNotFound( ... )
- trait ExtensionMethodConversions extends AnyRef
- trait ExtensionMethods[B1, P1] extends Any
-
trait
FlatShapeLevel extends NestedShapeLevel
ShapeLevel that does not allow nested collections.
ShapeLevel that does not allow nested collections. This is the standard level for executable queries.
-
final
class
ForeignKey extends AnyRef
Represents a foreign key.
Represents a foreign key. Objects of this type are used internally by Slick. At the user level you generally see
ForeignKeyQuery
objects instead. -
class
ForeignKeyQuery[E <: AbstractTable[_], U] extends WrappingQuery[E, U, Seq] with Constraint
A query that selects data linked by a foreign key.
-
final
class
FunctionSymbolExtensionMethods extends AnyRef
Utility methods for internal use in the lifted embedding
-
class
Index extends AnyRef
An index (or foreign key constraint with an implicit index).
-
final
case class
LiteralColumn[T](value: T)(implicit tt: TypedType[T]) extends ConstColumn[T] with Product with Serializable
A column with a constant value which is inserted into an SQL statement as a literal.
-
abstract
class
MappedProductShape[Level <: ShapeLevel, C, M <: C, U <: C, P <: C] extends ProductNodeShape[Level, C, M, U, P]
Base class for ProductNodeShapes with a type mapping
- class MappedProjection[T] extends Rep[T]
-
abstract
class
MappedScalaProductShape[Level <: ShapeLevel, C <: Product, M <: C, U <: C, P <: C] extends MappedProductShape[Level, C, M, U, P]
Base class for ProductNodeShapes with a type mapping to a type that extends scala.Product
-
trait
NestedShapeLevel extends ShapeLevel
ShapeLevel that allows nested collections.
-
trait
NumericColumnExtensionMethods[B1, P1] extends ExtensionMethods[B1, P1]
Extension methods for numeric columns
- final class OptionColumnExtensionMethods[B1] extends AnyVal with ColumnExtensionMethods[B1, Option[B1]] with OptionExtensionMethods[B1]
- trait OptionExtensionMethods[B1] extends ExtensionMethods[B1, Option[B1]]
-
sealed
trait
OptionLift[M, O] extends AnyRef
A typeclass that lifts a mixed type to the packed Option type.
- sealed trait OptionLiftLowPriority extends AnyRef
- trait OptionMapper[BR, R] extends (Rep[BR]) ⇒ Rep[R]
-
sealed
trait
OptionMapper2[B1, B2, BR, P1, P2, R] extends OptionMapper[BR, R]
- Annotations
- @implicitNotFound( ... )
-
sealed
trait
OptionMapper3[B1, B2, B3, BR, P1, P2, P3, R] extends OptionMapper[BR, R]
- Annotations
- @implicitNotFound( ... )
- final class OptionNumericColumnExtensionMethods[B1] extends AnyVal with NumericColumnExtensionMethods[B1, Option[B1]] with OptionExtensionMethods[B1]
- trait OptionShapeImplicits extends AnyRef
- class Ordered extends AnyRef
- final class Parameters[PU, PP] extends AnyRef
-
case class
PrimaryKey(name: String, columns: IndexedSeq[Node]) extends Constraint with Product with Serializable
An explicit primary key.
An explicit primary key. Simple primary keys can also be represented by
O.PrimaryKey
column options instead. -
class
ProductClassShape[E <: Product, C <: Product] extends MappedScalaProductShape[FlatShapeLevel, Product, C, E, C]
A generic Product class shape that can be used to lift a class of plain Scala types to a class of lifted types.
A generic Product class shape that can be used to lift a class of plain Scala types to a class of lifted types. This allows the type to be used as a record type (like tuples and HLists) in the Lifted Embedding.
This can help with mapping tables >22 columns to classes, especially when using code generation. This can be used for Scala 2.11 case classes >22 fields.
Example:
def columnShape[T](implicit s: Shape[FlatShapeLevel, Column[T], T, Column[T]]) = s class C(val a: Int, val b: Option[String]) extends Product{ def canEqual(that: Any): Boolean = that.isInstanceOf[C] def productArity: Int = 2 def productElement(n: Int): Any = Seq(a, b)(n) } class LiftedC(val a: Column[Int], val b: Column[Option[String]]) extends Product{ def canEqual(that: Any): Boolean = that.isInstanceOf[LiftedC] def productArity: Int = 2 def productElement(n: Int): Any = Seq(a, b)(n) } implicit object cShape extends ProductClassShape( Seq(columnShape[Int], columnShape[Option[String]]), seq => new LiftedC(seq(0).asInstanceOf[Column[Int]], seq(1).asInstanceOf[Column[Option[String]]]), seq => new C(seq(0).asInstanceOf[Int], seq(1).asInstanceOf[Option[String]]) )
-
abstract
class
ProductNodeShape[Level <: ShapeLevel, C, M <: C, U <: C, P <: C] extends Shape[Level, M, U, P]
Base class for Shapes of record values which are represented by ProductNodes in the AST.
Base class for Shapes of record values which are represented by ProductNodes in the AST.
- C
The supertype for the record values.
- M
The mixed type of the Shape (a subtype of C).
- U
The unpacked type of the Shape (a subtype of C).
- P
The fully packed type of the Shape (a subtype of C).
-
trait
ProvenShape[U] extends AnyRef
A limited version of ShapedValue which can be constructed for every type that has a valid shape.
A limited version of ShapedValue which can be constructed for every type that has a valid shape. We use it to enforce that a table's * projection has a valid shape. A ProvenShape has itself a Shape so it can be used in place of the value that it wraps for purposes of packing and unpacking.
-
abstract
class
Query[+E, U, C[_]] extends QueryBase[C[U]]
An instance of Query represents a query or view, i.e.
An instance of Query represents a query or view, i.e. a computation of a collection type (
Rep[Seq[T]]
). It is parameterized with both, the mixed type (the type of values you see e.g. when you call map()) and the unpacked type (the type of values that you get back when you run the query).Additional extension methods for queries containing a single column are defined in slick.lifted.SingleColumnQueryExtensionMethods.
- sealed trait QueryBase[T] extends Rep[T]
-
abstract
class
RefTag extends Tag
A Tag for table instances that represent a Node
-
trait
Rep[T] extends AnyRef
Common base trait for all lifted values, including columns.
Common base trait for all lifted values, including columns.
All column operations are added with extension methods that depend on the type inside the
Rep
. These are defined in:- slick.lifted.AnyExtensionMethods and slick.lifted.ColumnExtensionMethods for columns of all types
- slick.lifted.OptionColumnExtensionMethods for columns of all
Option
types - slick.lifted.BaseColumnExtensionMethods for columns of all non-
Option
types - slick.lifted.NumericColumnExtensionMethods for columns of numeric types (and Options thereof)
- slick.lifted.BooleanColumnExtensionMethods for columns of
Boolean
/Option[Boolean]
- slick.lifted.StringColumnExtensionMethods for columns of
String
/Option[String]
- slick.lifted.ColumnOrdered for using columns in
sortBy
calls
A
Rep[T : TypedType]
is alwaysTyped
, so that theTypedType
can be retrieved directly from theRep
value. -
final
case class
RepOption[T](base: ShapedValue[_, _], toNode: Node) extends Rep[Option[T]] with Product with Serializable
Represents
Rep[Option[T]]
in all cases whereT
is not a column base type.Represents
Rep[Option[T]]
in all cases whereT
is not a column base type. This special representation is necessary so that a non-OptionRep
value can be retrieved for encoding Option-based operations. This base value is of typeT
ifT <: Rep[_]
, otherwise of typeRep[T]
. - trait RepShapeImplicits extends OptionShapeImplicits
-
trait
RunnableCompiled[R, RU] extends Compiled[R]
A compiled value that can be executed to obtain its result.
-
abstract
class
Shape[Level <: ShapeLevel, -Mixed_, Unpacked_, Packed_] extends AnyRef
A type class that encodes the unpacking
Mixed => Unpacked
of aQuery[Mixed]
to its result element typeUnpacked
and the packing to a fully packed typePacked
, i.e.A type class that encodes the unpacking
Mixed => Unpacked
of aQuery[Mixed]
to its result element typeUnpacked
and the packing to a fully packed typePacked
, i.e. a type where everything which is not a transparent container is wrapped in aColumn[_]
.Example:
- Mixed:
(Column[Int], Column[(Int, String)], (Int, Option[Double]))
- Unpacked:
(Int, (Int, String), (Int, Option[Double]))
- Packed:
(Column[Int], Column[(Int, String)], (Column[Int], Column[Option[Double]]))
- Linearized:
(Int, Int, String, Int, Option[Double])
- Annotations
- @implicitNotFound( ... )
- Mixed:
-
trait
ShapeLevel extends AnyRef
The level of a Shape, i.e.
The level of a Shape, i.e. what kind of types it allows. Subtypes of this trait are used as a phantom type for Shape resolution. There are no instances of any ShapeLevel.
-
case class
ShapedValue[T, U](value: T, shape: Shape[_ <: FlatShapeLevel, T, U, _]) extends Rep[U] with Product with Serializable
A value together with its Shape
-
trait
SimpleBinaryOperator extends BinaryNode
A SimpleBinaryOperator gets translated to a binary operator call in SQL.
-
trait
SimpleExpression extends Node
A SimpleExpression allows arbitrary SQL code to be generated.
-
trait
SimpleFunction extends Node
A SimpleFunction gets translated to a plain function call or JDBC/ODBC scalar function {fn ...} call in SQL.
-
final
case class
SimpleLiteral(name: String)(buildType: Type) extends NullaryNode with SimplyTypedNode with Product with Serializable
A SimpleLiteral is inserted verbatim into a SQL query string.
A SimpleLiteral is inserted verbatim into a SQL query string. For the purpose of handling it in the query compiler it is assumed to be an expression of the specified type.
-
final
class
SingleColumnQueryExtensionMethods[B1, P1, C[_]] extends AnyVal
Extension methods for Queries of a single column
-
trait
StreamableCompiled[R, RU, EU] extends RunnableCompiled[R, RU]
A compiled value that can be executed to obtain its result as a stream of data.
-
trait
StreamingExecutable[T, TU, EU] extends Executable[T, TU]
Typeclass for types that can be executed as streaming queries, i.e.
Typeclass for types that can be executed as streaming queries, i.e. only collection-valued (
Query[_, _, _[_] ]
) types. This is used as a phantom type for computing the required types. The actual value is alwaysnull
.- Annotations
- @implicitNotFound( ... )
-
final
class
StringColumnExtensionMethods[P1] extends AnyVal with ExtensionMethods[String, P1]
Extension methods for
Rep[String]
andRep[Option[String]]
-
class
TableQuery[E <: AbstractTable[_]] extends Query[E, lifted.TableQuery.E.TableElementType, Seq]
Represents a database table.
Represents a database table. Profiles add extension methods to TableQuery for operations that can be performed on tables but not on arbitrary queries, e.g. getting the table DDL.
-
sealed
trait
Tag extends AnyRef
A Tag marks a specific row represented by an AbstractTable instance.
-
final
class
TupleShape[Level <: ShapeLevel, M <: Product, U <: Product, P <: Product] extends ProductNodeShape[Level, Product, M, U, P]
Shape for Scala tuples of all arities
- trait TupleShapeImplicits extends AnyRef
- class WrappingQuery[+E, U, C[_]] extends Query[E, U, C]
Value Members
- object CanBeQueryCondition
-
object
Case
Case
provides a DSL for conditional statements in the query language.Case
provides a DSL for conditional statements in the query language. An arbitrary number ofIf
...Then
expressions can be chained, optionally followed byElse
, e.g.:Case If u.id < 3 Then "low" If u.id < 6 Then "medium" Else "high"
All result expressions have to be of compatible type (modulo nullability). If at least one of them is an
Option
type or theElse
branch is missing, the result is also anOption
. - object Compilable extends CompilableFunctions
- object Compiled
- object Executable
- object ForeignKey
- object FunctionSymbolExtensionMethods
-
object
Functions
Contains stand-alone database functions for use in queries.
Contains stand-alone database functions for use in queries. Functions which operate on columns are generally added as extension methods to the appropriate column types instead.
- object OptionLift extends OptionLiftLowPriority
- object OptionMapper2
- object OptionMapper3
- object OptionMapperDSL
- object Ordered
- object Parameters
- object ProvenShape
-
object
Query
The companion object for Query contains factory methods for creating queries.
- object Rep
-
object
RepShape extends Shape[FlatShapeLevel, Rep[_], Any, Rep[_]]
Shape for Rep values (always fully packed)
- object Shape extends ConstColumnShapeImplicits with AbstractTableShapeImplicits with TupleShapeImplicits
- object ShapedValue extends Serializable
- object SimpleBinaryOperator
- object SimpleExpression
- object SimpleFunction
- object SimpleLiteral extends Serializable
-
object
StreamingExecutable extends StreamingExecutable[Rep[Any], Any, Any]
A prototype
StreamingExecutable
instance forRep
types. - object TableQuery
- object TableQueryMacroImpl
edit this text on github
Scala Language-Integrated Connection Kit
This is the API documentation for the Slick database library. It should be used as an additional resource to the user manual.
Further documentation for Slick can be found on the documentation pages.
To the slick package list...