ConnectorCatalog

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
def addDependentRelation(inTable: QualifiedTableName, dependentRelation: QualifiedTableName): Unit

Definition Classes
SnappyStoreHiveCatalog
def alterDatabase(dbDefinition: CatalogDatabase): Unit

Definition Classes
SessionCatalog
def alterPartitions(tableName: TableIdentifier, parts: Seq[CatalogTablePartition]): Unit

Definition Classes
SessionCatalog
def alterTable(tableDefinition: CatalogTable): Unit

Definition Classes
SessionCatalog
def alterTempViewDefinition(name: TableIdentifier, viewDefinition: LogicalPlan): Boolean

Definition Classes
SessionCatalog
final def asInstanceOf[T0]: T0

Definition Classes
Any
val cachedDataSourceTables: LoadingCache[QualifiedTableName, (LogicalRelation, CatalogTable, RelationInfo)]

A cache of Spark SQL data source tables that have been accessed.
A cache of Spark SQL data source tables that have been accessed.

Attributes
protected
Definition Classes
ConnectorCatalog → SnappyStoreHiveCatalog
val cachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]

Definition Classes
SnappyStoreHiveCatalog
def clearTempTables(): Unit

Definition Classes
SessionCatalog
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Definition Classes
SnappyStoreHiveCatalog
def compatibleSchema(schema1: StructType, schema2: StructType): Boolean

Definition Classes
SnappyStoreHiveCatalog
lazy val connectorHelper: SmartConnectorHelper
def createCachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]

Attributes
protected
Definition Classes
SnappyStoreHiveCatalog
def createDatabase(dbDefinition: CatalogDatabase, ignoreIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createFunction(funcDefinition: CatalogFunction, ignoreIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createGlobalTempView(name: String, viewDefinition: LogicalPlan, overrideIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createPartitions(tableName: TableIdentifier, parts: Seq[CatalogTablePartition], ignoreIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createTable(tableDefinition: CatalogTable, ignoreIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createTempFunction(name: String, info: ExpressionInfo, funcDefinition: FunctionBuilder, ignoreIfExists: Boolean): Unit

Definition Classes
SessionCatalog
def createTempView(name: String, tableDefinition: LogicalPlan, overrideIfExists: Boolean): Unit

Definition Classes
SessionCatalog
var currentDb: String

Attributes
protected
Definition Classes
SessionCatalog
var currentSchema: String

Attributes
protected
Definition Classes
SnappyStoreHiveCatalog
def databaseExists(db: String): Boolean

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def defaultTablePath(tableIdent: TableIdentifier): String

Definition Classes
SessionCatalog
def destroyAndRegisterBuiltInFunctions(): Unit

Test only method
Test only method

Definition Classes
SnappyStoreHiveCatalog
def dropDatabase(db: String, ignoreIfNotExists: Boolean, cascade: Boolean): Unit

Definition Classes
SessionCatalog
def dropFunction(name: FunctionIdentifier, ignoreIfNotExists: Boolean): Unit

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def dropGlobalTempView(name: String): Boolean

Definition Classes
SessionCatalog
def dropPartitions(tableName: TableIdentifier, specs: Seq[TablePartitionSpec], ignoreIfNotExists: Boolean, purge: Boolean, retainData: Boolean): Unit

Definition Classes
SessionCatalog
def dropTable(name: TableIdentifier, ignoreIfNotExists: Boolean, purge: Boolean): Unit

Definition Classes
SessionCatalog
def dropTempFunction(name: String, ignoreIfNotExists: Boolean): Unit

Definition Classes
SessionCatalog
def dropTempView(name: String): Boolean

Definition Classes
SessionCatalog
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def failFunctionLookup(name: String): Nothing

Attributes
protected
Definition Classes
SessionCatalog
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formatDatabaseName(name: String): String

Format database name, taking into account case sensitivity.
Format database name, taking into account case sensitivity.

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def formatTableName(name: String): String

Format table name, taking into account case sensitivity.
Format table name, taking into account case sensitivity.

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def functionExists(name: FunctionIdentifier): Boolean

Definition Classes
SessionCatalog
def getCachedCatalogTable(table: QualifiedTableName): Option[CatalogTable]

Definition Classes
SnappyStoreHiveCatalog
def getCachedHiveTable(table: QualifiedTableName): LogicalRelation

Definition Classes
SnappyStoreHiveCatalog
def getCachedHiveTableProperties(table: QualifiedTableName): Map[String, String]

Definition Classes
SnappyStoreHiveCatalog
def getCachedRelationInfo(table: QualifiedTableName): RelationInfo
def getCachedSampledRelations(table: QualifiedTableName): Seq[(LogicalPlan, String)]

Definition Classes
SnappyStoreHiveCatalog
def getCatalogTable(table: Table): Option[CatalogTable]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getCurrentDatabase: String

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def getCurrentSchema: String

Definition Classes
SnappyStoreHiveCatalog
def getDataSourceRelations[T](tableTypes: Seq[ExternalTableType], baseTable: Option[String] = None): Seq[T]

Definition Classes
SnappyStoreHiveCatalog
def getDataSourceTables(tableTypes: Seq[ExternalTableType], baseTable: Option[String] = None): Seq[QualifiedTableName]

Definition Classes
SnappyStoreHiveCatalog
def getDatabaseMetadata(db: String): CatalogDatabase

Definition Classes
SessionCatalog
def getDefaultDBPath(db: String): String

Definition Classes
SessionCatalog
def getFunctionMetadata(name: FunctionIdentifier): CatalogFunction

Definition Classes
SessionCatalog
def getGlobalTempView(name: String): Option[LogicalPlan]

Definition Classes
SessionCatalog
def getPartition(tableName: TableIdentifier, spec: TablePartitionSpec): CatalogTablePartition

Definition Classes
SessionCatalog
def getTableMetadata(name: TableIdentifier): CatalogTable

Definition Classes
SessionCatalog
def getTableMetadataOption(name: TableIdentifier): Option[CatalogTable]

Definition Classes
SessionCatalog
def getTableOption(qtn: QualifiedTableName): Option[CatalogTable]

Definition Classes
SnappyStoreHiveCatalog
def getTableType(relation: BaseRelation): ExternalTableType

Definition Classes
SnappyStoreHiveCatalog
def getTables(db: Option[String]): Seq[(String, Boolean)]

Definition Classes
SnappyStoreHiveCatalog
def getTempView(name: String): Option[LogicalPlan]

Definition Classes
SessionCatalog
def getTempViewOrPermanentTableMetadata(name: TableIdentifier): CatalogTable

Definition Classes
SessionCatalog
def hashCode(): Int

Definition Classes
AnyRef → Any
def initializeLogIfNecessary(isInterpreter: Boolean): Unit

Attributes
protected
Definition Classes
Logging
def invalidateAll(): Unit

Definition Classes
SnappyStoreHiveCatalog
def invalidateTable(tableIdent: QualifiedTableName): Unit

Definition Classes
SnappyStoreHiveCatalog
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTemporaryFunction(name: FunctionIdentifier): Boolean

Definition Classes
SessionCatalog
def isTemporaryTable(tableIdent: QualifiedTableName): Boolean

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

Definition Classes
SnappyStoreHiveCatalog
def isTemporaryTable(name: TableIdentifier): Boolean

Definition Classes
SessionCatalog
def isTraceEnabled(): Boolean

Attributes
protected
Definition Classes
Logging
def listDatabases(pattern: String): Seq[String]

Definition Classes
SessionCatalog
def listDatabases(): Seq[String]

Definition Classes
SessionCatalog
def listFunctions(db: String, pattern: String): Seq[(FunctionIdentifier, String)]

Definition Classes
SessionCatalog
def listFunctions(db: String): Seq[(FunctionIdentifier, String)]

Definition Classes
SessionCatalog
def listPartitionNames(tableName: TableIdentifier, partialSpec: Option[TablePartitionSpec]): Seq[String]

Definition Classes
SessionCatalog
def listPartitions(tableName: TableIdentifier, partialSpec: Option[TablePartitionSpec]): Seq[CatalogTablePartition]

Definition Classes
SessionCatalog
def listPartitionsByFilter(tableName: TableIdentifier, predicates: Seq[Expression]): Seq[CatalogTablePartition]

Definition Classes
SessionCatalog
def listTables(db: String, pattern: String): Seq[TableIdentifier]

Definition Classes
SessionCatalog
def listTables(db: String): Seq[TableIdentifier]

Definition Classes
SessionCatalog
def loadFunctionResources(resources: Seq[FunctionResource]): Unit

Definition Classes
SessionCatalog
def loadPartition(name: TableIdentifier, loadPath: String, spec: TablePartitionSpec, isOverwrite: Boolean, holdDDLTime: Boolean, inheritTableSpecs: Boolean): Unit

Definition Classes
SessionCatalog
def loadTable(name: TableIdentifier, loadPath: String, isOverwrite: Boolean, holdDDLTime: Boolean): Unit

Definition Classes
SessionCatalog
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 lookupFunction(name: FunctionIdentifier, children: Seq[Expression]): Expression

Return an Expression that represents the specified function, assuming it exists.
Return an Expression that represents the specified function, assuming it exists.
For a temporary function or a permanent function that has been loaded, this method will simply lookup the function through the FunctionRegistry and create an expression based on the builder.
For a permanent function that has not been loaded, we will first fetch its metadata from the underlying external catalog. Then, we will load all resources associated with this function (i.e. jars and files). Finally, we create a function builder based on the function class and put the builder into the FunctionRegistry. The name of this function in the FunctionRegistry will be databaseName.functionName.

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def lookupFunctionInfo(name: FunctionIdentifier): ExpressionInfo

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

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def lookupRelation(tableIdent: TableIdentifier, alias: Option[String]): LogicalPlan

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
final def lookupRelation(tableIdent: QualifiedTableName): LogicalPlan

Definition Classes
SnappyStoreHiveCatalog
final def lookupRelationOption(tableIdent: QualifiedTableName): Option[LogicalPlan]

Definition Classes
SnappyStoreHiveCatalog
def makeFunctionBuilder(funcName: String, className: String): FunctionBuilder

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newQualifiedTableName(tableIdent: String): QualifiedTableName

Definition Classes
SnappyStoreHiveCatalog
def newQualifiedTableName(tableIdent: TableIdentifier): QualifiedTableName

Definition Classes
SnappyStoreHiveCatalog
def newQualifiedTempTableName(tableIdent: String): QualifiedTableName

Definition Classes
SnappyStoreHiveCatalog
def normalizeSchema(schema: StructType): StructType

Definition Classes
SnappyStoreHiveCatalog
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def refreshTable(tableIdent: TableIdentifier): Unit

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def registerDataSourceTable(tableIdent: QualifiedTableName, userSpecifiedSchema: Option[StructType], partitionColumns: Array[String], provider: String, options: Map[String, String], relation: Option[BaseRelation]): Unit

Creates a data source table (a table created with USING clause) in Hive's meta-store.
Creates a data source table (a table created with USING clause) in Hive's meta-store.

Definition Classes
ConnectorCatalog → SnappyStoreHiveCatalog
def registerRelationDestroy(): Unit

Attributes
protected
Definition Classes
SnappyStoreHiveCatalog
def registerTable(tableName: QualifiedTableName, plan: LogicalPlan): Unit

Definition Classes
SnappyStoreHiveCatalog
var relationDestroyVersion: Int

Definition Classes
SnappyStoreHiveCatalog
def removeDependentRelation(table: QualifiedTableName, dependentRelation: QualifiedTableName): Unit

Definition Classes
SnappyStoreHiveCatalog
def removeDependentRelationFromHive(table: QualifiedTableName, dependentRelation: QualifiedTableName): Unit

Definition Classes
SnappyStoreHiveCatalog
def renamePartitions(tableName: TableIdentifier, specs: Seq[TablePartitionSpec], newSpecs: Seq[TablePartitionSpec]): Unit

Definition Classes
SessionCatalog
def renameTable(oldName: TableIdentifier, newName: TableIdentifier): Unit

Definition Classes
SessionCatalog
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 method will only remove tables from hive catalog.Don't use this method if you want to delete physical tables This is mainly used for tests.

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def setCurrentDatabase(db: String): Unit

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
final def setSchema(schema: String): Unit

Definition Classes
SnappyStoreHiveCatalog
val snappySession: SnappySession

Definition Classes
SnappyStoreHiveCatalog
val sparkConf: SparkConf

Definition Classes
SnappyStoreHiveCatalog
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tableExists(tableName: QualifiedTableName): Boolean

Definition Classes
SnappyStoreHiveCatalog
def tableExists(tableIdentifier: String): Boolean

Definition Classes
SnappyStoreHiveCatalog
def tableExists(tableIdentifier: TableIdentifier): Boolean

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
val tempTables: HashMap[String, LogicalPlan]

Attributes
protected
Definition Classes
SessionCatalog
def toString(): String

Definition Classes
AnyRef → Any
def unregisterAllTables(): Unit

Definition Classes
SnappyStoreHiveCatalog
def unregisterDataSourceTable(tableIdent: QualifiedTableName, relation: Option[BaseRelation]): Unit

Drops a data source table from Hive's meta-store.
Drops a data source table from Hive's meta-store.

Definition Classes
ConnectorCatalog → SnappyStoreHiveCatalog
def unregisterGlobalView(tableIdent: QualifiedTableName): Boolean

Definition Classes
SnappyStoreHiveCatalog
def unregisterTable(tableIdent: QualifiedTableName): Unit

Definition Classes
SnappyStoreHiveCatalog
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 withHiveExceptionHandling[T](function: ⇒ T): T

Definition Classes
SnappyStoreHiveCatalog

Related Doc: package hive

trait ConnectorCatalog extends SnappyStoreHiveCatalog

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addDependentRelation(inTable: QualifiedTableName, dependentRelation: QualifiedTableName): Unit

def alterDatabase(dbDefinition: CatalogDatabase): Unit

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

def alterTable(tableDefinition: CatalogTable): Unit

def alterTempViewDefinition(name: TableIdentifier, viewDefinition: LogicalPlan): Boolean

final def asInstanceOf[T0]: T0

val cachedDataSourceTables: LoadingCache[QualifiedTableName, (LogicalRelation, CatalogTable, RelationInfo)]

val cachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]

def clearTempTables(): Unit

def clone(): AnyRef

def close(): Unit

def compatibleSchema(schema1: StructType, schema2: StructType): Boolean

lazy val connectorHelper: SmartConnectorHelper

def createCachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]

def createDatabase(dbDefinition: CatalogDatabase, ignoreIfExists: Boolean): Unit

def createFunction(funcDefinition: CatalogFunction, ignoreIfExists: Boolean): Unit

def createGlobalTempView(name: String, viewDefinition: LogicalPlan, overrideIfExists: Boolean): Unit

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

def createTable(tableDefinition: CatalogTable, ignoreIfExists: Boolean): Unit

def createTempFunction(name: String, info: ExpressionInfo, funcDefinition: FunctionBuilder, ignoreIfExists: Boolean): Unit

def createTempView(name: String, tableDefinition: LogicalPlan, overrideIfExists: Boolean): Unit

var currentDb: String

var currentSchema: String

def databaseExists(db: String): Boolean

def defaultTablePath(tableIdent: TableIdentifier): String

def destroyAndRegisterBuiltInFunctions(): Unit

def dropDatabase(db: String, ignoreIfNotExists: Boolean, cascade: Boolean): Unit

def dropFunction(name: FunctionIdentifier, ignoreIfNotExists: Boolean): Unit

def dropGlobalTempView(name: String): Boolean

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

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

def dropTempFunction(name: String, ignoreIfNotExists: Boolean): Unit

def dropTempView(name: String): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failFunctionLookup(name: String): Nothing

def finalize(): Unit

def formatDatabaseName(name: String): String

def formatTableName(name: String): String

def functionExists(name: FunctionIdentifier): Boolean

def getCachedCatalogTable(table: QualifiedTableName): Option[CatalogTable]

def getCachedHiveTable(table: QualifiedTableName): LogicalRelation

def getCachedHiveTableProperties(table: QualifiedTableName): Map[String, String]

def getCachedRelationInfo(table: QualifiedTableName): RelationInfo

def getCachedSampledRelations(table: QualifiedTableName): Seq[(LogicalPlan, String)]

def getCatalogTable(table: Table): Option[CatalogTable]

final def getClass(): Class[_]

def getCurrentDatabase: String

def getCurrentSchema: String

def getDataSourceRelations[T](tableTypes: Seq[ExternalTableType], baseTable: Option[String] = None): Seq[T]

def getDataSourceTables(tableTypes: Seq[ExternalTableType], baseTable: Option[String] = None): Seq[QualifiedTableName]

def getDatabaseMetadata(db: String): CatalogDatabase

def getDefaultDBPath(db: String): String

def getFunctionMetadata(name: FunctionIdentifier): CatalogFunction

def getGlobalTempView(name: String): Option[LogicalPlan]

def getPartition(tableName: TableIdentifier, spec: TablePartitionSpec): CatalogTablePartition

def getTableMetadata(name: TableIdentifier): CatalogTable

def getTableMetadataOption(name: TableIdentifier): Option[CatalogTable]

def getTableOption(qtn: QualifiedTableName): Option[CatalogTable]

def getTableType(relation: BaseRelation): ExternalTableType

def getTables(db: Option[String]): Seq[(String, Boolean)]

def getTempView(name: String): Option[LogicalPlan]

def getTempViewOrPermanentTableMetadata(name: TableIdentifier): CatalogTable

def hashCode(): Int

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

def invalidateAll(): Unit

def invalidateTable(tableIdent: QualifiedTableName): Unit

final def isInstanceOf[T0]: Boolean

def isTemporaryFunction(name: FunctionIdentifier): Boolean

def isTemporaryTable(tableIdent: QualifiedTableName): Boolean

def isTemporaryTable(name: TableIdentifier): Boolean

def isTraceEnabled(): Boolean

def listDatabases(pattern: String): Seq[String]