Return

Instance Constructors

new Return(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], excludedNames: Set[String] = Set.empty)(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
Return → ProjectionClause
def dup(children: Seq[AnyRef]): Return.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
val excludedNames: Set[String]
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
Return → ProjectionClause
final def isWith: Boolean

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

Definition Classes
SemanticAnalysisTooling
val limit: Option[Limit]

Definition Classes
Return → ProjectionClause
def name: String

Definition Classes
Return → 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
Return → ProjectionClause
val popStateScope: SemanticCheck

Definition Classes
SemanticAnalysisTooling
val position: InputPosition

Definition Classes
Return → 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
Return → Clause
val returnItems: ReturnItemsDef

Definition Classes
Return → ProjectionClause
def semanticCheck: SemanticCheck

Definition Classes
Return → 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
Return → 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
def where: Option[Where]

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

returns
copy of this ProjectionClause with new return items

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

Definition Classes
SemanticAnalysisTooling

Related Docs: object Return | package ast

case class Return(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], excludedNames: Set[String] = Set.empty)(position: InputPosition) extends ProjectionClause with Product with Serializable

Instance Constructors

new Return(distinct: Boolean, returnItems: ReturnItemsDef, orderBy: Option[OrderBy], skip: Option[Skip], limit: Option[Limit], excludedNames: Set[String] = Set.empty)(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]): Return.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

val excludedNames: Set[String]

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

def where: Option[Where]

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

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