With

Instance Constructors

new With(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], where: Option[Where])(position: InputPosition)

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 asCanonicalStringVal: String

Definition Classes
ASTNode
final def asInstanceOf[T0]: T0

Definition Classes
Any
def checkTypes(expression: Expression, signatures: Seq[TypeSignature]): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def copyProjection(distinct: Boolean = this.distinct, returnItems: ReturnItemsDef = this.returnItems, orderBy: Option[OrderBy] = this.orderBy, skip: Option[Skip] = this.skip, limit: Option[Limit] = this.limit, where: Option[Where] = this.where): ProjectionClause

Definition Classes
ProjectionClause
def declareVariable(v: LogicalVariable, typeGen: TypeGenerator, positions: Set[InputPosition] = Set.empty, overriding: Boolean = false): (SemanticState) ⇒ Either[SemanticError, SemanticState]

overriding
if true then a previous occurrence of that variable is overridden. if false then a previous occurrence of that variable leads to an error

Definition Classes
SemanticAnalysisTooling
def declareVariable(v: LogicalVariable, possibleTypes: TypeSpec): (SemanticState) ⇒ Either[SemanticError, SemanticState]

Definition Classes
SemanticAnalysisTooling
val distinct: Boolean

Definition Classes
With → ProjectionClause
def dup(children: Seq[AnyRef]): With.this.type

Definition Classes
ASTNode → Rewritable
def ensureDefined(v: LogicalVariable): (SemanticState) ⇒ Either[SemanticError, SemanticState]

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

Definition Classes
AnyRef
def error(msg: String, position: InputPosition)(state: SemanticState): SemanticCheckResult

Definition Classes
SemanticAnalysisTooling
def expectType(possibleTypes: ⇒ TypeSpec, expression: Expression, messageGen: (String, String) ⇒ String = DefaultTypeMismatchMessageGenerator): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def expectType(possibleTypes: ⇒ TypeSpec)(ctx: SemanticContext, expr: Expression): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def expectType[Exp <: Expression](possibleTypes: TypeSpec, expressions: Traversable[Exp]): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def expectType(typeGen: TypeGenerator, expression: Expression, messageGen: (String, String) ⇒ String): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def expectType(possibleTypes: TypeSpec, opt: Option[Expression]): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def expectType(typeGen: TypeGenerator, expression: Expression): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def implicitVariable(v: LogicalVariable, possibleType: CypherType): (SemanticState) ⇒ Either[SemanticError, SemanticState]

Definition Classes
SemanticAnalysisTooling
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isReturn: Boolean

Definition Classes
ProjectionClause
final def isWith: Boolean

Definition Classes
ProjectionClause
def leastUpperBoundsOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

Definition Classes
SemanticAnalysisTooling
val limit: Option[Limit]

Definition Classes
With → ProjectionClause
def name: String

Definition Classes
With → Clause
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val orderBy: Option[OrderBy]

Definition Classes
With → ProjectionClause
val popStateScope: SemanticCheck

Definition Classes
SemanticAnalysisTooling
val position: InputPosition

Definition Classes
With → ASTNode
def possibleTypes(expression: Expression): TypeGenerator

Definition Classes
SemanticAnalysisTooling
val pushStateScope: SemanticCheck

Definition Classes
SemanticAnalysisTooling
def requireCypher10Support(msg: String, position: InputPosition): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def requireMultigraphSupport(msg: String, position: InputPosition): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def returnColumns: List[String]

Definition Classes
Clause
val returnItems: ReturnItemsDef

Definition Classes
With → ProjectionClause
def semanticCheck: SemanticCheck

Definition Classes
With → ProjectionClause → HorizonClause → SemanticCheckable
def semanticCheck[A <: SemanticCheckable](traversable: TraversableOnce[A]): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def semanticCheckContinuation(previousScope: Scope): SemanticCheck

Definition Classes
ProjectionClause → HorizonClause
def semanticCheckFold[A](traversable: Traversable[A])(f: (A) ⇒ SemanticCheck): SemanticCheck

Definition Classes
SemanticAnalysisTooling
val skip: Option[Skip]

Definition Classes
With → ProjectionClause
def specifyType(possibleTypes: ⇒ TypeSpec, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

Definition Classes
SemanticAnalysisTooling
def specifyType(typeGen: TypeGenerator, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

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

Definition Classes
AnyRef
def typeSwitch(expr: Expression)(choice: (TypeSpec) ⇒ SemanticCheck): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def types(expression: Expression): TypeGenerator

Definition Classes
SemanticAnalysisTooling
def unionOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

Definition Classes
SemanticAnalysisTooling
def unless(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

Definition Classes
SemanticAnalysisTooling
def validNumber(double: DoubleLiteral): Boolean

Definition Classes
SemanticAnalysisTooling
def validNumber(long: IntegerLiteral): Boolean

Definition Classes
SemanticAnalysisTooling
def verifyOrderByAggregationUse(fail: (String, InputPosition) ⇒ Nothing): Unit

Definition Classes
ProjectionClause
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( ... )
def when(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

Definition Classes
SemanticAnalysisTooling
val where: Option[Where]

Definition Classes
With → ProjectionClause
def withReturnItems(items: Seq[ReturnItem]): With

returns
copy of this ProjectionClause with new return items

Definition Classes
With → ProjectionClause
def withScopedState(check: ⇒ SemanticCheck): SemanticCheck

Definition Classes
SemanticAnalysisTooling

Related Docs: object With | package ast

case class With(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], where: Option[Where])(position: InputPosition) extends ProjectionClause with Product with Serializable

Instance Constructors

new With(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], where: Option[Where])(position: InputPosition)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def asCanonicalStringVal: String

final def asInstanceOf[T0]: T0

def checkTypes(expression: Expression, signatures: Seq[TypeSignature]): SemanticCheck

def clone(): AnyRef

def copyProjection(distinct: Boolean = this.distinct, returnItems: ReturnItemsDef = this.returnItems, orderBy: Option[OrderBy] = this.orderBy, skip: Option[Skip] = this.skip, limit: Option[Limit] = this.limit, where: Option[Where] = this.where): ProjectionClause

def declareVariable(v: LogicalVariable, typeGen: TypeGenerator, positions: Set[InputPosition] = Set.empty, overriding: Boolean = false): (SemanticState) ⇒ Either[SemanticError, SemanticState]

def declareVariable(v: LogicalVariable, possibleTypes: TypeSpec): (SemanticState) ⇒ Either[SemanticError, SemanticState]

val distinct: Boolean

def dup(children: Seq[AnyRef]): With.this.type

def ensureDefined(v: LogicalVariable): (SemanticState) ⇒ Either[SemanticError, SemanticState]

final def eq(arg0: AnyRef): Boolean

def error(msg: String, position: InputPosition)(state: SemanticState): SemanticCheckResult

def expectType(possibleTypes: ⇒ TypeSpec, expression: Expression, messageGen: (String, String) ⇒ String = DefaultTypeMismatchMessageGenerator): SemanticCheck

def expectType(possibleTypes: ⇒ TypeSpec)(ctx: SemanticContext, expr: Expression): SemanticCheck

def expectType[Exp <: Expression](possibleTypes: TypeSpec, expressions: Traversable[Exp]): SemanticCheck

def expectType(typeGen: TypeGenerator, expression: Expression, messageGen: (String, String) ⇒ String): SemanticCheck

def expectType(possibleTypes: TypeSpec, opt: Option[Expression]): SemanticCheck

def expectType(typeGen: TypeGenerator, expression: Expression): SemanticCheck

def finalize(): Unit

final def getClass(): Class[_]

def implicitVariable(v: LogicalVariable, possibleType: CypherType): (SemanticState) ⇒ Either[SemanticError, SemanticState]

final def isInstanceOf[T0]: Boolean

def isReturn: Boolean

final def isWith: Boolean

def leastUpperBoundsOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

val limit: Option[Limit]

def name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val orderBy: Option[OrderBy]

val popStateScope: SemanticCheck

val position: InputPosition

def possibleTypes(expression: Expression): TypeGenerator

val pushStateScope: SemanticCheck

def requireCypher10Support(msg: String, position: InputPosition): SemanticCheck

def requireMultigraphSupport(msg: String, position: InputPosition): SemanticCheck

def returnColumns: List[String]

val returnItems: ReturnItemsDef

def semanticCheck: SemanticCheck

def semanticCheck[A <: SemanticCheckable](traversable: TraversableOnce[A]): SemanticCheck

def semanticCheckContinuation(previousScope: Scope): SemanticCheck

def semanticCheckFold[A](traversable: Traversable[A])(f: (A) ⇒ SemanticCheck): SemanticCheck

val skip: Option[Skip]

def specifyType(possibleTypes: ⇒ TypeSpec, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

def specifyType(typeGen: TypeGenerator, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

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

def typeSwitch(expr: Expression)(choice: (TypeSpec) ⇒ SemanticCheck): SemanticCheck

def types(expression: Expression): TypeGenerator

def unionOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

def unless(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

def validNumber(double: DoubleLiteral): Boolean

def validNumber(long: IntegerLiteral): Boolean

def verifyOrderByAggregationUse(fail: (String, InputPosition) ⇒ Nothing): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

val where: Option[Where]

def withReturnItems(items: Seq[ReturnItem]): With

def withScopedState(check: ⇒ SemanticCheck): SemanticCheck

Inherited from Serializable

Inherited from Serializable

Inherited from ProjectionClause

Inherited from HorizonClause

Inherited from SemanticAnalysisTooling

Inherited from Clause

Inherited from SemanticCheckable

Inherited from ASTNode

Inherited from Rewritable

Inherited from Foldable