SnappyStoreHiveCatalog

Instance Constructors

new SnappyStoreHiveCatalog(externalCatalog: SnappyExternalCatalog, snappySession: SnappySession, metadataHive: HiveClient, globalTempViewManager: GlobalTempViewManager, functionResourceLoader: FunctionResourceLoader, functionRegistry: FunctionRegistry, sqlConf: SQLConf, hadoopConf: Configuration)

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
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
val cachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]
def caseSensitiveAnalysis: Boolean
def clearTempTables(): Unit

Definition Classes
SessionCatalog
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit
def compatibleSchema(schema1: StructType, schema2: StructType): Boolean
def createCachedSampleTables: LoadingCache[QualifiedTableName, Seq[(LogicalPlan, String)]]

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

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

Create a metastore function in the database specified in funcDefinition.
Create a metastore function in the database specified in funcDefinition. If no such database is specified, create it in the current database. If the specified database is not present in catalog, create that database. @ TODO Ideally create schema from gfxd should get routed to create the database in the Hive catalog.

Definition Classes
SnappyStoreHiveCatalog → 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[org.apache.spark.sql]
def databaseExists(db: String): Boolean

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

Definition Classes
SessionCatalog
def destroyAndRegisterBuiltInFunctions(): Unit

Test only method
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 formatName(name: String): String
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]
def getCachedHiveTable(table: QualifiedTableName): LogicalRelation
def getCachedHiveTableProperties(table: QualifiedTableName): Map[String, String]
def getCachedSampledRelations(table: QualifiedTableName): Seq[(LogicalPlan, String)]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def getCombinedPolicyFilterForExternalTable(rlsRelation: RowLevelSecurityRelation, wrappingLogicalRelation: Option[LogicalRelation], currentUser: Option[String]): Option[Filter]
final def getCombinedPolicyFilterForNativeTable(rlsRelation: RowLevelSecurityRelation, wrappingLogicalRelation: Option[LogicalRelation]): Option[Filter]
def getCurrentDatabase: String

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
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(name: String): CatalogDatabase

Definition Classes
SnappyStoreHiveCatalog → 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 getKeyColumns(table: String): Seq[catalog.Column]

API to get primary key or Key Columns of a SnappyData table
def getKeyColumnsAndPositions(table: String): Seq[(catalog.Column, Int)]

API to get primary key or Key Columns of a SnappyData table
def getPartition(tableName: TableIdentifier, spec: TablePartitionSpec): CatalogTablePartition

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

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

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def getTableOption(qtn: QualifiedTableName): Option[CatalogTable]
def getTableType(table: String): String

API to get table type of a SnappyData table
def getTableType(relation: BaseRelation): ExternalTableType
def getTables(db: Option[String]): Seq[(String, Boolean)]
def getTempView(name: String): Option[LogicalPlan]

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

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def hashCode(): Int

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

Attributes
protected
Definition Classes
Logging
def invalidateAll(): Unit
def invalidateTable(tableIdent: QualifiedTableName): Unit
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLocalTemporaryView(name: TableIdentifier): Boolean

Return whether a table with the specified name is a local temporary view.
def isTemporaryFunction(name: FunctionIdentifier): Boolean

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

Definition Classes
SnappyStoreHiveCatalog → SessionCatalog
def isTraceEnabled(): Boolean

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

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

Definition Classes
SnappyStoreHiveCatalog → 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(schema: String, pattern: String): Seq[TableIdentifier]

Definition Classes
SnappyStoreHiveCatalog → 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
final def lookupRelationOption(tableIdent: QualifiedTableName): Option[LogicalPlan]
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
def newQualifiedTableName(tableIdent: TableIdentifier): QualifiedTableName
def newQualifiedTempTableName(tableIdent: String): QualifiedTableName
def normalizeField(f: StructField, fieldName: String): StructField
def normalizeSchema(schema: StructType): StructType
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.
def registerPolicy(policyNameX: TableIdentifier, targetTableX: TableIdentifier, policyFor: String, policyApplyTo: Seq[String], expandedPolicyApplyTo: Seq[String], owner: String, filterString: String, filterPlan: BypassRowLevelSecurity): Unit
def registerRelationDestroy(relation: Option[QualifiedTableName]): Unit

Attributes
protected
def registerTable(tableName: QualifiedTableName, plan: LogicalPlan): Unit
var relationDestroyVersion: Int
def removeDependentRelation(table: QualifiedTableName, dependentRelation: QualifiedTableName): Unit
def removeDependentRelationFromHive(table: QualifiedTableName, dependentRelation: QualifiedTableName): Unit
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
val snappySession: SnappySession
val sparkConf: SparkConf
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tableExists(tableName: QualifiedTableName): Boolean
def tableExists(tableIdentifier: String): Boolean
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 toggleRLSForExternalRelation(tableIdent: QualifiedTableName, enableRowLevelSecurity: Boolean): Unit
def unregisterAllTables(): Unit
def unregisterDataSourceTable(tableIdent: QualifiedTableName, relation: Option[BaseRelation]): Unit

Drops a data source table from Hive's meta-store.
def unregisterGlobalView(tableIdent: QualifiedTableName): Boolean
def unregisterPolicy(policyIdent: QualifiedTableName, ct: CatalogTable): Unit
def unregisterTable(tableIdent: QualifiedTableName): Unit
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

Related Docs: object SnappyStoreHiveCatalog | package hive

class SnappyStoreHiveCatalog extends SessionCatalog

Instance Constructors

new SnappyStoreHiveCatalog(externalCatalog: SnappyExternalCatalog, snappySession: SnappySession, metadataHive: HiveClient, globalTempViewManager: GlobalTempViewManager, functionResourceLoader: FunctionResourceLoader, functionRegistry: FunctionRegistry, sqlConf: SQLConf, hadoopConf: Configuration)

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 caseSensitiveAnalysis: Boolean

def clearTempTables(): Unit

def clone(): AnyRef

def close(): Unit

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

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 formatName(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 getCachedSampledRelations(table: QualifiedTableName): Seq[(LogicalPlan, String)]

final def getClass(): Class[_]

final def getCombinedPolicyFilterForExternalTable(rlsRelation: RowLevelSecurityRelation, wrappingLogicalRelation: Option[LogicalRelation], currentUser: Option[String]): Option[Filter]

final def getCombinedPolicyFilterForNativeTable(rlsRelation: RowLevelSecurityRelation, wrappingLogicalRelation: Option[LogicalRelation]): Option[Filter]

def getCurrentDatabase: 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(name: String): CatalogDatabase

def getDefaultDBPath(db: String): String

def getFunctionMetadata(name: FunctionIdentifier): CatalogFunction

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

def getKeyColumns(table: String): Seq[catalog.Column]

def getKeyColumnsAndPositions(table: String): Seq[(catalog.Column, Int)]

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(table: String): String

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