TestHive

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def analyze(tableName: String): Unit

Analyzes the given table in the current database to generate statistics, which will be used in query optimizations.

lazy val analyzer: Analyzer

def applySchemaToPythonRDD(rdd: RDD[Array[Any]], schema: StructType): DataFrame

def applySchemaToPythonRDD(rdd: RDD[Array[Any]], schemaString: String): DataFrame

final def asInstanceOf[T0]: T0

def baseRelationToDataFrame(baseRelation: BaseRelation): DataFrame

val cacheManager: execution.CacheManager

def cacheTable(tableName: String): Unit

var cacheTables: Boolean

lazy val catalog: HiveMetastoreCatalog with OverrideCatalog

def clearCache(): Unit

def clone(): AnyRef

def conf: SQLConf

def configure(): Map[String, String]

Sets up the system initially or after a RESET command

def convertCTAS: Boolean

When true, a table created by a Hive CTAS statement (no USING clause) will be converted to a data source table, using the data source set by spark.sql.sources.default.

def convertMetastoreParquet: Boolean

When true, enables an experimental feature where metastore tables that use the parquet SerDe are automatically converted to use the Spark SQL parquet table scan, instead of the Hive SerDe.

def convertMetastoreParquetWithSchemaMerging: Boolean

When true, also tries to merge possibly different but compatible Parquet schemas in different Parquet data files.

def createDataFrame(rdd: JavaRDD[_], beanClass: Class[_]): DataFrame

def createDataFrame(rdd: RDD[_], beanClass: Class[_]): DataFrame

def createDataFrame(rowRDD: JavaRDD[Row], schema: StructType): DataFrame

def createDataFrame(rowRDD: RDD[Row], schema: StructType): DataFrame

def createDataFrame[A <: Product](data: Seq[A])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): DataFrame

def createDataFrame[A <: Product](rdd: RDD[A])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): DataFrame

def createExternalTable(tableName: String, source: String, schema: StructType, options: Map[String, String]): DataFrame

def createExternalTable(tableName: String, source: String, schema: StructType, options: Map[String, String]): DataFrame

def createExternalTable(tableName: String, source: String, options: Map[String, String]): DataFrame

def createExternalTable(tableName: String, source: String, options: Map[String, String]): DataFrame

def createExternalTable(tableName: String, path: String, source: String): DataFrame

def createExternalTable(tableName: String, path: String): DataFrame

def createSession(): SQLSession

def currentSession(): TestHive.SQLSession

val ddlParser: DDLParser

val defaultSession: TestHive.SQLSession

val describedTable: Regex

def detachSession(): Unit

def dialectClassName: String

def dropTempTable(tableName: String): Unit

lazy val emptyDataFrame: DataFrame

lazy val emptyResult: RDD[Row]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executePlan(plan: LogicalPlan): QueryExecution

def executeSql(sql: String): TestHive.QueryExecution

lazy val executionHive: ClientWrapper

The copy of the hive client that is used for execution.

val experimental: ExperimentalMethods

def finalize(): Unit

lazy val functionRegistry: HiveFunctionRegistry with OverrideFunctionRegistry

def getAllConfs: Map[String, String]

final def getClass(): Class[_]

def getConf(key: String, defaultValue: String): String

def getConf(key: String): String

def getHiveFile(path: String): File

def getSQLDialect(): ParserDialect

def getSchema(beanClass: Class[_]): Seq[AttributeReference]

def hashCode(): Int

lazy val hiveDevHome: Option[File]

The location of the hive source code.

val hiveFilesTemp: File

lazy val hiveHome: Option[File]

The location of the compiled hive distribution

def hiveMetastoreBarrierPrefixes: Seq[String]

A comma separated list of class prefixes that should explicitly be reloaded for each version of Hive that Spark SQL is communicating with.

def hiveMetastoreJars: String

The location of the jars that should be used to instantiate the HiveMetastoreClient.

def hiveMetastoreSharedPrefixes: Seq[String]

A comma separated list of class prefixes that should be loaded using the classloader that is shared between Spark SQL and a specific version of Hive.

def hiveMetastoreVersion: String

The version of the hive client that will be used to communicate with the metastore.

val hiveQTestUtilTables: Seq[TestTable]

def hiveconf: HiveConf

val inRepoTests: File

def invalidateTable(tableName: String): Unit

def isCached(tableName: String): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

def loadTestTable(name: String): Unit

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logName: String

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit

def logWarning(msg: ⇒ String): Unit

lazy val metadataHive: ClientInterface

The copy of the Hive client that is used to retrieve metadata from the Hive MetaStore.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openSession(): TestHive.SQLSession

lazy val optimizer: Optimizer

val originalUdfs: Set[String]

Records the UDFs present when the server starts, so we can delete ones that are created by tests.

def parseDataType(dataTypeString: String): DataType

def parseSql(sql: String): LogicalPlan

val planner: SparkPlanner with HiveStrategies

val prepareForExecution: RuleExecutor[SparkPlan] { val batches: List[this.Batch] }

def range(start: Long, end: Long, step: Long, numPartitions: Int): DataFrame

def range(end: Long): DataFrame

def range(start: Long, end: Long): DataFrame

def read: DataFrameReader

def refreshTable(tableName: String): Unit

Invalidate and refresh all the cached the metadata of the given table.

def registerTestTable(testTable: TestTable): Unit

def reset(): Unit

Resets the test instance by deleting any tables that have been created.

def runSqlHive(sql: String): Seq[String]

def setConf(key: String, value: String): Unit

def setConf(props: Properties): Unit

val sparkContext: SparkContext

def sql(sqlText: String): DataFrame

val sqlParser: SparkSQLParser

lazy val substitutor: VariableSubstitution

final def synchronized[T0](arg0: ⇒ T0): T0

def table(tableName: String): DataFrame

def tableNames(databaseName: String): Array[String]

def tableNames(): Array[String]

def tables(databaseName: String): DataFrame

def tables(): DataFrame

lazy val testTables: HashMap[String, TestTable]

A list of test tables and the DDL required to initialize them.

val testTempDir: File

val tlSession: ThreadLocal[TestHive.SQLSession]

def toString(): String

val udf: UDFRegistration

def uncacheTable(tableName: String): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val warehousePath: File

def applySchema(rdd: JavaRDD[_], beanClass: Class[_]): DataFrame

def applySchema(rdd: RDD[_], beanClass: Class[_]): DataFrame

def applySchema(rowRDD: JavaRDD[Row], schema: StructType): DataFrame

def applySchema(rowRDD: RDD[Row], schema: StructType): DataFrame

def jdbc(url: String, table: String, theParts: Array[String]): DataFrame

def jdbc(url: String, table: String, columnName: String, lowerBound: Long, upperBound: Long, numPartitions: Int): DataFrame

def jdbc(url: String, table: String): DataFrame

def jsonFile(path: String, samplingRatio: Double): DataFrame

def jsonFile(path: String, schema: StructType): DataFrame

def jsonFile(path: String): DataFrame

def jsonRDD(json: JavaRDD[String], samplingRatio: Double): DataFrame

def jsonRDD(json: RDD[String], samplingRatio: Double): DataFrame

def jsonRDD(json: JavaRDD[String], schema: StructType): DataFrame

def jsonRDD(json: RDD[String], schema: StructType): DataFrame

def jsonRDD(json: JavaRDD[String]): DataFrame

def jsonRDD(json: RDD[String]): DataFrame

def load(source: String, schema: StructType, options: Map[String, String]): DataFrame

def load(source: String, schema: StructType, options: Map[String, String]): DataFrame

def load(source: String, options: Map[String, String]): DataFrame

def load(source: String, options: Map[String, String]): DataFrame

def load(path: String, source: String): DataFrame

def load(path: String): DataFrame

def parquetFile(paths: String*): DataFrame