DynamicFoldableExpression

Wrap any TokenizedLiteral expression with this so that we can invoke literal initialization code within the .init() method of the generated class.

This pushes itself as reference object and uses a call to eval() on itself for actual evaluation and avoids embedding any generated code. This allows it to keep the generated code identical regardless of the constant expression (and in addition DynamicReplacableConstant trait casts to itself rather than actual object type).

We try to locate first foldable expression in a query tree such that all its child is foldable but parent isn't. That way we locate the exact point where an expression is safe to evaluate once instead of evaluating every row.

Expressions like select c from tab where case col2 when 1 then col3 else 'y' end = 22 like queries don't convert literal evaluation into init method.

expr: minimal expression tree that can be evaluated only once and turn into a constant.

Linear Supertypes

Serializable, Serializable, KryoSerializable, DynamicReplacableConstant, UnaryExpression, Expression, TreeNode[Expression], Product, Equals, AnyRef, Any

Instance Constructors

new DynamicFoldableExpression(expr: Expression)

expr
minimal expression tree that can be evaluated only once and turn into a constant.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def apply(number: Int): TreeNode[_]

Definition Classes
TreeNode
def argString: String

Definition Classes
TreeNode
def asCode: String

Definition Classes
TreeNode
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val canonicalized: Expression

Definition Classes
Expression
def checkInputDataTypes(): TypeCheckResult

Definition Classes
DynamicFoldableExpression → Expression
def child: Expression

Definition Classes
DynamicFoldableExpression → UnaryExpression
final def children: Seq[Expression]

Definition Classes
UnaryExpression → TreeNode
def childrenResolved: Boolean

Definition Classes
Expression
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[Expression, B]): Seq[B]

Definition Classes
TreeNode
def collectFirst[B](pf: PartialFunction[Expression, B]): Option[B]

Definition Classes
TreeNode
def collectLeaves(): Seq[Expression]

Definition Classes
TreeNode
lazy val containsChild: Set[TreeNode[_]]

Definition Classes
TreeNode
def dataType: DataType

Definition Classes
DynamicFoldableExpression → Expression
def defineCodeGen(ctx: CodegenContext, ev: ExprCode, f: (String) ⇒ String): ExprCode

Attributes
protected
Definition Classes
UnaryExpression
final def deterministic: Boolean

Definition Classes
DynamicReplacableConstant → Expression
final def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode

Definition Classes
DynamicReplacableConstant → Expression
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def eval(input: InternalRow): Any

Definition Classes
DynamicFoldableExpression → UnaryExpression → Expression
var expr: Expression

minimal expression tree that can be evaluated only once and turn into a constant.
def fastEquals(other: TreeNode[_]): Boolean

Definition Classes
TreeNode
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (Expression) ⇒ Boolean): Option[Expression]

Definition Classes
TreeNode
def flatArguments: Iterator[Any]

Attributes
protected
Definition Classes
Expression
def flatMap[A](f: (Expression) ⇒ TraversableOnce[A]): Seq[A]

Definition Classes
TreeNode
def foldable: Boolean

Definition Classes
UnaryExpression → Expression
def foreach(f: (Expression) ⇒ Unit): Unit

Definition Classes
TreeNode
def foreachUp(f: (Expression) ⇒ Unit): Unit

Definition Classes
TreeNode
def genCode(ctx: CodegenContext): ExprCode

Definition Classes
Expression
def generateTreeString(depth: Int, lastChildren: Seq[Boolean], builder: StringBuilder, verbose: Boolean, prefix: String): StringBuilder

Definition Classes
TreeNode
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
TreeNode → AnyRef → Any
def innerChildren: Seq[TreeNode[_]]

Attributes
protected
Definition Classes
TreeNode
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def jsonFields: List[JField]

Attributes
protected
Definition Classes
TreeNode
def makeCopy(newArgs: Array[AnyRef]): Expression

Definition Classes
DynamicFoldableExpression → TreeNode
def map[A](f: (Expression) ⇒ A): Seq[A]

Definition Classes
TreeNode
def mapChildren(f: (Expression) ⇒ Expression): Expression

Definition Classes
TreeNode
def mapProductIterator[B](f: (Any) ⇒ B)(implicit arg0: ClassTag[B]): Array[B]

Attributes
protected
Definition Classes
TreeNode
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nodeName: String

Definition Classes
DynamicFoldableExpression → TreeNode
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def nullSafeCodeGen(ctx: CodegenContext, ev: ExprCode, f: (String) ⇒ String): ExprCode

Attributes
protected
Definition Classes
UnaryExpression
def nullSafeEval(input: Any): Any

Attributes
protected
Definition Classes
UnaryExpression
def nullable: Boolean

Definition Classes
UnaryExpression → Expression
def numberedTreeString: String

Definition Classes
TreeNode
val origin: Origin

Definition Classes
TreeNode
def otherCopyArgs: Seq[AnyRef]

Attributes
protected
Definition Classes
TreeNode
def p(number: Int): Expression

Definition Classes
TreeNode
def prettyJson: String

Definition Classes
TreeNode
def prettyName: String

Definition Classes
DynamicFoldableExpression → Expression
def read(kryo: Kryo, input: Input): Unit

Definition Classes
DynamicFoldableExpression → KryoSerializable
def references: AttributeSet

Definition Classes
Expression
lazy val resolved: Boolean

Definition Classes
Expression
def semanticEquals(other: Expression): Boolean

Definition Classes
Expression
def semanticHash(): Int

Definition Classes
Expression
def simpleString: String

Definition Classes
Expression → TreeNode
def sql: String

Definition Classes
Expression
def stringArgs: Iterator[Any]

Attributes
protected
Definition Classes
TreeNode
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toJSON: String

Definition Classes
TreeNode
def toString(): String

Definition Classes
DynamicFoldableExpression → Expression → TreeNode → AnyRef → Any
def transform(rule: PartialFunction[Expression, Expression]): Expression

Definition Classes
TreeNode
def transformDown(rule: PartialFunction[Expression, Expression]): Expression

Definition Classes
TreeNode
def transformUp(rule: PartialFunction[Expression, Expression]): Expression

Definition Classes
TreeNode
def treeString(verbose: Boolean): String

Definition Classes
TreeNode
def treeString: String

Definition Classes
TreeNode
def value: Any

Definition Classes
DynamicFoldableExpression → DynamicReplacableConstant
final def verboseString: String

Definition Classes
Expression → TreeNode
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withNewChildren(newChildren: Seq[Expression]): Expression

Definition Classes
DynamicFoldableExpression → TreeNode
def write(kryo: Kryo, output: Output): Unit

Definition Classes
DynamicFoldableExpression → KryoSerializable

Related Doc: package expressions

case class DynamicFoldableExpression(expr: Expression) extends UnaryExpression with DynamicReplacableConstant with KryoSerializable with Product with Serializable

Instance Constructors

new DynamicFoldableExpression(expr: Expression)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply(number: Int): TreeNode[_]

def argString: String

def asCode: String

final def asInstanceOf[T0]: T0

lazy val canonicalized: Expression

def checkInputDataTypes(): TypeCheckResult

def child: Expression

final def children: Seq[Expression]

def childrenResolved: Boolean

def clone(): AnyRef

def collect[B](pf: PartialFunction[Expression, B]): Seq[B]

def collectFirst[B](pf: PartialFunction[Expression, B]): Option[B]

def collectLeaves(): Seq[Expression]

lazy val containsChild: Set[TreeNode[_]]

def dataType: DataType

def defineCodeGen(ctx: CodegenContext, ev: ExprCode, f: (String) ⇒ String): ExprCode

final def deterministic: Boolean

final def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode

final def eq(arg0: AnyRef): Boolean

def eval(input: InternalRow): Any

var expr: Expression

def fastEquals(other: TreeNode[_]): Boolean

def finalize(): Unit

def find(f: (Expression) ⇒ Boolean): Option[Expression]

def flatArguments: Iterator[Any]

def flatMap[A](f: (Expression) ⇒ TraversableOnce[A]): Seq[A]

def foldable: Boolean

def foreach(f: (Expression) ⇒ Unit): Unit

def foreachUp(f: (Expression) ⇒ Unit): Unit

def genCode(ctx: CodegenContext): ExprCode

def generateTreeString(depth: Int, lastChildren: Seq[Boolean], builder: StringBuilder, verbose: Boolean, prefix: String): StringBuilder

final def getClass(): Class[_]

def hashCode(): Int

def innerChildren: Seq[TreeNode[_]]

final def isInstanceOf[T0]: Boolean

def jsonFields: List[JField]

def makeCopy(newArgs: Array[AnyRef]): Expression

def map[A](f: (Expression) ⇒ A): Seq[A]

def mapChildren(f: (Expression) ⇒ Expression): Expression

def mapProductIterator[B](f: (Any) ⇒ B)(implicit arg0: ClassTag[B]): Array[B]

final def ne(arg0: AnyRef): Boolean

def nodeName: String

final def notify(): Unit

final def notifyAll(): Unit

def nullSafeCodeGen(ctx: CodegenContext, ev: ExprCode, f: (String) ⇒ String): ExprCode

def nullSafeEval(input: Any): Any

def nullable: Boolean

def numberedTreeString: String

val origin: Origin

def otherCopyArgs: Seq[AnyRef]

def p(number: Int): Expression

def prettyJson: String

def prettyName: String

def read(kryo: Kryo, input: Input): Unit

def references: AttributeSet

lazy val resolved: Boolean

def semanticEquals(other: Expression): Boolean

def semanticHash(): Int

def simpleString: String

def sql: String

def stringArgs: Iterator[Any]

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

def toJSON: String

def toString(): String

def transform(rule: PartialFunction[Expression, Expression]): Expression

def transformDown(rule: PartialFunction[Expression, Expression]): Expression

def transformUp(rule: PartialFunction[Expression, Expression]): Expression

def treeString(verbose: Boolean): String

def treeString: String

def value: Any

final def verboseString: String