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, Logging, 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: mode SaveMode

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, SaveMode mode)

Method Summary

Modifier and Type	Method and Description
static org.apache.spark.sql.catalyst.expressions.AttributeSeq	allAttributes()
static boolean	analyzed()
static org.apache.spark.sql.catalyst.trees.TreeNode<?>	apply(int number)
String	argString()
static String	asCode()
abstract static boolean	canEqual(Object that)
static PlanType	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, boolean addSuffix)
static String	generateTreeString$default$5()
static boolean	generateTreeString$default$6()
static int	hashCode()
scala.collection.Seq<org.apache.spark.sql.catalyst.plans.logical.LogicalPlan>	innerChildren()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	inputSet()
static void	invalidateStatsCache()
static boolean	isStreaming()
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 org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType>	mapExpressions(scala.Function1<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> f)
static scala.Option<Object>	maxRows()
static org.apache.spark.sql.catalyst.expressions.AttributeSet	missingInput()
SaveMode	mode()
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 BaseType	p(int number)
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 other)
static StructType	schema()
static String	schemaString()
static int	semanticHash()
static String	simpleString()
static org.apache.spark.sql.catalyst.plans.logical.Statistics	stats(org.apache.spark.sql.internal.SQLConf conf)
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, boolean addSuffix)
static boolean	treeString$default$2()
static String	verboseString()
static String	verboseStringWithSuffix()
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, childrenResolved, computeStats, initializeLogIfNecessary, invalidateStatsCache, 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, org$apache$spark$sql$catalyst$plans$logical$LogicalPlan$$statsCache_$eq, org$apache$spark$sql$catalyst$plans$logical$LogicalPlan$$statsCache, refresh, resolve, resolve, resolve, resolveChildren, resolved, resolveExpressions, resolveOperators, resolveQuoted, setAnalyzed, statePrefix, stats, verboseStringWithSuffix

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

allAttributes, canEvaluate, canEvaluateWithinJoin, canonicalized, constraints, expressions, getConstraints, getRelevantConstraints, inputSet, mapExpressions, missingInput, normalizeExprId, normalizePredicates, org$apache$spark$sql$catalyst$plans$QueryPlan$$aliasMap, org$apache$spark$sql$catalyst$plans$QueryPlan$$getConstraintClass, org$apache$spark$sql$catalyst$plans$QueryPlan$$inferIsNotNullConstraints, org$apache$spark$sql$catalyst$plans$QueryPlan$$isRecursiveDeduction, org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1, org$apache$spark$sql$catalyst$plans$QueryPlan$$scanNullIntolerantAttribute, org$apache$spark$sql$catalyst$plans$QueryPlan$$seqToExpressions$1, output, outputSet, preCanonicalized, printSchema, references, replaceAlias, sameResult, schema, schemaString, semanticHash, simpleString, splitConjunctivePredicates, splitDisjunctivePredicates, 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, generateTreeString, generateTreeString$default$5, generateTreeString$default$6, 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$$getNodeNumbered, org$apache$spark$sql$catalyst$trees$TreeNode$$parseToJson, origin, otherCopyArgs, p, prettyJson, productIterator, productPrefix, stringArgs, toJSON, toString, transform, transformDown, transformUp, treeString, treeString, treeString$default$2, 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

output

Methods inherited from interface scala.Product

productArity, productElement, productIterator, productPrefix

Methods inherited from interface scala.Equals

canEqual, equals

Methods inherited from interface org.apache.spark.internal.Logging

initializeLogging, log_

Constructor Detail

CreateHiveTableAsSelectCommand

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

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)

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)

mapChildren

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

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,
                                boolean addSuffix)

numberedTreeString

public static String numberedTreeString()

apply

public static org.apache.spark.sql.catalyst.trees.TreeNode<?> apply(int number)

p

public static BaseType p(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,
                                                                        boolean addSuffix)

asCode

public static String asCode()

toJSON

public static String toJSON()

prettyJson

public static String prettyJson()

treeString$default$2

public static boolean treeString$default$2()

generateTreeString$default$5

public static String generateTreeString$default$5()

generateTreeString$default$6

public static boolean generateTreeString$default$6()

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)

mapExpressions

public static org.apache.spark.sql.catalyst.plans.QueryPlan<PlanType> mapExpressions(scala.Function1<org.apache.spark.sql.catalyst.expressions.Expression,org.apache.spark.sql.catalyst.expressions.Expression> f)

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()

canonicalized

public static PlanType canonicalized()

sameResult

public static final boolean sameResult(PlanType other)

semanticHash

public static final int semanticHash()

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)

stats

public static final org.apache.spark.sql.catalyst.plans.logical.Statistics stats(org.apache.spark.sql.internal.SQLConf conf)

invalidateStatsCache

public static final void invalidateStatsCache()

verboseStringWithSuffix

public static String verboseStringWithSuffix()

maxRows

public static scala.Option<Object> maxRows()

resolved

public static boolean resolved()

childrenResolved

public static boolean childrenResolved()

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()

children

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

producedAttributes

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

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()

mode

public SaveMode mode()

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>