TestHiveContext

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def abs(e: Expression): Abs

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

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

:: DeveloperApi :: Creates a SchemaRDD from an RDD containing Rows by applying a schema to this RDD.

import org.apache.spark.sql._
val sqlContext = new org.apache.spark.sql.SQLContext(sc)

val schema =
  StructType(
    StructField("name", StringType, false) ::
    StructField("age", IntegerType, true) :: Nil)

val people =
  sc.textFile("examples/src/main/resources/people.txt").map(
    _.split(",")).map(p => Row(p(0), p(1).trim.toInt))
val peopleSchemaRDD = sqlContext. applySchema(people, schema)
peopleSchemaRDD.printSchema
// root
// |-- name: string (nullable = false)
// |-- age: integer (nullable = true)

  peopleSchemaRDD.registerTempTable("people")
sqlContext.sql("select name from people").collect.foreach(println)

def approxCountDistinct(e: Expression, rsd: Double): ApproxCountDistinct

final def asInstanceOf[T0]: T0

def avg(e: Expression): Average

implicit def baseRelationToSchemaRDD(baseRelation: BaseRelation): SchemaRDD

implicit def bigDecimalToLiteral(d: BigDecimal): Literal

implicit def binaryToLiteral(a: Array[Byte]): Literal

implicit def booleanToLiteral(b: Boolean): Literal

implicit def byteToLiteral(b: Byte): Literal

def cacheTable(tableName: String): Unit

Caches the specified table in-memory.

var cacheTables: Boolean

lazy val catalog: HiveMetastoreCatalog with OverrideCatalog

def clone(): AnyRef

def configure(): Unit

Sets up the system initially or after a RESET command

def count(e: Expression): Count

def countDistinct(e: Expression*): CountDistinct

def createParquetFile[A <: Product](path: String, allowExisting: Boolean = true, conf: Configuration = new Configuration())(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): SchemaRDD

:: Experimental :: Creates an empty parquet file with the schema of class A, which can be registered as a table.

val sqlContext = new SQLContext(...)
import sqlContext._

case class Person(name: String, age: Int)
createParquetFile[Person]("path/to/file.parquet").registerTempTable("people")
sql("INSERT INTO people SELECT 'michael', 29")

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

Creates a SchemaRDD from an RDD of case classes.

def createTable[A <: Product](tableName: String, allowExisting: Boolean = true)(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): Unit

Creates a table using the schema of the given class.

implicit def dateToLiteral(d: Date): Literal

val ddlParser: DDLParser

implicit def decimalToLiteral(d: Decimal): Literal

val describedTable: Regex

implicit def doubleToLiteral(d: Double): Literal

def dropTempTable(tableName: String): Unit

Drops the temporary table with the given table name in the catalog.

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): TestHiveContext.QueryExecution

var extraStrategies: Seq[Strategy]

:: DeveloperApi :: Allows extra strategies to be injected into the query planner at runtime.

def finalize(): Unit

def first(e: Expression): First

implicit def floatToLiteral(f: Float): Literal

lazy val functionRegistry: HiveFunctionRegistry with OverrideFunctionRegistry

def getAllConfs: Map[String, String]

Return all the configuration properties that have been set (i.

final def getClass(): Class[_]

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

Return the value of Spark SQL configuration property for the given key.

def getConf(key: String): String

Return the value of Spark SQL configuration property for the given key.

def getHiveFile(path: String): File

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 hivePlanner: SparkPlanner with HiveStrategies

val hiveQTestUtilTables: Seq[TestTable]

lazy val hiveconf: HiveConf

SQLConf and HiveConf contracts:

val inRepoTests: File

implicit def intToLiteral(i: Int): Literal

def isCached(tableName: String): Boolean

Returns true if the table is currently cached in-memory.

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

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

:: Experimental ::

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

:: Experimental :: Loads a JSON file (one object per line) and applies the given schema, returning the result as a SchemaRDD.

def jsonFile(path: String): SchemaRDD

Loads a JSON file (one object per line), returning the result as a SchemaRDD.

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

:: Experimental ::

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

:: Experimental :: Loads an RDD[String] storing JSON objects (one object per record) and applies the given schema, returning the result as a SchemaRDD.

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

Loads an RDD[String] storing JSON objects (one object per record), returning the result as a SchemaRDD.

def last(e: Expression): Last

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

implicit def logicalPlanToSparkQuery(plan: LogicalPlan): SchemaRDD

:: DeveloperApi :: Allows catalyst LogicalPlans to be executed as a SchemaRDD.

implicit def longToLiteral(l: Long): Literal

def lower(e: Expression): Lower

def max(e: Expression): Max

lazy val metastorePath: String

def min(e: Expression): Min

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

Loads a Parquet file, returning the result as a SchemaRDD.

def parseSql(sql: String): LogicalPlan

val planner: SparkPlanner with HiveStrategies

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

Prepares a planned SparkPlan for execution by inserting shuffle operations as needed.

def registerFunction[T](name: String, func: Function22[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function21[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function20[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function19[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function18[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function17[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function16[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function15[_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function14[_, _, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function13[_, _, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function12[_, _, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function11[_, _, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function10[_, _, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function9[_, _, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function8[_, _, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function7[_, _, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function6[_, _, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function5[_, _, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function4[_, _, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function3[_, _, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function2[_, _, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

def registerFunction[T](name: String, func: Function1[_, T])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

registerFunction 1-22 were generated by this script

def registerRDDAsTable(rdd: SchemaRDD, tableName: String): Unit

Registers the given RDD as a temporary table in the catalog.

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

Set the given Spark SQL configuration property.

def setConf(props: Properties): Unit

Set Spark SQL configuration properties.

val settings: Map[String, String]

Only low degree of contention is expected for conf, thus NOT using ConcurrentHashMap.

implicit def shortToLiteral(s: Short): Literal

val sparkContext: SparkContext

def sql(sqlText: String): SchemaRDD

Executes a SQL query using Spark, returning the result as a SchemaRDD.

val sqlParser: SparkSQLParser

def sqrt(e: Expression): Sqrt

implicit def stringToLiteral(s: String): Literal

def sum(e: Expression): Sum

def sumDistinct(e: Expression): SumDistinct

implicit def symbolToUnresolvedAttribute(s: Symbol): UnresolvedAttribute

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

def table(tableName: String): SchemaRDD

Returns the specified table as a SchemaRDD

lazy val testTables: HashMap[String, TestTable]

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

val testTempDir: File

implicit def timestampToLiteral(t: Timestamp): Literal

def toString(): String

def uncacheTable(tableName: String): Unit

Removes the specified table from the in-memory cache.

def upper(e: Expression): Upper

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val warehousePath: String

def hiveql(hqlQuery: String): SchemaRDD

def hql(hqlQuery: String): SchemaRDD