TableDef

Instance Constructors

new TableDef(model: model.Table)

model
corresponding Slick meta model component

Type Members

abstract type Column <: ColumnDef

Column generator virtual class
abstract case class ColumnDef(model: model.Column) extends TermDef with Product with Serializable

Column related generator definition
Column related generator definition
model
corresponding Slick meta model component
trait Def extends AnyRef

Common interface for any kind of definition within the generated code
abstract type EntityType <: EntityTypeDef

Entity case class or type alias generator virtual class
trait EntityTypeDef extends TypeDef

Entity case class or type alias generator definition (Mapped case class holding a complete row of data of this table).
abstract type ForeignKey <: ForeignKeyDef

Foreign key generator virtual class
abstract case class ForeignKeyDef(model: model.ForeignKey) extends TermDef with Product with Serializable

ForeignKey related generator definition
ForeignKey related generator definition
model
corresponding Slick meta model component
abstract type Index <: IndexDef

Index generator virtual class
abstract case class IndexDef(model: model.Index) extends TermDef with Product with Serializable

Index related generator definition
Index related generator definition
model
corresponding Slick meta model component
abstract type PlainSqlMapper <: PlainSqlMapperDef

Plain SQL GetResult mapper generator virtual class
trait PlainSqlMapperDef extends TermDef

Plain SQL GetResult mapper generator definition
abstract type PrimaryKey <: PrimaryKeyDef

Primary key generator virtual class
abstract case class PrimaryKeyDef(model: model.PrimaryKey) extends TermDef with Product with Serializable

PrimaryKey related generator definition (Currently only used for composite primary keys.)
PrimaryKey related generator definition (Currently only used for composite primary keys.)
model
corresponding Slick meta model component
abstract type TableClass <: TableClassDef

Table class generator virtual class
trait TableClassDef extends TypeDef

Table class generator definition
abstract type TableValue <: TableValueDef

Table value generator virtual class
trait TableValueDef extends TermDef

Table value generator definition (generates a collection-like value representing this database table).
trait TermDef extends Def

Common interface for definitions that define a term (val, def, ...) within the generated code
trait TypeDef extends Def

Common interface for definitions that define a type (class, case class, ...) within the generated code

Abstract Value Members

abstract def Column: (model.Column) ⇒ Column

Column generator factory.
Column generator factory. Override for customization.
abstract def EntityType: EntityType

Entity case class or type alias generator factory.
Entity case class or type alias generator factory. Override for customization.
abstract def ForeignKey: (model.ForeignKey) ⇒ ForeignKey

ForeignKey generator factory.
ForeignKey generator factory. Override for customization.
abstract def Index: (model.Index) ⇒ Index

Index generator factory.
Index generator factory. Override for customization.
abstract def PlainSqlMapper: PlainSqlMapper

Plain SQL GetResult mapper generator factory.
Plain SQL GetResult mapper generator factory. Override for customization.
abstract def PrimaryKey: (model.PrimaryKey) ⇒ PrimaryKey

PrimaryKey generator factory.
PrimaryKey generator factory. Override for customization.
abstract def TableClass: TableClass

Table class generator factory.
Table class generator factory. Override for customization.
abstract def TableValue: TableValue

Table value generator factory.
Table value generator factory. Override for customization.
abstract def compoundType(types: Seq[Code]): Code

Creates a compound type from a given sequence of types.
Creates a compound type from a given sequence of types. Uses HList if hlistEnabled else tuple.
abstract def compoundValue(values: Seq[Code]): Code

Creates a compound value from a given sequence of values.
Creates a compound value from a given sequence of values. Uses HList if hlistEnabled else tuple.
abstract def extractor: Code

Function that extracts the unmapped values from an entity object
abstract def factory: Code

Function that constructs an entity object from the unmapped values

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from TableDef to any2stringadd[TableDef] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (TableDef, B)

Implicit information
This member is added by an implicit conversion from TableDef to ArrowAssoc[TableDef] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def autoIncLast: Boolean

Indicates whether auto increment columns should be put last.
Indicates whether auto increment columns should be put last. Please set to !hlistEnabled for switching this on.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def code: Seq[Code]

Generates the complete code for this table and its subordinate generators.
final lazy val columns: Seq[Column]

Column code generators in the desired user-facing order.
final lazy val columnsByName: Map[String, Column]

Column code generators indexed by db column name
final lazy val columnsPositional: IndexedSeq[Column]

Column code generators in the order they appear in the model.
def definitions: Seq[Def]

Definitions to be generated for this table
lazy val desiredColumnOrder: Seq[Int]

Database column positions in the desired user-facing order.
Database column positions in the desired user-facing order. Currently just moves the positions of AutoInc columns to the end if autoIncLastAsOption is enabled.
def ensuring(cond: (TableDef) ⇒ Boolean, msg: ⇒ Any): TableDef

Implicit information
This member is added by an implicit conversion from TableDef to Ensuring[TableDef] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (TableDef) ⇒ Boolean): TableDef

Implicit information
This member is added by an implicit conversion from TableDef to Ensuring[TableDef] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): TableDef

Implicit information
This member is added by an implicit conversion from TableDef to Ensuring[TableDef] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): TableDef

Implicit information
This member is added by an implicit conversion from TableDef to Ensuring[TableDef] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final lazy val foreignKeys: Seq[ForeignKey]

Foreign key code generators
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from TableDef to StringFormat[TableDef] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hlistEnabled: Boolean

If HList should be used as a compound type instead of tuples.
If HList should be used as a compound type instead of tuples. Only if hugeClassEnabled is false.
def hugeClassEnabled: Boolean

Default is true, i.e.
Default is true, i.e. a case class will be generated even if column.size > 22. Override to false to get the code as before Slick 3.3, i.e. a HList based type will be generated instead.
final lazy val indices: Seq[Index]

Index code generators
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isMappedToHugeClass: Boolean

Indicates if table has more than 22 columns but still has to be mapped to a case class.
def mappingEnabled: Boolean

Indicates if this table should be mapped using factory and extractor or not, in which case tuples are used.
Indicates if this table should be mapped using factory and extractor or not, in which case tuples are used. (Consider overriding EntityType.enabled instead, which affects this, too.) Disabled by default when using hlists.
val model: model.Table

corresponding Slick meta model component
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final lazy val primaryKey: Option[PrimaryKey]

Primary key code generator, if this table has one
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )
def →[B](y: B): (TableDef, B)

Implicit information
This member is added by an implicit conversion from TableDef to ArrowAssoc[TableDef] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Deprecated Value Members

def autoIncLastAsOption: Boolean

Indicates whether auto increment columns should be put last and made an Option with a None default.
Indicates whether auto increment columns should be put last and made an Option with a None default. Please set to !hlistEnabled for switching this on.

Annotations
@deprecated
Deprecated
(Since version 3.2.0) Use autoIncLast = true and ColumnDef.asOption = autoInc instead.

Inherited from Serializable

Related Doc: package AbstractGenerator

abstract case class TableDef(model: model.Table) extends Product with Serializable

Instance Constructors

new TableDef(model: model.Table)

Type Members

abstract type Column <: ColumnDef

abstract case class ColumnDef(model: model.Column) extends TermDef with Product with Serializable

trait Def extends AnyRef

abstract type EntityType <: EntityTypeDef

trait EntityTypeDef extends TypeDef

abstract type ForeignKey <: ForeignKeyDef

abstract case class ForeignKeyDef(model: model.ForeignKey) extends TermDef with Product with Serializable

abstract type Index <: IndexDef

abstract case class IndexDef(model: model.Index) extends TermDef with Product with Serializable

abstract type PlainSqlMapper <: PlainSqlMapperDef

trait PlainSqlMapperDef extends TermDef

abstract type PrimaryKey <: PrimaryKeyDef

abstract case class PrimaryKeyDef(model: model.PrimaryKey) extends TermDef with Product with Serializable

abstract type TableClass <: TableClassDef

trait TableClassDef extends TypeDef

abstract type TableValue <: TableValueDef

trait TableValueDef extends TermDef

trait TermDef extends Def

trait TypeDef extends Def

Abstract Value Members

abstract def Column: (model.Column) ⇒ Column

abstract def EntityType: EntityType

abstract def ForeignKey: (model.ForeignKey) ⇒ ForeignKey

abstract def Index: (model.Index) ⇒ Index

abstract def PlainSqlMapper: PlainSqlMapper

abstract def PrimaryKey: (model.PrimaryKey) ⇒ PrimaryKey

abstract def TableClass: TableClass

abstract def TableValue: TableValue

abstract def compoundType(types: Seq[Code]): Code

abstract def compoundValue(values: Seq[Code]): Code

abstract def extractor: Code

abstract def factory: Code

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TableDef, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def autoIncLast: Boolean

def clone(): AnyRef

def code: Seq[Code]

final lazy val columns: Seq[Column]

final lazy val columnsByName: Map[String, Column]

final lazy val columnsPositional: IndexedSeq[Column]

def definitions: Seq[Def]

lazy val desiredColumnOrder: Seq[Int]

def ensuring(cond: (TableDef) ⇒ Boolean, msg: ⇒ Any): TableDef

def ensuring(cond: (TableDef) ⇒ Boolean): TableDef

def ensuring(cond: Boolean, msg: ⇒ Any): TableDef

def ensuring(cond: Boolean): TableDef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final lazy val foreignKeys: Seq[ForeignKey]

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hlistEnabled: Boolean

def hugeClassEnabled: Boolean

final lazy val indices: Seq[Index]

final def isInstanceOf[T0]: Boolean

final def isMappedToHugeClass: Boolean

def mappingEnabled: Boolean

val model: model.Table

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final lazy val primaryKey: Option[PrimaryKey]

final def synchronized[T0](arg0: ⇒ T0): T0

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def →[B](y: B): (TableDef, B)

Deprecated Value Members

def autoIncLastAsOption: Boolean