Table

abstract def *: ColumnBase[T]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val O: RelationalDriver.columnOptions.type

final def asInstanceOf[T0]: T0

def clone(): Table.this.type

def collectFieldSymbols(n: Node): Iterable[FieldSymbol]

def column[C](n: String, options: ColumnOption[C]*)(implicit tm: TypedType[C]): Column[C]

def createFinderBy[P](f: (Table.this.type) ⇒ Column[P])(implicit tm: TypedType[P]): RelationalDriver.ParameterizedQuery[P, T]

def create_*: Iterable[FieldSymbol]

def ddl: RelationalDriver.SchemaDescription

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foreignKey[P, PU, TT <: TableNode, U](name: String, sourceColumns: P, targetTable: TT)(targetColumns: (TT) ⇒ P, onUpdate: ForeignKeyAction = ForeignKeyAction.NoAction, onDelete: ForeignKeyAction = ForeignKeyAction.NoAction)(implicit unpack: Shape[TT, U, _], unpackp: Shape[P, PU, _]): ForeignKeyQuery[TT, U]

final def foreignKeys: Iterable[ForeignKey[_ <: TableNode, _]]

final def getClass(): Class[_]

def hashCode(): Int

def index[T](name: String, on: T, unique: Boolean = false)(implicit shape: Shape[T, _, _]): Index

def indexes: Iterable[Index]

final def isInstanceOf[T0]: Boolean

def mapOp(f: (Node, List[Int]) ⇒ Node, positions: List[Int] = Nil): Table.this.type

final def ne(arg0: AnyRef): Boolean

def nodeBuildTypedNode[T >: Table.this.type <: Node](newNode: T, newType: Type): T

def nodeChildNames: Iterable[String]

Names for the child nodes to show in AST dumps.

val nodeChildren: collection.immutable.Nil.type

All child nodes of this node.

def nodeDelegate: Node

def nodeHasType: Boolean

final def nodeIntrinsicSymbol: IntrinsicSymbol

The intrinsic symbol that points to this Node object.

final def nodeMapChildren(f: (Node) ⇒ Node): Self

Apply a mapping function to all children of this node and recreate the node with the new children.

final def nodeMapChildrenKeepType(f: (Node) ⇒ Node): Self

Like nodeMapChildren, except the type of this node is kept even if the children have changed.

def nodeRebuild: TableNode

final def nodeRebuild(ch: IndexedSeq[Node]): Self

Rebuild this node with a new list of children.

def nodeRebuildWithType(tpe: Type): Self

def nodeTableProjection: Node

def nodeType: Type

The current type of this node

def nodeTyped(tpe: Type): Table.this.type

Return this Node with a Type assigned.

def nodeTypedOrCopy(tpe: Type): Self

Return this Node with a Type assigned (if no other type has been seen for it yet) or a typed copy.

def nodeWithComputedType(scope: SymbolScope, retype: Boolean): Self

Rebuild this node and all children with their computed type.

final def notify(): Unit

final def notifyAll(): Unit

final def op: Node

def primaryKey[T](name: String, sourceColumns: T)(implicit shape: Shape[T, _, _]): PrimaryKey

final def primaryKeys: Iterable[PrimaryKey]

val schemaName: Option[String]

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

def tableConstraints: Iterator[Constraint]

val tableName: String

def tableProvider: RelationalDriver

def toString(): String

def tpe: CollectionType

final def wait(): Unit

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

final def wait(arg0: Long): Unit