TypedExpression

abstract def doWrite(sw: StatementWriter): Unit

abstract def mapper: OutMapper[A1]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def *[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

def +[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

def -[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

def /[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3, A4, T4](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3], tf: Floatifier[T3, A4, T4]): TypedExpression[A4, T4]

def :=(q: Query[Measures[A1]]): UpdateAssignment

def :=[B](b: B)(implicit arg0: (B) ⇒ TypedExpression[A1, T1]): UpdateAssignment

def <[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def <[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def <=[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def <=[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def <>[A2, T2](q: Query[Measures[A2]])(implicit tef: TypedExpressionFactory[A2, T2], ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def <>[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ===[A2, T2](q: Query[Measures[A2]])(implicit tef: TypedExpressionFactory[A2, T2], ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def ===[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): EqualityExpression

def >[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def >[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def >=[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def >=[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def ?: TypedExpression.this.type

var _inhibitedByWhen: Boolean

final def asInstanceOf[T0]: T0

def between[A2, T2, A3, T3](b1: TypedExpression[A2, T2], b2: TypedExpression[A3, T3])(implicit ev1: CanCompare[T1, T2], ev2: CanCompare[T2, T3]): BetweenExpression

def children: List[ExpressionNode]

def clone(): AnyRef

def defaultsTo[B](b: B)(implicit arg0: (B) ⇒ TypedExpression[A1, T1]): DefaultValueAssignment

def div[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3, A4, T4](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3], tf: Floatifier[T3, A4, T4]): TypedExpression[A4, T4]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterDescendants(predicate: (ExpressionNode) ⇒ Boolean): Iterable[ExpressionNode]

def filterDescendantsOfType[T](implicit manifest: Manifest[T]): Iterable[T]

def finalize(): Unit

final def getClass(): Class[_]

def gt[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def gt[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def gte[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def gte[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def hashCode(): Int

def id: String

def in[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def in[A2, T2](t: Traversable[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def inhibitWhen(inhibited: Boolean): TypedExpression.this.type

def inhibited: Boolean

def inhibitedFlagForAstDump: String

def is(columnAttributes: AttributeValidOnNumericalColumn*)(implicit restrictUsageWithinSchema: Schema): ColumnAttributeAssignment

final def isInstanceOf[T0]: Boolean

def isNotNull: PostfixOperatorNode with LogicalBoolean

def isNull: PostfixOperatorNode with LogicalBoolean

def like[A2, T2 <: TOptionString](s: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def lt[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def lt[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def lte[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def lte[A2, T2](b: TypedExpression[A2, T2])(implicit ev: CanCompare[T1, T2]): BinaryOperatorNodeLogicalBoolean

def minus[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

final def ne(arg0: AnyRef): Boolean

def notIn[A2, T2](q: Query[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

def notIn[A2, T2](t: Traversable[A2])(implicit cc: CanCompare[T1, T2]): LogicalBoolean

final def notify(): Unit

final def notifyAll(): Unit

var parent: Option[ExpressionNode]

def plus[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

def regex(pattern: String): FunctionNode with LogicalBoolean

def sample: A1

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

def times[T3 >: T1 <: TNumeric, T2 <: T3, A2, A3](e: TypedExpression[A2, T2])(implicit f: TypedExpressionFactory[A3, T3]): TypedExpression[A3, T3]

def toString(): String

def visitDescendants(visitor: (ExpressionNode, Option[ExpressionNode], Int) ⇒ Unit): Unit

visitor's args are : -the visited node, -it's parent -it's depth

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def write(sw: StatementWriter): Unit

def writeToString: String

def ||[A2, T2](e: TypedExpression[A2, T2]): ConcatOp[A1, A2, T1, T2]

def ~: TypedExpression[A1, T1]