ActiveTableQuery

abstract def tryDelete(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): Try[Unit]

Try to delete the model.

abstract def trySave(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): Try[M]

Try to save the model.

abstract def tryUpdate(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): Try[M]

Try to update the model.

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[O >: T, R, D[_]](other: Query[O, T.TableElementType, D]): Query[O, T.TableElementType, Seq]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def baseTableRow: T

def clone(): AnyRef

def count(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): Int

def countDistinct: Column[Int]

def delete(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): Unit

def drop(num: Int): Query[T, T.TableElementType, Seq]

def drop(num: Long): Query[T, T.TableElementType, Seq]

def drop(num: ConstColumn[Long]): Query[T, T.TableElementType, Seq]

def encodeRef(path: List[Symbol]): Query[T, T.TableElementType, Seq]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists: Column[Boolean]

def fetchAll(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): List[M]

def filter[T <: Column[_]](f: (T) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[T, T.TableElementType, Seq]

def filterNot[T <: Column[_]](f: (T) ⇒ T)(implicit wt: CanBeQueryCondition[T]): Query[T, T.TableElementType, Seq]

def finalize(): Unit

def flatMap[F, T, D[_]](f: (T) ⇒ Query[F, T, D]): Query[F, T, Seq]

final def getClass(): Class[_]

def groupBy[K, T, G, P](f: (T) ⇒ K)(implicit kshape: Shape[_ <: FlatShapeLevel, K, T, G], vshape: Shape[_ <: FlatShapeLevel, T, _, P]): Query[(G, Query[P, T.TableElementType, Seq]), (T, Query[P, T.TableElementType, Seq]), Seq]

def hashCode(): Int

def innerJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[T, E2, T.TableElementType, U2, Seq]

final def isInstanceOf[T0]: Boolean

def join[E2, U2, D[_]](q2: Query[E2, U2, D], jt: JoinType): BaseJoinQuery[T, E2, T.TableElementType, U2, Seq]

def leftJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[T, E2, T.TableElementType, U2, Seq]

def length: Column[Int]

def map[F, G, T](f: (T) ⇒ F)(implicit shape: Shape[_ <: FlatShapeLevel, F, T, G]): Query[G, T, Seq]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def outerJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[T, E2, T.TableElementType, U2, Seq]

def pack[R](implicit packing: Shape[_ <: FlatShapeLevel, T, _, R]): Query[R, T.TableElementType, Seq]

final lazy val packed: Node

def pagedList(pageIndex: Int, limit: Int)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): List[M]

def rightJoin[E2, U2, D[_]](q2: Query[E2, U2, D]): BaseJoinQuery[T, E2, T.TableElementType, U2, Seq]

def save(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): M

lazy val shaped: ShapedValue[T, T.TableElementType]

def size: Column[Int]

def sortBy[T](f: (T) ⇒ T)(implicit arg0: (T) ⇒ Ordered): Query[T, T.TableElementType, Seq]

def sorted(implicit ev: (T) ⇒ Ordered): Query[T, T.TableElementType, Seq]

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

def take(num: Int): Query[T, T.TableElementType, Seq]

def take(num: Long): Query[T, T.TableElementType, Seq]

def take(num: ConstColumn[Long]): Query[T, T.TableElementType, Seq]

def to[D[_]](implicit ctc: TypedCollectionTypeConstructor[D]): Query[T, T.TableElementType, D]

lazy val toNode: Node

def toString(): String

def union[O >: T, R, D[_]](other: Query[O, T.TableElementType, D]): Query[O, T.TableElementType, Seq]

def unionAll[O >: T, R, D[_]](other: Query[O, T.TableElementType, D]): Query[O, T.TableElementType, Seq]

def update(model: M)(implicit sess: scala.slick.driver.JdbcProfile.SimpleQL.Session): M

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter[T](f: (T) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[T, T.TableElementType, Seq]

def zip[E2, U2, D[_]](q2: Query[E2, U2, D]): Query[(T, E2), (T.TableElementType, U2), Seq]

def zipWith[E2, U2, F, G, T, D[_]](q2: Query[E2, U2, D], f: (T, E2) ⇒ F)(implicit shape: Shape[_ <: FlatShapeLevel, F, T, G]): Query[G, T, Seq]

def zipWithIndex: BaseJoinQuery[T, Column[Long], T.TableElementType, Long, Seq]

def where[T <: Column[_]](f: (T) ⇒ T)(implicit arg0: CanBeQueryCondition[T]): Query[T, T.TableElementType, Seq]