CreateTableAsSelect

Instance Constructors

new CreateTableAsSelect(database: String, tableName: String, query: LogicalPlan, allowExisting: Boolean, desc: Option[CreateTableDesc])

database
the database name of the new relation
tableName
the table name of the new relation
query
the query whose result will be insert into the new relation
allowExisting
allow continue working if it's already exists, otherwise raise exception
desc
the CreateTableDesc, which may contains serde, storage handler etc.

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
val allowExisting: Boolean

allow continue working if it's already exists, otherwise raise exception
def apply(number: Int): SparkPlan

Definition Classes
TreeNode
def argString: String

Definition Classes
CreateTableAsSelect → TreeNode
def asCode: String

Definition Classes
TreeNode
final def asInstanceOf[T0]: T0

Definition Classes
Any
def children: Nil.type

Definition Classes
LeafNode
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val codegenEnabled: Boolean

Definition Classes
SparkPlan
def collect[B](pf: PartialFunction[SparkPlan, B]): Seq[B]

Definition Classes
TreeNode
val database: String

the database name of the new relation
val desc: Option[CreateTableDesc]

the CreateTableDesc, which may contains serde, storage handler etc.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def execute(): RDD[catalyst.expressions.Row]

Definition Classes
CreateTableAsSelect → Command → SparkPlan
def executeCollect(): Array[catalyst.expressions.Row]

Definition Classes
Command
def expressions: Seq[Expression]

Definition Classes
QueryPlan
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 flatMap[A](f: (SparkPlan) ⇒ TraversableOnce[A]): Seq[A]

Definition Classes
TreeNode
def foreach(f: (SparkPlan) ⇒ Unit): Unit

Definition Classes
TreeNode
def generateTreeString(depth: Int, builder: StringBuilder): StringBuilder

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

Definition Classes
AnyRef → Any
def getNodeNumbered(number: MutableInt): SparkPlan

Attributes
protected
Definition Classes
TreeNode
def inputSet: AttributeSet

Definition Classes
QueryPlan
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraceEnabled(): Boolean

Attributes
protected
Definition Classes
Logging
def log: Logger

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logName: String

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def makeCopy(newArgs: Array[AnyRef]): CreateTableAsSelect.this.type

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

Definition Classes
TreeNode
def mapChildren(f: (SparkPlan) ⇒ SparkPlan): CreateTableAsSelect.this.type

Definition Classes
TreeNode
def missingInput: AttributeSet

Definition Classes
QueryPlan
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newMutableProjection(expressions: Seq[Expression], inputSchema: Seq[Attribute]): () ⇒ MutableProjection

Attributes
protected
Definition Classes
SparkPlan
def newOrdering(order: Seq[SortOrder], inputSchema: Seq[Attribute]): Ordering[catalyst.expressions.Row]

Attributes
protected
Definition Classes
SparkPlan
def newPredicate(expression: Expression, inputSchema: Seq[Attribute]): (catalyst.expressions.Row) ⇒ Boolean

Attributes
protected
Definition Classes
SparkPlan
def newProjection(expressions: Seq[Expression], inputSchema: Seq[Attribute]): Projection

Attributes
protected
Definition Classes
SparkPlan
def nodeName: String

Definition Classes
TreeNode
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numberedTreeString: String

Definition Classes
TreeNode
def otherCopyArgs: Seq[AnyRef]

Attributes
protected
Definition Classes
TreeNode
def output: Seq[Nothing]

Definition Classes
CreateTableAsSelect → QueryPlan
def outputPartitioning: Partitioning

Definition Classes
SparkPlan
def outputSet: AttributeSet

Definition Classes
QueryPlan
def printSchema(): Unit

Definition Classes
QueryPlan
val query: LogicalPlan

the query whose result will be insert into the new relation
def references: AttributeSet

Definition Classes
QueryPlan
def requiredChildDistribution: Seq[Distribution]

Definition Classes
SparkPlan
def schema: catalyst.types.StructType

Definition Classes
QueryPlan
def schemaString: String

Definition Classes
QueryPlan
lazy val sideEffectResult: Seq[catalyst.expressions.Row]

Attributes
protected[org.apache.spark.sql]
Definition Classes
CreateTableAsSelect → Command
def simpleString: String

Definition Classes
QueryPlan → TreeNode
def sparkContext: SparkContext

Attributes
protected
Definition Classes
SparkPlan
val sqlContext: SQLContext

Attributes
protected[org.apache.spark]
Definition Classes
SparkPlan
def statePrefix: String

Attributes
protected
Definition Classes
QueryPlan
def stringArgs: Iterator[Any]

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

Definition Classes
AnyRef
val tableName: String

the table name of the new relation
def toString(): String

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

Definition Classes
TreeNode
def transformAllExpressions(rule: PartialFunction[Expression, Expression]): CreateTableAsSelect.this.type

Definition Classes
QueryPlan
def transformChildrenDown(rule: PartialFunction[SparkPlan, SparkPlan]): CreateTableAsSelect.this.type

Definition Classes
TreeNode
def transformChildrenUp(rule: PartialFunction[SparkPlan, SparkPlan]): CreateTableAsSelect.this.type

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

Definition Classes
TreeNode
def transformExpressions(rule: PartialFunction[Expression, Expression]): CreateTableAsSelect.this.type

Definition Classes
QueryPlan
def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): CreateTableAsSelect.this.type

Definition Classes
QueryPlan
def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): CreateTableAsSelect.this.type

Definition Classes
QueryPlan
def transformUp(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

Definition Classes
TreeNode
def treeString: String

Definition Classes
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[SparkPlan]): CreateTableAsSelect.this.type

Definition Classes
TreeNode

case class CreateTableAsSelect(database: String, tableName: String, query: LogicalPlan, allowExisting: Boolean, desc: Option[CreateTableDesc]) extends SparkPlan with LeafNode with Command with Product with Serializable

Instance Constructors

new CreateTableAsSelect(database: String, tableName: String, query: LogicalPlan, allowExisting: Boolean, desc: Option[CreateTableDesc])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val allowExisting: Boolean

def apply(number: Int): SparkPlan

def argString: String

def asCode: String

final def asInstanceOf[T0]: T0

def children: Nil.type

def clone(): AnyRef

val codegenEnabled: Boolean

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

val database: String

val desc: Option[CreateTableDesc]

final def eq(arg0: AnyRef): Boolean

def execute(): RDD[catalyst.expressions.Row]

def executeCollect(): Array[catalyst.expressions.Row]

def expressions: Seq[Expression]

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

def finalize(): Unit

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

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

def generateTreeString(depth: Int, builder: StringBuilder): StringBuilder

final def getClass(): Class[_]

def getNodeNumbered(number: MutableInt): SparkPlan

def inputSet: AttributeSet

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

def makeCopy(newArgs: Array[AnyRef]): CreateTableAsSelect.this.type

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

def mapChildren(f: (SparkPlan) ⇒ SparkPlan): CreateTableAsSelect.this.type

def missingInput: AttributeSet

final def ne(arg0: AnyRef): Boolean

def newMutableProjection(expressions: Seq[Expression], inputSchema: Seq[Attribute]): () ⇒ MutableProjection

def newOrdering(order: Seq[SortOrder], inputSchema: Seq[Attribute]): Ordering[catalyst.expressions.Row]

def newPredicate(expression: Expression, inputSchema: Seq[Attribute]): (catalyst.expressions.Row) ⇒ Boolean

def newProjection(expressions: Seq[Expression], inputSchema: Seq[Attribute]): Projection

def nodeName: String

final def notify(): Unit

final def notifyAll(): Unit

def numberedTreeString: String

def otherCopyArgs: Seq[AnyRef]

def output: Seq[Nothing]

def outputPartitioning: Partitioning

def outputSet: AttributeSet

def printSchema(): Unit

val query: LogicalPlan

def references: AttributeSet

def requiredChildDistribution: Seq[Distribution]

def schema: catalyst.types.StructType

def schemaString: String

lazy val sideEffectResult: Seq[catalyst.expressions.Row]

def simpleString: String

def sparkContext: SparkContext

val sqlContext: SQLContext

def statePrefix: String

def stringArgs: Iterator[Any]

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

val tableName: String

def toString(): String

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

def transformAllExpressions(rule: PartialFunction[Expression, Expression]): CreateTableAsSelect.this.type

def transformChildrenDown(rule: PartialFunction[SparkPlan, SparkPlan]): CreateTableAsSelect.this.type