SnappyDDLParser

Instance Constructors

new SnappyDDLParser(session: SnappySession)

Type Members

sealed trait ActionOperator[I <: HList, O <: HList, Ops] extends AnyRef

Definition Classes
RuleDSLActions
sealed trait CharRangeSupport extends AnyRef

Definition Classes
RuleDSLBasics
final type ColumnDirectionMap = Seq[(String, Option[SortDirection])]
sealed trait NTimes extends AnyRef

Definition Classes
RuleDSLCombinators
final type TableEnd = (Option[String], Option[Map[String, String]], Array[String], Option[BucketSpec], Option[LogicalPlan])
class TracingBubbleException extends RuntimeException with NoStackTrace

Definition Classes
Parser
trait WithSeparatedBy[I <: HList, O <: HList] extends AnyRef

Definition Classes
RuleDSLCombinators
class __SubParserInput extends ParserInput

Attributes
protected
Definition Classes
Parser

Abstract Value Members

abstract def expression: Rule1[Expression]

Attributes
protected
abstract def input: ParserInput

Definition Classes
Parser
abstract def newInstance(): SnappyDDLParser

Attributes
protected
abstract def parseSQL[T](sqlText: String, parseRule: ⇒ Try[T]): T

Attributes
protected
abstract def partitionSpec: Rule1[Map[String, Option[String]]]

Attributes
protected
abstract def query: Rule1[LogicalPlan]

Attributes
protected
abstract def start: Rule1[LogicalPlan]

Attributes
protected
Definition Classes
SnappyBaseParser

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def &(r: Rule[_, _]): Rule0

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ADD: Rule0
final def ALL: Rule0
final def ALTER: Rule0
final def ANALYZE: Rule0
final def AND: Rule0
final def ANTI: Rule0
def ANY: Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
final def ARRAY: Rule0

Definition Classes
SnappyBaseParser
final def AS: Rule0
final def ASC: Rule0
final def AUTHORIZATION: Rule0
final def BETWEEN: Rule0
final def BIGINT: Rule0

Definition Classes
SnappyBaseParser
final def BINARY: Rule0

Definition Classes
SnappyBaseParser
final def BLOB: Rule0

Definition Classes
SnappyBaseParser
final def BOOLEAN: Rule0

Definition Classes
SnappyBaseParser
final def BUCKETS: Rule0
final def BY: Rule0
final def BYTE: Rule0

Definition Classes
SnappyBaseParser
final def CACHE: Rule0
final def CALL: Rule0
final def CASCADE: Rule0
final def CASE: Rule0
final def CAST: Rule0
final def CHAR: Rule0

Definition Classes
SnappyBaseParser
final def CHECK: Rule0
final def CLEAR: Rule0
final def CLOB: Rule0

Definition Classes
SnappyBaseParser
final def CLUSTER: Rule0
final def CLUSTERED: Rule0
final def CODEGEN: Rule0
final def COLUMN: Rule0
final def COLUMNS: Rule0
final def COMMENT: Rule0
final def COMPUTE: Rule0
final def CONSTRAINT: Rule0
final def CREATE: Rule0
final def CROSS: Rule0
final def CUBE: Rule0
final def CURRENT: Rule0
final def CURRENT_DATE: Rule0
final def CURRENT_TIMESTAMP: Rule0
final def CURRENT_USER: Rule0
final def DATABASE: Rule0
final def DATABASES: Rule0
final def DATE: Rule0

Definition Classes
SnappyBaseParser
final def DAY: Rule0
final def DECIMAL: Rule0

Definition Classes
SnappyBaseParser
final def DELETE: Rule0
final def DEPLOY: Rule0
final def DESC: Rule0
final def DESCRIBE: Rule0
final def DISABLE: Rule0
final def DISKSTORE: Rule0
final def DISTINCT: Rule0
final def DISTRIBUTE: Rule0
final def DOUBLE: Rule0

Definition Classes
SnappyBaseParser
final def DROP: Rule0
final def DURATION: Rule0
final def ELSE: Rule0
final def ENABLE: Rule0
final def END: Rule0
def EOI: Char

Definition Classes
RuleDSLBasics
final def EXCEPT: Rule0
final def EXEC: Rule0
final def EXECUTE: Rule0
final def EXISTS: Rule0
final def EXPLAIN: Rule0
final def EXTENDED: Rule0
final def EXTERNAL: Rule0
final def ExtTableIdentifier: Rule1[TableIdentifier]
final def FALSE: Rule0
final def FETCH: Rule0
final def FIRST: Rule0
final def FLOAT: Rule0

Definition Classes
SnappyBaseParser
final def FN: Rule0
final def FOLLOWING: Rule0
final def FOR: Rule0
final def FOREIGN: Rule0
final def FORMAT: Rule0
final def FORMATTED: Rule0
final def FROM: Rule0
final def FULL: Rule0
final def FUNCTION: Rule0
final def FUNCTIONS: Rule0
final def GLOBAL: Rule0
final def GRANT: Rule0
final def GROUP: Rule0
final def GROUPING: Rule0
final def HASH: Rule0
final def HAVING: Rule0
final def HOUR: Rule0
final def IF: Rule0
final def IN: Rule0
final def INDEX: Rule0
final def INIT: Rule0
final def INNER: Rule0
final def INSERT: Rule0
final def INT: Rule0

Definition Classes
SnappyBaseParser
final def INTEGER: Rule0

Definition Classes
SnappyBaseParser
final def INTERSECT: Rule0
final def INTERVAL: Rule0
final def INTO: Rule0
final def IS: Rule0
final def JAR: Rule0
final def JARS: Rule0
final def JOIN: Rule0
final def LAST: Rule0
final def LATERAL: Rule0
final def LAZY: Rule0
final def LDAPGROUP: Rule0
final def LEFT: Rule0
final def LEVEL: Rule0
final def LIKE: Rule0
final def LIMIT: Rule0
final def LIST: Rule0
final def LOAD: Rule0
final def LOCATION: Rule0
final def LONG: Rule0

Definition Classes
SnappyBaseParser
final def MAP: Rule0

Definition Classes
SnappyBaseParser
def MATCH: Rule0

Definition Classes
RuleDSLBasics
final def MEMBERS: Rule0
final def MICROS: Rule0
final def MICROSECOND: Rule0
final def MILLIS: Rule0
final def MILLISECOND: Rule0
final def MINS: Rule0
final def MINUS: Rule0
final def MINUTE: Rule0
def MISMATCH[I <: HList, O <: HList]: Rule[I, O]

Definition Classes
RuleDSLBasics
def MISMATCH0: Rule0

Definition Classes
RuleDSLBasics
final def MONTH: Rule0
final def MSCK: Rule0
final def NATURAL: Rule0
final def NOT: Rule0
final def NULL: Rule0
final def NULLS: Rule0
final def NUMERIC: Rule0

Definition Classes
SnappyBaseParser
final def OF: Rule0
final def ON: Rule0
final def ONLY: Rule0
final def OPTIONS: Rule0
final def OR: Rule0
final def ORDER: Rule0
final def OUT: Rule0
final def OUTER: Rule0
final def OVER: Rule0
final def OVERWRITE: Rule0
final def PACKAGE: Rule0
final def PACKAGES: Rule0
final def PARTITION: Rule0
final def PARTITIONED: Rule0
final def PATH: Rule0
final def PERCENT: Rule0
final def PIVOT: Rule0
final def POLICY: Rule0
final def PRECEDING: Rule0
final def PRECISION: Rule0

Definition Classes
SnappyBaseParser
final def PRIMARY: Rule0
final def PRIVILEGE: Rule0
final def PURGE: Rule0
final def PUT: Rule0
final def RANGE: Rule0
final def REAL: Rule0

Definition Classes
SnappyBaseParser
final def REFRESH: Rule0
final def REGEXP: Rule0
final def RENAME: Rule0
final def REPLACE: Rule0
final def REPOS: Rule0
final def RESET: Rule0
final def RESTRICT: Rule0
final def RETURNS: Rule0
final def REVOKE: Rule0
final def RIGHT: Rule0
final def RLIKE: Rule0
final def ROLLUP: Rule0
final def ROW: Rule0
final def ROWS: Rule0
final def SCALA: Rule0
final def SCHEMA: Rule0
final def SCHEMAS: Rule0
final def SECOND: Rule0
final def SECS: Rule0
final def SECURITY: Rule0
final def SELECT: Rule0
final def SEMI: Rule0
final def SERDE: Rule0
final def SERDEPROPERTIES: Rule0
final def SET: Rule0
final def SETS: Rule0
final def SHORT: Rule0

Definition Classes
SnappyBaseParser
final def SHOW: Rule0
final def SKEWED: Rule0
final def SLIDE: Rule0
final def SMALLINT: Rule0

Definition Classes
SnappyBaseParser
final def SORT: Rule0
final def SORTED: Rule0
final def START: Rule0
final def STATISTICS: Rule0
final def STOP: Rule0
final def STORED: Rule0
final def STREAM: Rule0
final def STREAMING: Rule0
final def STRING: Rule0

Definition Classes
SnappyBaseParser
final def STRUCT: Rule0

Definition Classes
SnappyBaseParser
final def TABLE: Rule0
final def TABLES: Rule0
final def TABLESAMPLE: Rule0
final def TBLPROPERTIES: Rule0
final def TEMPORARY: Rule0
final def THEN: Rule0
final def TIMESTAMP: Rule0

Definition Classes
SnappyBaseParser
final def TINYINT: Rule0

Definition Classes
SnappyBaseParser
final def TO: Rule0
final def TRIGGER: Rule0
final def TRUE: Rule0
final def TRUNCATE: Rule0
final def UNBOUNDED: Rule0
final def UNCACHE: Rule0
final def UNDEPLOY: Rule0
final def UNION: Rule0
final def UNIQUE: Rule0
final def UNSET: Rule0
final def UPDATE: Rule0
final def USE: Rule0
final def USER: Rule0
final def USING: Rule0
final def VALUES: Rule0
final def VARBINARY: Rule0

Definition Classes
SnappyBaseParser
final def VARCHAR: Rule0

Definition Classes
SnappyBaseParser
final def VIEW: Rule0
final def VIEWS: Rule0
final def WEEK: Rule0
final def WHEN: Rule0
final def WHERE: Rule0
final def WINDOW: Rule0
final def WITH: Rule0
final def YEAR: Rule0
def __advance(): Boolean

Definition Classes
Parser
def __bubbleUp(prefix: List[NonTerminal], terminal: Terminal): Nothing

Definition Classes
Parser
def __bubbleUp(terminal: Terminal): Nothing

Definition Classes
Parser
def __enterAtomic(start: Int): Boolean

Definition Classes
Parser
def __enterNotPredicate(): AnyRef

Definition Classes
Parser
def __enterQuiet(): Int

Definition Classes
Parser
def __exitAtomic(saved: Boolean): Unit

Definition Classes
Parser
def __exitNotPredicate(saved: AnyRef): Unit

Definition Classes
Parser
def __exitQuiet(saved: Int): Unit

Definition Classes
Parser
def __hardFail(expected: String): Nothing

Definition Classes
Parser
def __inErrorAnalysis: Boolean

Definition Classes
Parser
final def __matchAnyOf(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
final def __matchIgnoreCaseString(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
final def __matchIgnoreCaseStringWrapped(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
def __matchMap(m: Map[String, Any], ignoreCase: Boolean): Boolean

Definition Classes
Parser
def __matchMapWrapped(m: Map[String, Any], ignoreCase: Boolean): Boolean

Definition Classes
Parser
final def __matchNoneOf(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
final def __matchString(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
final def __matchStringWrapped(string: String, ix: Int): Boolean

Definition Classes
Parser
Annotations
@tailrec()
def __push(value: Any): Boolean

Definition Classes
Parser
def __registerMismatch(): Boolean

Definition Classes
Parser
def __restoreState(mark: Mark): Unit

Definition Classes
Parser
def __run[L <: HList](rule: ⇒ RuleN[L])(implicit scheme: DeliveryScheme[L]): Result

Definition Classes
Parser
def __saveState: Mark

Definition Classes
Parser
def __updateMaxCursor(): Boolean

Definition Classes
Parser
final def allowDDL: Rule0

Attributes
protected
def alterTable: Rule1[LogicalPlan]

Attributes
protected
def alterTableOrView: Rule1[LogicalPlan]

Attributes
protected
def alterTableToggleRowLevelSecurity: Rule1[LogicalPlan]

Attributes
protected
def alterView: Rule1[LogicalPlan]

Attributes
protected
def anyOf(chars: String): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
final def arrayType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atomic[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def beforeDDLEnd: Rule0

Attributes
protected
final def booleanLiteral: Rule1[Boolean]

Attributes
protected
final def bucketSpec: Rule1[BucketSpec]

Attributes
protected
def cache: Rule1[LogicalPlan]

Attributes
protected
final def canAlter(id: TableIdentifier, op: String, allBuiltins: Boolean = false): TableIdentifier

Attributes
protected
def capture[I <: HList, O <: HList](r: Rule[I, O])(implicit p: Prepend[O, ::[String, HNil]]): Rule[I, Out]

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
var caseSensitive: Boolean

Attributes
protected
Definition Classes
SnappyBaseParser
implicit def ch(c: Char): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
def charAt(offset: Int): Char

Definition Classes
Parser
def charAtRC(offset: Int): Char

Definition Classes
Parser
final def charType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
def checkExists(resource: FunctionResource): Unit

Attributes
protected
def clearQueryHints(): Unit

Attributes
protected
Definition Classes
SnappyBaseParser
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def codeChunk: Rule1[String]

Attributes
protected
final def colsWithDirection: Rule1[ColumnDirectionMap]

Attributes
protected
def column: Rule1[StructField]

Attributes
protected
final def columnCharType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
final def columnDataType: Rule1[DataType]

Definition Classes
SnappyBaseParser
final def commaSep: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
final def commentBody: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
final def commentBodyOrHint: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
def copyStateFrom(other: Parser, offset: Int): Unit

Definition Classes
Parser
def createFunction: Rule1[LogicalPlan]

Create a CreateFunctionCommand command.
Create a CreateFunctionCommand command.
For example:
```
CREATE [TEMPORARY] FUNCTION [db_name.]function_name AS class_name RETURNS ReturnType
 USING JAR 'file_uri';
```
Attributes
protected
def createHiveTable: Rule1[LogicalPlan]

Attributes
protected
def createIndex: Rule1[LogicalPlan]

Attributes
protected
def createPolicy: Rule1[LogicalPlan]

Attributes
protected
def createSchema: Rule1[LogicalPlan]

Attributes
protected
def createStream: Rule1[LogicalPlan]

Attributes
protected
def createTable: Rule1[LogicalPlan]

Attributes
protected
def createTableLike: Rule1[LogicalPlan]

Attributes
protected
def createTempViewUsing: Rule1[LogicalPlan]

Attributes
protected
def createView: Rule1[LogicalPlan]

Attributes
protected
def cursor: Int

Definition Classes
Parser
def cursorChar: Char

Definition Classes
Parser
final def dataType: Rule1[DataType]

Definition Classes
SnappyBaseParser
def ddl: Rule1[LogicalPlan]

Attributes
protected
final def ddlEnd: Rule1[TableEnd]

Attributes
protected
def delegateToSpark: Rule1[LogicalPlan]

Handle other statements not appropriate for SnappyData's builtin sources but used by hive/file based sources in Spark.
Handle other statements not appropriate for SnappyData's builtin sources but used by hive/file based sources in Spark. This rule should always be at the end of the "start" rule so that this is used as the last fallback and not before any of the SnappyData customizations.

Attributes
protected
final def delimiter: Rule0

All recognized delimiters including whitespace.
All recognized delimiters including whitespace.

Definition Classes
SnappyBaseParser
def deployPackages: Rule1[LogicalPlan]

Attributes
protected
def describe: Rule1[LogicalPlan]

Attributes
protected
final def digits: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
def drop[T](implicit h: HListable[T]): PopRule[Out]

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
def dropFunction: Rule1[LogicalPlan]

Create a DropFunctionCommand command.
Create a DropFunctionCommand command.
For example:
```
DROP [TEMPORARY] FUNCTION [IF EXISTS] function;
```
Attributes
protected
def dropIndex: Rule1[LogicalPlan]

Attributes
protected
def dropPolicy: Rule1[LogicalPlan]

Attributes
protected
def dropSchema: Rule1[LogicalPlan]

Attributes
protected
def dropTable: Rule1[LogicalPlan]

Attributes
protected
def dropView: Rule1[LogicalPlan]

Attributes
protected
final def durationUnit: Rule1[Duration]

Attributes
protected
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def errorTraceCollectionLimit: Int

Definition Classes
Parser
def fail(expected: String): Rule0

Definition Classes
RuleDSLBasics
def failX[I <: HList, O <: HList](expected: String): Rule[I, O]

Definition Classes
RuleDSLBasics
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def fixedDecimalType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
def formatError(error: ParseError, formatter: ErrorFormatter): String

Definition Classes
Parser
final def functionIdentifier: Rule1[FunctionIdentifier]

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

Definition Classes
AnyRef → Any
final def globalOrTemporary: Rule1[Boolean]

Attributes
protected
def grantRevokeExternal: Rule1[LogicalPlan]

Attributes
protected
def grantRevokeIntp: Rule1[LogicalPlan]

Attributes
protected
def handleQueryHint(hint: String, hintValue: String): Unit

Handle query hints including plan-level like joinType that are marked to be handled later.
Handle query hints including plan-level like joinType that are marked to be handled later.

Attributes
protected
Definition Classes
SnappyBaseParser
def hashCode(): Int

Definition Classes
AnyRef → Any
final def hexLiteral: Rule1[Array[Byte]]

Attributes
protected
Definition Classes
SnappyBaseParser
final def identifier: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
final def identifierExt: Rule1[String]

allow for first character of unquoted identifier to be a numeric
allow for first character of unquoted identifier to be a numeric

Attributes
protected
Definition Classes
SnappyBaseParser
final def identifierList: Rule1[Seq[String]]

Attributes
protected
final def identifierWithComment: Rule1[(String, Option[String])]

Attributes
protected
final def ifExists: Rule1[Boolean]

Attributes
protected
final def ifNotExists: Rule1[Boolean]

Attributes
protected
def ignoreCase(s: String): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
def ignoreCase(c: Char): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
def initializeLogIfNecessary(): Unit

Attributes
protected
Definition Classes
Logging
implicit def int2NTimes(i: Int): NTimes

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def integral: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
def interpretCode: Rule1[LogicalPlan]

Attributes
protected
final def intervalUnit(k: Keyword): Rule0

Attributes
protected
final def intervalUnit(k: String): Rule0

the string passed in *SHOULD* be lower case
the string passed in *SHOULD* be lower case

Attributes
protected
final def isDebugEnabled: Boolean

Definition Classes
Logging
final def isInfoEnabled: Boolean

Definition Classes
Logging
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraceEnabled: Boolean

Definition Classes
Logging
final def keyword(k: Keyword): Rule0

Definition Classes
SnappyBaseParser
def lastChar: Char

Definition Classes
Parser
final var levelFlags: Int

Attributes
protected
Definition Classes
Logging
final def lineCommentOrHint: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
def log: Logger

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

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

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

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

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

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

Definition Classes
Logging
def logName: String

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

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

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

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

Definition Classes
Logging
final var log_: Logger

Attributes
protected
Definition Classes
Logging
final def mapType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
macro def namedRule[I <: HList, O <: HList](name: String)(r: Rule[I, O]): Rule[I, O]

Definition Classes
Parser
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def newDataType(t: Keyword): Rule0

Used for DataTypes.
Used for DataTypes. Not reserved and otherwise identical to "keyword" apart from the name so as to appear properly in error messages related to incorrect DataType definition.

Attributes
protected
Definition Classes
SnappyBaseParser
def noneOf(chars: String): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def numericLiteral: Rule1[String]

Attributes
protected
def oneOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, StrictOut] with Repeated

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def option: Rule1[(String, String)]

Attributes
protected
final def optionKey: Rule1[String]

Attributes
protected
def optional[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Option, I, O]): Rule[In, OptionalOut]

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def options: Rule1[Map[String, String]]

Attributes
protected
final def packageIdentifier: Rule1[TableIdentifier]

Definition Classes
SnappyBaseParser
final def packageIdentifierPart: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
def passThrough: Rule1[LogicalPlan]

Commands like GRANT/REVOKE/CREATE DISKSTORE/CALL on a table that are passed through as is to the SnappyData store layer (only for column and row tables).
Commands like GRANT/REVOKE/CREATE DISKSTORE/CALL on a table that are passed through as is to the SnappyData store layer (only for column and row tables).
Example:
```
GRANT SELECT ON table TO user1, user2;
GRANT INSERT ON table TO ldapGroup: group1;
CREATE DISKSTORE diskstore_name ('dir1' 10240)
DROP DISKSTORE diskstore_name
CALL SYSCS_UTIL.SYSCS_SET_RUNTIMESTATISTICS(1)
```
Attributes
protected
final def policyFor: Rule1[String]

Attributes
protected
final def policyTo: Rule1[Seq[String]]

Attributes
protected
implicit def predicate(p: CharPredicate): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
final def primitiveType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
def push[T](value: T)(implicit h: HListable[T]): RuleN[Out]

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
final def qualifiedName: Rule1[String]

Attributes
protected
final def questionMark: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
def quiet[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def quotedIdentifier: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
final def quotedUppercaseId(id: IdentifierWithDatabase): String

Attributes
protected
Definition Classes
SnappyBaseParser
implicit def range2NTimes(range: Range): NTimes

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
def refreshTable: Rule1[LogicalPlan]

Attributes
protected
def reset: Rule1[LogicalPlan]

Attributes
protected
def resetLogger(): Unit

Attributes
protected
Definition Classes
Logging
final def resourceType: Rule1[FunctionResource]

Attributes
protected
macro def rule[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

Definition Classes
Parser
implicit def rule2ActionOperator[I <: HList, O <: HList](r: Rule[I, O])(implicit ops: ActionOps[I, O]): ActionOperator[I, O, Out]

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
implicit def rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
def run[T](arg: T)(implicit rr: RunResult[T]): Out

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
def runSubParser[I <: HList, O <: HList](f: (ParserInput) ⇒ Rule[I, O]): Rule[I, O]

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )
final def scientificNotation: Rule0

Attributes
protected
Definition Classes
SnappyBaseParser
def set: Rule1[LogicalPlan]

Attributes
protected
final def sortDirection: Rule1[SortDirection]

Attributes
protected
final lazy val sparkParser: SparkSqlParser

spark parser used for hive DDLs that are not relevant to SnappyData's builtin sources
spark parser used for hive DDLs that are not relevant to SnappyData's builtin sources

Attributes
protected
final def sql: Rule1[LogicalPlan]

Definition Classes
SnappyBaseParser
implicit def str(s: String): Rule0

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
implicit def str2CharRangeSupport(s: String): CharRangeSupport

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
def streamContext: Rule1[LogicalPlan]

Attributes
protected
final def strictIdentifier: Rule1[String]

A strictIdentifier is more restricted than an identifier in that neither any of the SQL reserved keywords nor non-reserved keywords will be interpreted as a strictIdentifier.
A strictIdentifier is more restricted than an identifier in that neither any of the SQL reserved keywords nor non-reserved keywords will be interpreted as a strictIdentifier.

Attributes
protected
Definition Classes
SnappyBaseParser
final def stringLiteral: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
final def structField: Rule1[StructField]

Attributes
protected
Definition Classes
SnappyBaseParser
final def structType: Rule1[DataType]

Attributes
protected
Definition Classes
SnappyBaseParser
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def tableEnd: Rule2[StringBuilder, TableEnd]

Attributes
protected
final def tableEnd1: Rule[::[StringBuilder, HNil], ::[StringBuilder, ::[TableEnd, HNil]]]

Attributes
protected
final def tableIdentifier: Rule1[TableIdentifier]

Definition Classes
SnappyBaseParser
final def tableSchema: Rule1[Seq[StructField]]

Attributes
protected
final def tableSchemaOpt: Rule1[Option[Seq[StructField]]]
def test(condition: Boolean): Rule0

Definition Classes
RuleDSLActions
Annotations
@compileTimeOnly( ... )
def toString(): String

Definition Classes
AnyRef → Any
def truncateTable: Rule1[LogicalPlan]

Attributes
protected
def uncache: Rule1[LogicalPlan]

Attributes
protected
final def unquotedIdentifier: Rule1[String]

Attributes
protected
Definition Classes
SnappyBaseParser
def valueMap[T](m: Map[String, T], ignoreCase: Boolean)(implicit h: HListable[T]): RuleN[Out]

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
implicit def valueMap[T](m: Map[String, T])(implicit h: HListable[T]): RuleN[Out]

Definition Classes
RuleDSLBasics
Annotations
@compileTimeOnly( ... )
def valueStack: ValueStack

Definition Classes
Parser
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( ... )
final def ws: Rule0

The recognized whitespace characters and comments.
The recognized whitespace characters and comments.

Attributes
protected
Definition Classes
SnappyBaseParser
def zeroOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit l: Lifter[Seq, I, O]): Rule[In, OptionalOut] with Repeated

Definition Classes
RuleDSLCombinators
Annotations
@compileTimeOnly( ... )

Related Doc: package sql

abstract class SnappyDDLParser extends SnappyBaseParser with Logging

Instance Constructors

new SnappyDDLParser(session: SnappySession)

Type Members

sealed trait ActionOperator[I <: HList, O <: HList, Ops] extends AnyRef

sealed trait CharRangeSupport extends AnyRef

final type ColumnDirectionMap = Seq[(String, Option[SortDirection])]

sealed trait NTimes extends AnyRef

final type TableEnd = (Option[String], Option[Map[String, String]], Array[String], Option[BucketSpec], Option[LogicalPlan])

class TracingBubbleException extends RuntimeException with NoStackTrace

trait WithSeparatedBy[I <: HList, O <: HList] extends AnyRef

class __SubParserInput extends ParserInput

Abstract Value Members

abstract def expression: Rule1[Expression]

abstract def input: ParserInput

abstract def newInstance(): SnappyDDLParser

abstract def parseSQL[T](sqlText: String, parseRule: ⇒ Try[T]): T

abstract def partitionSpec: Rule1[Map[String, Option[String]]]

abstract def query: Rule1[LogicalPlan]

abstract def start: Rule1[LogicalPlan]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(r: Rule[_, _]): Rule0

final def ==(arg0: Any): Boolean

final def ADD: Rule0

final def ALL: Rule0

final def ALTER: Rule0

final def ANALYZE: Rule0

final def AND: Rule0

final def ANTI: Rule0

def ANY: Rule0

final def ARRAY: Rule0

final def AS: Rule0

final def ASC: Rule0

final def AUTHORIZATION: Rule0

final def BETWEEN: Rule0

final def BIGINT: Rule0

final def BINARY: Rule0

final def BLOB: Rule0

final def BOOLEAN: Rule0

final def BUCKETS: Rule0

final def BY: Rule0

final def BYTE: Rule0

final def CACHE: Rule0

final def CALL: Rule0

final def CASCADE: Rule0

final def CASE: Rule0

final def CAST: Rule0

final def CHAR: Rule0

final def CHECK: Rule0

final def CLEAR: Rule0

final def CLOB: Rule0

final def CLUSTER: Rule0

final def CLUSTERED: Rule0

final def CODEGEN: Rule0

final def COLUMN: Rule0

final def COLUMNS: Rule0

final def COMMENT: Rule0

final def COMPUTE: Rule0

final def CONSTRAINT: Rule0

final def CREATE: Rule0

final def CROSS: Rule0

final def CUBE: Rule0

final def CURRENT: Rule0

final def CURRENT_DATE: Rule0

final def CURRENT_TIMESTAMP: Rule0

final def CURRENT_USER: Rule0

final def DATABASE: Rule0

final def DATABASES: Rule0

final def DATE: Rule0

final def DAY: Rule0

final def DECIMAL: Rule0

final def DELETE: Rule0

final def DEPLOY: Rule0

final def DESC: Rule0

final def DESCRIBE: Rule0

final def DISABLE: Rule0