SnappyDDLParser

abstract def input: ParserInput

abstract def newInstance(): SnappyDDLParser

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

abstract def query: Rule1[LogicalPlan]

abstract def start: Rule1[LogicalPlan]

final def !=(arg0: Any): Boolean

final def ##(): Int

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

final def ==(arg0: Any): Boolean

final def ALL: 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 BETWEEN: Rule0

final def BIGINT: Rule0

final def BINARY: Rule0

final def BLOB: Rule0

final def BOOLEAN: Rule0

final def BY: Rule0

final def BYTE: Rule0

final def CACHE: Rule0

final def CASE: Rule0

final def CAST: Rule0

final def CHAR: Rule0

final def CLEAR: Rule0

final def CLOB: Rule0

final def CLUSTER: Rule0

final def COMMENT: Rule0

final def CREATE: Rule0

final def CUBE: Rule0

final def CURRENT: Rule0

final def CURRENT_DATE: Rule0

final def CURRENT_TIMESTAMP: Rule0

final def DATE: Rule0

final def DAY: Rule0

final def DECIMAL: Rule0

final def DELETE: Rule0

final def DESC: Rule0

final def DESCRIBE: Rule0

final def DISTINCT: Rule0

final def DISTRIBUTE: Rule0

final def DOUBLE: Rule0

final def DROP: Rule0

final def DURATION: Rule0

final def ELSE: Rule0

final def END: Rule0

def EOI: Char

final def EXCEPT: Rule0

final def EXISTS: Rule0

final def EXTENDED: Rule0

final def EXTERNAL: Rule0

final def FALSE: Rule0

final def FLOAT: Rule0

final def FOLLOWING: Rule0

final def FROM: Rule0

final def FULL: Rule0

final def FUNCTION: Rule0

final def FUNCTIONS: Rule0

final def GLOBAL: 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

final def INTEGER: Rule0

final def INTERSECT: Rule0

final def INTERVAL: Rule0

final def INTO: Rule0

final def IS: Rule0

final def JOIN: Rule0

final def LAZY: Rule0

final def LEFT: Rule0

final def LIKE: Rule0

final def LIMIT: Rule0

final def LONG: Rule0

final def MAP: Rule0

def MATCH: Rule0

final def MICROS: Rule0

final def MICROSECOND: Rule0

final def MILLIS: Rule0

final def MILLISECOND: Rule0

final def MINS: Rule0

final def MINUTE: Rule0

def MISMATCH[I <: HList, O <: HList]: Rule[I, O]

def MISMATCH0: Rule0

final def MONTH: Rule0

final def NATURAL: Rule0

final def NOT: Rule0

final def NULL: Rule0

final def NUMERIC: Rule0

final def ON: Rule0

final def OPTIONS: Rule0

final def OR: Rule0

final def ORDER: Rule0

final def OUTER: Rule0

final def OVER: Rule0

final def OVERWRITE: Rule0

final def PARTITION: Rule0

final def PRECEDING: Rule0

final def PUT: Rule0

final def RANGE: Rule0

final def REAL: Rule0

final def REFRESH: Rule0

final def REGEXP: Rule0

final def RIGHT: Rule0

final def RLIKE: Rule0

final def ROLLUP: Rule0

final def ROW: Rule0

final def ROWS: Rule0

final def SCHEMA: Rule0

final def SECOND: Rule0

final def SECS: Rule0

final def SELECT: Rule0

final def SEMI: Rule0

final def SET: Rule0

final def SETS: Rule0

final def SHORT: Rule0

final def SHOW: Rule0

final def SLIDE: Rule0

final def SMALLINT: Rule0

final def SORT: Rule0

final def START: Rule0

final def STOP: Rule0

final def STREAM: Rule0

final def STREAMING: Rule0

final def STRING: Rule0

final def STRUCT: Rule0

final def TABLE: Rule0

final def TABLES: Rule0

final def TEMPORARY: Rule0

final def THEN: Rule0

final def TIMESTAMP: Rule0

final def TINYINT: Rule0

final def TO: Rule0

final def TRUE: Rule0

final def TRUNCATE: Rule0

final def UNBOUNDED: Rule0

final def UNCACHE: Rule0

final def UNION: Rule0

final def UNIQUE: Rule0

final def UPDATE: Rule0

final def USING: Rule0

final def VARBINARY: Rule0

final def VARCHAR: 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

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

def __bubbleUp(terminal: Terminal): Nothing

def __enterAtomic(start: Int): Boolean

def __enterNotPredicate(): AnyRef

def __enterQuiet(): Int

def __exitAtomic(saved: Boolean): Unit

def __exitNotPredicate(saved: AnyRef): Unit

def __exitQuiet(saved: Int): Unit

def __hardFail(expected: String): Nothing

def __inErrorAnalysis: Boolean

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

final def __matchIgnoreCaseString(string: String, ix: Int): Boolean

final def __matchIgnoreCaseStringWrapped(string: String, ix: Int): Boolean

def __matchMap(m: Map[String, Any]): Boolean

def __matchMapWrapped(m: Map[String, Any]): Boolean

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

final def __matchString(string: String, ix: Int): Boolean

final def __matchStringWrapped(string: String, ix: Int): Boolean

def __push(value: Any): Boolean

def __registerMismatch(): Boolean

def __restoreState(mark: Mark): Unit

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

def __saveState: Mark

def __updateMaxCursor(): Boolean

def anyOf(chars: String): Rule0

final def arrayType: Rule1[DataType]

final def asInstanceOf[T0]: T0

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

final def beforeDDLEnd: Rule0

def cache: Rule1[LogicalPlan]

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

val caseSensitive: Boolean

implicit def ch(c: Char): Rule0

def charAt(offset: Int): Char

def charAtRC(offset: Int): Char

final def charType: Rule1[DataType]

def clone(): AnyRef

final def colsWithDirection: Rule1[Map[String, Option[SortDirection]]]

def column: Rule1[StructField]

final def columnCharType: Rule1[DataType]

final def columnDataType: Rule1[DataType]

final def commaSep: Rule0

final def commentBody: Rule0

final def commentBodyOrHint: Rule0

def copyStateFrom(other: Parser, offset: Int): Unit

def createIndex: Rule1[LogicalPlan]

def createStream: Rule1[LogicalPlan]

def createTable: Rule1[LogicalPlan]

def cursor: Int

def cursorChar: Char

final def dataType: Rule1[DataType]

def ddl: Rule1[LogicalPlan]

final def ddlEnd: Rule1[TableEnd]

final def delimiter: Rule0

All recognized delimiters including whitespace.

def desc: Rule1[LogicalPlan]

def describeTable: Rule1[LogicalPlan]

final def digits: Rule1[String]

def drop[T](implicit h: HListable[T]): PopRule[Out]

def dropIndex: Rule1[LogicalPlan]

def dropTable: Rule1[LogicalPlan]

final def durationUnit: Rule1[Duration]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorTraceCollectionLimit: Int

def fail(expected: String): Rule0

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

def finalize(): Unit

final def fixedDecimalType: Rule1[DataType]

def formatError(error: ParseError, formatter: ErrorFormatter): String

final def getClass(): Class[_]

def hashCode(): Int

final def identifier: Rule1[String]

def ignoreCase(s: String): Rule0

def ignoreCase(c: Char): Rule0

implicit def int2NTimes(i: Int): NTimes

final def integral: Rule1[String]

final def intervalUnit(k: Keyword): Rule0

final def intervalUnit(k: String): Rule0

the string passed in *SHOULD* be lower case

final def isInstanceOf[T0]: Boolean

final def keyword(k: Keyword): Rule0

def lastChar: Char

final def lineCommentOrHint: Rule0

final def mapType: Rule1[DataType]

macro def namedRule[I <: HList, O <: HList](name: String)(r: Rule[I, O]): Rule[I, O]

final def ne(arg0: AnyRef): Boolean

final def newDataType(t: Keyword): Rule0

Used for DataTypes.

def noneOf(chars: String): Rule0

final def notify(): Unit

final def notifyAll(): Unit

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

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

final def options: Rule1[Map[String, String]]

final def pair: Rule1[(String, String)]

implicit def predicate(p: CharPredicate): Rule0

final def primitiveType: Rule1[DataType]

def push[T](value: T)(implicit h: HListable[T]): RuleN[Out]

final def qualifiedName: Rule1[String]

def quiet[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

final def quotedIdentifier: Rule1[String]

implicit def range2NTimes(range: Range): NTimes

def refreshTable: Rule1[LogicalPlan]

def reset(): Unit

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

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

implicit def rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]

def run[T](arg: T)(implicit rr: RunResult[T]): Out

def runSubParser[I <: HList, O <: HList](f: (ParserInput) ⇒ Rule[I, O]): Rule[I, O]

final def scientificNotation: Rule0

def set: Rule1[LogicalPlan]

def show: Rule1[LogicalPlan]

final def sortDirection: Rule1[SortDirection]

final def sql: Rule1[LogicalPlan]

implicit def str(s: String): Rule0

implicit def str2CharRangeSupport(s: String): CharRangeSupport

def streamContext: Rule1[LogicalPlan]

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.

final def stringLiteral: Rule1[String]

final def structField: Rule1[StructField]

final def structType: Rule1[DataType]

final def synchronized[T0](arg0: ⇒ T0): T0

final def tableEnd: Rule2[StringBuilder, TableEnd]

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

final def tableIdentifier: Rule1[TableIdentifier]

final def tableSchema: Rule1[Seq[StructField]]

final def tableSchemaOpt: Rule1[Option[Seq[StructField]]]

def test(condition: Boolean): Rule0

def toString(): String

def truncateTable: Rule1[LogicalPlan]

def uncache: Rule1[LogicalPlan]

implicit def valueMap[T](m: Map[String, T])(implicit h: HListable[T]): RuleN[Out]

def valueStack: ValueStack

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def ws: Rule0

The recognized whitespace characters and comments.

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