SnappyContext

Instance Constructors

new SnappyContext(sc: SparkContext)

Attributes
protected[org.apache.spark]
new SnappyContext(sparkContext: SparkContext, listener: SQLListener, isRootContext: Boolean)

Attributes
protected[org.apache.spark]

Type Members

class QueryExecution extends execution.QueryExecution

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.6.0) use org.apache.spark.sql.QueryExecution
class SparkPlanner extends execution.SparkPlanner

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.6.0) use org.apache.spark.sql.SparkPlanner

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def addJar(path: String): Unit

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
lazy val analyzer: Analyzer

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
def appendToTempTableCache(df: DataFrame, table: String, storageLevel: StorageLevel = StorageLevel.MEMORY_AND_DISK): Unit

Append dataframe to cache table in Spark.
Append dataframe to cache table in Spark.
df
table
storageLevel
default storage level is MEMORY_AND_DISK
returns
@todo -> return type?

Annotations
@DeveloperApi()
def applySchemaToPythonRDD(rdd: RDD[Array[Any]], schema: StructType): DataFrame

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def applySchemaToPythonRDD(rdd: RDD[Array[Any]], schemaString: String): DataFrame

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
final def asInstanceOf[T0]: T0

Definition Classes
Any
def baseRelationToDataFrame(baseRelation: BaseRelation): DataFrame

Definition Classes
SQLContext
val cacheManager: execution.CacheManager

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def cacheTable(tableName: String): Unit

Definition Classes
SQLContext
lazy val catalog: SnappyStoreHiveCatalog

Definition Classes
SnappyContext → SQLContext
def clearCache(): Unit

Definition Classes
SQLContext
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val conf: SQLConf

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
def createApproxTSTopK(topKName: String, keyColumnName: String, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create approximate structure to query top-K with time series support.
Create approximate structure to query top-K with time series support. Java friendly api.
topKName
the qualified name of the top-K structure
keyColumnName
topkOptions
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using TopK with time series
def createApproxTSTopK(topKName: String, keyColumnName: String, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create approximate structure to query top-K with time series support.
Create approximate structure to query top-K with time series support.
topKName
the qualified name of the top-K structure
keyColumnName
topkOptions
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using TopK with time series
def createApproxTSTopK(topKName: String, keyColumnName: String, inputDataSchema: StructType, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create approximate structure to query top-K with time series support.
Create approximate structure to query top-K with time series support. Java friendly api.
topKName
the qualified name of the top-K structure
keyColumnName
inputDataSchema
topkOptions
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using TopK with time series
def createApproxTSTopK(topKName: String, keyColumnName: String, inputDataSchema: StructType, topkOptions: Map[String, String], allowExisting: Boolean = false): DataFrame

Create approximate structure to query top-K with time series support.
Create approximate structure to query top-K with time series support.
topKName
the qualified name of the top-K structure
keyColumnName
inputDataSchema
topkOptions
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using TopK with time series
def createDataFrame(data: List[_], beanClass: Class[_]): DataFrame

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

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

Definition Classes
SQLContext
def createDataFrame(rows: List[Row], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@DeveloperApi()
def createDataFrame(rowRDD: JavaRDD[Row], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@DeveloperApi()
def createDataFrame(rowRDD: RDD[Row], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@DeveloperApi()
def createDataFrame[A <: Product](data: Seq[A])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createDataFrame[A <: Product](rdd: RDD[A])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createDataset[T](data: List[T])(implicit arg0: Encoder[T]): Dataset[T]

Definition Classes
SQLContext
def createDataset[T](data: RDD[T])(implicit arg0: Encoder[T]): Dataset[T]

Definition Classes
SQLContext
def createDataset[T](data: Seq[T])(implicit arg0: Encoder[T]): Dataset[T]

Definition Classes
SQLContext
def createExternalTable(tableName: String, source: String, schema: StructType, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createExternalTable(tableName: String, source: String, schema: StructType, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createExternalTable(tableName: String, source: String, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createExternalTable(tableName: String, source: String, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createExternalTable(tableName: String, path: String, source: String): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createExternalTable(tableName: String, path: String): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def createIndex(indexName: String, baseTable: String, indexColumns: Map[String, Option[SortDirection]], options: Map[String, String]): Unit

Create an index on a table.
Create an index on a table.
indexName
Index name which goes in the catalog
baseTable
Fully qualified name of table on which the index is created.
indexColumns
Columns on which the index has to be created with the direction of sorting. Direction can be specified as None.
options
Options for indexes. For e.g. column table index - ("COLOCATE_WITH"->"CUSTOMER"). row table index - ("INDEX_TYPE"->"GLOBAL HASH") or ("INDEX_TYPE"->"UNIQUE")
def createIndex(indexName: String, baseTable: String, indexColumns: Map[String, Option[SortDirection]], options: Map[String, String]): Unit

Create an index on a table.
Create an index on a table.
indexName
Index name which goes in the catalog
baseTable
Fully qualified name of table on which the index is created.
indexColumns
Columns on which the index has to be created
options
Options for indexes. For e.g. column table index - ("COLOCATE_WITH"->"CUSTOMER"). row table index - ("INDEX_TYPE"->"GLOBAL HASH") or ("INDEX_TYPE"->"UNIQUE")
def createSampleTable(tableName: String, schema: StructType, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create a stratified sample table.
Create a stratified sample table. Java friendly version.
tableName
the qualified name of the table
schema
schema of the table
samplingOptions
sampling options like QCS, reservoir size etc.
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using sample tables with time series and otherwise
def createSampleTable(tableName: String, schema: StructType, samplingOptions: Map[String, String], allowExisting: Boolean = false): DataFrame

Create a stratified sample table.
Create a stratified sample table.
tableName
the qualified name of the table
schema
schema of the table
samplingOptions
sampling options like QCS, reservoir size etc.
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using sample tables with time series and otherwise
def createSampleTable(tableName: String, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create a stratified sample table.
Create a stratified sample table. Java friendly version.
tableName
the qualified name of the table
samplingOptions
sampling options like QCS, reservoir size etc.
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using sample tables with time series and otherwise
def createSampleTable(tableName: String, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

Create a stratified sample table.
Create a stratified sample table.
tableName
the qualified name of the table
samplingOptions
sampling options like QCS, reservoir size etc.
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception

To do
provide lot more details and examples to explain creating and using sample tables with time series and otherwise
def createTable(tableName: String, provider: String, schemaDDL: String, options: Map[String, String], allowExisting: Boolean): DataFrame

Creates a Snappy managed JDBC table which takes a free format ddl string.
Creates a Snappy managed JDBC table which takes a free format ddl string. The ddl string should adhere to syntax of underlying JDBC store. SnappyData ships with inbuilt JDBC store , which can be accessed by Row format data store. The option parameter can take connection details. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
```
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")
```
tableName
Name of the table
provider
Provider name 'ROW' and 'JDBC'.
schemaDDL
Table schema as a string interpreted by provider
options
Properties for table creation. See options list for different tables. https://github.com/SnappyDataInc/snappydata/blob/master/docs/rowAndColumnTables.md
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table

Annotations
@Experimental()
def createTable(tableName: String, provider: String, schemaDDL: String, options: Map[String, String], allowExisting: Boolean): DataFrame

Creates a Snappy managed JDBC table which takes a free format ddl string.
Creates a Snappy managed JDBC table which takes a free format ddl string. The ddl string should adhere to syntax of underlying JDBC store. SnappyData ships with inbuilt JDBC store , which can be accessed by Row format data store. The option parameter can take connection details. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
```
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")
```
tableName
Name of the table
provider
Provider name 'ROW' and 'JDBC'.
schemaDDL
Table schema as a string interpreted by provider
options
Properties for table creation. See options list for different tables. https://github.com/SnappyDataInc/snappydata/blob/master/docs/rowAndColumnTables.md
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table
def createTable(tableName: String, provider: String, schema: StructType, options: Map[String, String], allowExisting: Boolean): DataFrame

Creates a Snappy managed table.
Creates a Snappy managed table. Any relation providers (e.g. parquet, jdbc etc) supported by Spark & Snappy can be created here. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
```
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)
```
tableName
Name of the table
provider
Provider name such as 'COLUMN', 'ROW', 'JDBC', 'PARQUET' etc.
schema
Table schema
options
Properties for table creation. See options list for different tables. https://github.com/SnappyDataInc/snappydata/blob/master/docs/rowAndColumnTables.md
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table

Annotations
@Experimental()
def createTable(tableName: String, provider: String, schema: StructType, options: Map[String, String], allowExisting: Boolean = false): DataFrame

Creates a Snappy managed table.
Creates a Snappy managed table. Any relation providers (e.g. parquet, jdbc etc) supported by Spark & Snappy can be created here. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
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)
}}}
tableName
Name of the table
provider
Provider name such as 'COLUMN', 'ROW', 'JDBC', 'PARQUET' etc.
schema
Table schema
options
Properties for table creation. See options list for different tables. https://github.com/SnappyDataInc/snappydata/blob/master/docs/rowAndColumnTables.md
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table
def createTable(tableName: String, provider: String, options: Map[String, String], allowExisting: Boolean): DataFrame

Creates a Snappy managed table.
Creates a Snappy managed table. Any relation providers (e.g. parquet, jdbc etc) supported by Spark & Snappy can be created here. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
```
val airlineDF = snappyContext.createTable(stagingAirline, "parquet", Map("path" -> airlinefilePath))
```
tableName
Name of the table
provider
Provider name such as 'COLUMN', 'ROW', 'JDBC', 'PARQUET' etc.
options
Properties for table creation
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table

Annotations
@Experimental()
def createTable(tableName: String, provider: String, options: Map[String, String], allowExisting: Boolean): DataFrame

Creates a Snappy managed table.
Creates a Snappy managed table. Any relation providers (e.g. parquet, jdbc etc) supported by Spark & Snappy can be created here. Unlike SqlContext.createExternalTable this API creates a persistent catalog entry.
```
val airlineDF = snappyContext.createTable(stagingAirline, "parquet", Map("path" -> airlinefilePath))
```
tableName
Name of the table
provider
Provider name such as 'COLUMN', 'ROW', 'JDBC', 'PARQUET' etc.
options
Properties for table creation
allowExisting
When set to true it will ignore if a table with the same name is present , else it will throw table exist exception
returns
DataFrame for the table
val ddlParser: DDLParser

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
def delete(tableName: String, filterExpr: String): Int

Delete all rows in table that match passed filter expression
Delete all rows in table that match passed filter expression
tableName
table name
filterExpr
SQL WHERE criteria to select rows that will be updated
returns
number of rows deleted

Annotations
@DeveloperApi()
def dialectClassName: String

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def dropIndex(indexName: String, ifExists: Boolean): Unit

Drops an index on a table
Drops an index on a table
indexName
Index name which goes in catalog
ifExists
Drop if exists, else exit gracefully
def dropTable(tableName: String, ifExists: Boolean = false): Unit

Drop a SnappyData table created by a call to SnappyContext.
Drop a SnappyData table created by a call to SnappyContext.createTable
tableName
table to be dropped
ifExists
attempt drop only if the table exists
def dropTempTable(tableName: String): Unit

Definition Classes
SQLContext
lazy val emptyDataFrame: DataFrame

Definition Classes
SQLContext
lazy val emptyResult: RDD[InternalRow]

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def executePlan(plan: LogicalPlan): execution.QueryExecution

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
def executeSql(sql: String): execution.QueryExecution

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
val experimental: ExperimentalMethods

Definition Classes
SQLContext
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
lazy val functionRegistry: FunctionRegistry

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def getAllConfs: Map[String, String]

Definition Classes
SQLContext
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getConf(key: String, defaultValue: String): String

Definition Classes
SQLContext
def getConf(key: String): String

Definition Classes
SQLContext
def getSQLDialect(): ParserDialect

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
def getSchema(beanClass: Class[_]): Seq[AttributeReference]

Attributes
protected
Definition Classes
SQLContext
def hashCode(): Int

Definition Classes
AnyRef → Any
def insert(tableName: String, rows: ArrayList[ArrayList[_]]): Int

Insert one or more org.apache.spark.sql.Row into an existing table A user can insert a DataFrame using foreachPartition.
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)
)
```
tableName
rows
returns
number of rows inserted

Annotations
@Experimental()
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.
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)
)
```
tableName
rows
returns
number of rows inserted

Annotations
@DeveloperApi()
def isCached(tableName: String): Boolean

Definition Classes
SQLContext
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val isRootContext: Boolean

Definition Classes
SnappyContext → SQLContext
def isTraceEnabled(): Boolean

Attributes
protected
Definition Classes
Logging
val listener: SQLListener

Definition Classes
SnappyContext → SQLContext
lazy val listenerManager: ExecutionListenerManager

Definition Classes
SQLContext
def log: Logger

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logName: String

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newSession(): SnappyContext

Definition Classes
SnappyContext → SQLContext
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val optimizer: Optimizer

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def parseDataType(dataTypeString: String): DataType

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
def parseSql(sql: String): LogicalPlan

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
val planner: execution.SparkPlanner

Attributes
protected[org.apache.spark.sql]
Definition Classes
SnappyContext → SQLContext
val prepareForExecution: RuleExecutor[SparkPlan]

Definition Classes
SnappyContext → SQLContext
def put(tableName: String, rows: ArrayList[ArrayList[_]]): Int

Upsert one or more org.apache.spark.sql.Row into an existing table upsert a DataFrame using foreachPartition.
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)
)
```
tableName
rows
returns

Annotations
@Experimental()
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.
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)
)
```
tableName
rows
returns

Annotations
@DeveloperApi()
def queryApproxTSTopK(topK: String, startTime: Long, endTime: Long, k: Int): DataFrame
def queryApproxTSTopK(topKName: String, startTime: Long, endTime: Long): DataFrame

To do
why do we need this method? K is optional in the above method
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.
Fetch the topK entries in the Approx TopK synopsis for the specified time interval. See _createTopK_ for how to create this data structure and associate this to a base table (i.e. the full data set). The time interval specified here should not be less than the minimum time interval used when creating the TopK synopsis.
topKName
- The topK structure that is to be queried.
startTime
start time as string of the format "yyyy-mm-dd hh:mm:ss". If passed as null, oldest interval is considered as the start interval.
endTime
end time as string of the format "yyyy-mm-dd hh:mm:ss". If passed as null, newest interval is considered as the last interval.
k
Optional. Number of elements to be queried. This is to be passed only for stream summary
returns
returns the top K elements with their respective frequencies between two time

To do
provide an example and explain the returned DataFrame. Key is the attribute stored but the value is a struct containing count_estimate, and lower, upper bounds? How many elements are returned if K is not specified?
def range(start: Long, end: Long, step: Long, numPartitions: Int): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def range(start: Long, end: Long): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def range(end: Long): DataFrame

Definition Classes
SQLContext
Annotations
@Experimental()
def read: DataFrameReader

Definition Classes
SQLContext
Annotations
@Experimental()
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 ::
:: DeveloperApi ::
T
stream
aqpTables
transformer
v
returns

Annotations
@DeveloperApi()
To do
do we need this anymore? If useful functionality, make this private to sql package ... SchemaDStream should use the data source API? Tagging as developer API, for now
def setConf(key: String, value: String): Unit

Definition Classes
SQLContext
def setConf(props: Properties): Unit

Definition Classes
SQLContext
val sparkContext: SparkContext

Definition Classes
SnappyContext → SQLContext
def sql(sqlText: String): DataFrame

Definition Classes
SQLContext
val sqlParser: SparkSQLParser

Attributes
protected[org.apache.spark.sql]
Definition Classes
SQLContext
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def table(tableName: String): DataFrame

Definition Classes
SQLContext
def tableNames(databaseName: String): Array[String]

Definition Classes
SQLContext
def tableNames(): Array[String]

Definition Classes
SQLContext
def tables(databaseName: String): DataFrame

Definition Classes
SQLContext
def tables(): DataFrame

Definition Classes
SQLContext
def toString(): String

Definition Classes
AnyRef → Any
def truncateTable(tableName: String): Unit

Empties the contents of the table without deleting the catalog entry.
Empties the contents of the table without deleting the catalog entry.
tableName
full table name to be truncated
val udf: UDFRegistration

Definition Classes
SQLContext
def uncacheTable(tableName: String): Unit

Definition Classes
SQLContext
def update(tableName: String, filterExpr: String, newColumnValues: ArrayList[_], updateColumns: ArrayList[String]): Int

Update all rows in table that match passed filter expression
Update all rows in table that match passed filter expression
```
snappyContext.update("jdbcTable", "ITEMREF = 3" , Row(99) , "ITEMREF" )
```
tableName
table name which needs to be updated
filterExpr
SQL WHERE criteria to select rows that will be updated
newColumnValues
A list containing all the updated column values. They MUST match the updateColumn list passed
updateColumns
List of all column names being updated
returns

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

Update all rows in table that match passed filter expression
Update all rows in table that match passed filter expression
```
snappyContext.update("jdbcTable", "ITEMREF = 3" , Row(99) , "ITEMREF" )
```
tableName
table name which needs to be updated
filterExpr
SQL WHERE criteria to select rows that will be updated
newColumnValues
A single Row containing all updated column values. They MUST match the updateColumn list passed
updateColumns
List of all column names being updated
returns

Annotations
@DeveloperApi()
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

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

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.3.0) Use createDataFrame. This will be removed in Spark 2.0.
def applySchema(rdd: RDD[_], beanClass: Class[_]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.3.0) Use createDataFrame. This will be removed in Spark 2.0.
def applySchema(rowRDD: JavaRDD[Row], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.3.0) Use createDataFrame. This will be removed in Spark 2.0.
def applySchema(rowRDD: RDD[Row], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.3.0) Use createDataFrame. This will be removed in Spark 2.0.
def jdbc(url: String, table: String, theParts: Array[String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.jdbc(). This will be removed in Spark 2.0.
def jdbc(url: String, table: String, columnName: String, lowerBound: Long, upperBound: Long, numPartitions: Int): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.jdbc(). This will be removed in Spark 2.0.
def jdbc(url: String, table: String): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.jdbc(). This will be removed in Spark 2.0.
def jsonFile(path: String, samplingRatio: Double): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonFile(path: String, schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonFile(path: String): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: JavaRDD[String], samplingRatio: Double): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: RDD[String], samplingRatio: Double): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: JavaRDD[String], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: RDD[String], schema: StructType): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: JavaRDD[String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def jsonRDD(json: RDD[String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.json(). This will be removed in Spark 2.0.
def load(source: String, schema: StructType, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.format(source).schema(schema).options(options).load(). This will be removed in Spark 2.0.
def load(source: String, schema: StructType, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.format(source).schema(schema).options(options).load(). This will be removed in Spark 2.0.
def load(source: String, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.format(source).options(options).load(). This will be removed in Spark 2.0.
def load(source: String, options: Map[String, String]): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.format(source).options(options).load(). This will be removed in Spark 2.0.
def load(path: String, source: String): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.format(source).load(path). This will be removed in Spark 2.0.
def load(path: String): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated
Deprecated
(Since version 1.4.0) Use read.load(path). This will be removed in Spark 2.0.
def parquetFile(paths: String*): DataFrame

Definition Classes
SQLContext
Annotations
@deprecated @varargs()
Deprecated
(Since version 1.4.0) Use read.parquet(). This will be removed in Spark 2.0.

class SnappyContext extends SQLContext with Serializable with Logging

Instance Constructors

new SnappyContext(sc: SparkContext)

new SnappyContext(sparkContext: SparkContext, listener: SQLListener, isRootContext: Boolean)

Type Members

class QueryExecution extends execution.QueryExecution

class SparkPlanner extends execution.SparkPlanner

Value Members

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): Unit

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, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

def createApproxTSTopK(topKName: String, keyColumnName: String, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

def createApproxTSTopK(topKName: String, keyColumnName: String, inputDataSchema: StructType, topkOptions: Map[String, String], allowExisting: Boolean): DataFrame

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

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: List[T])(implicit arg0: Encoder[T]): Dataset[T]

def createDataset[T](data: RDD[T])(implicit arg0: Encoder[T]): Dataset[T]

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 createIndex(indexName: String, baseTable: String, indexColumns: Map[String, Option[SortDirection]], options: Map[String, String]): Unit

def createIndex(indexName: String, baseTable: String, indexColumns: Map[String, Option[SortDirection]], options: Map[String, String]): Unit

def createSampleTable(tableName: String, schema: StructType, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

def createSampleTable(tableName: String, schema: StructType, samplingOptions: Map[String, String], allowExisting: Boolean = false): DataFrame

def createSampleTable(tableName: String, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

def createSampleTable(tableName: String, samplingOptions: Map[String, String], allowExisting: Boolean): DataFrame

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

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

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

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

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

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

val ddlParser: DDLParser

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

def dialectClassName: String

def dropIndex(indexName: String, ifExists: Boolean): Unit

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

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