NoIdFinderFeature

abstract def defaultAlias: Alias[Entity]

Returns default table alias.

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

Extracts entity from ResultSet.

final def !=(arg0: Any): Boolean

final def ##(): Int

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.QuerySQLSyntaxProvider[scalikejdbc.SQLSyntaxSupport[Entity], Entity]): scalikejdbc.TableAsAliasSQLSyntax

final def asInstanceOf[T0]: T0

val associations: LinkedHashSet[Association[_]]

Associations

def autoSession: DBSession

AutoSession definition.

def average(fieldName: Symbol, decimals: Option[Int] = None)(implicit s: DBSession = autoSession): BigDecimal

Calculates average of a column.

def avg(fieldName: Symbol, decimals: Option[Int] = None)(implicit s: DBSession = autoSession): BigDecimal

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

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

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

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

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

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

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

def calculate(sql: scalikejdbc.SQLSyntax)(implicit s: DBSession = autoSession): BigDecimal

Calculates rows.

def clearLoadedColumns(): Unit

def clone(): AnyRef

def column: scalikejdbc.ColumnName[Entity]

def columnNames: Seq[String]

Returns column names.

def columns: Seq[String]

def connectionPool: ConnectionPool

Returns connection pool.

def connectionPoolName: Any

def count(fieldName: Symbol = Symbol(""), distinct: Boolean = false)(implicit s: DBSession = autoSession): Long

Count only.

def countBy(where: scalikejdbc.SQLSyntax)(implicit s: DBSession = autoSession): Long

Counts all rows by condition.

def countQueryWithAssociations: scalikejdbc.SelectSQLBuilder[Entity]

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.SQLSyntax): JoinDefinition[Entity]

Creates a new join definition.

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 defaultOrdering: scalikejdbc.SQLSyntax

Default ordering condition.

def defaultOrderings: Seq[scalikejdbc.SQLSyntax]

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

Returns default scope for select queries.

def defaultScopeWithDefaultAlias: Option[scalikejdbc.SQLSyntax]

def defaultSelectQuery: scalikejdbc.SelectSQLBuilder[Entity]

Returns the default select query builder for this mapper.

def delimiterForResultName: String

def distinctCount(fieldName: Symbol = Symbol(primaryKeyFieldName))(implicit s: DBSession = autoSession): Long

Counts distinct rows.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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], fk: String, alias: Alias[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 findAll(orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities.

def findAllBy(where: scalikejdbc.SQLSyntax, orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities by condition.

def findAllByWithLimitOffset(where: scalikejdbc.SQLSyntax, limit: Int = 100, offset: Int = 0, orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities by condition and with pagination.

def findAllByWithPagination(where: scalikejdbc.SQLSyntax, pagination: Pagination, orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities by condition and with pagination.

def findAllWithLimitOffset(limit: Int = 100, offset: Int = 0, orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities with pagination.

def findAllWithPagination(pagination: Pagination, orderings: Seq[scalikejdbc.SQLSyntax] = defaultOrderings)(implicit s: DBSession = autoSession): List[Entity]

Finds all entities with pagination.

def findBy(where: scalikejdbc.SQLSyntax)(implicit s: DBSession = autoSession): Option[Entity]

Finds an entity by condition.

def forceUpperCase: Boolean

final def getClass(): Class[_]

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

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

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

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

def hasManyWithFk[M](many: (AssociationsFeature[M], Alias[M]), fk: String, on: (Alias[Entity], Alias[M]) ⇒ scalikejdbc.SQLSyntax, merge: (Entity, Seq[M]) ⇒ 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.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAliasAndJoinCondition[A](right: (AssociationsFeature[A], Alias[A]), on: scalikejdbc.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.SQLSyntax, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

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

def hashCode(): Int

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

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

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

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

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

final def isInstanceOf[T0]: Boolean

def isValidFieldName(name: String): Boolean

Predicates the field name is valid.

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

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

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

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

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

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

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

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

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

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

def logger: Logger

def loggerName: String

def max(fieldName: Symbol)(implicit s: DBSession = autoSession): BigDecimal

def maximum(fieldName: Symbol)(implicit s: DBSession = autoSession): BigDecimal

Calculates minimum value of a column.

def min(fieldName: Symbol)(implicit s: DBSession = autoSession): BigDecimal

def minimum(fieldName: Symbol)(implicit s: DBSession = autoSession): BigDecimal

Calculates minimum value of a column.

def nameConverters: Map[String, String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def primaryKeyField: scalikejdbc.SQLSyntax

def primaryKeyFieldName: String

Returns primary key name.

def schemaName: Option[String]

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

Returns a select query builder that all associations are joined.

def selectQueryWithAssociations: scalikejdbc.SelectSQLBuilder[Entity]

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

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

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

def settings: SettingsProvider

def simpleCountQuery: scalikejdbc.SelectSQLBuilder[Entity]

Returns the count query builder for this mapper.

def singleSelectQuery: scalikejdbc.SelectSQLBuilder[Entity]

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

def sum(fieldName: Symbol)(implicit s: DBSession = autoSession): BigDecimal

Calculates sum of a column.

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

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

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

def table: scalikejdbc.TableDefSQLSyntax

def tableName: String

Returns table name.

def tableNameWithSchema: String

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

Expects mapper's name + primary key name by default.

def toString(): String

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 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.ColumnName[Entity]) ⇒ A): A

Provides a code block with the column name provider.