HiveContext

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

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

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

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): HiveContext.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 getSchema(beanClass: Class[_]): Seq[AttributeReference]

def hashCode(): Int

lazy val hiveconf: HiveConf

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val optimizer: Optimizer

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

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

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