CassandraSQLContext

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (CassandraSQLContext, B)

final def ==(arg0: Any): Boolean

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

def cassandraSql(cassandraQuery: String): DataFrame

Executes SQL query against Cassandra and returns DataFrame representing the result.

lazy val catalog: CassandraCatalog

A catalyst metadata catalog that points to Cassandra.

def clearCache(): Unit

def clone(): AnyRef

def conf: SQLConf

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

val ddlParser: DDLParser

val defaultSession: SQLSession

def detachSession(): Unit

def dialectClassName: String

def dropTempTable(tableName: String): Unit

lazy val emptyDataFrame: DataFrame

lazy val emptyResult: RDD[Row]

def ensuring(cond: (CassandraSQLContext) ⇒ Boolean, msg: ⇒ Any): CassandraSQLContext

def ensuring(cond: (CassandraSQLContext) ⇒ Boolean): CassandraSQLContext

def ensuring(cond: Boolean, msg: ⇒ Any): CassandraSQLContext

def ensuring(cond: Boolean): CassandraSQLContext

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executePlan(plan: LogicalPlan): QueryExecution

def executeSql(sql: String): QueryExecution

val experimental: ExperimentalMethods

def finalize(): Unit

def formatted(fmtstr: String): String

lazy val functionRegistry: FunctionRegistry

def getAllConfs: Map[String, String]

final def getClass(): Class[_]

def getCluster: String

Get current used cluster name

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

def getConf(key: String): String

def getKeyspace: String

Returns keyspace/database set previously by setKeyspace or throws IllegalStateException if keyspace has not been set yet.

def getSQLDialect(): ParserDialect

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

def hashCode(): Int

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openSession(): SQLSession

lazy val optimizer: Optimizer

def parseDataType(dataTypeString: String): DataType

def parseSql(sql: String): LogicalPlan

val planner: SparkPlanner { ... /* 2 definitions in type refinement */ }

Modified Catalyst planner that does Cassandra-specific predicate pushdown

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 setCluster(cluster: String): Unit

Set current used cluster name

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

def setConf(props: Properties): Unit

def setDatabase(db: String): Unit

Set current used database name.

def setKeyspace(ks: String): Unit

Set default Cassandra keyspace to be used when accessing tables with unqualified names.

val sparkContext: SparkContext

def sql(cassandraQuery: String): DataFrame

Delegates to cassandraSql

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

val tlSession: ThreadLocal[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 →[B](y: B): (CassandraSQLContext, B)

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