hydra.cypher.open_cypher module

A Cypher model based on the OpenCypher specification (version 23), copyright Neo Technology, available at: https://opencypher.org/resources/.

class hydra.cypher.open_cypher.AddOrSubtractExpression(left: MultiplyDivideModuloExpression, right: Sequence[AddOrSubtractRightHandSide])

Bases: object

An additive expression: a multiply/divide/modulo expression with zero or more +/- terms.

class Builder(_left: 'MultiplyDivideModuloExpression' = None, _right: 'Sequence[AddOrSubtractRightHandSide]' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.AddOrSubtractExpression')

static builder()

left: MultiplyDivideModuloExpression

right: Sequence[AddOrSubtractRightHandSide]

with_left(left)

with_right(right)

class hydra.cypher.open_cypher.AddOrSubtractOperator(*values)

Bases: Enum

An additive operator: + or -.

ADD = Name(value='add')

SUBTRACT = Name(value='subtract')

TYPE_ = Name(value='hydra.cypher.openCypher.AddOrSubtractOperator')

class hydra.cypher.open_cypher.AddOrSubtractRightHandSide(operator: AddOrSubtractOperator, expression: MultiplyDivideModuloExpression)

Bases: object

An additive operator applied to a right-hand multiply/divide/modulo expression.

class Builder(_operator: 'AddOrSubtractOperator' = None, _expression: 'MultiplyDivideModuloExpression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.cypher.openCypher.AddOrSubtractRightHandSide')

static builder()

expression: MultiplyDivideModuloExpression

operator: AddOrSubtractOperator

with_expression(expression)

with_operator(operator)

class hydra.cypher.open_cypher.AndExpression(value: T)

Bases: Node[Sequence[NotExpression]]

A conjunction of NOT expressions.

TYPE_ = Name(value='hydra.cypher.openCypher.AndExpression')

class hydra.cypher.open_cypher.AnonymousPatternPart(value: T)

Bases: Node[PatternElement]

A pattern part with no bound path variable.

TYPE_ = Name(value='hydra.cypher.openCypher.AnonymousPatternPart')

class hydra.cypher.open_cypher.Atom

Bases: object

CASE = Name(value='case')

COUNT_STAR = Name(value='countStar')

EXISTENTIAL_SUBQUERY = Name(value='existentialSubquery')

FUNCTION_INVOCATION = Name(value='functionInvocation')

LIST_COMPREHENSION = Name(value='listComprehension')

LITERAL = Name(value='literal')

PARAMETER = Name(value='parameter')

PARENTHESIZED = Name(value='parenthesized')

PATTERN_COMPREHENSION = Name(value='patternComprehension')

PATTERN_PREDICATE = Name(value='patternPredicate')

QUANTIFIER = Name(value='quantifier')

TYPE_ = Name(value='hydra.cypher.openCypher.Atom')

VARIABLE = Name(value='variable')

class hydra.cypher.open_cypher.AtomCase(value: T): Bases: Node[CaseExpression]

class hydra.cypher.open_cypher.AtomCountStar: Bases: object

class hydra.cypher.open_cypher.AtomExistentialSubquery(value: T): Bases: Node[ExistentialSubquery]

class hydra.cypher.open_cypher.AtomFunctionInvocation(value: T): Bases: Node[FunctionInvocation]

class hydra.cypher.open_cypher.AtomListComprehension(value: T): Bases: Node[ListComprehension]

class hydra.cypher.open_cypher.AtomLiteral(value: T): Bases: Node[Literal]

class hydra.cypher.open_cypher.AtomParameter(value: T): Bases: Node[Parameter]

class hydra.cypher.open_cypher.AtomParenthesized(value: T): Bases: Node[ParenthesizedExpression]

class hydra.cypher.open_cypher.AtomPatternComprehension(value: T): Bases: Node[PatternComprehension]

class hydra.cypher.open_cypher.AtomPatternPredicate(value: T): Bases: Node[PatternPredicate]

class hydra.cypher.open_cypher.AtomQuantifier(value: T): Bases: Node[Quantifier]

class hydra.cypher.open_cypher.AtomVariable(value: T): Bases: Node[Variable]

class hydra.cypher.open_cypher.CaseAlternative(condition: Expression, result: Expression)

Bases: object

One WHEN/THEN alternative of a CASE expression.

class Builder(_condition: 'Expression' = None, _result: 'Expression' = None)

Bases: object

build()

condition(condition)

result(result)

CONDITION = Name(value='condition')

RESULT = Name(value='result')

TYPE_ = Name(value='hydra.cypher.openCypher.CaseAlternative')

static builder()

condition: Expression

result: Expression

with_condition(condition)

with_result(result)

class hydra.cypher.open_cypher.CaseExpression(expression: object, alternatives: Sequence[CaseAlternative], else_: object)

Bases: object

A CASE expression, with an optional test and one or more alternatives.

ALTERNATIVES = Name(value='alternatives')

class Builder(_expression: 'Optional[Expression]' = None, _alternatives: 'Sequence[CaseAlternative]' = None, _else_: 'Optional[Expression]' = None)

Bases: object

alternatives(alternatives)

build()

else_(else_)

expression(expression)

ELSE = Name(value='else')

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.cypher.openCypher.CaseExpression')

alternatives: Sequence[CaseAlternative]

static builder()

else_: object

expression: object

with_alternatives(alternatives)

with_else_(else_)

with_expression(expression)

class hydra.cypher.open_cypher.ComparisonExpression(left: StringListNullPredicateExpression, right: Sequence[PartialComparisonExpression])

Bases: object

A comparison expression: an add/subtract expression with zero or more partial comparisons.

class Builder(_left: 'StringListNullPredicateExpression' = None, _right: 'Sequence[PartialComparisonExpression]' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.ComparisonExpression')

static builder()

left: StringListNullPredicateExpression

right: Sequence[PartialComparisonExpression]

with_left(left)

with_right(right)

class hydra.cypher.open_cypher.ComparisonOperator(*values)

Bases: Enum

A comparison operator: equality, inequality, or an ordering relation.

EQ = Name(value='eq')

GT = Name(value='gt')

GTE = Name(value='gte')

LT = Name(value='lt')

LTE = Name(value='lte')

NEQ = Name(value='neq')

TYPE_ = Name(value='hydra.cypher.openCypher.ComparisonOperator')

class hydra.cypher.open_cypher.Create(value: T)

Bases: Node[Pattern]

A CREATE clause creating a pattern.

TYPE_ = Name(value='hydra.cypher.openCypher.Create')

class hydra.cypher.open_cypher.Delete(detach: bool, expressions: Sequence[Expression])

Bases: object

A DELETE clause, optionally DETACH, removing nodes or relationships.

class Builder(_detach: 'bool' = None, _expressions: 'Sequence[Expression]' = None)

Bases: object

build()

detach(detach)

expressions(expressions)

DETACH = Name(value='detach')

EXPRESSIONS = Name(value='expressions')

TYPE_ = Name(value='hydra.cypher.openCypher.Delete')

static builder()

detach: bool

expressions: Sequence[Expression]

with_detach(detach)

with_expressions(expressions)

class hydra.cypher.open_cypher.ExistentialSubquery

Bases: object

ExistentialSubqueryRegular | ExistentialSubqueryPattern

PATTERN = Name(value='pattern')

REGULAR = Name(value='regular')

TYPE_ = Name(value='hydra.cypher.openCypher.ExistentialSubquery')

class hydra.cypher.open_cypher.ExistentialSubqueryPattern(value: T): Bases: Node[PatternWhere]

class hydra.cypher.open_cypher.ExistentialSubqueryRegular(value: T): Bases: Node[RegularQuery]

class hydra.cypher.open_cypher.ExplicitProcedureInvocation(name: QualifiedName, arguments: Sequence[Expression])

Bases: object

A procedure call with an explicit, parenthesized argument list.

ARGUMENTS = Name(value='arguments')

class Builder(_name: 'QualifiedName' = None, _arguments: 'Sequence[Expression]' = None)

Bases: object

arguments(arguments)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.cypher.openCypher.ExplicitProcedureInvocation')

arguments: Sequence[Expression]

static builder()

name: QualifiedName

with_arguments(arguments)

with_name(name)

class hydra.cypher.open_cypher.Expression(value: T)

Bases: Node[OrExpression]

The top-level openCypher expression production: an OR expression.

TYPE_ = Name(value='hydra.cypher.openCypher.Expression')

class hydra.cypher.open_cypher.FilterExpression(id_in_coll: IdInColl, where: object)

Bases: object

An id-in-collection clause with an optional WHERE filter.

class Builder(_id_in_coll: 'IdInColl' = None, _where: 'Optional[Where]' = None)

Bases: object

build()

id_in_coll(id_in_coll)

where(where)

ID_IN_COLL = Name(value='idInColl')

TYPE_ = Name(value='hydra.cypher.openCypher.FilterExpression')

WHERE = Name(value='where')

static builder()

id_in_coll: IdInColl

where: object

with_id_in_coll(id_in_coll)

with_where(where)

class hydra.cypher.open_cypher.FunctionInvocation(name: QualifiedName, distinct: bool, arguments: Sequence[Expression])

Bases: object

A function call: a qualified name, an optional DISTINCT, and arguments.

ARGUMENTS = Name(value='arguments')

class Builder(_name: 'QualifiedName' = None, _distinct: 'bool' = None, _arguments: 'Sequence[Expression]' = None)

Bases: object

arguments(arguments)

build()

distinct(distinct)

name(name)

DISTINCT = Name(value='distinct')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.cypher.openCypher.FunctionInvocation')

arguments: Sequence[Expression]

static builder()

distinct: bool

name: QualifiedName

with_arguments(arguments)

with_distinct(distinct)

with_name(name)

class hydra.cypher.open_cypher.IdInColl(variable: Variable, expression: Expression)

Bases: object

A variable bound over a list expression, as in x IN list.

class Builder(_variable: 'Variable' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

variable(variable)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.cypher.openCypher.IdInColl')

VARIABLE = Name(value='variable')

static builder()

expression: Expression

variable: Variable

with_expression(expression)

with_variable(variable)

class hydra.cypher.open_cypher.ImplicitProcedureInvocation(value: T)

Bases: Node[QualifiedName]

A procedure call with no argument list, taking its arguments from bound variables.

TYPE_ = Name(value='hydra.cypher.openCypher.ImplicitProcedureInvocation')

class hydra.cypher.open_cypher.InQueryCall(call: ExplicitProcedureInvocation, yield_items: object)

Bases: object

An in-query CALL to a procedure.

class Builder(_call: 'ExplicitProcedureInvocation' = None, _yield_items: 'Optional[YieldItems]' = None)

Bases: object

build()

call(call)

yield_items(yield_items)

CALL = Name(value='call')

TYPE_ = Name(value='hydra.cypher.openCypher.InQueryCall')

YIELD_ITEMS = Name(value='yieldItems')

static builder()

call: ExplicitProcedureInvocation

with_call(call)

with_yield_items(yield_items)

yield_items: object

class hydra.cypher.open_cypher.KeyValuePair(key: PropertyKeyName, value: Expression)

Bases: object

A key-value pair in a map literal.

class Builder(_key: 'PropertyKeyName' = None, _value: 'Expression' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.cypher.openCypher.KeyValuePair')

VALUE = Name(value='value')

static builder()

key: PropertyKeyName

value: Expression

with_key(key)

with_value(value)

class hydra.cypher.open_cypher.Limit(value: T)

Bases: Node[Expression]

A LIMIT clause limiting the number of results.

TYPE_ = Name(value='hydra.cypher.openCypher.Limit')

class hydra.cypher.open_cypher.ListComprehension(left: FilterExpression, right: object)

Bases: object

A list comprehension: a filter expression with an optional projection.

class Builder(_left: 'FilterExpression' = None, _right: 'Optional[Expression]' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.ListComprehension')

static builder()

left: FilterExpression

right: object

with_left(left)

with_right(right)

class hydra.cypher.open_cypher.ListLiteral(value: T)

Bases: Node[Sequence[Expression]]

A list literal.

TYPE_ = Name(value='hydra.cypher.openCypher.ListLiteral')

class hydra.cypher.open_cypher.ListOperatorExpression

Bases: object

ListOperatorExpressionSingle | ListOperatorExpressionRange

RANGE = Name(value='range')

SINGLE = Name(value='single')

TYPE_ = Name(value='hydra.cypher.openCypher.ListOperatorExpression')

class hydra.cypher.open_cypher.ListOperatorExpressionOrPropertyLookup

Bases: object

ListOperatorExpressionOrPropertyLookupList | ListOperatorExpressionOrPropertyLookupProperty

LIST = Name(value='list')

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.cypher.openCypher.ListOperatorExpressionOrPropertyLookup')

class hydra.cypher.open_cypher.ListOperatorExpressionOrPropertyLookupList(value: T): Bases: Node[ListOperatorExpression]

class hydra.cypher.open_cypher.ListOperatorExpressionOrPropertyLookupProperty(value: T): Bases: Node[PropertyLookup]

class hydra.cypher.open_cypher.ListOperatorExpressionRange(value: T): Bases: Node[RangeExpression]

class hydra.cypher.open_cypher.ListOperatorExpressionSingle(value: T): Bases: Node[Expression]

class hydra.cypher.open_cypher.ListPredicateExpression(value: T)

Bases: Node[AddOrSubtractExpression]

An IN predicate testing list membership.

TYPE_ = Name(value='hydra.cypher.openCypher.ListPredicateExpression')

class hydra.cypher.open_cypher.Literal

Bases: object

BOOLEAN = Name(value='boolean')

LIST = Name(value='list')

MAP = Name(value='map')

NULL = Name(value='null')

NUMBER = Name(value='number')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.cypher.openCypher.Literal')

class hydra.cypher.open_cypher.LiteralBoolean(value: T): Bases: Node[bool]

class hydra.cypher.open_cypher.LiteralList(value: T): Bases: Node[ListLiteral]

class hydra.cypher.open_cypher.LiteralMap(value: T): Bases: Node[MapLiteral]

class hydra.cypher.open_cypher.LiteralNull: Bases: object

class hydra.cypher.open_cypher.LiteralNumber(value: T): Bases: Node[NumberLiteral]

class hydra.cypher.open_cypher.LiteralString(value: T): Bases: Node[StringLiteral]

class hydra.cypher.open_cypher.MapLiteral(value: T)

Bases: Node[Sequence[KeyValuePair]]

A map literal.

TYPE_ = Name(value='hydra.cypher.openCypher.MapLiteral')

class hydra.cypher.open_cypher.Match(optional: bool, pattern: Pattern, where: object)

Bases: object

A MATCH clause, optionally OPTIONAL, over a pattern with an optional WHERE clause.

class Builder(_optional: 'bool' = None, _pattern: 'Pattern' = None, _where: 'Optional[Where]' = None)

Bases: object

build()

optional(optional)

pattern(pattern)

where(where)

OPTIONAL = Name(value='optional')

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.cypher.openCypher.Match')

WHERE = Name(value='where')

static builder()

optional: bool

pattern: Pattern

where: object

with_optional(optional)

with_pattern(pattern)

with_where(where)

class hydra.cypher.open_cypher.MatchOrCreate(*values)

Bases: Enum

Either a MATCH or a CREATE, used within a MERGE action.

CREATE = Name(value='create')

MATCH = Name(value='match')

TYPE_ = Name(value='hydra.cypher.openCypher.MatchOrCreate')

class hydra.cypher.open_cypher.Merge(pattern_part: PatternPart, actions: Sequence[MergeAction])

Bases: object

A MERGE clause matching or creating a pattern, with optional merge actions.

ACTIONS = Name(value='actions')

class Builder(_pattern_part: 'PatternPart' = None, _actions: 'Sequence[MergeAction]' = None)

Bases: object

actions(actions)

build()

pattern_part(pattern_part)

PATTERN_PART = Name(value='patternPart')

TYPE_ = Name(value='hydra.cypher.openCypher.Merge')

actions: Sequence[MergeAction]

static builder()

pattern_part: PatternPart

with_actions(actions)

with_pattern_part(pattern_part)

class hydra.cypher.open_cypher.MergeAction(action: MatchOrCreate, set: Set)

Bases: object

An ON MATCH or ON CREATE action attached to a MERGE clause.

ACTION = Name(value='action')

class Builder(_action: 'MatchOrCreate' = None, _set: 'Set' = None)

Bases: object

action(action)

build()

set(set)

SET = Name(value='set')

TYPE_ = Name(value='hydra.cypher.openCypher.MergeAction')

action: MatchOrCreate

static builder()

set: Set

with_action(action)

with_set(set)

class hydra.cypher.open_cypher.MultiPartQuery(with_: Sequence[WithClause], body: SinglePartQuery)

Bases: object

A multi-part query: one or more WITH-delimited parts followed by a single-part query.

BODY = Name(value='body')

class Builder(_with_: 'Sequence[WithClause]' = None, _body: 'SinglePartQuery' = None)

Bases: object

body(body)

build()

with_(with_)

TYPE_ = Name(value='hydra.cypher.openCypher.MultiPartQuery')

WITH = Name(value='with')

body: SinglePartQuery

static builder()

with_: Sequence[WithClause]

with_body(body)

with_with_(with_)

class hydra.cypher.open_cypher.MultiplyDivideModuloExpression(left: PowerOfExpression, right: Sequence[MultiplyDivideModuloRightHandSide])

Bases: object

A multiplicative expression: a power expression with zero or more multiply, divide, or modulo terms.

class Builder(_left: 'PowerOfExpression' = None, _right: 'Sequence[MultiplyDivideModuloRightHandSide]' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.MultiplyDivideModuloExpression')

static builder()

left: PowerOfExpression

right: Sequence[MultiplyDivideModuloRightHandSide]

with_left(left)

with_right(right)

class hydra.cypher.open_cypher.MultiplyDivideModuloOperator(*values)

Bases: Enum

A multiplicative operator: *, /, or %.

DIVIDE = Name(value='divide')

MODULO = Name(value='modulo')

MULTIPLY = Name(value='multiply')

TYPE_ = Name(value='hydra.cypher.openCypher.MultiplyDivideModuloOperator')

class hydra.cypher.open_cypher.MultiplyDivideModuloRightHandSide(operator: MultiplyDivideModuloOperator, expression: PowerOfExpression)

Bases: object

A multiplicative operator applied to a right-hand power expression.

class Builder(_operator: 'MultiplyDivideModuloOperator' = None, _expression: 'PowerOfExpression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.cypher.openCypher.MultiplyDivideModuloRightHandSide')

static builder()

expression: PowerOfExpression

operator: MultiplyDivideModuloOperator

with_expression(expression)

with_operator(operator)

class hydra.cypher.open_cypher.NodeLabel(value: T)

Bases: Node[str]

A single node label.

TYPE_ = Name(value='hydra.cypher.openCypher.NodeLabel')

class hydra.cypher.open_cypher.NodeLabels(value: T)

Bases: Node[Sequence[NodeLabel]]

One or more node labels attached to a node pattern.

TYPE_ = Name(value='hydra.cypher.openCypher.NodeLabels')

class hydra.cypher.open_cypher.NodePattern(variable: object, labels: object, properties: object)

Bases: object

A node pattern: an optional variable, node labels, and properties.

class Builder(_variable: 'Optional[Variable]' = None, _labels: 'Optional[NodeLabels]' = None, _properties: 'Optional[Properties]' = None)

Bases: object

build()

labels(labels)

properties(properties)

variable(variable)

LABELS = Name(value='labels')

PROPERTIES = Name(value='properties')

TYPE_ = Name(value='hydra.cypher.openCypher.NodePattern')

VARIABLE = Name(value='variable')

static builder()

labels: object

properties: object

variable: object

with_labels(labels)

with_properties(properties)

with_variable(variable)

class hydra.cypher.open_cypher.NodePatternChain(node_pattern: NodePattern, chain: Sequence[PatternElementChain])

Bases: object

A node pattern followed by a chain of pattern-element continuations.

class Builder(_node_pattern: 'NodePattern' = None, _chain: 'Sequence[PatternElementChain]' = None)

Bases: object

build()

chain(chain)

node_pattern(node_pattern)

CHAIN = Name(value='chain')

NODE_PATTERN = Name(value='nodePattern')

TYPE_ = Name(value='hydra.cypher.openCypher.NodePatternChain')

static builder()

chain: Sequence[PatternElementChain]

node_pattern: NodePattern

with_chain(chain)

with_node_pattern(node_pattern)

class hydra.cypher.open_cypher.NonArithmeticOperatorExpression(atom: Atom, lists_and_lookups: Sequence[ListOperatorExpressionOrPropertyLookup], labels: object)

Bases: object

An atom followed by zero or more list operators, property lookups, or node labels.

ATOM = Name(value='atom')

class Builder(_atom: 'Atom' = None, _lists_and_lookups: 'Sequence[ListOperatorExpressionOrPropertyLookup]' = None, _labels: 'Optional[NodeLabels]' = None)

Bases: object

atom(atom)

build()

labels(labels)

lists_and_lookups(lists_and_lookups)

LABELS = Name(value='labels')

LISTS_AND_LOOKUPS = Name(value='listsAndLookups')

TYPE_ = Name(value='hydra.cypher.openCypher.NonArithmeticOperatorExpression')

atom: Atom

static builder()

labels: object

lists_and_lookups: Sequence[ListOperatorExpressionOrPropertyLookup]

with_atom(atom)

with_labels(labels)

with_lists_and_lookups(lists_and_lookups)

class hydra.cypher.open_cypher.NotExpression(not_: bool, expression: ComparisonExpression)

Bases: object

A possibly-negated comparison expression.

class Builder(_not_: 'bool' = None, _expression: 'ComparisonExpression' = None)

Bases: object

build()

expression(expression)

not_(not_)

EXPRESSION = Name(value='expression')

NOT = Name(value='not')

TYPE_ = Name(value='hydra.cypher.openCypher.NotExpression')

static builder()

expression: ComparisonExpression

not_: bool

with_expression(expression)

with_not_(not_)

class hydra.cypher.open_cypher.NullPredicateExpression(value: T)

Bases: Node[bool]

An IS NULL or IS NOT NULL predicate.

TYPE_ = Name(value='hydra.cypher.openCypher.NullPredicateExpression')

class hydra.cypher.open_cypher.NumberLiteral

Bases: object

NumberLiteralDouble | NumberLiteralInteger

DOUBLE = Name(value='double')

INTEGER = Name(value='integer')

TYPE_ = Name(value='hydra.cypher.openCypher.NumberLiteral')

class hydra.cypher.open_cypher.NumberLiteralDouble(value: T): Bases: Node[float]

class hydra.cypher.open_cypher.NumberLiteralInteger(value: T): Bases: Node[int]

class hydra.cypher.open_cypher.OrExpression(value: T)

Bases: Node[Sequence[XorExpression]]

A disjunction of XOR expressions.

TYPE_ = Name(value='hydra.cypher.openCypher.OrExpression')

class hydra.cypher.open_cypher.Order(value: T)

Bases: Node[Sequence[SortItem]]

An ORDER BY clause.

TYPE_ = Name(value='hydra.cypher.openCypher.Order')

class hydra.cypher.open_cypher.Parameter

Bases: object

ParameterSymbolic | ParameterInteger

INTEGER = Name(value='integer')

SYMBOLIC = Name(value='symbolic')

TYPE_ = Name(value='hydra.cypher.openCypher.Parameter')

class hydra.cypher.open_cypher.ParameterInteger(value: T): Bases: Node[int]

class hydra.cypher.open_cypher.ParameterSymbolic(value: T): Bases: Node[str]

class hydra.cypher.open_cypher.ParenthesizedExpression(value: T)

Bases: Node[Expression]

A parenthesized expression.

TYPE_ = Name(value='hydra.cypher.openCypher.ParenthesizedExpression')

class hydra.cypher.open_cypher.PartialComparisonExpression(operator: ComparisonOperator, right: StringListNullPredicateExpression)

Bases: object

A comparison operator applied to a right-hand add/subtract expression.

class Builder(_operator: 'ComparisonOperator' = None, _right: 'StringListNullPredicateExpression' = None)

Bases: object

build()

operator(operator)

right(right)

OPERATOR = Name(value='operator')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.PartialComparisonExpression')

static builder()

operator: ComparisonOperator

right: StringListNullPredicateExpression

with_operator(operator)

with_right(right)

class hydra.cypher.open_cypher.Pattern(value: T)

Bases: Node[Sequence[PatternPart]]

A graph pattern: one or more pattern parts.

TYPE_ = Name(value='hydra.cypher.openCypher.Pattern')

class hydra.cypher.open_cypher.PatternComprehension(variable: object, pattern: RelationshipsPattern, where: object, right: Expression)

Bases: object

A pattern comprehension: a pattern with optional filter and projection expressions.

class Builder(_variable: 'Optional[Variable]' = None, _pattern: 'RelationshipsPattern' = None, _where: 'Optional[Where]' = None, _right: 'Expression' = None)

Bases: object

build()

pattern(pattern)

right(right)

variable(variable)

where(where)

PATTERN = Name(value='pattern')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.PatternComprehension')

VARIABLE = Name(value='variable')

WHERE = Name(value='where')

static builder()

pattern: RelationshipsPattern

right: Expression

variable: object

where: object

with_pattern(pattern)

with_right(right)

with_variable(variable)

with_where(where)

class hydra.cypher.open_cypher.PatternElement

Bases: object

PatternElementChained | PatternElementParenthesized

CHAINED = Name(value='chained')

PARENTHESIZED = Name(value='parenthesized')

TYPE_ = Name(value='hydra.cypher.openCypher.PatternElement')

class hydra.cypher.open_cypher.PatternElementChain(relationship: RelationshipPattern, node: NodePattern)

Bases: object

A relationship pattern followed by the node pattern it connects to.

class Builder(_relationship: 'RelationshipPattern' = None, _node: 'NodePattern' = None)

Bases: object

build()

node(node)

relationship(relationship)

NODE = Name(value='node')

RELATIONSHIP = Name(value='relationship')

TYPE_ = Name(value='hydra.cypher.openCypher.PatternElementChain')

static builder()

node: NodePattern

relationship: RelationshipPattern

with_node(node)

with_relationship(relationship)

class hydra.cypher.open_cypher.PatternElementChained(value: T): Bases: Node[NodePatternChain]

class hydra.cypher.open_cypher.PatternElementParenthesized(value: T): Bases: Node[PatternElement]

class hydra.cypher.open_cypher.PatternPart(variable: object, pattern: AnonymousPatternPart)

Bases: object

One part of a graph pattern, optionally bound to a variable.

class Builder(_variable: 'Optional[Variable]' = None, _pattern: 'AnonymousPatternPart' = None)

Bases: object

build()

pattern(pattern)

variable(variable)

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.cypher.openCypher.PatternPart')

VARIABLE = Name(value='variable')

static builder()

pattern: AnonymousPatternPart

variable: object

with_pattern(pattern)

with_variable(variable)

class hydra.cypher.open_cypher.PatternPredicate(value: T)

Bases: Node[RelationshipsPattern]

A pattern used as a boolean existence predicate.

TYPE_ = Name(value='hydra.cypher.openCypher.PatternPredicate')

class hydra.cypher.open_cypher.PatternWhere(pattern: Pattern, where: object)

Bases: object

A pattern together with an optional WHERE clause, used in an existential subquery.

class Builder(_pattern: 'Pattern' = None, _where: 'Optional[Where]' = None)

Bases: object

build()

pattern(pattern)

where(where)

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.cypher.openCypher.PatternWhere')

WHERE = Name(value='where')

static builder()

pattern: Pattern

where: object

with_pattern(pattern)

with_where(where)

class hydra.cypher.open_cypher.PowerOfExpression(value: T)

Bases: Node[Sequence[UnaryAddOrSubtractExpression]]

An exponentiation expression: a unary expression with zero or more ^ terms.

TYPE_ = Name(value='hydra.cypher.openCypher.PowerOfExpression')

class hydra.cypher.open_cypher.ProcedureInvocation

Bases: object

ProcedureInvocationExplicit | ProcedureInvocationImplicit

EXPLICIT = Name(value='explicit')

IMPLICIT = Name(value='implicit')

TYPE_ = Name(value='hydra.cypher.openCypher.ProcedureInvocation')

class hydra.cypher.open_cypher.ProcedureInvocationExplicit(value: T): Bases: Node[ExplicitProcedureInvocation]

class hydra.cypher.open_cypher.ProcedureInvocationImplicit(value: T): Bases: Node[ImplicitProcedureInvocation]

class hydra.cypher.open_cypher.ProcedureResultField(value: T)

Bases: Node[str]

The name of a single field yielded by a procedure.

TYPE_ = Name(value='hydra.cypher.openCypher.ProcedureResultField')

class hydra.cypher.open_cypher.ProjectionBody(distinct: bool, projection_items: ProjectionItems, order: object, skip: object, limit: object)

Bases: object

The body of a WITH or RETURN clause: distinctness, projection items, and ordering/paging.

class Builder(_distinct: 'bool' = None, _projection_items: 'ProjectionItems' = None, _order: 'Optional[Order]' = None, _skip: 'Optional[Skip]' = None, _limit: 'Optional[Limit]' = None)

Bases: object

build()

distinct(distinct)

limit(limit)

order(order)

projection_items(projection_items)

skip(skip)

DISTINCT = Name(value='distinct')

LIMIT = Name(value='limit')

ORDER = Name(value='order')

PROJECTION_ITEMS = Name(value='projectionItems')

SKIP = Name(value='skip')

TYPE_ = Name(value='hydra.cypher.openCypher.ProjectionBody')

static builder()

distinct: bool

limit: object

order: object

projection_items: ProjectionItems

skip: object

with_distinct(distinct)

with_limit(limit)

with_order(order)

with_projection_items(projection_items)

with_skip(skip)

class hydra.cypher.open_cypher.ProjectionItem(expression: Expression, variable: object)

Bases: object

One item of a projection: an expression, optionally aliased.

class Builder(_expression: 'Expression' = None, _variable: 'Optional[Variable]' = None)

Bases: object

build()

expression(expression)

variable(variable)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.cypher.openCypher.ProjectionItem')

VARIABLE = Name(value='variable')

static builder()

expression: Expression

variable: object

with_expression(expression)

with_variable(variable)

class hydra.cypher.open_cypher.ProjectionItems(star: bool, explicit: Sequence[ProjectionItem])

Bases: object

The list of items in a projection, or a star for all variables.

class Builder(_star: 'bool' = None, _explicit: 'Sequence[ProjectionItem]' = None)

Bases: object

build()

explicit(explicit)

star(star)

EXPLICIT = Name(value='explicit')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.cypher.openCypher.ProjectionItems')

static builder()

explicit: Sequence[ProjectionItem]

star: bool

with_explicit(explicit)

with_star(star)

class hydra.cypher.open_cypher.Properties

Bases: object

PropertiesMap | PropertiesParameter

MAP = Name(value='map')

PARAMETER = Name(value='parameter')

TYPE_ = Name(value='hydra.cypher.openCypher.Properties')

class hydra.cypher.open_cypher.PropertiesMap(value: T): Bases: Node[MapLiteral]

class hydra.cypher.open_cypher.PropertiesParameter(value: T): Bases: Node[Parameter]

class hydra.cypher.open_cypher.PropertyEquals(lhs: PropertyExpression, rhs: Expression)

Bases: object

A property assignment of the form property = expression.

class Builder(_lhs: 'PropertyExpression' = None, _rhs: 'Expression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.cypher.openCypher.PropertyEquals')

static builder()

lhs: PropertyExpression

rhs: Expression

with_lhs(lhs)

with_rhs(rhs)

class hydra.cypher.open_cypher.PropertyExpression(atom: Atom, lookups: Sequence[PropertyLookup])

Bases: object

An atom followed by one or more property lookups.

ATOM = Name(value='atom')

class Builder(_atom: 'Atom' = None, _lookups: 'Sequence[PropertyLookup]' = None)

Bases: object

atom(atom)

build()

lookups(lookups)

LOOKUPS = Name(value='lookups')

TYPE_ = Name(value='hydra.cypher.openCypher.PropertyExpression')

atom: Atom

static builder()

lookups: Sequence[PropertyLookup]

with_atom(atom)

with_lookups(lookups)

class hydra.cypher.open_cypher.PropertyKeyName(value: T)

Bases: Node[str]

The name of a property key.

TYPE_ = Name(value='hydra.cypher.openCypher.PropertyKeyName')

class hydra.cypher.open_cypher.PropertyLookup(value: T)

Bases: Node[PropertyKeyName]

A single property access, as in .property.

TYPE_ = Name(value='hydra.cypher.openCypher.PropertyLookup')

class hydra.cypher.open_cypher.QualifiedName(namespace: str, local: str)

Bases: object

A namespace-qualified function or procedure name.

class Builder(_namespace: 'str' = None, _local: 'str' = None)

Bases: object

build()

local(local)

namespace(namespace)

LOCAL = Name(value='local')

NAMESPACE = Name(value='namespace')

TYPE_ = Name(value='hydra.cypher.openCypher.QualifiedName')

static builder()

local: str

namespace: str

with_local(local)

with_namespace(namespace)

class hydra.cypher.open_cypher.Quantifier(operator: QuantifierOperator, expression: FilterExpression)

Bases: object

A quantifier over a list predicate: all, any, none, or single.

class Builder(_operator: 'QuantifierOperator' = None, _expression: 'FilterExpression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.cypher.openCypher.Quantifier')

static builder()

expression: FilterExpression

operator: QuantifierOperator

with_expression(expression)

with_operator(operator)

class hydra.cypher.open_cypher.QuantifierOperator(*values)

Bases: Enum

The keyword of a quantifier: ALL, ANY, NONE, or SINGLE.

ALL = Name(value='all')

ANY = Name(value='any')

NONE = Name(value='none')

SINGLE = Name(value='single')

TYPE_ = Name(value='hydra.cypher.openCypher.QuantifierOperator')

class hydra.cypher.open_cypher.Query

Bases: object

QueryRegular | QueryStandalone

REGULAR = Name(value='regular')

STANDALONE = Name(value='standalone')

TYPE_ = Name(value='hydra.cypher.openCypher.Query')

class hydra.cypher.open_cypher.QueryRegular(value: T): Bases: Node[RegularQuery]

class hydra.cypher.open_cypher.QueryStandalone(value: T): Bases: Node[StandaloneCall]

class hydra.cypher.open_cypher.RangeExpression(start: object, end: object)

Bases: object

The bracketed range of a list-slice operator.

class Builder(_start: 'Optional[Expression]' = None, _end: 'Optional[Expression]' = None)

Bases: object

build()

end(end)

start(start)

END = Name(value='end')

START = Name(value='start')

TYPE_ = Name(value='hydra.cypher.openCypher.RangeExpression')

static builder()

end: object

start: object

with_end(end)

with_start(start)

class hydra.cypher.open_cypher.RangeLiteral(start: object, end: object)

Bases: object

A variable-length relationship range, as in *1..3.

class Builder(_start: 'Optional[int]' = None, _end: 'Optional[int]' = None)

Bases: object

build()

end(end)

start(start)

END = Name(value='end')

START = Name(value='start')

TYPE_ = Name(value='hydra.cypher.openCypher.RangeLiteral')

static builder()

end: object

start: object

with_end(end)

with_start(start)

class hydra.cypher.open_cypher.ReadingClause

Bases: object

ReadingClauseMatch | ReadingClauseUnwind | ReadingClauseInQueryCall

IN_QUERY_CALL = Name(value='inQueryCall')

MATCH = Name(value='match')

TYPE_ = Name(value='hydra.cypher.openCypher.ReadingClause')

UNWIND = Name(value='unwind')

class hydra.cypher.open_cypher.ReadingClauseInQueryCall(value: T): Bases: Node[InQueryCall]

class hydra.cypher.open_cypher.ReadingClauseMatch(value: T): Bases: Node[Match]

class hydra.cypher.open_cypher.ReadingClauseUnwind(value: T): Bases: Node[Unwind]

class hydra.cypher.open_cypher.RegularQuery(head: SingleQuery, rest: Sequence[Union])

Bases: object

A regular openCypher query: a single query, optionally unioned with further queries.

class Builder(_head: 'SingleQuery' = None, _rest: 'Sequence[Union]' = None)

Bases: object

build()

head(head)

rest(rest)

HEAD = Name(value='head')

REST = Name(value='rest')

TYPE_ = Name(value='hydra.cypher.openCypher.RegularQuery')

static builder()

head: SingleQuery

rest: Sequence[Union]

with_head(head)

with_rest(rest)

class hydra.cypher.open_cypher.RelTypeName(value: T)

Bases: Node[str]

The name of a relationship type.

TYPE_ = Name(value='hydra.cypher.openCypher.RelTypeName')

class hydra.cypher.open_cypher.RelationshipDetail(variable: object, types: object, range_: object, properties: object)

Bases: object

The bracketed detail of a relationship pattern: variable, types, range, and properties.

class Builder(_variable: 'Optional[Variable]' = None, _types: 'Optional[RelationshipTypes]' = None, _range_: 'Optional[RangeLiteral]' = None, _properties: 'Optional[Properties]' = None)

Bases: object

build()

properties(properties)

range_(range_)

types(types)

variable(variable)

PROPERTIES = Name(value='properties')

RANGE = Name(value='range')

TYPES = Name(value='types')

TYPE_ = Name(value='hydra.cypher.openCypher.RelationshipDetail')

VARIABLE = Name(value='variable')

static builder()

properties: object

range_: object

types: object

variable: object

with_properties(properties)

with_range_(range_)

with_types(types)

with_variable(variable)

class hydra.cypher.open_cypher.RelationshipPattern(left_arrow: bool, detail: object, right_arrow: bool)

Bases: object

A relationship pattern: direction markers around an optional relationship detail.

class Builder(_left_arrow: 'bool' = None, _detail: 'Optional[RelationshipDetail]' = None, _right_arrow: 'bool' = None)

Bases: object

build()

detail(detail)

left_arrow(left_arrow)

right_arrow(right_arrow)

DETAIL = Name(value='detail')

LEFT_ARROW = Name(value='leftArrow')

RIGHT_ARROW = Name(value='rightArrow')

TYPE_ = Name(value='hydra.cypher.openCypher.RelationshipPattern')

static builder()

detail: object

left_arrow: bool

right_arrow: bool

with_detail(detail)

with_left_arrow(left_arrow)

with_right_arrow(right_arrow)

class hydra.cypher.open_cypher.RelationshipTypes(value: T)

Bases: Node[Sequence[RelTypeName]]

The relationship type disjunction of a relationship pattern.

TYPE_ = Name(value='hydra.cypher.openCypher.RelationshipTypes')

class hydra.cypher.open_cypher.RelationshipsPattern(node_pattern: NodePattern, chain: Sequence[PatternElementChain])

Bases: object

A relationship pattern chain anchored at a node pattern.

class Builder(_node_pattern: 'NodePattern' = None, _chain: 'Sequence[PatternElementChain]' = None)

Bases: object

build()

chain(chain)

node_pattern(node_pattern)

CHAIN = Name(value='chain')

NODE_PATTERN = Name(value='nodePattern')

TYPE_ = Name(value='hydra.cypher.openCypher.RelationshipsPattern')

static builder()

chain: Sequence[PatternElementChain]

node_pattern: NodePattern

with_chain(chain)

with_node_pattern(node_pattern)

class hydra.cypher.open_cypher.Remove(value: T)

Bases: Node[Sequence[RemoveItem]]

A REMOVE clause removing properties or labels.

TYPE_ = Name(value='hydra.cypher.openCypher.Remove')

class hydra.cypher.open_cypher.RemoveItem

Bases: object

RemoveItemVariableLabels | RemoveItemProperty

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.cypher.openCypher.RemoveItem')

VARIABLE_LABELS = Name(value='variableLabels')

class hydra.cypher.open_cypher.RemoveItemProperty(value: T): Bases: Node[PropertyExpression]

class hydra.cypher.open_cypher.RemoveItemVariableLabels(value: T): Bases: Node[VariableAndNodeLabels]

class hydra.cypher.open_cypher.Return(value: T)

Bases: Node[ProjectionBody]

The RETURN clause: a projection body producing the query’s result.

TYPE_ = Name(value='hydra.cypher.openCypher.Return')

class hydra.cypher.open_cypher.Set(value: T)

Bases: Node[Sequence[SetItem]]

A SET clause updating properties or labels.

TYPE_ = Name(value='hydra.cypher.openCypher.Set')

class hydra.cypher.open_cypher.SetItem

Bases: object

SetItemProperty | SetItemVariableEqual | SetItemVariablePlusEqual | SetItemVariableLabels

PROPERTY = Name(value='property')

TYPE_ = Name(value='hydra.cypher.openCypher.SetItem')

VARIABLE_EQUAL = Name(value='variableEqual')

VARIABLE_LABELS = Name(value='variableLabels')

VARIABLE_PLUS_EQUAL = Name(value='variablePlusEqual')

class hydra.cypher.open_cypher.SetItemProperty(value: T): Bases: Node[PropertyEquals]

class hydra.cypher.open_cypher.SetItemVariableEqual(value: T): Bases: Node[VariableEquals]

class hydra.cypher.open_cypher.SetItemVariableLabels(value: T): Bases: Node[VariableAndNodeLabels]

class hydra.cypher.open_cypher.SetItemVariablePlusEqual(value: T): Bases: Node[VariablePlusEquals]

class hydra.cypher.open_cypher.SinglePartQuery(reading: Sequence[ReadingClause], updating: Sequence[UpdatingClause], return_: object)

Bases: object

A single-part query: reading and updating clauses followed by an optional RETURN clause.

class Builder(_reading: 'Sequence[ReadingClause]' = None, _updating: 'Sequence[UpdatingClause]' = None, _return_: 'Optional[Return]' = None)

Bases: object

build()

reading(reading)

return_(return_)

updating(updating)

READING = Name(value='reading')

RETURN = Name(value='return')

TYPE_ = Name(value='hydra.cypher.openCypher.SinglePartQuery')

UPDATING = Name(value='updating')

static builder()

reading: Sequence[ReadingClause]

return_: object

updating: Sequence[UpdatingClause]

with_reading(reading)

with_return_(return_)

with_updating(updating)

class hydra.cypher.open_cypher.SingleQuery

Bases: object

SingleQuerySinglePart | SingleQueryMultiPart

MULTI_PART = Name(value='multiPart')

SINGLE_PART = Name(value='singlePart')

TYPE_ = Name(value='hydra.cypher.openCypher.SingleQuery')

class hydra.cypher.open_cypher.SingleQueryMultiPart(value: T): Bases: Node[MultiPartQuery]

class hydra.cypher.open_cypher.SingleQuerySinglePart(value: T): Bases: Node[SinglePartQuery]

class hydra.cypher.open_cypher.Skip(value: T)

Bases: Node[Expression]

A SKIP clause limiting the starting offset of results.

TYPE_ = Name(value='hydra.cypher.openCypher.Skip')

class hydra.cypher.open_cypher.SortItem(expression: Expression, order: object)

Bases: object

One item of an ORDER BY clause: an expression and its sort order.

class Builder(_expression: 'Expression' = None, _order: 'Optional[SortOrder]' = None)

Bases: object

build()

expression(expression)

order(order)

EXPRESSION = Name(value='expression')

ORDER = Name(value='order')

TYPE_ = Name(value='hydra.cypher.openCypher.SortItem')

static builder()

expression: Expression

order: object

with_expression(expression)

with_order(order)

class hydra.cypher.open_cypher.SortOrder(*values)

Bases: Enum

The sort order of a sort item: ascending or descending.

ASCENDING = Name(value='ascending')

DESCENDING = Name(value='descending')

TYPE_ = Name(value='hydra.cypher.openCypher.SortOrder')

class hydra.cypher.open_cypher.StandaloneCall(call: ProcedureInvocation, yield_items: object)

Bases: object

A standalone CALL statement invoking a procedure without a surrounding query.

class Builder(_call: 'ProcedureInvocation' = None, _yield_items: 'Optional[StarOrYieldItems]' = None)

Bases: object

build()

call(call)

yield_items(yield_items)

CALL = Name(value='call')

TYPE_ = Name(value='hydra.cypher.openCypher.StandaloneCall')

YIELD_ITEMS = Name(value='yieldItems')

static builder()

call: ProcedureInvocation

with_call(call)

with_yield_items(yield_items)

yield_items: object

class hydra.cypher.open_cypher.StarOrYieldItems

Bases: object

StarOrYieldItemsStar | StarOrYieldItemsItems

ITEMS = Name(value='items')

STAR = Name(value='star')

TYPE_ = Name(value='hydra.cypher.openCypher.StarOrYieldItems')

class hydra.cypher.open_cypher.StarOrYieldItemsItems(value: T): Bases: Node[YieldItems]

class hydra.cypher.open_cypher.StarOrYieldItemsStar: Bases: object

class hydra.cypher.open_cypher.StringListNullPredicateExpression(left: AddOrSubtractExpression, right: Sequence[StringListNullPredicateRightHandSide])

Bases: object

An add/subtract expression with zero or more string, list, or null predicates.

class Builder(_left: 'AddOrSubtractExpression' = None, _right: 'Sequence[StringListNullPredicateRightHandSide]' = None)

Bases: object

build()

left(left)

right(right)

LEFT = Name(value='left')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.cypher.openCypher.StringListNullPredicateExpression')

static builder()

left: AddOrSubtractExpression

right: Sequence[StringListNullPredicateRightHandSide]

with_left(left)

with_right(right)

class hydra.cypher.open_cypher.StringListNullPredicateRightHandSide

Bases: object

StringListNullPredicateRightHandSideString | StringListNullPredicateRightHandSideList | StringListNullPredicateRightHandSideNull

LIST = Name(value='list')

NULL = Name(value='null')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.cypher.openCypher.StringListNullPredicateRightHandSide')

class hydra.cypher.open_cypher.StringListNullPredicateRightHandSideList(value: T): Bases: Node[ListPredicateExpression]

class hydra.cypher.open_cypher.StringListNullPredicateRightHandSideNull(value: T): Bases: Node[NullPredicateExpression]

class hydra.cypher.open_cypher.StringListNullPredicateRightHandSideString(value: T): Bases: Node[StringPredicateExpression]

class hydra.cypher.open_cypher.StringLiteral(value: T)

Bases: Node[str]

A string literal.

TYPE_ = Name(value='hydra.cypher.openCypher.StringLiteral')

class hydra.cypher.open_cypher.StringPredicateExpression(operator: StringPredicateOperator, expression: AddOrSubtractExpression)

Bases: object

A string predicate: STARTS WITH, ENDS WITH, or CONTAINS.

class Builder(_operator: 'StringPredicateOperator' = None, _expression: 'AddOrSubtractExpression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.cypher.openCypher.StringPredicateExpression')

static builder()

expression: AddOrSubtractExpression

operator: StringPredicateOperator

with_expression(expression)

with_operator(operator)

class hydra.cypher.open_cypher.StringPredicateOperator(*values)

Bases: Enum

A string predicate operator: STARTS WITH, ENDS WITH, or CONTAINS.

CONTAINS = Name(value='contains')

ENDS_WITH = Name(value='endsWith')

STARTS_WITH = Name(value='startsWith')

TYPE_ = Name(value='hydra.cypher.openCypher.StringPredicateOperator')

class hydra.cypher.open_cypher.UnaryAddOrSubtractExpression(operator: object, expression: NonArithmeticOperatorExpression)

Bases: object

A unary plus or minus applied to a list-operator expression.

class Builder(_operator: 'Optional[AddOrSubtractOperator]' = None, _expression: 'NonArithmeticOperatorExpression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.cypher.openCypher.UnaryAddOrSubtractExpression')

static builder()

expression: NonArithmeticOperatorExpression

operator: object

with_expression(expression)

with_operator(operator)

class hydra.cypher.open_cypher.Union(all: bool, query: SingleQuery)

Bases: object

A UNION combining a single query with a preceding query, with optional ALL semantics.

ALL = Name(value='all')

class Builder(_all: 'bool' = None, _query: 'SingleQuery' = None)

Bases: object

all(all)

build()

query(query)

QUERY = Name(value='query')

TYPE_ = Name(value='hydra.cypher.openCypher.Union')

all: bool

static builder()

query: SingleQuery

with_all(all)

with_query(query)

class hydra.cypher.open_cypher.Unwind(expression: Expression, variable: Variable)

Bases: object

An UNWIND clause expanding a list expression into bound rows.

class Builder(_expression: 'Expression' = None, _variable: 'Variable' = None)

Bases: object

build()

expression(expression)

variable(variable)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.cypher.openCypher.Unwind')

VARIABLE = Name(value='variable')

static builder()

expression: Expression

variable: Variable

with_expression(expression)

with_variable(variable)

class hydra.cypher.open_cypher.UpdatingClause

Bases: object

UpdatingClauseCreate | UpdatingClauseMerge | UpdatingClauseDelete | UpdatingClauseSet | UpdatingClauseRemove

CREATE = Name(value='create')

DELETE = Name(value='delete')

MERGE = Name(value='merge')

REMOVE = Name(value='remove')

SET = Name(value='set')

TYPE_ = Name(value='hydra.cypher.openCypher.UpdatingClause')

class hydra.cypher.open_cypher.UpdatingClauseCreate(value: T): Bases: Node[Create]

class hydra.cypher.open_cypher.UpdatingClauseDelete(value: T): Bases: Node[Delete]

class hydra.cypher.open_cypher.UpdatingClauseMerge(value: T): Bases: Node[Merge]

class hydra.cypher.open_cypher.UpdatingClauseRemove(value: T): Bases: Node[Remove]

class hydra.cypher.open_cypher.UpdatingClauseSet(value: T): Bases: Node[Set]

class hydra.cypher.open_cypher.Variable(value: T)

Bases: Node[str]

A variable name.

TYPE_ = Name(value='hydra.cypher.openCypher.Variable')

class hydra.cypher.open_cypher.VariableAndNodeLabels(variable: Variable, labels: NodeLabels)

Bases: object

A variable together with node labels to set, as in SET n:Label.

class Builder(_variable: 'Variable' = None, _labels: 'NodeLabels' = None)

Bases: object

build()

labels(labels)

variable(variable)

LABELS = Name(value='labels')

TYPE_ = Name(value='hydra.cypher.openCypher.VariableAndNodeLabels')

VARIABLE = Name(value='variable')

static builder()

labels: NodeLabels

variable: Variable

with_labels(labels)

with_variable(variable)

class hydra.cypher.open_cypher.VariableEquals(lhs: Variable, rhs: Expression)

Bases: object

A variable assignment of the form variable = expression.

class Builder(_lhs: 'Variable' = None, _rhs: 'Expression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.cypher.openCypher.VariableEquals')

static builder()

lhs: Variable

rhs: Expression

with_lhs(lhs)

with_rhs(rhs)

class hydra.cypher.open_cypher.VariablePlusEquals(lhs: Variable, rhs: Expression)

Bases: object

A variable increment assignment of the form variable += expression.

class Builder(_lhs: 'Variable' = None, _rhs: 'Expression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.cypher.openCypher.VariablePlusEquals')

static builder()

lhs: Variable

rhs: Expression

with_lhs(lhs)

with_rhs(rhs)

class hydra.cypher.open_cypher.Where(value: T)

Bases: Node[Expression]

A WHERE clause filtering by an expression.

TYPE_ = Name(value='hydra.cypher.openCypher.Where')

class hydra.cypher.open_cypher.With(projection: ProjectionBody, where: object)

Bases: object

The WITH keyword clause: a projection body carrying values forward.

class Builder(_projection: 'ProjectionBody' = None, _where: 'Optional[Where]' = None)

Bases: object

build()

projection(projection)

where(where)

PROJECTION = Name(value='projection')

TYPE_ = Name(value='hydra.cypher.openCypher.With')

WHERE = Name(value='where')

static builder()

projection: ProjectionBody

where: object

with_projection(projection)

with_where(where)

class hydra.cypher.open_cypher.WithClause(reading: Sequence[ReadingClause], updating: Sequence[UpdatingClause], with_: With)

Bases: object

A WITH clause carrying projected values forward, with optional WHERE filtering.

class Builder(_reading: 'Sequence[ReadingClause]' = None, _updating: 'Sequence[UpdatingClause]' = None, _with_: 'With' = None)

Bases: object

build()

reading(reading)

updating(updating)

with_(with_)

READING = Name(value='reading')

TYPE_ = Name(value='hydra.cypher.openCypher.WithClause')

UPDATING = Name(value='updating')

WITH = Name(value='with')

static builder()

reading: Sequence[ReadingClause]

updating: Sequence[UpdatingClause]

with_: With

with_reading(reading)

with_updating(updating)

with_with_(with_)

class hydra.cypher.open_cypher.XorExpression(value: T)

Bases: Node[Sequence[AndExpression]]

An exclusive-or of AND expressions.

TYPE_ = Name(value='hydra.cypher.openCypher.XorExpression')

class hydra.cypher.open_cypher.YieldItem(field: object, variable: Variable)

Bases: object

One yielded field of a procedure call, with an optional alias.

class Builder(_field: 'Optional[ProcedureResultField]' = None, _variable: 'Variable' = None)

Bases: object

build()

field(field)

variable(variable)

FIELD = Name(value='field')

TYPE_ = Name(value='hydra.cypher.openCypher.YieldItem')

VARIABLE = Name(value='variable')

static builder()

field: object

variable: Variable

with_field(field)

with_variable(variable)

class hydra.cypher.open_cypher.YieldItems(items: Sequence[YieldItem], where: object)

Bases: object

The YIELD items of a standalone CALL, with an optional WHERE clause.

class Builder(_items: 'Sequence[YieldItem]' = None, _where: 'Optional[Where]' = None)

Bases: object

build()

items(items)

where(where)

ITEMS = Name(value='items')

TYPE_ = Name(value='hydra.cypher.openCypher.YieldItems')

WHERE = Name(value='where')

static builder()

items: Sequence[YieldItem]

where: object

with_items(items)

with_where(where)