HiveContext

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

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

lazy val catalog: HiveMetastoreCatalog with OverrideCatalog

def clearCache(): Unit

def clone(): AnyRef

def conf: SQLConf

def configure(): Map[String, String]

Overridden by child classes that need to set configuration before the client init.

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 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(): HiveContext.SQLSession

val ddlParser: DDLParser

val defaultSession: HiveContext.SQLSession

def detachSession(): Unit

def dialectClassName: String

def dropTempTable(tableName: String): Unit

lazy val emptyDataFrame: DataFrame

lazy val emptyResult: RDD[InternalRow]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executePlan(plan: LogicalPlan): QueryExecution

def executeSql(sql: String): HiveContext.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: FunctionRegistry

def getAllConfs: Map[String, String]

final def getClass(): Class[_]

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

def getConf(key: String): String

def getSQLDialect(): ParserDialect

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

def hashCode(): Int

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.

def hiveThriftServerAsync: Boolean

def hiveconf: HiveConf

def invalidateTable(tableName: String): Unit

def isCached(tableName: String): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

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(): HiveContext.SQLSession

lazy val optimizer: Optimizer

def parseDataType(dataTypeString: String): DataType

def parseSql(sql: String): LogicalPlan

val planner: SparkPlanner with HiveStrategies

val prepareForExecution: RuleExecutor[SparkPlan]

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

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

def range(end: Long): DataFrame

def read: DataFrameReader

def refreshTable(tableName: String): Unit

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

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

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

def setConf(props: Properties): Unit

def setSession(session: HiveContext.SQLSession): 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

val tlSession: ThreadLocal[HiveContext.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

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