JoinsFeature

abstract def defaultAlias: Alias[Entity]

Returns default table alias.

abstract def extract(rs: WrappedResultSet, n: scalikejdbc.SQLInterpolation.ResultName[Entity]): Entity

Extracts entity from ResultSet.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply(rs: WrappedResultSet): Entity

Extracts entity from ResultSet.

def apply(a: Alias[Entity])(rs: WrappedResultSet): Entity

Extracts entity from ResultSet.

def as(provider: scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]): scalikejdbc.SQLInterpolation.TableAsAliasSQLSyntax

final def asInstanceOf[T0]: T0

def associations: LinkedHashSet[Association[_]]

Associations

def autoSession: DBSession

AutoSession definition.

def belongsTo[A](right: AssociationsFeature[A], merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithAlias[A](right: (AssociationsFeature[A], Alias[A]), merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithAliasAndFk[A](right: (AssociationsFeature[A], Alias[A]), fk: String, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithAliasAndFkAndJoinCondition[A](right: (AssociationsFeature[A], Alias[A]), fk: String, on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithFk[A](right: AssociationsFeature[A], fk: String, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithFkAndJoinCondition[A](right: AssociationsFeature[A], fk: String, on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithJoinCondition[A](right: AssociationsFeature[A], on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def clone(): AnyRef

def column: scalikejdbc.SQLInterpolation.ColumnName[Entity]

def columnNames: Seq[String]

Returns column names.

def columns: Seq[String]

def connectionPool: ConnectionPool

Returns connection pool.

def connectionPoolName: Any

def createAlias(name: String): Alias[Entity]

Creates a new table alias for this mapper.

def createJoinDefinition(joinType: JoinType, left: (AssociationsFeature[_], Alias[_]), right: (AssociationsFeature[_], Alias[_]), on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

Creates a new join definition.

def debug(msg: ⇒ Any, t: ⇒ Throwable): Unit

def debug(msg: ⇒ Any): Unit

val defaultBelongsToExtractors: LinkedHashSet[BelongsToExtractor[Entity]]

val defaultHasOneExtractors: LinkedHashSet[HasOneExtractor[Entity]]

val defaultJoinDefinitions: LinkedHashSet[JoinDefinition[_]]

Join definitions that are enabled by default.

val defaultOneToManyExtractors: LinkedHashSet[HasManyExtractor[Entity]]

def defaultScope(alias: Alias[Entity]): Option[scalikejdbc.SQLInterpolation.SQLSyntax]

Returns default scope for select queries.

def defaultScopeWithDefaultAlias: Option[scalikejdbc.SQLInterpolation.SQLSyntax]

def defaultSelectQuery: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

Returns th default select query builder for this mapper.

def delimiterForResultName: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(msg: ⇒ Any, t: ⇒ Throwable): Unit

def error(msg: ⇒ Any): Unit

def extract(sql: SQL[Entity, NoExtractor])(implicit includesRepository: IncludesQueryRepository[Entity]): SQL[Entity, HasExtractor]

def extractBelongsTo[That](mapper: AssociationsFeature[That], fk: String, alias: Alias[That], merge: (Entity, Option[That]) ⇒ Entity, includesMerge: (Seq[Entity], Seq[That]) ⇒ Seq[Entity] = defaultIncludesMerge[Entity, That]): BelongsToExtractor[Entity]

def extractHasOne[That](mapper: AssociationsFeature[That], fk: String, alias: Alias[That], merge: (Entity, Option[That]) ⇒ Entity, includesMerge: (Seq[Entity], Seq[That]) ⇒ Seq[Entity] = defaultIncludesMerge[Entity, That]): HasOneExtractor[Entity]

def extractOneToMany[M1](mapper: AssociationsFeature[M1], alias: Alias[M1], merge: (Entity, Seq[M1]) ⇒ Entity, includesMerge: (Seq[Entity], Seq[M1]) ⇒ Seq[Entity] = defaultIncludesMerge[Entity, M1]): HasManyExtractor[Entity]

def extractOneToManyWithDefaults[M1](mapper: AssociationsFeature[M1], merge: (Entity, Seq[M1]) ⇒ Entity, includesMerge: (Seq[Entity], Seq[M1]) ⇒ Seq[Entity] = defaultIncludesMerge[Entity, M1]): HasManyExtractor[Entity]

One-to-Many relationship definition.

object Member extends RelationshipFeature[Member] {
oneToMany[Group](
  mapper = Group,
  merge = (m, c) => m.copy(company = c)
)
}

def extractWithAssociations(sql: SQL[Entity, NoExtractor], belongsToAssociations: Seq[BelongsToAssociation[Entity]], hasOneAssociations: Seq[HasOneAssociation[Entity]], oneToManyAssociations: Seq[HasManyAssociation[Entity]])(implicit includesRepository: IncludesQueryRepository[Entity] = IncludesQueryRepository[Entity]()): SQL[Entity, HasExtractor]

Creates an extractor for this query.

def extractWithOneToOneTables(rs: WrappedResultSet, belongsToExtractors: Set[BelongsToExtractor[Entity]], hasOneExtractors: Set[HasOneExtractor[Entity]])(implicit includesRepository: IncludesQueryRepository[Entity]): Entity

Extracts entity with one-to-one tables.

def finalize(): Unit

def forceUpperCase: Boolean

final def getClass(): Class[_]

def hasMany[M](many: (AssociationsFeature[M], Alias[M]), on: (Alias[Entity], Alias[M]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Seq[M]) ⇒ Entity): HasManyAssociation[Entity]

def hasManyThrough[M1, M2](through: (AssociationsFeature[M1], Alias[M1]), throughOn: (Alias[Entity], Alias[M1]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, many: (AssociationsFeature[M2], Alias[M2]), on: (Alias[M1], Alias[M2]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Seq[M2]) ⇒ Entity): HasManyAssociation[Entity]

def hasManyThrough[M2](through: AssociationsFeature[_], many: AssociationsFeature[M2], merge: (Entity, Seq[M2]) ⇒ Entity): HasManyAssociation[Entity]

def hasManyThroughWithFk[M2](through: AssociationsFeature[_], many: AssociationsFeature[M2], throughFk: String, manyFk: String, merge: (Entity, Seq[M2]) ⇒ Entity): HasManyAssociation[Entity]

def hasOne[A](right: AssociationsFeature[A], merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAlias[A](right: (AssociationsFeature[A], Alias[A]), merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAliasAndFk[A](right: (AssociationsFeature[A], Alias[A]), fk: String, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAliasAndFkAndJoinCondition[A](right: (AssociationsFeature[A], Alias[A]), fk: String, on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAliasAndJoinCondition[A](right: (AssociationsFeature[A], Alias[A]), on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithFk[A](right: AssociationsFeature[A], fk: String, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithFkAndJoinCondition[A](right: AssociationsFeature[A], fk: String, on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithJoinCondition[A](right: AssociationsFeature[A], on: scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hashCode(): Int

def info(msg: ⇒ Any, t: ⇒ Throwable): Unit

def info(msg: ⇒ Any): Unit

def innerJoin[Left](left: (AssociationsFeature[Left], Alias[Left]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoin(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults[Left](left: AssociationsFeature[Left], right: AssociationsFeature[_], on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def isDebugEnabled: Boolean

def isErrorEnabled: Boolean

def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled: Boolean

def isValidFieldName(name: String): Boolean

Predicates the field name is valid.

def isWarnEnabled: Boolean

def join[Left](left: (AssociationsFeature[Left], Alias[Left]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def join(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults[Left](left: AssociationsFeature[Left], right: AssociationsFeature[_], on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joins[Id](associations: Association[_]*): JoinsFeature[Entity] with IdFeature[Id] with FinderFeatureWithId[Id, Entity] with QueryingFeatureWithId[Id, Entity]

Appends join definition on runtime.

def leftJoin(left: (AssociationsFeature[_], Alias[_]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[_], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoin(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(left: AssociationsFeature[_], right: AssociationsFeature[_], on: (Alias[_], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def logger: Logger

def loggerName: String

def nameConverters: Map[String, String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def primaryKeyField: scalikejdbc.SQLInterpolation.SQLSyntax

def primaryKeyFieldName: String

Returns primary key name.

def schemaName: Option[String]

def selectQueryWithAdditionalAssociations(sql: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity], belongsToAssociations: Seq[BelongsToAssociation[Entity]], hasOneAssociations: Seq[HasOneAssociation[Entity]], hasManyAssociations: Seq[HasManyAssociation[Entity]]): scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

Returns a select query builder that all associations are joined.

def selectQueryWithAssociations: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

def setAsByDefault(extractor: HasManyExtractor[Entity]): Unit

def setAsByDefault(extractor: HasOneExtractor[Entity]): Unit

def setAsByDefault(extractor: BelongsToExtractor[Entity]): Unit

def singleSelectQuery: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

Returns select query builder object to simply fetch rows without other joined tables.

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

def syntax(name: String): scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]

def syntax: scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]

def table: scalikejdbc.SQLInterpolation.TableDefSQLSyntax

def tableName: String

Returns table name.

def tableNameWithSchema: String

def toDefaultForeignKeyName[A](mapper: AssociationsFeature[A]): String

Expects mapper's name + "Id" by default.

def toString(): String

def trace(msg: ⇒ Any, t: ⇒ Throwable): Unit

def trace(msg: ⇒ Any): Unit

def underlying: SkinnyMapperBase[Entity]

def useShortenedResultName: Boolean

def useSnakeCaseColumnName: Boolean

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(msg: ⇒ Any, t: ⇒ Throwable): Unit

def warn(msg: ⇒ Any): Unit

def withAlias[A](name: String)(op: (Alias[Entity]) ⇒ A): A

Provides a code block with a table alias.

def withAlias[A](op: (Alias[Entity]) ⇒ A): A

Provides a code block with a table alias.

def withColumns[A](op: (scalikejdbc.SQLInterpolation.ColumnName[Entity]) ⇒ A): A

Provides a code block with the column name provider.