TestHive

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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 { val extendedResolutionRules: List[org.apache.spark.sql.catalyst.rules.Rule[org.apache.spark.sql.catalyst.plans.logical.LogicalPlan]] }

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: CacheManager

def cacheTable(tableName: String): Unit

var cacheTables: Boolean

lazy val catalog: HiveMetastoreCatalog with OverrideCatalog

lazy val checkAnalysis: CheckAnalysis { val extendedCheckRules: Seq[org.apache.spark.sql.sources.PreWriteCheck] }

def clearCache(): Unit

def clone(): AnyRef

lazy val conf: SQLConf

Fewer partitions to speed up testing.

def configure(): Unit

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.

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 createDataFrame(rdd: JavaRDD[_], beanClass: Class[_]): DataFrame

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

def createDataFrame(rowRDD: JavaRDD[Row], columns: List[String]): 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

val ddlParser: DDLParser

val ddlParserWithHiveQL: DDLParser

val describedTable: Regex

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

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

val hiveQTestUtilTables: Seq[TestTable]

lazy val hiveconf: HiveConf

val inRepoTests: File

def invalidateTable(tableName: String): Unit

def isCached(tableName: String): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

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 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 metastorePath: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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.

lazy val outputBuffer: OutputStream { ... /* 4 definitions in type refinement */ }

def parquetFile(paths: String*): DataFrame

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 refreshTable(tableName: String): Unit

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

def registerTestTable(testTable: TestTable): HashMap[String, TestTable]

def reset(): Unit

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

def runHive(cmd: String, maxRows: Int = 1000): Seq[String]

Execute the command using Hive and return the results as a sequence.

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

Runs the specified SQL query using Hive.

lazy val sessionState: SessionState

SQLConf and HiveConf contracts:

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

def setConf(props: Properties): Unit

val sparkContext: SparkContext

def sql(sqlText: String): DataFrame

val sqlParser: SparkSQLParser

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

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: String

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