fun exprSFW(select: Select, exclude: Exclude?, from: From, let: Let?, where: Expr?, groupBy: GroupBy?, having: Expr?, setOp: Expr.SFW.SetOp?, orderBy: OrderBy?, limit: Expr?, offset: Expr?): Expr.SFW

exprSFWSetOp

fun exprSFWSetOp(type: SetOp, operand: Expr.SFW): Expr.SFW.SetOp

exprStruct

fun exprStruct(fields: List<Expr.Struct.Field>): Expr.Struct

exprStructField

fun exprStructField(name: Expr, value: Expr): Expr.Struct.Field

exprSubstring

fun exprSubstring(value: Expr, start: Expr?, length: Expr?): Expr.Substring

exprTrim

fun exprTrim(value: Expr, chars: Expr?, spec: Expr.Trim.Spec?): Expr.Trim

exprUnary

fun exprUnary(op: Expr.Unary.Op, expr: Expr): Expr.Unary

exprValues

fun exprValues(rows: List<Expr.Values.Row>): Expr.Values

exprValuesRow

fun exprValuesRow(items: List<Expr>): Expr.Values.Row

exprVar

fun exprVar(identifier: Identifier, scope: Expr.Var.Scope): Expr.Var

exprWindow

fun exprWindow(function: Expr.Window.Function, expression: Expr, offset: Expr?, default: Expr?, over: Expr.Window.Over): Expr.Window

exprWindowOver

fun exprWindowOver(partitions: List<Expr>?, sorts: List<Sort>?): Expr.Window.Over

fromJoin

fun fromJoin(lhs: From, rhs: From, type: From.Join.Type?, condition: Expr?): From.Join

fromValue

fun fromValue(expr: Expr, type: From.Value.Type, asAlias: Identifier.Symbol?, atAlias: Identifier.Symbol?, byAlias: Identifier.Symbol?): From.Value

graphMatch

fun graphMatch(patterns: List<GraphMatch.Pattern>, selector: GraphMatch.Selector?): GraphMatch

graphMatchLabelConj

fun graphMatchLabelConj(lhs: GraphMatch.Label, rhs: GraphMatch.Label): GraphMatch.Label.Conj

graphMatchLabelDisj

fun graphMatchLabelDisj(lhs: GraphMatch.Label, rhs: GraphMatch.Label): GraphMatch.Label.Disj

graphMatchLabelName

fun graphMatchLabelName(name: String): GraphMatch.Label.Name

graphMatchLabelNegation

fun graphMatchLabelNegation(arg: GraphMatch.Label): GraphMatch.Label.Negation

graphMatchLabelWildcard

fun graphMatchLabelWildcard(): GraphMatch.Label.Wildcard

graphMatchPattern

fun graphMatchPattern(restrictor: GraphMatch.Restrictor?, prefilter: Expr?, variable: String?, quantifier: GraphMatch.Quantifier?, parts: List<GraphMatch.Pattern.Part>): GraphMatch.Pattern

graphMatchPatternPartEdge

fun graphMatchPatternPartEdge(direction: GraphMatch.Direction, quantifier: GraphMatch.Quantifier?, prefilter: Expr?, variable: String?, label: GraphMatch.Label?): GraphMatch.Pattern.Part.Edge

graphMatchPatternPartNode

fun graphMatchPatternPartNode(prefilter: Expr?, variable: String?, label: GraphMatch.Label?): GraphMatch.Pattern.Part.Node

graphMatchPatternPartPattern

fun graphMatchPatternPartPattern(pattern: GraphMatch.Pattern): GraphMatch.Pattern.Part.Pattern

graphMatchQuantifier

fun graphMatchQuantifier(lower: Long, upper: Long?): GraphMatch.Quantifier

graphMatchSelectorAllShortest

fun graphMatchSelectorAllShortest(): GraphMatch.Selector.AllShortest

graphMatchSelectorAny

fun graphMatchSelectorAny(): GraphMatch.Selector.Any

graphMatchSelectorAnyK

fun graphMatchSelectorAnyK(k: Long): GraphMatch.Selector.AnyK

graphMatchSelectorAnyShortest

fun graphMatchSelectorAnyShortest(): GraphMatch.Selector.AnyShortest

graphMatchSelectorShortestK

fun graphMatchSelectorShortestK(k: Long): GraphMatch.Selector.ShortestK

graphMatchSelectorShortestKGroup

fun graphMatchSelectorShortestKGroup(k: Long): GraphMatch.Selector.ShortestKGroup

groupBy

fun groupBy(strategy: GroupBy.Strategy, keys: List<GroupBy.Key>, asAlias: Identifier.Symbol?): GroupBy

groupByKey

fun groupByKey(expr: Expr, asAlias: Identifier.Symbol?): GroupBy.Key

identifierQualified

fun identifierQualified(root: Identifier.Symbol, steps: List<Identifier.Symbol>): Identifier.Qualified

identifierSymbol

fun identifierSymbol(symbol: String, caseSensitivity: Identifier.CaseSensitivity): Identifier.Symbol

let

fun let(bindings: List<Let.Binding>): Let

letBinding

fun letBinding(expr: Expr, asAlias: Identifier.Symbol): Let.Binding

onConflict

fun onConflict(target: OnConflict.Target?, action: OnConflict.Action): OnConflict

onConflictActionDoNothing

fun onConflictActionDoNothing(): OnConflict.Action.DoNothing

onConflictActionDoReplace

fun onConflictActionDoReplace(condition: Expr?): OnConflict.Action.DoReplace

onConflictActionDoUpdate

fun onConflictActionDoUpdate(condition: Expr?): OnConflict.Action.DoUpdate

onConflictTargetConstraint

fun onConflictTargetConstraint(constraint: Identifier): OnConflict.Target.Constraint

onConflictTargetSymbols

fun onConflictTargetSymbols(symbols: List<Identifier>): OnConflict.Target.Symbols

orderBy

fun orderBy(sorts: List<Sort>): OrderBy

path

fun path(root: Identifier.Symbol, steps: List<Path.Step>): Path

pathStepIndex

fun pathStepIndex(index: Int): Path.Step.Index

pathStepSymbol

fun pathStepSymbol(symbol: Identifier.Symbol): Path.Step.Symbol

returning

fun returning(columns: List<Returning.Column>): Returning

returningColumn

fun returningColumn(status: Returning.Column.Status, age: Returning.Column.Age, value: Returning.Column.Value): Returning.Column

returningColumnValueExpression

fun returningColumnValueExpression(expr: Expr): Returning.Column.Value.Expression

returningColumnValueWildcard

fun returningColumnValueWildcard(): Returning.Column.Value.Wildcard

selectPivot

fun selectPivot(key: Expr, value: Expr): Select.Pivot

selectProject

fun selectProject(items: List<Select.Project.Item>, setq: SetQuantifier?): Select.Project

selectProjectItemAll

fun selectProjectItemAll(expr: Expr): Select.Project.Item.All

selectProjectItemExpression

fun selectProjectItemExpression(expr: Expr, asAlias: Identifier.Symbol?): Select.Project.Item.Expression

selectStar

fun selectStar(setq: SetQuantifier?): Select.Star

selectValue

fun selectValue(constructor: Expr, setq: SetQuantifier?): Select.Value

setOp

fun setOp(type: SetOp.Type, setq: SetQuantifier?): SetOp

sort

fun sort(expr: Expr, dir: Sort.Dir?, nulls: Sort.Nulls?): Sort

statementDDLCreateIndex

fun statementDDLCreateIndex(index: Identifier?, table: Identifier, fields: List<Path>): Statement.DDL.CreateIndex

statementDDLCreateTable

fun statementDDLCreateTable(name: Identifier, definition: TableDefinition?): Statement.DDL.CreateTable

statementDDLDropIndex

fun statementDDLDropIndex(index: Identifier, table: Identifier): Statement.DDL.DropIndex

statementDDLDropTable

fun statementDDLDropTable(table: Identifier): Statement.DDL.DropTable

statementDMLBatchLegacy

fun statementDMLBatchLegacy(ops: List<Statement.DML.BatchLegacy.Op>, target: From?, where: Expr?, returning: Returning?): Statement.DML.BatchLegacy

statementDMLBatchLegacyOpDelete

fun statementDMLBatchLegacyOpDelete(): Statement.DML.BatchLegacy.Op.Delete

statementDMLBatchLegacyOpInsert

fun statementDMLBatchLegacyOpInsert(target: Identifier, values: Expr, asAlias: Identifier.Symbol?, onConflict: OnConflict?): Statement.DML.BatchLegacy.Op.Insert

statementDMLBatchLegacyOpInsertLegacy

fun statementDMLBatchLegacyOpInsertLegacy(target: Path, value: Expr, index: Expr?, conflictCondition: Expr?): Statement.DML.BatchLegacy.Op.InsertLegacy

statementDMLBatchLegacyOpRemove

fun statementDMLBatchLegacyOpRemove(target: Path): Statement.DML.BatchLegacy.Op.Remove

statementDMLBatchLegacyOpSet

fun statementDMLBatchLegacyOpSet(assignments: List<Statement.DML.Update.Assignment>): Statement.DML.BatchLegacy.Op.Set

statementDMLDelete

fun statementDMLDelete(target: Statement.DML.Delete.Target, where: Expr?, returning: Returning?): Statement.DML.Delete

statementDMLDeleteTarget

fun statementDMLDeleteTarget(path: Path, asAlias: Identifier.Symbol?, atAlias: Identifier.Symbol?, byAlias: Identifier.Symbol?): Statement.DML.Delete.Target

statementDMLInsert

fun statementDMLInsert(target: Identifier, values: Expr, asAlias: Identifier.Symbol?, onConflict: OnConflict?): Statement.DML.Insert

statementDMLInsertLegacy

fun statementDMLInsertLegacy(target: Path, value: Expr, index: Expr?, conflictCondition: Expr?): Statement.DML.InsertLegacy

statementDMLRemove

fun statementDMLRemove(target: Path): Statement.DML.Remove

statementDMLReplace

fun statementDMLReplace(target: Identifier, values: Expr, asAlias: Identifier.Symbol?): Statement.DML.Replace

statementDMLUpdate

fun statementDMLUpdate(target: Path, assignments: List<Statement.DML.Update.Assignment>): Statement.DML.Update

statementDMLUpdateAssignment

fun statementDMLUpdateAssignment(target: Path, value: Expr): Statement.DML.Update.Assignment

statementDMLUpsert

fun statementDMLUpsert(target: Identifier, values: Expr, asAlias: Identifier.Symbol?): Statement.DML.Upsert

statementExec

fun statementExec(procedure: String, args: List<Expr>): Statement.Exec

statementExplain

fun statementExplain(target: Statement.Explain.Target): Statement.Explain

statementExplainTargetDomain

fun statementExplainTargetDomain(statement: Statement, type: String?, format: String?): Statement.Explain.Target.Domain

statementQuery

fun statementQuery(expr: Expr): Statement.Query

tableDefinition

fun tableDefinition(columns: List<TableDefinition.Column>): TableDefinition

tableDefinitionColumn

fun tableDefinitionColumn(name: String, type: Type, constraints: List<TableDefinition.Column.Constraint>): TableDefinition.Column

tableDefinitionColumnConstraint

fun tableDefinitionColumnConstraint(name: String?, body: TableDefinition.Column.Constraint.Body): TableDefinition.Column.Constraint

tableDefinitionColumnConstraintBodyCheck

fun tableDefinitionColumnConstraintBodyCheck(expr: Expr): TableDefinition.Column.Constraint.Body.Check

tableDefinitionColumnConstraintBodyNotNull

fun tableDefinitionColumnConstraintBodyNotNull(): TableDefinition.Column.Constraint.Body.NotNull

tableDefinitionColumnConstraintBodyNullable

fun tableDefinitionColumnConstraintBodyNullable(): TableDefinition.Column.Constraint.Body.Nullable

typeAny

fun typeAny(): Type.Any

typeBag

fun typeBag(): Type.Bag

typeBigint

fun typeBigint(): Type.Bigint

typeBit

fun typeBit(length: Int?): Type.Bit

typeBitVarying

fun typeBitVarying(length: Int?): Type.BitVarying

typeBlob

fun typeBlob(length: Int?): Type.Blob

typeBool

fun typeBool(): Type.Bool

typeByteString

fun typeByteString(length: Int?): Type.ByteString

typeChar

fun typeChar(length: Int?): Type.Char

typeClob

fun typeClob(length: Int?): Type.Clob

typeCustom

fun typeCustom(name: String): Type.Custom

typeDate

fun typeDate(): Type.Date

typeDecimal

fun typeDecimal(precision: Int?, scale: Int?): Type.Decimal

typeFloat32

fun typeFloat32(): Type.Float32

typeFloat64

fun typeFloat64(): Type.Float64

typeInt

fun typeInt(): Type.Int

typeInt2

fun typeInt2(): Type.Int2

typeInt4

fun typeInt4(): Type.Int4

typeInt8

fun typeInt8(): Type.Int8

typeInterval

fun typeInterval(precision: Int?): Type.Interval

typeList

fun typeList(): Type.List

typeMissing

fun typeMissing(): Type.Missing

typeNullType

fun typeNullType(): Type.NullType

typeNumeric

fun typeNumeric(precision: Int?, scale: Int?): Type.Numeric

typeReal

fun typeReal(): Type.Real

typeSexp

fun typeSexp(): Type.Sexp

typeSmallint

fun typeSmallint(): Type.Smallint

typeString

fun typeString(length: Int?): Type.String

typeStruct

fun typeStruct(): Type.Struct

typeSymbol

fun typeSymbol(): Type.Symbol

typeTime

fun typeTime(precision: Int?): Type.Time

typeTimestamp

fun typeTimestamp(precision: Int?): Type.Timestamp

typeTimestampWithTz

fun typeTimestampWithTz(precision: Int?): Type.TimestampWithTz

typeTimeWithTz

fun typeTimeWithTz(precision: Int?): Type.TimeWithTz

typeTinyint

fun typeTinyint(): Type.Tinyint

typeTuple

fun typeTuple(): Type.Tuple

typeVarchar

fun typeVarchar(length: Int?): Type.Varchar