case class RepairTableCommand(tableName: TableIdentifier, enableAddPartitions: Boolean, enableDropPartitions: Boolean, cmd: String = "MSCK REPAIR TABLE") extends LogicalPlan with LeafRunnableCommand with Product with Serializable
Instance Constructors
- new RepairTableCommand(tableName: TableIdentifier, enableAddPartitions: Boolean, enableDropPartitions: Boolean, cmd: String = "MSCK REPAIR TABLE")
Value Members
- final def !=(arg0: Any): Boolean
- final def ##: Int
- final def ==(arg0: Any): Boolean
- val DDL_TIME: String
- val NUM_FILES: String
- val TOTAL_SIZE: String
- lazy val allAttributes: AttributeSeq
- def analyzed: Boolean
- def apply(number: Int): TreeNode[_]
- def argString(maxFields: Int): String
- def asCode: String
- final def asInstanceOf[T0]: T0
- def assertNotAnalysisRule(): Unit
- final lazy val canonicalized: LogicalPlan
- final def children: Seq[LogicalPlan]
- def childrenResolved: Boolean
- def clone(): LogicalPlan
- val cmd: String
- def collect[B](pf: PartialFunction[LogicalPlan, B]): Seq[B]
- def collectFirst[B](pf: PartialFunction[LogicalPlan, B]): Option[B]
- def collectLeaves(): Seq[LogicalPlan]
- def collectWithSubqueries[B](f: PartialFunction[LogicalPlan, B]): Seq[B]
- def conf: SQLConf
- lazy val constraints: ExpressionSet
- def constructIsNotNullConstraints(constraints: ExpressionSet, output: Seq[Attribute]): ExpressionSet
- final def containsAllPatterns(patterns: TreePattern*): Boolean
- final def containsAnyPattern(patterns: TreePattern*): Boolean
- lazy val containsChild: Set[TreeNode[_]]
- final def containsPattern(t: TreePattern): Boolean
- def copyTagsFrom(other: LogicalPlan): Unit
- def doCanonicalize(): LogicalPlan
- val enableAddPartitions: Boolean
- val enableDropPartitions: Boolean
- final def eq(arg0: AnyRef): Boolean
- final def expressions: Seq[Expression]
- def fastEquals(other: TreeNode[_]): Boolean
- def finalize(): Unit
- def find(f: (LogicalPlan) => Boolean): Option[LogicalPlan]
- def flatMap[A](f: (LogicalPlan) => TraversableOnce[A]): Seq[A]
- def foreach(f: (LogicalPlan) => Unit): Unit
- def foreachUp(f: (LogicalPlan) => Unit): Unit
- def formattedNodeName: String
- def generateTreeString(depth: Int, lastChildren: Seq[Boolean], append: (String) => Unit, verbose: Boolean, prefix: String, addSuffix: Boolean, maxFields: Int, printNodeId: Boolean, indent: Int): Unit
- final def getClass(): Class[_ <: AnyRef]
- def getDefaultTreePatternBits: BitSet
- def getTagValue[T](tag: TreeNodeTag[T]): Option[T]
- def hashCode(): Int
- def inferAdditionalConstraints(constraints: ExpressionSet): ExpressionSet
- def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- def initializeLogIfNecessary(isInterpreter: Boolean): Unit
- def innerChildren: Seq[QueryPlan[_]]
- def inputSet: AttributeSet
- final def invalidateStatsCache(): Unit
- def isCanonicalizedPlan: Boolean
- final def isInstanceOf[T0]: Boolean
- def isRuleIneffective(ruleId: RuleId): Boolean
- def isStreaming: Boolean
- def isTraceEnabled(): Boolean
- def jsonFields: List[JField]
- final def legacyWithNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
- 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
- def makeCopy(newArgs: Array[AnyRef]): LogicalPlan
- def map[A](f: (LogicalPlan) => A): Seq[A]
- final def mapChildren(f: (LogicalPlan) => LogicalPlan): LogicalPlan
- def mapExpressions(f: (Expression) => Expression): RepairTableCommand.this.type
- def mapProductIterator[B](f: (Any) => B)(implicit arg0: ClassTag[B]): Array[B]
- def markRuleAsIneffective(ruleId: RuleId): Unit
- def maxRows: Option[Long]
- def maxRowsPerPartition: Option[Long]
- def metadataOutput: Seq[Attribute]
- lazy val metrics: Map[String, SQLMetric]
- final def missingInput: AttributeSet
- final def ne(arg0: AnyRef): Boolean
- def nodeName: String
- final val nodePatterns: Seq[TreePattern]
- final def notify(): Unit
- final def notifyAll(): Unit
- def numberedTreeString: String
- val origin: Origin
- def otherCopyArgs: Seq[AnyRef]
- def output: Seq[Attribute]
- def outputOrdering: Seq[SortOrder]
- lazy val outputSet: AttributeSet
- def p(number: Int): LogicalPlan
- def prettyJson: String
- def printSchema(): Unit
- def producedAttributes: AttributeSet
- def productElementNames: Iterator[String]
- lazy val references: AttributeSet
- def refresh(): Unit
- def resolve(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolve(schema: StructType, resolver: Resolver): Seq[Attribute]
- def resolveChildren(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolveExpressions(r: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveOperators(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])]): LogicalPlan
- def resolveOperatorsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveQuoted(name: String, resolver: Resolver): Option[NamedExpression]
- lazy val resolved: Boolean
- def rewriteAttrs(attrMap: AttributeMap[Attribute]): LogicalPlan
- def run(spark: SparkSession): Seq[Row]
- def sameOutput(other: LogicalPlan): Boolean
- final def sameResult(other: LogicalPlan): Boolean
- lazy val schema: StructType
- def schemaString: String
- final def semanticHash(): Int
- def setTagValue[T](tag: TreeNodeTag[T], value: T): Unit
- def simpleString(maxFields: Int): String
- def simpleStringWithNodeId(): String
- def statePrefix: String
- def stats: Statistics
- val statsCache: Option[Statistics]
- def stringArgs: Iterator[Any]
- def subqueries: Seq[LogicalPlan]
- def subqueriesAll: Seq[LogicalPlan]
- final def synchronized[T0](arg0: => T0): T0
- val tableName: TableIdentifier
- def toJSON: String
- def toString(): String
- def transform(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformAllExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformAllExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithSubqueriesAndPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithBeforeAndAfterRuleOnChildren(cond: (LogicalPlan) => Boolean, ruleId: RuleId)(rule: PartialFunction[(LogicalPlan, LogicalPlan), LogicalPlan]): LogicalPlan
- def transformUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])], skipCond: (LogicalPlan) => Boolean, canGetOutput: (LogicalPlan) => Boolean): LogicalPlan
- def transformUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- lazy val treePatternBits: BitSet
- def treeString(append: (String) => Unit, verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): Unit
- final def treeString(verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): String
- final def treeString: String
- def unsetTagValue[T](tag: TreeNodeTag[T]): Unit
- def updateOuterReferencesInSubquery(plan: LogicalPlan, attrMap: AttributeMap[Attribute]): LogicalPlan
- lazy val validConstraints: ExpressionSet
- def verboseString(maxFields: Int): String
- def verboseStringWithOperatorId(): String
- def verboseStringWithSuffix(maxFields: Int): String
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit
- final def withNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
- final def withNewChildrenInternal(newChildren: IndexedSeq[LogicalPlan]): LogicalPlan
Inherited from LeafLike[LogicalPlan]
Value Members
- final def children: Seq[LogicalPlan]
- final def mapChildren(f: (LogicalPlan) => LogicalPlan): LogicalPlan
- final def withNewChildrenInternal(newChildren: IndexedSeq[LogicalPlan]): LogicalPlan
Value Members
- lazy val metrics: Map[String, SQLMetric]
Inherited from Command
Value Members
- final val nodePatterns: Seq[TreePattern]
- def output: Seq[Attribute]
- def producedAttributes: AttributeSet
- def stats: Statistics
Inherited from LogicalPlan
Value Members
- def childrenResolved: Boolean
- def isStreaming: Boolean
- def maxRows: Option[Long]
- def maxRowsPerPartition: Option[Long]
- def metadataOutput: Seq[Attribute]
- def outputOrdering: Seq[SortOrder]
- def refresh(): Unit
- def resolve(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolve(schema: StructType, resolver: Resolver): Seq[Attribute]
- def resolveChildren(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolveQuoted(name: String, resolver: Resolver): Option[NamedExpression]
- lazy val resolved: Boolean
- def sameOutput(other: LogicalPlan): Boolean
- def statePrefix: String
- def verboseStringWithSuffix(maxFields: Int): String
Inherited from Logging
Value Members
- def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- def initializeLogIfNecessary(isInterpreter: Boolean): Unit
- 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
Inherited from QueryPlanConstraints
Value Members
- lazy val constraints: ExpressionSet
- lazy val validConstraints: ExpressionSet
Inherited from ConstraintHelper
Value Members
- def constructIsNotNullConstraints(constraints: ExpressionSet, output: Seq[Attribute]): ExpressionSet
- def inferAdditionalConstraints(constraints: ExpressionSet): ExpressionSet
Inherited from LogicalPlanStats
Value Members
- final def invalidateStatsCache(): Unit
- val statsCache: Option[Statistics]
Inherited from AnalysisHelper
Value Members
- def analyzed: Boolean
- def assertNotAnalysisRule(): Unit
- def clone(): LogicalPlan
- def resolveExpressions(r: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveOperators(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])]): LogicalPlan
- def resolveOperatorsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformAllExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])], skipCond: (LogicalPlan) => Boolean, canGetOutput: (LogicalPlan) => Boolean): LogicalPlan
- def transformUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def updateOuterReferencesInSubquery(plan: LogicalPlan, attrMap: AttributeMap[Attribute]): LogicalPlan
Inherited from QueryPlan[LogicalPlan]
Value Members
- lazy val allAttributes: AttributeSeq
- final lazy val canonicalized: LogicalPlan
- def collectWithSubqueries[B](f: PartialFunction[LogicalPlan, B]): Seq[B]
- def doCanonicalize(): LogicalPlan
- final def expressions: Seq[Expression]
- def formattedNodeName: String
- def innerChildren: Seq[QueryPlan[_]]
- def inputSet: AttributeSet
- def isCanonicalizedPlan: Boolean
- def mapExpressions(f: (Expression) => Expression): RepairTableCommand.this.type
- final def missingInput: AttributeSet
- lazy val outputSet: AttributeSet
- def printSchema(): Unit
- lazy val references: AttributeSet
- def rewriteAttrs(attrMap: AttributeMap[Attribute]): LogicalPlan
- final def sameResult(other: LogicalPlan): Boolean
- lazy val schema: StructType
- def schemaString: String
- final def semanticHash(): Int
- def simpleString(maxFields: Int): String
- def simpleStringWithNodeId(): String
- def subqueries: Seq[LogicalPlan]
- def subqueriesAll: Seq[LogicalPlan]
- def transformAllExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformDownWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithSubqueriesAndPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformUpWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- lazy val treePatternBits: BitSet
- def verboseString(maxFields: Int): String
- def verboseStringWithOperatorId(): String
Inherited from SQLConfHelper
Value Members
- def conf: SQLConf
Inherited from TreeNode[LogicalPlan]
Value Members
- def apply(number: Int): TreeNode[_]
- def argString(maxFields: Int): String
- def asCode: String
- def collect[B](pf: PartialFunction[LogicalPlan, B]): Seq[B]
- def collectFirst[B](pf: PartialFunction[LogicalPlan, B]): Option[B]
- def collectLeaves(): Seq[LogicalPlan]
- lazy val containsChild: Set[TreeNode[_]]
- def copyTagsFrom(other: LogicalPlan): Unit
- def fastEquals(other: TreeNode[_]): Boolean
- def find(f: (LogicalPlan) => Boolean): Option[LogicalPlan]
- def flatMap[A](f: (LogicalPlan) => TraversableOnce[A]): Seq[A]
- def foreach(f: (LogicalPlan) => Unit): Unit
- def foreachUp(f: (LogicalPlan) => Unit): Unit
- def generateTreeString(depth: Int, lastChildren: Seq[Boolean], append: (String) => Unit, verbose: Boolean, prefix: String, addSuffix: Boolean, maxFields: Int, printNodeId: Boolean, indent: Int): Unit
- def getDefaultTreePatternBits: BitSet
- def getTagValue[T](tag: TreeNodeTag[T]): Option[T]
- def hashCode(): Int
- def isRuleIneffective(ruleId: RuleId): Boolean
- def jsonFields: List[JField]
- final def legacyWithNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
- def makeCopy(newArgs: Array[AnyRef]): LogicalPlan
- def map[A](f: (LogicalPlan) => A): Seq[A]
- def mapProductIterator[B](f: (Any) => B)(implicit arg0: ClassTag[B]): Array[B]
- def markRuleAsIneffective(ruleId: RuleId): Unit
- def nodeName: String
- def numberedTreeString: String
- val origin: Origin
- def otherCopyArgs: Seq[AnyRef]
- def p(number: Int): LogicalPlan
- def prettyJson: String
- def setTagValue[T](tag: TreeNodeTag[T], value: T): Unit
- def stringArgs: Iterator[Any]
- def toJSON: String
- def toString(): String
- def transform(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithBeforeAndAfterRuleOnChildren(cond: (LogicalPlan) => Boolean, ruleId: RuleId)(rule: PartialFunction[(LogicalPlan, LogicalPlan), LogicalPlan]): LogicalPlan
- def transformWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def treeString(append: (String) => Unit, verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): Unit
- final def treeString(verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): String
- final def treeString: String
- def unsetTagValue[T](tag: TreeNodeTag[T]): Unit
- final def withNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
Inherited from TreePatternBits
Value Members
- final def containsAllPatterns(patterns: TreePattern*): Boolean
- final def containsAnyPattern(patterns: TreePattern*): Boolean
- final def containsPattern(t: TreePattern): Boolean
Inherited from Product
Value Members
- def productElementNames: Iterator[String]
Inherited from AnyRef
Value Members
- final def !=(arg0: Any): Boolean
- final def ##: Int
- final def ==(arg0: Any): Boolean
- final def eq(arg0: AnyRef): Boolean
- def finalize(): Unit
- final def getClass(): Class[_ <: AnyRef]
- final def ne(arg0: AnyRef): Boolean
- final def notify(): Unit
- final def notifyAll(): Unit
- final def synchronized[T0](arg0: => T0): T0
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit
Inherited from Any
Value Members
- final def asInstanceOf[T0]: T0
- final def isInstanceOf[T0]: Boolean
Ungrouped
- final def !=(arg0: Any): Boolean
- final def ##: Int
- final def ==(arg0: Any): Boolean
- val DDL_TIME: String
- val NUM_FILES: String
- val TOTAL_SIZE: String
- lazy val allAttributes: AttributeSeq
- def analyzed: Boolean
- def apply(number: Int): TreeNode[_]
- def argString(maxFields: Int): String
- def asCode: String
- final def asInstanceOf[T0]: T0
- def assertNotAnalysisRule(): Unit
- final lazy val canonicalized: LogicalPlan
- final def children: Seq[LogicalPlan]
- def childrenResolved: Boolean
- def clone(): LogicalPlan
- val cmd: String
- def collect[B](pf: PartialFunction[LogicalPlan, B]): Seq[B]
- def collectFirst[B](pf: PartialFunction[LogicalPlan, B]): Option[B]
- def collectLeaves(): Seq[LogicalPlan]
- def collectWithSubqueries[B](f: PartialFunction[LogicalPlan, B]): Seq[B]
- def conf: SQLConf
- lazy val constraints: ExpressionSet
- def constructIsNotNullConstraints(constraints: ExpressionSet, output: Seq[Attribute]): ExpressionSet
- final def containsAllPatterns(patterns: TreePattern*): Boolean
- final def containsAnyPattern(patterns: TreePattern*): Boolean
- lazy val containsChild: Set[TreeNode[_]]
- final def containsPattern(t: TreePattern): Boolean
- def copyTagsFrom(other: LogicalPlan): Unit
- def doCanonicalize(): LogicalPlan
- val enableAddPartitions: Boolean
- val enableDropPartitions: Boolean
- final def eq(arg0: AnyRef): Boolean
- final def expressions: Seq[Expression]
- def fastEquals(other: TreeNode[_]): Boolean
- def finalize(): Unit
- def find(f: (LogicalPlan) => Boolean): Option[LogicalPlan]
- def flatMap[A](f: (LogicalPlan) => TraversableOnce[A]): Seq[A]
- def foreach(f: (LogicalPlan) => Unit): Unit
- def foreachUp(f: (LogicalPlan) => Unit): Unit
- def formattedNodeName: String
- def generateTreeString(depth: Int, lastChildren: Seq[Boolean], append: (String) => Unit, verbose: Boolean, prefix: String, addSuffix: Boolean, maxFields: Int, printNodeId: Boolean, indent: Int): Unit
- final def getClass(): Class[_ <: AnyRef]
- def getDefaultTreePatternBits: BitSet
- def getTagValue[T](tag: TreeNodeTag[T]): Option[T]
- def hashCode(): Int
- def inferAdditionalConstraints(constraints: ExpressionSet): ExpressionSet
- def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- def initializeLogIfNecessary(isInterpreter: Boolean): Unit
- def innerChildren: Seq[QueryPlan[_]]
- def inputSet: AttributeSet
- final def invalidateStatsCache(): Unit
- def isCanonicalizedPlan: Boolean
- final def isInstanceOf[T0]: Boolean
- def isRuleIneffective(ruleId: RuleId): Boolean
- def isStreaming: Boolean
- def isTraceEnabled(): Boolean
- def jsonFields: List[JField]
- final def legacyWithNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
- 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
- def makeCopy(newArgs: Array[AnyRef]): LogicalPlan
- def map[A](f: (LogicalPlan) => A): Seq[A]
- final def mapChildren(f: (LogicalPlan) => LogicalPlan): LogicalPlan
- def mapExpressions(f: (Expression) => Expression): RepairTableCommand.this.type
- def mapProductIterator[B](f: (Any) => B)(implicit arg0: ClassTag[B]): Array[B]
- def markRuleAsIneffective(ruleId: RuleId): Unit
- def maxRows: Option[Long]
- def maxRowsPerPartition: Option[Long]
- def metadataOutput: Seq[Attribute]
- lazy val metrics: Map[String, SQLMetric]
- final def missingInput: AttributeSet
- final def ne(arg0: AnyRef): Boolean
- def nodeName: String
- final val nodePatterns: Seq[TreePattern]
- final def notify(): Unit
- final def notifyAll(): Unit
- def numberedTreeString: String
- val origin: Origin
- def otherCopyArgs: Seq[AnyRef]
- def output: Seq[Attribute]
- def outputOrdering: Seq[SortOrder]
- lazy val outputSet: AttributeSet
- def p(number: Int): LogicalPlan
- def prettyJson: String
- def printSchema(): Unit
- def producedAttributes: AttributeSet
- def productElementNames: Iterator[String]
- lazy val references: AttributeSet
- def refresh(): Unit
- def resolve(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolve(schema: StructType, resolver: Resolver): Seq[Attribute]
- def resolveChildren(nameParts: Seq[String], resolver: Resolver): Option[NamedExpression]
- def resolveExpressions(r: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): LogicalPlan
- def resolveOperators(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])]): LogicalPlan
- def resolveOperatorsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveOperatorsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def resolveQuoted(name: String, resolver: Resolver): Option[NamedExpression]
- lazy val resolved: Boolean
- def rewriteAttrs(attrMap: AttributeMap[Attribute]): LogicalPlan
- def run(spark: SparkSession): Seq[Row]
- def sameOutput(other: LogicalPlan): Boolean
- final def sameResult(other: LogicalPlan): Boolean
- lazy val schema: StructType
- def schemaString: String
- final def semanticHash(): Int
- def setTagValue[T](tag: TreeNodeTag[T], value: T): Unit
- def simpleString(maxFields: Int): String
- def simpleStringWithNodeId(): String
- def statePrefix: String
- def stats: Statistics
- val statsCache: Option[Statistics]
- def stringArgs: Iterator[Any]
- def subqueries: Seq[LogicalPlan]
- def subqueriesAll: Seq[LogicalPlan]
- final def synchronized[T0](arg0: => T0): T0
- val tableName: TableIdentifier
- def toJSON: String
- def toString(): String
- def transform(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformAllExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformAllExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformDown(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformDownWithSubqueriesAndPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformExpressions(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsDownWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformExpressionsWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[Expression, Expression]): RepairTableCommand.this.type
- def transformUp(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithBeforeAndAfterRuleOnChildren(cond: (LogicalPlan) => Boolean, ruleId: RuleId)(rule: PartialFunction[(LogicalPlan, LogicalPlan), LogicalPlan]): LogicalPlan
- def transformUpWithNewOutput(rule: PartialFunction[LogicalPlan, (LogicalPlan, Seq[(Attribute, Attribute)])], skipCond: (LogicalPlan) => Boolean, canGetOutput: (LogicalPlan) => Boolean): LogicalPlan
- def transformUpWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformUpWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformWithPruning(cond: (TreePatternBits) => Boolean, ruleId: RuleId)(rule: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- def transformWithSubqueries(f: PartialFunction[LogicalPlan, LogicalPlan]): LogicalPlan
- lazy val treePatternBits: BitSet
- def treeString(append: (String) => Unit, verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): Unit
- final def treeString(verbose: Boolean, addSuffix: Boolean, maxFields: Int, printOperatorId: Boolean): String
- final def treeString: String
- def unsetTagValue[T](tag: TreeNodeTag[T]): Unit
- def updateOuterReferencesInSubquery(plan: LogicalPlan, attrMap: AttributeMap[Attribute]): LogicalPlan
- lazy val validConstraints: ExpressionSet
- def verboseString(maxFields: Int): String
- def verboseStringWithOperatorId(): String
- def verboseStringWithSuffix(maxFields: Int): String
- final def wait(): Unit
- final def wait(arg0: Long, arg1: Int): Unit
- final def wait(arg0: Long): Unit
- final def withNewChildren(newChildren: Seq[LogicalPlan]): LogicalPlan
- final def withNewChildrenInternal(newChildren: IndexedSeq[LogicalPlan]): LogicalPlan