GpuBaseWindowExecMeta

abstract def getInputWindowExpressions: Seq[NamedExpression]

Extracts window-expression from WindowExecType.

abstract def getOrderSpecs: Seq[SortOrder]

Extracts order-by spec from WindowExecType.

abstract def getPartitionSpecs: Seq[Expression]

Extracts partition-spec from WindowExecType.

abstract def getResultColumnsOnly: Boolean

Indicates the output column semantics for the WindowExecType, i.e.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def addConvertedDataType(expression: Expression, typeMeta: DataTypeMeta): Unit

Call this method to record information about type conversions via DataTypeMeta.

final def asInstanceOf[T0]: T0

val availableRuntimeDataTransition: Boolean

Whether there exists runtime data transition for the wrapped plan, if true, the overriding of output attributes will always work even when the wrapped plan can't be replaced by GPU overrides.

def canDataWriteCmdsBeReplaced: Boolean

Returns true iff all of the data writing commands can be replaced.

def canExprTreeBeReplaced: Boolean

Returns true iff all of the expressions and their children could be replaced.

def canPartsBeReplaced: Boolean

Returns true iff all of the partitioning can be replaced.

final def canThisBeReplaced: Boolean

Returns true iff this could be replaced.

var cannotBeReplacedReasons: Option[Set[String]]

var cannotRunOnGpuBecauseOfCost: Boolean

var cannotRunOnGpuBecauseOfSparkPlan: Boolean

def checkExistingTags(): Unit

When AQE is enabled and we are planning a new query stage, we need to look at meta-data previously stored on the spark plan to determine whether this operator can run on GPU

def checkTimeZoneId(timeZoneId: Option[String]): Unit

val childDataWriteCmds: Seq[DataWritingCommandMeta[_]]

The wrapped data writing commands that should be examined

val childExprs: Seq[BaseExprMeta[_]]

The wrapped expressions that should be examined

val childParts: Seq[PartMeta[_]]

The wrapped partitioning that should be examined

val childPlans: Seq[SparkPlanMeta[SparkPlan]]

The wrapped plans that should be examined

def clone(): AnyRef

val conf: RapidsConf

the config

def confKey: String

final def convertIfNeeded(): SparkPlan

If this is enabled to be converted to a GPU version convert it and return the result, else do what is needed to possibly convert the rest of the plan.

def convertToCpu(): SparkPlan

Keep this on the CPU, but possibly convert its children under it to run on the GPU if enabled.

final def costPreventsRunningOnGpu(): Unit

var cpuCost: Double

final val disabledMsg: Option[String]

final def entirePlanExcludedReasons: Seq[String]

Returns the list of reasons the entire plan can't be replaced.

final def entirePlanWillNotWork(because: String): Unit

Call this if there is a condition found that the entire plan is not allowed to run on the GPU.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var estimatedOutputRows: Option[BigInt]

def explain(all: Boolean): String

def finalize(): Unit

final def getClass(): Class[_]

def getReasonsNotToReplaceEntirePlan: Seq[String]

var gpuCost: Double

def hashCode(): Int

final val incompatDoc: Option[String]

def indent(append: StringBuilder, depth: Int): Unit

def initReasons(): Unit

def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

lazy val inputFields: Seq[BaseExprMeta[Attribute]]

final def inputFilePreventsRunningOnGpu(): Unit

def isDisabledByDefault: Boolean

def isIncompat: Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logName: String

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit

def logWarning(msg: ⇒ String): Unit

final def mustBeReplaced(because: String): Unit

final def mustThisBeReplaced: Boolean

Returns true iff this must be replaced because its children have already been replaced and this needs to also be replaced for compatibility.

def namedChildExprs: Map[String, Seq[BaseExprMeta[_]]]

final def ne(arg0: AnyRef): Boolean

def noReplacementPossibleMessage(reasons: String): String

final def notify(): Unit

final def notifyAll(): Unit

final val operationName: String

val orderSpec: Seq[BaseExprMeta[SortOrder]]

def outputAttributes: Seq[Attribute]

Gets output attributes of current SparkPlanMeta, which is supposed to be called during type checking for the current plan.

lazy val outputTypeMetas: Option[Seq[DataTypeMeta]]

Overrides this method to implement custom conversions for specific plans.

val parent: Option[RapidsMeta[_, _]]

the parent of this node, if there is one.

val partitionSpec: Seq[BaseExprMeta[Expression]]

def print(strBuilder: StringBuilder, depth: Int, all: Boolean): Unit

Create a string representation of this in append.

val printWrapped: Boolean

When converting this to a string should we include the string representation of what this wraps too? This is off by default.

final def recursiveCostPreventsRunningOnGpu(): Unit

Recursively force a section of the plan back onto CPU, stopping once a plan is reached that is already on CPU.

final def recursiveSparkPlanPreventsRunningOnGpu(): Unit

final def recursiveSparkPlanRemoved(): Unit

def replaceMessage: String

def requireAstForGpuOn(exprMeta: BaseExprMeta[_]): Unit

def runAfterTagRules(): Unit

Run rules that happen for the entire tree after it has been tagged initially.

final def shouldBeRemoved(because: String): Unit

final def shouldThisBeRemoved: Boolean

Returns true if this node should be removed.

def suppressWillWorkOnGpuInfo: Boolean

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

def tagForExplain(): Unit

final def tagForGpu(): Unit

Tag all of the children to see if they are GPU compatible first.

def tagPlanForGpu(): Unit

Called to verify that this plan will work on the GPU.

final def tagSelfForGpu(): Unit

Do any extra checks and tag yourself if you are compatible or not.

def toString(): String

val useOutputAttributesOfChild: Boolean

Whether to pass through the outputAttributes of childPlan's meta, only for UnaryPlan

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def willNotWorkOnGpu(because: String): Unit

Call this to indicate that this should not be replaced with a GPU enabled version

val windowExpressions: Seq[BaseExprMeta[NamedExpression]]

val wrapped: WindowExecType

what we are wrapping