SnappyBaseParser

abstract def input: ParserInput

abstract def start: Rule1[LogicalPlan]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ANY: Rule0

final def ARRAY: Rule0

final def BIGINT: Rule0

final def BINARY: Rule0

final def BLOB: Rule0

final def BOOLEAN: Rule0

final def BYTE: Rule0

final def CHAR: Rule0

final def CLOB: Rule0

final def DATE: Rule0

final def DECIMAL: Rule0

final def DOUBLE: Rule0

def EOI: Char

final def FLOAT: Rule0

final def INT: Rule0

final def INTEGER: Rule0

final def LONG: Rule0

final def MAP: Rule0

def MATCH: Rule0

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

def MISMATCH0: Rule0

final def NUMERIC: Rule0

final def REAL: Rule0

final def SHORT: Rule0

final def SMALLINT: Rule0

final def STRING: Rule0

final def STRUCT: Rule0

final def TIMESTAMP: Rule0

final def TINYINT: Rule0

final def VARBINARY: Rule0

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

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

def clone(): AnyRef

final def commentBody: Rule0

final def commentBodyOrHint: Rule0

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

def cursor: Int

def cursorChar: Char

final def dataType: Rule1[DataType]

final def dataType(t: Keyword): Rule0

Used for DataTypes.

final def delimiter: Rule0

All recognized delimiters including whitespace.

final def digits: Rule1[String]

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

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 isInstanceOf[T0]: Boolean

final def keyword(k: Keyword): Rule0

def lastChar: Char

final def lineCommentOrHint: Rule0

final def mapType: Rule1[DataType]

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

final def ne(arg0: AnyRef): Boolean

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]

def parse(): LogicalPlan

implicit def predicate(p: CharPredicate): Rule0

final def primitiveType: Rule1[DataType]

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

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

implicit def range2NTimes(range: Range): NTimes

def reset(): Unit

final def restInput: String

Returns the rest of the input string that are not parsed yet

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

final def sql: Rule1[LogicalPlan]

implicit def str(s: String): Rule0

implicit def str2CharRangeSupport(s: String): CharRangeSupport

final def stringLiteral: Rule1[String]

final def structField: Rule1[StructField]

final def structType: Rule1[DataType]

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

final def tableIdentifier: Rule1[QualifiedTableName]

def test(condition: Boolean): Rule0

def toString(): String

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