SnappyContext

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addJar(path: String): Unit

lazy val analyzer: Analyzer

def appendToTempTableCache(df: DataFrame, table: String, storageLevel: StorageLevel = StorageLevel.MEMORY_AND_DISK): Any

Append dataframe to cache table in Spark.

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

def clearCache(): Unit

def clone(): AnyRef

lazy val conf: SQLConf

def createApproxTSTopK(topKName: String, keyColumnName: String, inputDataSchema: Option[StructType], topkOptions: Map[String, String], ifExists: Boolean = false): DataFrame

Create approximate structure to query top-K with time series support.

def createDataFrame(data: List[_], beanClass: Class[_]): DataFrame

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

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

def createDataFrame(rows: List[Row], schema: StructType): 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 createDataset[T](data: Seq[T])(implicit arg0: Encoder[T]): Dataset[T]

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 createSampleTable(tableName: String, schema: Option[StructType], samplingOptions: Map[String, String], ifExists: Boolean = false): DataFrame

Create a stratified sample table.

def createTable(tableName: String, provider: String, schemaDDL: String, options: Map[String, String]): DataFrame

Creates a Snappy managed JDBC table which takes a free format ddl string.

val props = Map(
"url" -> s"jdbc:derby:$path",
"driver" -> "org.apache.derby.jdbc.EmbeddedDriver",
"poolImpl" -> "tomcat",
"user" -> "app",
"password" -> "app"
)


val schemaDDL = "(OrderId INT NOT NULL PRIMARY KEY,ItemId INT, ITEMREF INT)"
snappyContext.createTable("jdbcTable", "jdbc", schemaDDL, props)

Any DataFrame of the same schema can be inserted into the JDBC table using
DataFrameWriter Api.

e.g.

case class Data(col1: Int, col2: Int, col3: Int)

val data = Seq(Seq(1, 2, 3), Seq(7, 8, 9), Seq(9, 2, 3), Seq(4, 2, 3), Seq(5, 6, 7))
val rdd = sc.parallelize(data, data.length).map(s => new Data(s(0), s(1), s(2)))
val dataDF = snc.createDataFrame(rdd)
dataDF.write.format("jdbc").mode(SaveMode.Append).saveAsTable("jdbcTable")

def createTable(tableName: String, provider: String, schema: StructType, options: Map[String, String]): DataFrame

Creates a Snappy managed table.

case class Data(col1: Int, col2: Int, col3: Int)
val props = Map.empty[String, String]
val data = Seq(Seq(1, 2, 3), Seq(7, 8, 9), Seq(9, 2, 3), Seq(4, 2, 3), Seq(5, 6, 7))
val rdd = sc.parallelize(data, data.length).map(s => new Data(s(0), s(1), s(2)))
val dataDF = snc.createDataFrame(rdd)
snappyContext.createTable(tableName, "column", dataDF.schema, props)

def createTable(tableName: String, provider: String, options: Map[String, String]): DataFrame

Creates a Snappy managed table.

val airlineDF = snappyContext.createTable(stagingAirline, "parquet", Map("path" -> airlinefilePath))

val ddlParser: DDLParser

def delete(tableName: String, filterExpr: String): Int

Delete all rows in table that match passed filter expression

def dialectClassName: String

def dropTable(tableName: String, ifExists: Boolean = false): Unit

Drop a SnappyData table created by a call to SnappyContext.

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

def executeSql(sql: String): execution.QueryExecution

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 insert(tableName: String, rows: Row*): Int

Insert one or more org.apache.spark.sql.Row into an existing table A user can insert a DataFrame using foreachPartition.

someDataFrame.foreachPartition (x => snappyContext.insert
("MyTable", x.toSeq)
)

def isCached(tableName: String): Boolean

final def isInstanceOf[T0]: Boolean

val isRootContext: Boolean

def isTraceEnabled(): Boolean

val listener: SQLListener

lazy val listenerManager: ExecutionListenerManager

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

def newSession(): SnappyContext

final def notify(): Unit

final def notifyAll(): Unit

lazy val optimizer: Optimizer

def parseDataType(dataTypeString: String): DataType

def parseSql(sql: String): LogicalPlan

val planner: execution.SparkPlanner

val prepareForExecution: RuleExecutor[SparkPlan]

def put(tableName: String, rows: Row*): Int

Upsert one or more org.apache.spark.sql.Row into an existing table upsert a DataFrame using foreachPartition.

someDataFrame.foreachPartition (x => snappyContext.put
("MyTable", x.toSeq)
)

def queryApproxTSTopK(topK: String, startTime: Long, endTime: Long, k: Int): DataFrame

def queryApproxTSTopK(topKName: String, startTime: Long, endTime: Long): DataFrame

def queryApproxTSTopK(topKName: String, startTime: String = null, endTime: String = null, k: Int = 1): DataFrame

Fetch the topK entries in the Approx TopK synopsis for the specified time interval.

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 saveStream[T](stream: DStream[T], aqpTables: Seq[String], transformer: Option[(RDD[T]) ⇒ RDD[Row]])(implicit v: scala.reflect.api.JavaUniverse.TypeTag[T]): Unit

:: DeveloperApi ::

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

def setConf(props: Properties): Unit

val snappyCacheManager: SnappyCacheManager

val snappyContextFunctions: SnappyContextFunctions

val sparkContext: SparkContext

def sql(sqlText: String): DataFrame

val sqlDialect: ParserDialect

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

def truncateTable(tableName: String): Unit

Empties the contents of the table without deleting the catalog entry.

val udf: UDFRegistration

def uncacheTable(tableName: String): Unit

def update(tableName: String, filterExpr: String, newColumnValues: Row, updateColumns: String*): Int

Update all rows in table that match passed filter expression

snappyContext.update("jdbcTable", "ITEMREF = 3" , Row(99) , "ITEMREF" )

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