org.apache.spark.sql.hive.execution

Class CreateHiveTableAsSelectCommand

Object

org.apache.spark.sql.catalyst.trees.TreeNode<PlanType>

org.apache.spark.sql.catalyst.plans.QueryPlan<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan>

org.apache.spark.sql.catalyst.plans.logical.LogicalPlan

org.apache.spark.sql.catalyst.plans.logical.LeafNode

org.apache.spark.sql.hive.execution.CreateHiveTableAsSelectCommand

All Implemented Interfaces:

java.io.Serializable, org.apache.spark.sql.catalyst.plans.logical.Command, org.apache.spark.sql.execution.command.RunnableCommand, scala.Equals, scala.Product

public class CreateHiveTableAsSelectCommand
extends org.apache.spark.sql.catalyst.plans.logical.LeafNode
implements org.apache.spark.sql.execution.command.RunnableCommand, scala.Product, scala.Serializable

Create table and insert the query result into it.

param: tableDesc the Table Describe, which may contains serde, storage handler etc. param: query the query whose result will be insert into the new relation param: ignoreIfExists allow continue working if it's already exists, otherwise raise exception

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
CreateHiveTableAsSelectCommand(org.apache.spark.sql.catalyst.catalog.CatalogTable tableDesc, org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query, boolean ignoreIfExists)

Method Summary

Methods

Modifier and Type	Method and Description
static org.apache.spark.sql.catalyst.expressions.AttributeSeq	allAttributes()
static boolean	analyzed()
static BaseType	apply(int number)
String	argString()
static String	asCode()
abstract static boolean	canEqual(Object that)
static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan	canonicalized()
static scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan>	children()
static boolean	childrenResolved()
static <B> scala.collection.Seq<B>	collect(scala.PartialFunction<BaseType,B> pf)
static <B> scala.Option<B>	collectFirst(scala.PartialFunction<BaseType,B> pf)
static scala.collection.Seq<BaseType>	collectLeaves()
static org.apache.spark.sql.catalyst.expressions.ExpressionSet	constraints()
static scala.collection.immutable.Set<org.apache.spark.sql.catalyst.trees.TreeNode<?>>	containsChild()
abstract static boolean	equals(Object that)
static scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression>	expressions()
static boolean	fastEquals(org.apache.spark.sql.catalyst.trees.TreeNode<?> other)
static scala.Option<BaseType>	find(scala.Function1<BaseType,Object> f)
static <A> scala.collection.Seq<A>	flatMap(scala.Function1<BaseType,scala.collection.TraversableOnce<A>> f)
static void	foreach(scala.Function1<BaseType,scala.runtime.BoxedUnit> f)
static void	foreachUp(scala.Function1<BaseType,scala.runtime.BoxedUnit> f)
static scala.collection.mutable.StringBuilder	generateTreeString(int depth, scala.collection.Seq<Object> lastChildren, scala.collection.mutable.StringBuilder builder, boolean verbose, String prefix)
static String	generateTreeString$default$5()
static int	hashCode()
boolean	ignoreIfExists()
void	initializeLogging(boolean isInterpreter)
scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan>	innerChildren()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	inputSet()
static boolean	isStreaming()
org.slf4j.Logger	log_()
static BaseType	makeCopy(Object[] newArgs)
static <A> scala.collection.Seq<A>	map(scala.Function1<BaseType,A> f)
static BaseType	mapChildren(scala.Function1<BaseType,BaseType> f)
static scala.Option<Object>	maxRows()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	missingInput()
static String	nodeName()
static String	numberedTreeString()
static org.apache.spark.sql.catalyst.trees.Origin	origin()
static scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute>	output()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	outputSet()
static String	prettyJson()
static void	printSchema()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	producedAttributes()
abstract static int	productArity()
abstract static Object	productElement(int n)
static scala.collection.Iterator<Object>	productIterator()
static String	productPrefix()
org.apache.spark.sql.catalyst.plans.logical.LogicalPlan	query()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	references()
static void	refresh()
static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression>	resolve(scala.collection.Seq<String> nameParts, scala.Function2<String,String,Object> resolver)
static scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute>	resolve(StructType schema, scala.Function2<String,String,Object> resolver)
static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression>	resolveChildren(scala.collection.Seq<String> nameParts, scala.Function2<String,String,Object> resolver)
static boolean	resolved()
static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan	resolveExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> r)
static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan	resolveOperators(scala.PartialFunction<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan,org.apache.spark.sql.catalyst.plans.logical.LogicalPlan> rule)
static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression>	resolveQuoted(String name, scala.Function2<String,String,Object> resolver)
scala.collection.Seq<Row>	run(SparkSession sparkSession)
static boolean	sameResult(PlanType plan)
static StructType	schema()
static String	schemaString()
static String	simpleString()
static org.apache.spark.sql.catalyst.plans.logical.Statistics	statistics()
static scala.collection.Seq<PlanType>	subqueries()
org.apache.spark.sql.catalyst.catalog.CatalogTable	tableDesc()
static String	toJSON()
static String	toString()
static BaseType	transform(scala.PartialFunction<BaseType,BaseType> rule)
static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType>	transformAllExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)
static BaseType	transformDown(scala.PartialFunction<BaseType,BaseType> rule)
static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType>	transformExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)
static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType>	transformExpressionsDown(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)
static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType>	transformExpressionsUp(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)
static BaseType	transformUp(scala.PartialFunction<BaseType,BaseType> rule)
static String	treeString()
static String	treeString(boolean verbose)
static String	verboseString()
static BaseType	withNewChildren(scala.collection.Seq<BaseType> newChildren)

Methods inherited from class org.apache.spark.sql.catalyst.plans.logical.LeafNode

children, producedAttributes

Methods inherited from class org.apache.spark.sql.catalyst.plans.logical.LogicalPlan

analyzed, canonicalized, childrenResolved, initializeLogIfNecessary, isStreaming, isTraceEnabled, log, logDebug, logDebug, logError, logError, logInfo, logInfo, logName, logTrace, logTrace, logWarning, logWarning, maxRows, org$apache$spark$internal$Logging$$log__$eq, org$apache$spark$internal$Logging$$log_, org$apache$spark$sql$catalyst$plans$logical$LogicalPlan$$name$1, org$apache$spark$sql$catalyst$plans$logical$LogicalPlan$$resolveAsColumn, org$apache$spark$sql$catalyst$plans$logical$LogicalPlan$$resolveAsTableColumn, refresh, resolve, resolve, resolve, resolveChildren, resolved, resolveExpressions, resolveOperators, resolveQuoted, setAnalyzed, statePrefix, statistics

Methods inherited from class org.apache.spark.sql.catalyst.plans.QueryPlan

allAttributes, cleanArgs, constraints, expressions, getRelevantConstraints, inputSet, missingInput, org$apache$spark$sql$catalyst$plans$QueryPlan$$aliasMap, org$apache$spark$sql$catalyst$plans$QueryPlan$$cleanArg$1, org$apache$spark$sql$catalyst$plans$QueryPlan$$getConstraintClass, org$apache$spark$sql$catalyst$plans$QueryPlan$$isRecursiveDeduction, org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1, org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2, org$apache$spark$sql$catalyst$plans$QueryPlan$$scanNullIntolerantExpr, org$apache$spark$sql$catalyst$plans$QueryPlan$$seqToExpressions$1, output, outputSet, printSchema, references, sameResult, schema, schemaString, simpleString, subqueries, transformAllExpressions, transformExpressions, transformExpressionsDown, transformExpressionsUp, validConstraints, verboseString

Methods inherited from class org.apache.spark.sql.catalyst.trees.TreeNode

apply, asCode, collect, collectFirst, collectLeaves, containsChild, fastEquals, find, flatMap, foreach, foreachUp, fromJSON, generateTreeString, generateTreeString$default$5, getNodeNumbered, hashCode, jsonFields, makeCopy, map, mapChildren, mapProductIterator, nodeName, numberedTreeString, org$apache$spark$sql$catalyst$trees$TreeNode$$allChildren, org$apache$spark$sql$catalyst$trees$TreeNode$$collectJsonValue$1, org$apache$spark$sql$catalyst$trees$TreeNode$$parseToJson, origin, otherCopyArgs, prettyJson, productIterator, productPrefix, stringArgs, toJSON, toString, transform, transformChildren, transformDown, transformUp, treeString, treeString, withNewChildren

Methods inherited from class Object

equals, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.spark.sql.catalyst.plans.logical.Command

children, output

Methods inherited from interface scala.Product

productArity, productElement, productIterator, productPrefix

Methods inherited from interface scala.Equals

canEqual, equals

Constructor Detail

CreateHiveTableAsSelectCommand

public CreateHiveTableAsSelectCommand(org.apache.spark.sql.catalyst.catalog.CatalogTable tableDesc,
                              org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query,
                              boolean ignoreIfExists)

Method Detail

canEqual

public abstract static boolean canEqual(Object that)

equals

public abstract static boolean equals(Object that)

productElement

public abstract static Object productElement(int n)

productArity

public abstract static int productArity()

productIterator

public static scala.collection.Iterator<Object> productIterator()

productPrefix

public static String productPrefix()

origin

public static org.apache.spark.sql.catalyst.trees.Origin origin()

containsChild

public static scala.collection.immutable.Set<org.apache.spark.sql.catalyst.trees.TreeNode<?>> containsChild()

hashCode

public static int hashCode()

fastEquals

public static boolean fastEquals(org.apache.spark.sql.catalyst.trees.TreeNode<?> other)

find

public static scala.Option<BaseType> find(scala.Function1<BaseType,Object> f)

foreach

public static void foreach(scala.Function1<BaseType,scala.runtime.BoxedUnit> f)

foreachUp

public static void foreachUp(scala.Function1<BaseType,scala.runtime.BoxedUnit> f)

map

public static <A> scala.collection.Seq<A> map(scala.Function1<BaseType,A> f)

flatMap

public static <A> scala.collection.Seq<A> flatMap(scala.Function1<BaseType,scala.collection.TraversableOnce<A>> f)

collect

public static <B> scala.collection.Seq<B> collect(scala.PartialFunction<BaseType,B> pf)

collectLeaves

public static scala.collection.Seq<BaseType> collectLeaves()

collectFirst

public static <B> scala.Option<B> collectFirst(scala.PartialFunction<BaseType,B> pf)

mapChildren

public static BaseType mapChildren(scala.Function1<BaseType,BaseType> f)

withNewChildren

public static BaseType withNewChildren(scala.collection.Seq<BaseType> newChildren)

transform

public static BaseType transform(scala.PartialFunction<BaseType,BaseType> rule)

transformDown

public static BaseType transformDown(scala.PartialFunction<BaseType,BaseType> rule)

transformUp

public static BaseType transformUp(scala.PartialFunction<BaseType,BaseType> rule)

makeCopy

public static BaseType makeCopy(Object[] newArgs)

nodeName

public static String nodeName()

toString

public static String toString()

treeString

public static String treeString()

treeString

public static String treeString(boolean verbose)

numberedTreeString

public static String numberedTreeString()

apply

public static BaseType apply(int number)

generateTreeString

public static scala.collection.mutable.StringBuilder generateTreeString(int depth,
                                                        scala.collection.Seq<Object> lastChildren,
                                                        scala.collection.mutable.StringBuilder builder,
                                                        boolean verbose,
                                                        String prefix)

asCode

public static String asCode()

toJSON

public static String toJSON()

prettyJson

public static String prettyJson()

generateTreeString$default$5

public static String generateTreeString$default$5()

constraints

public static org.apache.spark.sql.catalyst.expressions.ExpressionSet constraints()

outputSet

public static org.apache.spark.sql.catalyst.expressions.AttributeSet outputSet()

references

public static org.apache.spark.sql.catalyst.expressions.AttributeSet references()

inputSet

public static org.apache.spark.sql.catalyst.expressions.AttributeSet inputSet()

missingInput

public static org.apache.spark.sql.catalyst.expressions.AttributeSet missingInput()

transformExpressions

public static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType> transformExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)

transformExpressionsDown

public static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType> transformExpressionsDown(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)

transformExpressionsUp

public static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType> transformExpressionsUp(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)

transformAllExpressions

public static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType> transformAllExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> rule)

expressions

public static final scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Expression> expressions()

schema

public static StructType schema()

schemaString

public static String schemaString()

printSchema

public static void printSchema()

simpleString

public static String simpleString()

verboseString

public static String verboseString()

subqueries

public static scala.collection.Seq<PlanType> subqueries()

sameResult

public static boolean sameResult(PlanType plan)

allAttributes

public static org.apache.spark.sql.catalyst.expressions.AttributeSeq allAttributes()

analyzed

public static boolean analyzed()

isStreaming

public static boolean isStreaming()

resolveOperators

public static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan resolveOperators(scala.PartialFunction<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan,org.apache.spark.sql.catalyst.plans.logical.LogicalPlan> rule)

resolveExpressions

public static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan resolveExpressions(scala.PartialFunction<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> r)

statistics

public static org.apache.spark.sql.catalyst.plans.logical.Statistics statistics()

maxRows

public static scala.Option<Object> maxRows()

resolved

public static boolean resolved()

childrenResolved

public static boolean childrenResolved()

canonicalized

public static org.apache.spark.sql.catalyst.plans.logical.LogicalPlan canonicalized()

resolve

public static scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> resolve(StructType schema,
                                                                                scala.Function2<String,String,Object> resolver)

resolveChildren

public static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression> resolveChildren(scala.collection.Seq<String> nameParts,
                                                                                      scala.Function2<String,String,Object> resolver)

resolve

public static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression> resolve(scala.collection.Seq<String> nameParts,
                                                                              scala.Function2<String,String,Object> resolver)

resolveQuoted

public static scala.Option<org.apache.spark.sql.catalyst.expressions.NamedExpression> resolveQuoted(String name,
                                                                                    scala.Function2<String,String,Object> resolver)

refresh

public static void refresh()

producedAttributes

public static org.apache.spark.sql.catalyst.expressions.AttributeSet producedAttributes()

children

public static final scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan> children()

output

public static scala.collection.Seq<org.apache.spark.sql.catalyst.expressions.Attribute> output()

tableDesc

public org.apache.spark.sql.catalyst.catalog.CatalogTable tableDesc()

query

public org.apache.spark.sql.catalyst.plans.logical.LogicalPlan query()

ignoreIfExists

public boolean ignoreIfExists()

innerChildren

public scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan> innerChildren()

run

public scala.collection.Seq<Row> run(SparkSession sparkSession)

Specified by:

run in interface org.apache.spark.sql.execution.command.RunnableCommand

argString

public String argString()

Overrides:

argString in class org.apache.spark.sql.catalyst.trees.TreeNode<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan>

log_

public org.slf4j.Logger log_()

initializeLogging

public void initializeLogging(boolean isInterpreter)