QueryParsers

Type Members

case class Arr(elements: List[Exp]) extends Exp with Product with Serializable
case class BinOp(op: String, lop: Exp, rop: Exp) extends Exp with Product with Serializable
case class Braces(expr: Exp) extends Exp with Product with Serializable
case class Cast(exp: Exp, typ: String) extends Exp with Product with Serializable
case class Col(col: Exp, alias: String) extends Exp with Product with Serializable
case class Cols(distinct: Boolean, cols: List[Col]) extends Exp with Product with Serializable
case class Const(value: Any) extends Exp with Product with Serializable
trait DMLExp extends Exp
case class Delete(table: Ident, alias: String, filter: Arr, using: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable
type Elem = Char

Definition Classes
RegexParsers → Parsers
case class Error extends NoSuccess with Product with Serializable

Definition Classes
Parsers
trait Exp extends AnyRef
case class Failure extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class Filters(filters: List[Arr]) extends Exp with Product with Serializable
case class Fun(name: String, parameters: List[Exp], distinct: Boolean, aggregateOrder: Option[Ord], aggregateWhere: Option[Exp]) extends Exp with Product with Serializable
case class Grp(cols: List[Exp], having: Exp) extends Exp with Product with Serializable
case class Id(name: String) extends Exp with Product with Serializable
case class IdRef(name: String) extends Exp with Product with Serializable
case class Ident(ident: List[String]) extends Exp with Product with Serializable
case class IdentAll(ident: Ident) extends Exp with Product with Serializable
case class In(lop: Exp, rop: List[Exp], not: Boolean) extends Exp with Product with Serializable
type Input = Reader[Elem]

Definition Classes
Parsers
case class Insert(table: Ident, alias: String, cols: List[Col], vals: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable
case class Join(default: Boolean, expr: Exp, noJoin: Boolean) extends Exp with Product with Serializable
class MemParser[+T] extends Parser[T]

Definition Classes
MemParsers
sealed abstract class NoSuccess extends ParseResult[Nothing]

Definition Classes
Parsers
trait Null extends Exp
case class Obj(obj: Exp, alias: String, join: Join, outerJoin: String, nullable: Boolean = false) extends Exp with Product with Serializable
trait OnceParser[+T] extends Parser[T]

Definition Classes
Parsers
case class Ord(cols: List[(Exp, Exp, Exp)]) extends Exp with Product with Serializable
sealed abstract class ParseResult[+T] extends AnyRef

Definition Classes
Parsers
abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Definition Classes
Parsers
case class Query(tables: List[Obj], filter: Filters, cols: Cols, group: Grp, order: Ord, offset: Exp, limit: Exp) extends Exp with Product with Serializable
case class Res(rNr: Int, col: Any) extends Exp with Product with Serializable
case class Success[+T] extends ParseResult[T] with Product with Serializable

Definition Classes
Parsers
case class TerOp(lop: Exp, op1: String, mop: Exp, op2: String, rop: Exp) extends Exp with Product with Serializable
case class UnOp(operation: String, operand: Exp) extends Exp with Product with Serializable
case class Update(table: Ident, alias: String, filter: Arr, cols: List[Col], vals: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable
case class Values(values: List[Arr]) extends Exp with Product with Serializable
case class ValuesFromSelect(select: Query) extends Exp with Product with Serializable
case class Variable(variable: String, members: List[String], opt: Boolean) extends Exp with Product with Serializable
case class With(tables: List[WithTable], query: Exp) extends Exp with Product with Serializable
case class WithTable(name: String, cols: List[String], recursive: Boolean, table: Exp) extends Exp with Product with Serializable
case class ~[+a, +b] extends Product with Serializable

Definition Classes
Parsers

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
def ALL: MemParser[All.type]
object All extends Exp
val DefaultJoin: Join
def FALSE: MemParser[Boolean]
def NULL: MemParser[Null.type]
val NoJoin: Join
object Null extends Null with Product with Serializable
object NullUpdate extends Null with Product with Serializable
def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

Definition Classes
Parsers
def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

Definition Classes
Parsers
def TRUE: MemParser[Boolean]
def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def accept[ES](es: ES)(implicit f: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

Definition Classes
Parsers
def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

Definition Classes
Parsers
def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit f: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
def any2tresql(any: Any): String
def array: MemParser[Arr]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def braces: MemParser[Braces]
def cast: MemParser[Exp]
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

Definition Classes
Parsers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def column: MemParser[Col]
def columns: MemParser[Cols]
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def comp: MemParser[Exp]
val comp_op: Regex
def const: MemParser[Const]
def decimalNr: MemParser[BigDecimal]
def decimalNumber: Parser[String]

Definition Classes
JavaTokenParsers
def delete: MemParser[Delete]
def elem(e: Elem): Parser[Elem]

Definition Classes
Parsers
def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

Definition Classes
Parsers
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
Parsers
def expr: MemParser[Exp]
def exprList: MemParser[Exp]
def failure(msg: String): Parser[Nothing]

Definition Classes
Parsers
def filter: MemParser[Arr]
def filters: MemParser[Filters]
def floatingPointNumber: Parser[String]

Definition Classes
JavaTokenParsers
def function: MemParser[Fun]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def group: MemParser[Grp]
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def handleWhiteSpace(source: CharSequence, offset: Int): Int

Copied from RegexParsers to support comment handling as whitespace
Copied from RegexParsers to support comment handling as whitespace

Attributes
protected
Definition Classes
QueryParsers → RegexParsers
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def id: MemParser[Id]
def ident: MemParser[String]

Definition Classes
QueryParsers → JavaTokenParsers
def idref: MemParser[IdRef]
def in: MemParser[In]
def insert: MemParser[Insert]
val intermediateResults: ThreadLocal[Map[(String, Int), ParseResult[_]]] { def initialValue(): scala.collection.mutable.HashMap[(String, Int),QueryParsers.this.ParseResult[_]] }

Attributes
protected
Definition Classes
MemParsers
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join: MemParser[Join]
implicit def literal(s: String): Parser[String]

Definition Classes
RegexParsers
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
def logicalOp: MemParser[Exp]
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
def mulDiv: MemParser[Exp]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def obj: MemParser[Obj]
def objWithJoin: MemParser[Obj]
def objs: MemParser[List[Obj]]
def offsetLimit: MemParser[(Exp, Exp)]
def operand: MemParser[Exp]
def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
def order: MemParser[Ord]
def orderMember: MemParser[(Exp, Exp, Exp)]
def parse[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

Definition Classes
RegexParsers
def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

Definition Classes
RegexParsers
implicit def parser2MemParser[T](parser: Parser[T]): MemParser[T]

Definition Classes
MemParsers
def phrase[T](p: Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def plusMinus: MemParser[Exp]
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def qualifiedIdent: MemParser[Ident]
def qualifiedIdentAll: MemParser[IdentAll]
def query: MemParser[Exp]
def queryWithCols: MemParser[Exp]
implicit def regex(r: Regex): Parser[String]

Definition Classes
RegexParsers
def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
Annotations
@migration
Migration
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
val reserved: Set[String]
def result: MemParser[Res]
def skipWhitespace: Boolean

Definition Classes
RegexParsers
def stringLiteral: MemParser[String]

Definition Classes
QueryParsers → JavaTokenParsers
def success[T](v: T): Parser[T]

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unaryExpr: MemParser[Exp]
def update: MemParser[Update]
def values: MemParser[Values]
def valuesSelect: MemParser[Exp]
def variable: MemParser[Variable]
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 wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
val whiteSpace: Regex

Definition Classes
QueryParsers → RegexParsers
def wholeNumber: MemParser[String]

Definition Classes
QueryParsers → JavaTokenParsers
def withQuery: MemParser[With]
def withTable: MemParser[WithTable]

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package parsing

trait QueryParsers extends JavaTokenParsers with MemParsers

Type Members

case class Arr(elements: List[Exp]) extends Exp with Product with Serializable

case class BinOp(op: String, lop: Exp, rop: Exp) extends Exp with Product with Serializable

case class Braces(expr: Exp) extends Exp with Product with Serializable

case class Cast(exp: Exp, typ: String) extends Exp with Product with Serializable

case class Col(col: Exp, alias: String) extends Exp with Product with Serializable

case class Cols(distinct: Boolean, cols: List[Col]) extends Exp with Product with Serializable

case class Const(value: Any) extends Exp with Product with Serializable

trait DMLExp extends Exp

case class Delete(table: Ident, alias: String, filter: Arr, using: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable

type Elem = Char

case class Error extends NoSuccess with Product with Serializable

trait Exp extends AnyRef

case class Failure extends NoSuccess with Product with Serializable

case class Filters(filters: List[Arr]) extends Exp with Product with Serializable

case class Fun(name: String, parameters: List[Exp], distinct: Boolean, aggregateOrder: Option[Ord], aggregateWhere: Option[Exp]) extends Exp with Product with Serializable

case class Grp(cols: List[Exp], having: Exp) extends Exp with Product with Serializable

case class Id(name: String) extends Exp with Product with Serializable

case class IdRef(name: String) extends Exp with Product with Serializable

case class Ident(ident: List[String]) extends Exp with Product with Serializable

case class IdentAll(ident: Ident) extends Exp with Product with Serializable

case class In(lop: Exp, rop: List[Exp], not: Boolean) extends Exp with Product with Serializable

type Input = Reader[Elem]

case class Insert(table: Ident, alias: String, cols: List[Col], vals: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable

case class Join(default: Boolean, expr: Exp, noJoin: Boolean) extends Exp with Product with Serializable

class MemParser[+T] extends Parser[T]

sealed abstract class NoSuccess extends ParseResult[Nothing]

trait Null extends Exp

case class Obj(obj: Exp, alias: String, join: Join, outerJoin: String, nullable: Boolean = false) extends Exp with Product with Serializable

trait OnceParser[+T] extends Parser[T]

case class Ord(cols: List[(Exp, Exp, Exp)]) extends Exp with Product with Serializable

sealed abstract class ParseResult[+T] extends AnyRef

abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

case class Query(tables: List[Obj], filter: Filters, cols: Cols, group: Grp, order: Ord, offset: Exp, limit: Exp) extends Exp with Product with Serializable

case class Res(rNr: Int, col: Any) extends Exp with Product with Serializable

case class Success[+T] extends ParseResult[T] with Product with Serializable

case class TerOp(lop: Exp, op1: String, mop: Exp, op2: String, rop: Exp) extends Exp with Product with Serializable

case class UnOp(operation: String, operand: Exp) extends Exp with Product with Serializable

case class Update(table: Ident, alias: String, filter: Arr, cols: List[Col], vals: Exp, returning: Option[Cols]) extends DMLExp with Product with Serializable

case class Values(values: List[Arr]) extends Exp with Product with Serializable

case class ValuesFromSelect(select: Query) extends Exp with Product with Serializable

case class Variable(variable: String, members: List[String], opt: Boolean) extends Exp with Product with Serializable

case class With(tables: List[WithTable], query: Exp) extends Exp with Product with Serializable

case class WithTable(name: String, cols: List[String], recursive: Boolean, table: Exp) extends Exp with Product with Serializable

case class ~[+a, +b] extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ALL: MemParser[All.type]

object All extends Exp

val DefaultJoin: Join

def FALSE: MemParser[Boolean]

def NULL: MemParser[Null.type]

val NoJoin: Join

object Null extends Null with Product with Serializable

object NullUpdate extends Null with Product with Serializable

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def TRUE: MemParser[Boolean]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit f: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit f: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

def any2tresql(any: Any): String

def array: MemParser[Arr]

final def asInstanceOf[T0]: T0

def braces: MemParser[Braces]

def cast: MemParser[Exp]

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

def clone(): AnyRef

def column: MemParser[Col]

def columns: MemParser[Cols]