Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##: Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  def alterDatabase(dbDefinition: CatalogDatabase): Unit
5.  def alterFunction(funcDefinition: CatalogFunction): Unit

   overwrite a metastore function in the database specified in funcDefinition..

   overwrite a metastore function in the database specified in funcDefinition.. If no database is specified, assume the function is in the current database.

6.  def alterPartitions(tableName: TableIdentifier, parts: Seq[CatalogTablePartition]): Unit

   Alter one or many table partitions whose specs that match those specified in parts, assuming the partitions exist.

   Alter one or many table partitions whose specs that match those specified in parts, assuming the partitions exist.

   If no database is specified, assume the table is in the current database.

   Note: If the underlying implementation does not support altering a certain field, this becomes a no-op.

7.  def alterTable(tableDefinition: CatalogTable): Unit

   Alter the metadata of an existing metastore table identified by tableDefinition.

   Alter the metadata of an existing metastore table identified by tableDefinition.

   If no database is specified in tableDefinition, assume the table is in the current database.

   Note: If the underlying implementation does not support altering a certain field, this becomes a no-op.

8.  def alterTableDataSchema(identifier: TableIdentifier, newDataSchema: StructType): Unit

   Alter the data schema of a table identified by the provided table identifier.

   Alter the data schema of a table identified by the provided table identifier. The new data schema should not have conflict column names with the existing partition columns, and should still contain all the existing data columns.

   identifier

   TableIdentifier

   newDataSchema

   Updated data schema to be used for the table

9.  def alterTableStats(identifier: TableIdentifier, newStats: Option[CatalogStatistics]): Unit

   Alter Spark's statistics of an existing metastore table identified by the provided table identifier.

10.  def alterTempViewDefinition(name: TableIdentifier, viewDefinition: TemporaryViewRelation): Boolean

    Alter the definition of a local/global temp view matching the given name, returns true if a temp view is matched and altered, false otherwise.

11.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

12.  def cacheTable(t: QualifiedTableName, l: LogicalPlan): Unit

    This method provides a way to cache a plan.

13.  def clearTempTables(): Unit

    Drop all existing temporary views.

    Drop all existing temporary views. For testing only.

14.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.CloneNotSupportedException]) @native()

15.  def conf: SQLConf

    The active config object within the current scope.

    The active config object within the current scope. See SQLConf.get for more information.

    Definition Classes

    SQLConfHelper

16.  def createDatabase(dbDefinition: CatalogDatabase, ignoreIfExists: Boolean): Unit
17.  def createFunction(funcDefinition: CatalogFunction, ignoreIfExists: Boolean): Unit

    Create a function in the database specified in funcDefinition.

    Create a function in the database specified in funcDefinition. If no such database is specified, create it in the current database.

18.  def createGlobalTempView(name: String, viewDefinition: TemporaryViewRelation, overrideIfExists: Boolean): Unit

    Create a global temporary view.

19.  def createPartitions(tableName: TableIdentifier, parts: Seq[CatalogTablePartition], ignoreIfExists: Boolean): Unit

    Create partitions in an existing table, assuming it exists.

    Create partitions in an existing table, assuming it exists. If no database is specified, assume the table is in the current database.

20.  def createTable(tableDefinition: CatalogTable, ignoreIfExists: Boolean, validateLocation: Boolean = true): Unit

    Create a metastore table in the database specified in tableDefinition.

    Create a metastore table in the database specified in tableDefinition. If no such database is specified, create it in the current database.

21.  def createTempView(name: String, viewDefinition: TemporaryViewRelation, overrideIfExists: Boolean): Unit

    Create a local temporary view.

22.  var currentDb: String

    Attributes

    protected

23.  def databaseExists(db: String): Boolean
24.  def defaultTablePath(tableIdent: TableIdentifier): URI
25.  def dropDatabase(db: String, ignoreIfNotExists: Boolean, cascade: Boolean): Unit
26.  def dropFunction(name: FunctionIdentifier, ignoreIfNotExists: Boolean): Unit

    Drop a metastore function.

    Drop a metastore function. If no database is specified, assume the function is in the current database.

27.  def dropGlobalTempView(name: String): Boolean

    Drop a global temporary view.

    Drop a global temporary view.

    Returns true if this view is dropped successfully, false otherwise.

28.  def dropPartitions(tableName: TableIdentifier, specs: Seq[TablePartitionSpec], ignoreIfNotExists: Boolean, purge: Boolean, retainData: Boolean): Unit

    Drop partitions from a table, assuming they exist.

    Drop partitions from a table, assuming they exist. If no database is specified, assume the table is in the current database.

29.  def dropTable(name: TableIdentifier, ignoreIfNotExists: Boolean, purge: Boolean): Unit

    Drop a table.

    Drop a table.

    If a database is specified in name, this will drop the table from that database. If no database is specified, this will first attempt to drop a temporary view with the same name, then, if that does not exist, drop the table from the current database.

30.  def dropTempFunction(name: String, ignoreIfNotExists: Boolean): Unit

    Drop a temporary function.

31.  def dropTempView(name: String): Boolean

    Drop a local temporary view.

    Drop a local temporary view.

    Returns true if this view is dropped successfully, false otherwise.

32.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

33.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

34.  lazy val externalCatalog: ExternalCatalog
35.  def failFunctionLookup(name: FunctionIdentifier): Nothing

    Attributes

    protected[sql]

36.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

37.  def format(name: String): String

    Formats object names, taking into account case sensitivity.

    Formats object names, taking into account case sensitivity.

    Attributes

    protected

38.  def functionExists(name: FunctionIdentifier): Boolean

    Check if the function with the specified name exists

39.  def getCachedPlan(t: QualifiedTableName, c: Callable[LogicalPlan]): LogicalPlan

    This method provides a way to get a cached plan.

40.  def getCachedTable(key: QualifiedTableName): LogicalPlan

    This method provides a way to get a cached plan if the key exists.

41.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

42.  def getCurrentDatabase: String
43.  def getDatabaseMetadata(db: String): CatalogDatabase
44.  def getDefaultDBPath(db: String): URI

    Get the path for creating a non-default database when database location is not provided by users.

45.  def getFunctionMetadata(name: FunctionIdentifier): CatalogFunction

    Retrieve the metadata of a metastore function.

    Retrieve the metadata of a metastore function.

    If a database is specified in name, this will return the function in that database. If no database is specified, this will return the function in the current database.

46.  def getGlobalTempView(name: String): Option[View]

    Generate a View operator from the global temporary view stored.

47.  def getLocalOrGlobalTempView(name: TableIdentifier): Option[View]

    Generate a View operator from the local or global temporary view stored.

48.  def getPartition(tableName: TableIdentifier, spec: TablePartitionSpec): CatalogTablePartition

    Retrieve the metadata of a table partition, assuming it exists.

    Retrieve the metadata of a table partition, assuming it exists. If no database is specified, assume the table is in the current database.

49.  def getRawGlobalTempView(name: String): Option[TemporaryViewRelation]

    Return a global temporary view exactly as it was stored.

50.  def getRawLocalOrGlobalTempView(name: Seq[String]): Option[TemporaryViewRelation]

    Return the raw logical plan of a temporary local or global view for the given name.

51.  def getRawTempView(name: String): Option[TemporaryViewRelation]

    Return a local temporary view exactly as it was stored.

52.  def getRelation(metadata: CatalogTable, options: CaseInsensitiveStringMap = CaseInsensitiveStringMap.empty()): LogicalPlan
53.  def getTableMetadata(name: TableIdentifier): CatalogTable

    Retrieve the metadata of an existing permanent table/view.

    Retrieve the metadata of an existing permanent table/view. If no database is specified, assume the table/view is in the current database. We replace char/varchar with "annotated" string type in the table schema, as the query engine doesn't support char/varchar yet.

    Annotations

    @throws(scala.this.throws.<init>$default$1[org.apache.spark.sql.catalyst.analysis.NoSuchDatabaseException]) @throws(scala.this.throws.<init>$default$1[org.apache.spark.sql.catalyst.analysis.NoSuchTableException])

54.  def getTableRawMetadata(name: TableIdentifier): CatalogTable

    Retrieve the metadata of an existing permanent table/view.

    Retrieve the metadata of an existing permanent table/view. If no database is specified, assume the table/view is in the current database.

    Annotations

    @throws(scala.this.throws.<init>$default$1[org.apache.spark.sql.catalyst.analysis.NoSuchDatabaseException]) @throws(scala.this.throws.<init>$default$1[org.apache.spark.sql.catalyst.analysis.NoSuchTableException])

55.  def getTablesByName(names: Seq[TableIdentifier]): Seq[CatalogTable]

    Retrieve all metadata of existing permanent tables/views.

    Retrieve all metadata of existing permanent tables/views. If no database is specified, assume the table/view is in the current database. Only the tables/views belong to the same database that can be retrieved are returned. For example, if none of the requested tables could be retrieved, an empty list is returned. There is no guarantee of ordering of the returned tables.

    Annotations

    @throws(scala.this.throws.<init>$default$1[org.apache.spark.sql.catalyst.analysis.NoSuchDatabaseException])

56.  def getTempView(name: String): Option[View]

    Generate a View operator from the temporary view stored.

57.  def getTempViewNames(): Seq[String]
58.  def getTempViewOrPermanentTableMetadata(name: TableIdentifier): CatalogTable

    Retrieve the metadata of an existing temporary view or permanent table/view.

    Retrieve the metadata of an existing temporary view or permanent table/view.

    If a database is specified in name, this will return the metadata of table/view in that database. If no database is specified, this will first attempt to get the metadata of a temporary view with the same name, then, if that does not exist, return the metadata of table/view in the current database.

59.  def getTempViewRelation(viewInfo: TemporaryViewRelation): SubqueryAlias

    Generates a SubqueryAlias operator from the stored temporary view.

60.  lazy val globalTempViewManager: GlobalTempViewManager
61.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

62.  def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean

    Attributes

    protected

    Definition Classes

    Logging

63.  def initializeLogIfNecessary(isInterpreter: Boolean): Unit

    Attributes

    protected

    Definition Classes

    Logging

64.  def invalidateAllCachedTables(): Unit

    This method provides a way to invalidate all the cached plans.

65.  def invalidateCachedTable(name: TableIdentifier): Unit

    This method discards any cached table relation plans for the given table identifier.

66.  def invalidateCachedTable(key: QualifiedTableName): Unit

    This method provides a way to invalidate a cached plan.

67.  def isBuiltinFunction(name: FunctionIdentifier): Boolean

    Returns whether it is a built-in function.

68.  def isGlobalTempViewDB(dbName: String): Boolean
69.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

70.  def isPersistentFunction(name: FunctionIdentifier): Boolean

    Returns whether it is a persistent function.

    Returns whether it is a persistent function. If not existed, returns false.

71.  def isRegisteredFunction(name: FunctionIdentifier): Boolean

    Return whether this function has been registered in the function registry of the current session.

    Return whether this function has been registered in the function registry of the current session. If not existed, return false.

72.  def isTempView(name: TableIdentifier): Boolean

    Return whether a table with the specified name is a temporary view.

73.  def isTempView(nameParts: Seq[String]): Boolean

    Return whether the given name parts belong to a temporary or global temporary view.

74.  def isTemporaryFunction(name: FunctionIdentifier): Boolean

    Returns whether it is a temporary function.

    Returns whether it is a temporary function. If not existed, returns false.

75.  def isTraceEnabled(): Boolean

    Attributes

    protected

    Definition Classes

    Logging

76.  def isView(nameParts: Seq[String]): Boolean
77.  def listDatabases(pattern: String): Seq[String]
78.  def listDatabases(): Seq[String]
79.  def listFunctions(db: String, pattern: String): Seq[(FunctionIdentifier, String)]

    List all matching functions in the specified database, including temporary functions.

    List all matching functions in the specified database, including temporary functions. This returns the function identifier and the scope in which it was defined (system or user defined).

80.  def listFunctions(db: String): Seq[(FunctionIdentifier, String)]

    List all functions in the specified database, including temporary functions.

    List all functions in the specified database, including temporary functions. This returns the function identifier and the scope in which it was defined (system or user defined).

81.  def listLocalTempViews(pattern: String): Seq[TableIdentifier]

    List all matching local temporary views.

82.  def listPartitionNames(tableName: TableIdentifier, partialSpec: Option[TablePartitionSpec] = None): Seq[String]

    List the names of all partitions that belong to the specified table, assuming it exists.

    List the names of all partitions that belong to the specified table, assuming it exists.

    A partial partition spec may optionally be provided to filter the partitions returned. For instance, if there exist partitions (a='1', b='2'), (a='1', b='3') and (a='2', b='4'), then a partial spec of (a='1') will return the first two only.

83.  def listPartitions(tableName: TableIdentifier, partialSpec: Option[TablePartitionSpec] = None): Seq[CatalogTablePartition]

    List the metadata of all partitions that belong to the specified table, assuming it exists.

    List the metadata of all partitions that belong to the specified table, assuming it exists.

    A partial partition spec may optionally be provided to filter the partitions returned. For instance, if there exist partitions (a='1', b='2'), (a='1', b='3') and (a='2', b='4'), then a partial spec of (a='1') will return the first two only.

84.  def listPartitionsByFilter(tableName: TableIdentifier, predicates: Seq[Expression]): Seq[CatalogTablePartition]

    List the metadata of partitions that belong to the specified table, assuming it exists, that satisfy the given partition-pruning predicate expressions.

85.  def listTables(db: String, pattern: String, includeLocalTempViews: Boolean): Seq[TableIdentifier]

    List all matching tables in the specified database, including local temporary views if includeLocalTempViews is enabled.

    List all matching tables in the specified database, including local temporary views if includeLocalTempViews is enabled.

    Note that, if the specified database is global temporary view database, we will list global temporary views.

86.  def listTables(db: String, pattern: String): Seq[TableIdentifier]

    List all matching tables in the specified database, including local temporary views.

    List all matching tables in the specified database, including local temporary views.

    Note that, if the specified database is global temporary view database, we will list global temporary views.

87.  def listTables(db: String): Seq[TableIdentifier]

    List all tables in the specified database, including local temporary views.

    List all tables in the specified database, including local temporary views.

    Note that, if the specified database is global temporary view database, we will list global temporary views.

88.  def listTemporaryFunctions(): Seq[FunctionIdentifier]

    List all temporary functions.

89.  def listViews(db: String, pattern: String): Seq[TableIdentifier]

    List all matching views in the specified database, including local temporary views.

90.  def loadFunctionResources(resources: Seq[FunctionResource]): Unit

    Loads resources such as JARs and Files for a function.

    Loads resources such as JARs and Files for a function. Every resource is represented by a tuple (resource type, resource uri).

91.  def loadPartition(name: TableIdentifier, loadPath: String, spec: TablePartitionSpec, isOverwrite: Boolean, inheritTableSpecs: Boolean, isSrcLocal: Boolean): Unit

    Load files stored in given path into the partition of an existing metastore table.

    Load files stored in given path into the partition of an existing metastore table. If no database is specified, assume the table is in the current database. If the specified table is not found in the database then a NoSuchTableException is thrown.

92.  def loadTable(name: TableIdentifier, loadPath: String, isOverwrite: Boolean, isSrcLocal: Boolean): Unit

    Load files stored in given path into an existing metastore table.

    Load files stored in given path into an existing metastore table. If no database is specified, assume the table is in the current database. If the specified table is not found in the database then a NoSuchTableException is thrown.

93.  def log: Logger

    Attributes

    protected

    Definition Classes

    Logging

94.  def logDebug(msg: => String, throwable: Throwable): Unit

    Attributes

    protected

    Definition Classes

    Logging

95.  def logDebug(msg: => String): Unit

    Attributes

    protected

    Definition Classes

    Logging

96.  def logError(msg: => String, throwable: Throwable): Unit

    Attributes

    protected

    Definition Classes

    Logging

97.  def logError(msg: => String): Unit

    Attributes

    protected

    Definition Classes

    Logging

98.  def logInfo(msg: => String, throwable: Throwable): Unit

    Attributes

    protected

    Definition Classes

    Logging

99.  def logInfo(msg: => String): Unit

    Attributes

    protected

    Definition Classes

    Logging

100.  def logName: String

     Attributes

     protected

     Definition Classes

     Logging

101.  def logTrace(msg: => String, throwable: Throwable): Unit

     Attributes

     protected

     Definition Classes

     Logging

102.  def logTrace(msg: => String): Unit

     Attributes

     protected

     Definition Classes

     Logging

103.  def logWarning(msg: => String, throwable: Throwable): Unit

     Attributes

     protected

     Definition Classes

     Logging

104.  def logWarning(msg: => String): Unit

     Attributes

     protected

     Definition Classes

     Logging

105.  def lookupBuiltinOrTempFunction(name: String): Option[ExpressionInfo]

     Look up the ExpressionInfo of the given function by name if it's a built-in or temp function.

     Look up the ExpressionInfo of the given function by name if it's a built-in or temp function. This only supports scalar functions.

106.  def lookupBuiltinOrTempTableFunction(name: String): Option[ExpressionInfo]

     Look up the ExpressionInfo of the given function by name if it's a built-in or temp table function.

107.  def lookupFunction(name: FunctionIdentifier, children: Seq[Expression]): Expression
108.  def lookupFunctionInfo(name: FunctionIdentifier): ExpressionInfo

     Look up the ExpressionInfo associated with the specified function, assuming it exists.

109.  def lookupPersistentFunction(name: FunctionIdentifier): ExpressionInfo

     Look up the ExpressionInfo of the given function by name if it's a persistent function.

     Look up the ExpressionInfo of the given function by name if it's a persistent function. This supports both scalar and table functions.

110.  def lookupRelation(name: TableIdentifier): LogicalPlan

     Return a LogicalPlan that represents the given table or view.

     Return a LogicalPlan that represents the given table or view.

     If a database is specified in name, this will return the table/view from that database. If no database is specified, this will first attempt to return a temporary view with the same name, then, if that does not exist, return the table/view from the current database.

     Note that, the global temp view database is also valid here, this will return the global temp view matching the given name.

     If the relation is a view, we generate a View operator from the view description, and wrap the logical plan in a SubqueryAlias which will track the name of the view. SubqueryAlias will also keep track of the name and database(optional) of the table/view

     name

     The name of the table/view that we look up.

111.  def lookupTableFunction(name: FunctionIdentifier, children: Seq[Expression]): LogicalPlan
112.  def makeQualifiedTablePath(locationUri: URI, database: String): URI
113.  final def ne(arg0: AnyRef): Boolean

     Definition Classes

     AnyRef

114.  final def notify(): Unit

     Definition Classes

     AnyRef

     Annotations

     @native()

115.  final def notifyAll(): Unit

     Definition Classes

     AnyRef

     Annotations

     @native()

116.  def qualifyIdentifier(ident: FunctionIdentifier): FunctionIdentifier

     Qualifies the function identifier with the current database if not specified, and normalize all the names.

117.  def qualifyIdentifier(ident: TableIdentifier): TableIdentifier

     Qualifies the table identifier with the current database if not specified, and normalize all the names.

118.  def refreshTable(name: TableIdentifier): Unit

     Refresh table entries in structures maintained by the session catalog such as:

     Refresh table entries in structures maintained by the session catalog such as:

     • The map of temporary or global temporary view names to their logical plans
     • The relation cache which maps table identifiers to their logical plans

     For temp views, it refreshes their logical plans, and as a consequence of that it can refresh the file indexes of the base relations (HadoopFsRelation for instance) used in the views. The method still keeps the views in the internal lists of session catalog.

     For tables/views, it removes their entries from the relation cache.

     The method is supposed to use in the following situations:

     1. The logical plan of a table/view was changed, and cached table/view data is cleared explicitly. For example, like in AlterTableRenameCommand which re-caches the table itself. Otherwise if you need to refresh cached data, consider using of CatalogImpl.refreshTable(). 2. A table/view doesn't exist, and need to only remove its entry in the relation cache since the cached data is invalidated explicitly like in DropTableCommand which uncaches table/view data itself. 3. Meta-data (such as file indexes) of any relation used in a temporary view should be updated.
119.  def registerFunction(funcDefinition: CatalogFunction, overrideIfExists: Boolean, functionBuilder: Option[FunctionBuilder] = None): Unit

     Registers a temporary or permanent scalar function into a session-specific FunctionRegistry

120.  def renamePartitions(tableName: TableIdentifier, specs: Seq[TablePartitionSpec], newSpecs: Seq[TablePartitionSpec]): Unit

     Override the specs of one or many existing table partitions, assuming they exist.

     Override the specs of one or many existing table partitions, assuming they exist.

     This assumes index i of specs corresponds to index i of newSpecs. If no database is specified, assume the table is in the current database.

121.  def renameTable(oldName: TableIdentifier, newName: TableIdentifier): Unit

     Rename a table.

     Rename a table.

     If a database is specified in oldName, this will rename the table in that database. If no database is specified, this will first attempt to rename a temporary view with the same name, then, if that does not exist, rename the table in the current database.

     This assumes the database specified in newName matches the one in oldName.

122.  def reset(): Unit

     Drop all existing databases (except "default"), tables, partitions and functions, and set the current database to "default".

     Drop all existing databases (except "default"), tables, partitions and functions, and set the current database to "default".

     This is mainly used for tests.

123.  def resolveBuiltinOrTempFunction(name: String, arguments: Seq[Expression]): Option[Expression]

     Look up a built-in or temp scalar function by name and resolves it to an Expression if such a function exists.

124.  def resolveBuiltinOrTempTableFunction(name: String, arguments: Seq[Expression]): Option[LogicalPlan]

     Look up a built-in or temp table function by name and resolves it to a LogicalPlan if such a function exists.

125.  def resolvePersistentFunction(name: FunctionIdentifier, arguments: Seq[Expression]): Expression

     Look up a persistent scalar function by name and resolves it to an Expression.

126.  def resolvePersistentTableFunction(name: FunctionIdentifier, arguments: Seq[Expression]): LogicalPlan

     Look up a persistent table function by name and resolves it to a LogicalPlan.

127.  def setCurrentDatabase(db: String): Unit
128.  def setCurrentDatabaseWithNameCheck(db: String, nameCheck: (String) => Unit): Unit
129.  final def synchronized[T0](arg0: => T0): T0

     Definition Classes

     AnyRef

130.  def tableExists(name: TableIdentifier): Boolean

     Return whether a table/view with the specified name exists.

     Return whether a table/view with the specified name exists. If no database is specified, check with current database.

131.  val tempViews: HashMap[String, TemporaryViewRelation]

     List of temporary views, mapping from table name to their logical plan.

     List of temporary views, mapping from table name to their logical plan.

     Attributes

     protected

132.  def toString(): String

     Definition Classes

     AnyRef → Any

133.  def unregisterFunction(name: FunctionIdentifier): Boolean

     Unregister a temporary or permanent function from a session-specific FunctionRegistry or TableFunctionRegistry.

     Unregister a temporary or permanent function from a session-specific FunctionRegistry or TableFunctionRegistry. Return true if function exists.

134.  def validateTableLocation(table: CatalogTable): Unit
135.  final def wait(): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

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

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException])

137.  final def wait(arg0: Long): Unit

     Definition Classes

     AnyRef

     Annotations

     @throws(classOf[java.lang.InterruptedException]) @native()