SkinnySession

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Remove extends LastOperation with Product with Serializable

object Set extends LastOperation with Product with Serializable

def addAttributeForCreation(namedValue: ⇒ (scalikejdbc.SQLSyntax, Any)): SkinnySession.this.type

def afterCreate(handler: AfterCreateHandler): Unit

val afterCreateHandlers: ListBuffer[AfterCreateHandler]

def afterDeleteBy(handler: (DBSession, scalikejdbc.SQLSyntax, Int) ⇒ Unit): Unit

val afterDeleteByHandlers: ListBuffer[AfterDeleteByHandler]

def afterUpdateBy(handler: AfterUpdateByHandler): Unit

val afterUpdateByHandlers: ListBuffer[AfterUpdateByHandler]

def appendIncludedAttributes(entity: Option[SkinnySession])(implicit s: DBSession, repository: IncludesQueryRepository[SkinnySession]): Option[SkinnySession]

def appendIncludedAttributes(entities: List[SkinnySession])(implicit s: DBSession, repository: IncludesQueryRepository[SkinnySession]): List[SkinnySession]

def apply(rs: WrappedResultSet): SkinnySession

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

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

final def asInstanceOf[T0]: T0

val associations: LinkedHashSet[Association[_]]

val attributesRef: Association[SkinnySession]

def autoSession: DBSession

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

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

def beforeCreate(handler: BeforeCreateHandler): Unit

val beforeCreateHandlers: ListBuffer[BeforeCreateHandler]

def beforeDeleteBy(handler: (DBSession, scalikejdbc.SQLSyntax) ⇒ Unit): Unit

val beforeDeleteByHandlers: ListBuffer[BeforeDeleteByHandler]

def beforeUpdateBy(handler: BeforeUpdateByHandler): Unit

val beforeUpdateByHandlers: ListBuffer[BeforeUpdateByHandler]

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

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

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

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

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

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

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

def byId(id: Long): scalikejdbc.SQLSyntax

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

def clearLoadedColumns(): Unit

def clone(): AnyRef

def column: scalikejdbc.ColumnName[SkinnySession]

def columnNames: Seq[String]

def columns: Seq[String]

def connectionPool: ConnectionPool

def connectionPoolName: Any

def convertAutoGeneratedIdToId[A](id: Long): Option[Long]

def count(fieldName: Symbol, distinct: Boolean)(implicit s: DBSession): Long

def countAllModels(): Long

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

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

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

def createNewModel(parameters: PermittedStrongParameters): Long

def createWithAttributes(parameters: (Symbol, Any)*)(implicit s: DBSession): Long

def createWithNamedValues(namedValues: (scalikejdbc.SQLSyntax, Any)*)(implicit s: DBSession): Long

def createWithPermittedAttributes(strongParameters: PermittedStrongParameters)(implicit s: DBSession): Long

def defaultAlias: Alias[SkinnySession]

val defaultBelongsToExtractors: LinkedHashSet[BelongsToExtractor[SkinnySession]]

val defaultHasOneExtractors: LinkedHashSet[HasOneExtractor[SkinnySession]]

val defaultJoinDefinitions: LinkedHashSet[JoinDefinition[_]]

val defaultOneToManyExtractors: LinkedHashSet[HasManyExtractor[SkinnySession]]

def defaultOrdering: scalikejdbc.SQLSyntax

def defaultOrderings: Seq[scalikejdbc.SQLSyntax]

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

def defaultScopeForUpdateOperations: Option[scalikejdbc.SQLSyntax]

def defaultScopeWithDefaultAlias: Option[scalikejdbc.SQLSyntax]

def defaultSelectQuery: scalikejdbc.SelectSQLBuilder[SkinnySession]

def deleteAll()(implicit s: DBSession): Int

def deleteBy(where: scalikejdbc.SQLSyntax)(implicit s: DBSession): Int

def deleteById(id: Long)(implicit s: DBSession): Int

def deleteModelById(id: Long): Int

def delimiterForResultName: String

def distinctCount(fieldName: Symbol)(implicit s: DBSession): Long

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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

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

def extractOneToMany[M1](mapper: AssociationsFeature[M1], fk: String, alias: Alias[M1], merge: (SkinnySession, Seq[M1]) ⇒ SkinnySession, includesMerge: (Seq[SkinnySession], Seq[M1]) ⇒ Seq[SkinnySession]): HasManyExtractor[SkinnySession]

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

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

def finalize(): Unit

def findAll(orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findAllBy(where: scalikejdbc.SQLSyntax, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findAllByIds(ids: Long*)(implicit s: DBSession): List[SkinnySession]

def findAllByWithLimitOffset(where: scalikejdbc.SQLSyntax, limit: Int, offset: Int, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findAllByWithLimitOffsetForOneToManyRelations(where: scalikejdbc.SQLSyntax, limit: Int, offset: Int, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

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

def findAllModels(): List[SkinnySession]

def findAllWithLimitOffset(limit: Int, offset: Int, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findAllWithLimitOffsetForOneToManyRelations(limit: Int, offset: Int, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findAllWithPagination(pagination: Pagination, orderings: Seq[scalikejdbc.SQLSyntax])(implicit s: DBSession): List[SkinnySession]

def findBy(where: scalikejdbc.SQLSyntax)(implicit s: DBSession): Option[SkinnySession]

def findById(id: Long)(implicit s: DBSession): Option[SkinnySession]

def findModel(id: Long): Option[SkinnySession]

def findModels(pageSize: Int, pageNo: Int): List[SkinnySession]

def findModelsDesc(pageSize: Int, pageNo: Int): List[SkinnySession]

def findOrCreate(jsessionId: String, jsessionidToBeAttached: Option[String], expireAt: DateTime)(implicit s: DBSession = autoSession): SkinnySession

Finds a SkinnySession which specified JSESSIONID is attached from database.

def forceUpperCase: Boolean

def generateId: Long

final def getClass(): Class[_]

def getExpireAtFromMaxInactiveInterval(maxInactiveInterval: Int): DateTime

Returns expireAt value to be set for the ServletSession's maxInactiveInterval.

def getTypedValueFromStrongParameter(fieldName: String, value: Any, paramType: ParamType): Option[Any]

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

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

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

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

def hasManyWithFk[M](many: (AssociationsFeature[M], Alias[M]), fk: String, on: (Alias[SkinnySession], Alias[M]) ⇒ scalikejdbc.SQLSyntax, merge: (SkinnySession, Seq[M]) ⇒ SkinnySession): HasManyAssociation[SkinnySession]

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

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

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

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

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

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

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

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

def hashCode(): Int

def idToRawValue(id: Long): Long

def includes(associations: Association[_]*): IncludesFeatureWithId[Long, SkinnySession] with FinderFeatureWithId[Long, SkinnySession] with QueryingFeatureWithId[Long, SkinnySession]

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

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

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

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

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

def invalidate(jsessionId: String)(implicit s: DBSession = autoSession): Unit

Invalidates this SkinnySession and all the JSESSIONID are detached too.

final def isInstanceOf[T0]: Boolean

def isValidFieldName(name: String): Boolean

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

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

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

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

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

def joins[Id](associations: Association[_]*): CRUDFeatureWithId[Id, SkinnySession]

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

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

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

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

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

def limit(n: Int): EntitiesSelectOperationBuilder

def logger: Logger

def loggerName: String

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

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

def mergeNamedValuesForCreation(namedValues: Seq[(scalikejdbc.SQLSyntax, Any)]): Seq[(scalikejdbc.SQLSyntax, Any)]

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

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

def nameConverters: Map[String, String]

def namedValuesForCreation(strongParameters: PermittedStrongParameters): Seq[(scalikejdbc.SQLSyntax, Any)]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def offset(n: Int): EntitiesSelectOperationBuilder

def paginate(pagination: Pagination): EntitiesSelectOperationBuilder

def primaryKeyField: scalikejdbc.SQLSyntax

def primaryKeyFieldName: String

def rawValueToId(value: Any): Long

def removeAttributeFromDatabase(id: Long, name: String)(implicit s: DBSession = autoSession): Unit

Removes an attribute from the database.

def schemaName: Option[String]

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

def selectQueryWithAssociations: scalikejdbc.SelectSQLBuilder[SkinnySession]

val servletSessionsAlias: Alias[ServletSession]

val servletSessionsRef: HasManyAssociation[SkinnySession]

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

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

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

def setAttributeToDatabase(id: Long, name: String, value: Any)(implicit s: DBSession = autoSession): Unit

Saves an attribute to the database.

def settings: SettingsProvider

def singleSelectQuery: scalikejdbc.SelectSQLBuilder[SkinnySession]

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

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

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

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

def table: scalikejdbc.TableDefSQLSyntax

def tableName: String

def tableNameWithSchema: String

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

def toString(): String

def underlying: SkinnyMapperBase[SkinnySession]

def updateBy(where: scalikejdbc.SQLSyntax): UpdateOperationBuilder

def updateById(id: Long, parameters: PermittedStrongParameters): Int

def updateById(id: Long): UpdateOperationBuilder

def updateModelById(id: Long, parameters: PermittedStrongParameters): Int

def useAutoIncrementPrimaryKey: Boolean

def useExternalIdGenerator: Boolean

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 where(condition: scalikejdbc.SQLSyntax): EntitiesSelectOperationBuilder

def where(conditions: (Symbol, Any)*): EntitiesSelectOperationBuilder

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

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

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

def withTableName(tableName: String): CRUDFeatureWithId[Long, SkinnySession]

def afterCreate(namedValues: Seq[(scalikejdbc.SQLSyntax, Any)], generatedId: Option[Long])(implicit s: DBSession): Unit

def afterDeleteBy(where: scalikejdbc.SQLSyntax, deletedCount: Int)(implicit s: DBSession): Int

def beforeCreate(namedValues: Seq[(scalikejdbc.SQLSyntax, Any)])(implicit s: DBSession): Unit

def beforeDeleteBy(where: scalikejdbc.SQLSyntax)(implicit s: DBSession): Unit