hydra.cypher.features module

A model for characterizing OpenCypher queries and implementations in terms of included features.Based on the OpenCypher grammar and the list of standard Cypher functions at https://neo4j.com/docs/cypher-manual/current/functions. Current as of August 2024.

class hydra.cypher.features.AggregateFunctionFeatures(avg: Annotated[bool, 'The avg() function / AVG. Returns the average of a set of DURATION values.; Returns the average of a set of FLOAT values.; Returns the average of a set of INTEGER values.'], collect: Annotated[bool, 'The collect() function / COLLECT. Returns a list containing the values returned by an expression.'], count: Annotated[bool, 'The count() function / COUNT. Returns the number of values or rows.'], max: Annotated[bool, 'The max() function / MAX. Returns the maximum value in a set of values.'], min: Annotated[bool, 'The min() function / MIN. Returns the minimum value in a set of values.'], percentile_cont: Annotated[bool, 'The percentileCont() function. Returns the percentile of a value over a group using linear interpolation.'], percentile_disc: Annotated[bool, 'The percentileDisc() function. Returns the nearest FLOAT value to the given percentile over a group using a rounding method.; Returns the nearest INTEGER value to the given percentile over a group using a rounding method.'], stdev: Annotated[bool, 'The stdev() function. Returns the standard deviation for the given value over a group for a sample of a population.'], stdevp: Annotated[bool, 'The stdevp() function. Returns the standard deviation for the given value over a group for an entire population.'], sum: Annotated[bool, 'The sum() function / SUM. Returns the sum of a set of DURATION values.; Returns the sum of a set of FLOAT values.; Returns the sum of a set of INTEGER values.'])

Bases: object

Aggregate functions.

AVG = Name(value='avg')
class Builder(_avg: 'bool' = None, _collect: 'bool' = None, _count: 'bool' = None, _max: 'bool' = None, _min: 'bool' = None, _percentile_cont: 'bool' = None, _percentile_disc: 'bool' = None, _stdev: 'bool' = None, _stdevp: 'bool' = None, _sum: 'bool' = None)

Bases: object

avg(avg)
build()
collect(collect)
count(count)
max(max)
min(min)
percentile_cont(percentile_cont)
percentile_disc(percentile_disc)
stdev(stdev)
stdevp(stdevp)
sum(sum)
COLLECT = Name(value='collect')
COUNT = Name(value='count')
MAX = Name(value='max')
MIN = Name(value='min')
PERCENTILE_CONT = Name(value='percentileCont')
PERCENTILE_DISC = Name(value='percentileDisc')
STDEV = Name(value='stdev')
STDEVP = Name(value='stdevp')
SUM = Name(value='sum')
TYPE_ = Name(value='hydra.cypher.features.AggregateFunctionFeatures')
avg: Annotated[bool, 'The avg() function / AVG. Returns the average of a set of DURATION values.; Returns the average of a set of FLOAT values.; Returns the average of a set of INTEGER values.']
static builder()
collect: Annotated[bool, 'The collect() function / COLLECT. Returns a list containing the values returned by an expression.']
count: Annotated[bool, 'The count() function / COUNT. Returns the number of values or rows.']
max: Annotated[bool, 'The max() function / MAX. Returns the maximum value in a set of values.']
min: Annotated[bool, 'The min() function / MIN. Returns the minimum value in a set of values.']
percentile_cont: Annotated[bool, 'The percentileCont() function. Returns the percentile of a value over a group using linear interpolation.']
percentile_disc: Annotated[bool, 'The percentileDisc() function. Returns the nearest FLOAT value to the given percentile over a group using a rounding method.; Returns the nearest INTEGER value to the given percentile over a group using a rounding method.']
stdev: Annotated[bool, 'The stdev() function. Returns the standard deviation for the given value over a group for a sample of a population.']
stdevp: Annotated[bool, 'The stdevp() function. Returns the standard deviation for the given value over a group for an entire population.']
sum: Annotated[bool, 'The sum() function / SUM. Returns the sum of a set of DURATION values.; Returns the sum of a set of FLOAT values.; Returns the sum of a set of INTEGER values.']
with_avg(avg)
with_collect(collect)
with_count(count)
with_max(max)
with_min(min)
with_percentile_cont(percentile_cont)
with_percentile_disc(percentile_disc)
with_stdev(stdev)
with_stdevp(stdevp)
with_sum(sum)
class hydra.cypher.features.ArithmeticFeatures(plus: Annotated[bool, 'The + operator'], minus: Annotated[bool, 'The - operator'], multiply: Annotated[bool, 'The * operator'], divide: Annotated[bool, 'The / operator'], modulus: Annotated[bool, 'The % operator'], power_of: Annotated[bool, 'The ^ operator'])

Bases: object

Arithmetic operations.

class Builder(_plus: 'bool' = None, _minus: 'bool' = None, _multiply: 'bool' = None, _divide: 'bool' = None, _modulus: 'bool' = None, _power_of: 'bool' = None)

Bases: object

build()
divide(divide)
minus(minus)
modulus(modulus)
multiply(multiply)
plus(plus)
power_of(power_of)
DIVIDE = Name(value='divide')
MINUS = Name(value='minus')
MODULUS = Name(value='modulus')
MULTIPLY = Name(value='multiply')
PLUS = Name(value='plus')
POWER_OF = Name(value='powerOf')
TYPE_ = Name(value='hydra.cypher.features.ArithmeticFeatures')
static builder()
divide: Annotated[bool, 'The / operator']
minus: Annotated[bool, 'The - operator']
modulus: Annotated[bool, 'The % operator']
multiply: Annotated[bool, 'The * operator']
plus: Annotated[bool, 'The + operator']
power_of: Annotated[bool, 'The ^ operator']
with_divide(divide)
with_minus(minus)
with_modulus(modulus)
with_multiply(multiply)
with_plus(plus)
with_power_of(power_of)
class hydra.cypher.features.AtomFeatures(case_expression: Annotated[bool, 'CASE expressions'], count: Annotated[bool, 'The COUNT (*) expression'], existential_subquery: Annotated[bool, 'Existential subqueries'], function_invocation: Annotated[bool, 'Function invocation'], parameter: Annotated[bool, 'Parameter expressions'], pattern_comprehension: Annotated[bool, 'Pattern comprehensions'], pattern_predicate: Annotated[bool, 'Relationship patterns as subexpressions'], variable: Annotated[bool, 'Variable expressions (note: included by most if not all implementations).'])

Bases: object

Various kinds of atomic expressions.

class Builder(_case_expression: 'bool' = None, _count: 'bool' = None, _existential_subquery: 'bool' = None, _function_invocation: 'bool' = None, _parameter: 'bool' = None, _pattern_comprehension: 'bool' = None, _pattern_predicate: 'bool' = None, _variable: 'bool' = None)

Bases: object

build()
case_expression(case_expression)
count(count)
existential_subquery(existential_subquery)
function_invocation(function_invocation)
parameter(parameter)
pattern_comprehension(pattern_comprehension)
pattern_predicate(pattern_predicate)
variable(variable)
CASE_EXPRESSION = Name(value='caseExpression')
COUNT = Name(value='count')
EXISTENTIAL_SUBQUERY = Name(value='existentialSubquery')
FUNCTION_INVOCATION = Name(value='functionInvocation')
PARAMETER = Name(value='parameter')
PATTERN_COMPREHENSION = Name(value='patternComprehension')
PATTERN_PREDICATE = Name(value='patternPredicate')
TYPE_ = Name(value='hydra.cypher.features.AtomFeatures')
VARIABLE = Name(value='variable')
static builder()
case_expression: Annotated[bool, 'CASE expressions']
count: Annotated[bool, 'The COUNT (*) expression']
existential_subquery: Annotated[bool, 'Existential subqueries']
function_invocation: Annotated[bool, 'Function invocation']
parameter: Annotated[bool, 'Parameter expressions']
pattern_comprehension: Annotated[bool, 'Pattern comprehensions']
pattern_predicate: Annotated[bool, 'Relationship patterns as subexpressions']
variable: Annotated[bool, 'Variable expressions (note: included by most if not all implementations).']
with_case_expression(case_expression)
with_count(count)
with_existential_subquery(existential_subquery)
with_function_invocation(function_invocation)
with_parameter(parameter)
with_pattern_comprehension(pattern_comprehension)
with_pattern_predicate(pattern_predicate)
with_variable(variable)
class hydra.cypher.features.ComparisonFeatures(equal: Annotated[bool, 'The = comparison operator'], greater_than: Annotated[bool, 'The > comparison operator'], greater_than_or_equal: Annotated[bool, 'The >= comparison operator'], less_than: Annotated[bool, 'The < comparison operator'], less_than_or_equal: Annotated[bool, 'The <= comparison operator'], not_equal: Annotated[bool, 'The <> comparison operator'])

Bases: object

Comparison operators and functions.

class Builder(_equal: 'bool' = None, _greater_than: 'bool' = None, _greater_than_or_equal: 'bool' = None, _less_than: 'bool' = None, _less_than_or_equal: 'bool' = None, _not_equal: 'bool' = None)

Bases: object

build()
equal(equal)
greater_than(greater_than)
greater_than_or_equal(greater_than_or_equal)
less_than(less_than)
less_than_or_equal(less_than_or_equal)
not_equal(not_equal)
EQUAL = Name(value='equal')
GREATER_THAN = Name(value='greaterThan')
GREATER_THAN_OR_EQUAL = Name(value='greaterThanOrEqual')
LESS_THAN = Name(value='lessThan')
LESS_THAN_OR_EQUAL = Name(value='lessThanOrEqual')
NOT_EQUAL = Name(value='notEqual')
TYPE_ = Name(value='hydra.cypher.features.ComparisonFeatures')
static builder()
equal: Annotated[bool, 'The = comparison operator']
greater_than: Annotated[bool, 'The > comparison operator']
greater_than_or_equal: Annotated[bool, 'The >= comparison operator']
less_than: Annotated[bool, 'The < comparison operator']
less_than_or_equal: Annotated[bool, 'The <= comparison operator']
not_equal: Annotated[bool, 'The <> comparison operator']
with_equal(equal)
with_greater_than(greater_than)
with_greater_than_or_equal(greater_than_or_equal)
with_less_than(less_than)
with_less_than_or_equal(less_than_or_equal)
with_not_equal(not_equal)
class hydra.cypher.features.CypherFeatures(arithmetic: Annotated[ArithmeticFeatures, 'Arithmetic operations'], atom: Annotated[AtomFeatures, 'Various kinds of atomic expressions'], comparison: Annotated[ComparisonFeatures, 'Comparison operators and functions'], delete: Annotated[DeleteFeatures, 'Delete operations'], function: Annotated[FunctionFeatures, 'Standard Cypher functions'], list: Annotated[ListFeatures, 'List functionality'], literal: Annotated[LiteralFeatures, 'Various types of literal values'], logical: Annotated[LogicalFeatures, 'Logical operations'], match: Annotated[MatchFeatures, 'Match queries'], merge: Annotated[MergeFeatures, 'Merge operations'], node_pattern: Annotated[NodePatternFeatures, 'Node patterns'], null: Annotated[NullFeatures, 'IS NULL / IS NOT NULL checks'], path: Annotated[PathFeatures, 'Path functions only found in OpenCypher'], procedure_call: Annotated[ProcedureCallFeatures, 'Procedure calls'], projection: Annotated[ProjectionFeatures, 'Projections'], quantifier: Annotated[QuantifierFeatures, 'Quantifier expressions'], range_literal: Annotated[RangeLiteralFeatures, 'Range literals within relationship patterns'], reading: Annotated[ReadingFeatures, 'Specific syntax related to reading data from the graph.'], relationship_direction: Annotated[RelationshipDirectionFeatures, 'Relationship directions / arrow patterns'], relationship_pattern: Annotated[RelationshipPatternFeatures, 'Relationship patterns'], remove: Annotated[RemoveFeatures, 'REMOVE operations'], set: Annotated[SetFeatures, 'Set definitions'], string: Annotated[StringFeatures, 'String functions/keywords only found in OpenCypher'], updating: Annotated[UpdatingFeatures, 'Specific syntax related to updating data in the graph'])

Bases: object

A set of features which characterize an OpenCypher query or implementation. Any features which are omitted from the set are assumed to be unsupported or nonrequired.

ARITHMETIC = Name(value='arithmetic')
ATOM = Name(value='atom')
class Builder(_arithmetic: 'ArithmeticFeatures' = None, _atom: 'AtomFeatures' = None, _comparison: 'ComparisonFeatures' = None, _delete: 'DeleteFeatures' = None, _function: 'FunctionFeatures' = None, _list: 'ListFeatures' = None, _literal: 'LiteralFeatures' = None, _logical: 'LogicalFeatures' = None, _match: 'MatchFeatures' = None, _merge: 'MergeFeatures' = None, _node_pattern: 'NodePatternFeatures' = None, _null: 'NullFeatures' = None, _path: 'PathFeatures' = None, _procedure_call: 'ProcedureCallFeatures' = None, _projection: 'ProjectionFeatures' = None, _quantifier: 'QuantifierFeatures' = None, _range_literal: 'RangeLiteralFeatures' = None, _reading: 'ReadingFeatures' = None, _relationship_direction: 'RelationshipDirectionFeatures' = None, _relationship_pattern: 'RelationshipPatternFeatures' = None, _remove: 'RemoveFeatures' = None, _set: 'SetFeatures' = None, _string: 'StringFeatures' = None, _updating: 'UpdatingFeatures' = None)

Bases: object

arithmetic(arithmetic)
atom(atom)
build()
comparison(comparison)
delete(delete)
function(function)
list(list)
literal(literal)
logical(logical)
match(match)
merge(merge)
node_pattern(node_pattern)
null(null)
path(path)
procedure_call(procedure_call)
projection(projection)
quantifier(quantifier)
range_literal(range_literal)
reading(reading)
relationship_direction(relationship_direction)
relationship_pattern(relationship_pattern)
remove(remove)
set(set)
string(string)
updating(updating)
COMPARISON = Name(value='comparison')
DELETE = Name(value='delete')
FUNCTION = Name(value='function')
LIST = Name(value='list')
LITERAL = Name(value='literal')
LOGICAL = Name(value='logical')
MATCH = Name(value='match')
MERGE = Name(value='merge')
NODE_PATTERN = Name(value='nodePattern')
NULL = Name(value='null')
PATH = Name(value='path')
PROCEDURE_CALL = Name(value='procedureCall')
PROJECTION = Name(value='projection')
QUANTIFIER = Name(value='quantifier')
RANGE_LITERAL = Name(value='rangeLiteral')
READING = Name(value='reading')
RELATIONSHIP_DIRECTION = Name(value='relationshipDirection')
RELATIONSHIP_PATTERN = Name(value='relationshipPattern')
REMOVE = Name(value='remove')
SET = Name(value='set')
STRING = Name(value='string')
TYPE_ = Name(value='hydra.cypher.features.CypherFeatures')
UPDATING = Name(value='updating')
arithmetic: Annotated[ArithmeticFeatures, 'Arithmetic operations']
atom: Annotated[AtomFeatures, 'Various kinds of atomic expressions']
static builder()
comparison: Annotated[ComparisonFeatures, 'Comparison operators and functions']
delete: Annotated[DeleteFeatures, 'Delete operations']
function: Annotated[FunctionFeatures, 'Standard Cypher functions']
list: Annotated[ListFeatures, 'List functionality']
literal: Annotated[LiteralFeatures, 'Various types of literal values']
logical: Annotated[LogicalFeatures, 'Logical operations']
match: Annotated[MatchFeatures, 'Match queries']
merge: Annotated[MergeFeatures, 'Merge operations']
node_pattern: Annotated[NodePatternFeatures, 'Node patterns']
null: Annotated[NullFeatures, 'IS NULL / IS NOT NULL checks']
path: Annotated[PathFeatures, 'Path functions only found in OpenCypher']
procedure_call: Annotated[ProcedureCallFeatures, 'Procedure calls']
projection: Annotated[ProjectionFeatures, 'Projections']
quantifier: Annotated[QuantifierFeatures, 'Quantifier expressions']
range_literal: Annotated[RangeLiteralFeatures, 'Range literals within relationship patterns']
reading: Annotated[ReadingFeatures, 'Specific syntax related to reading data from the graph.']
relationship_direction: Annotated[RelationshipDirectionFeatures, 'Relationship directions / arrow patterns']
relationship_pattern: Annotated[RelationshipPatternFeatures, 'Relationship patterns']
remove: Annotated[RemoveFeatures, 'REMOVE operations']
set: Annotated[SetFeatures, 'Set definitions']
string: Annotated[StringFeatures, 'String functions/keywords only found in OpenCypher']
updating: Annotated[UpdatingFeatures, 'Specific syntax related to updating data in the graph']
with_arithmetic(arithmetic)
with_atom(atom)
with_comparison(comparison)
with_delete(delete)
with_function(function)
with_list(list)
with_literal(literal)
with_logical(logical)
with_match(match)
with_merge(merge)
with_node_pattern(node_pattern)
with_null(null)
with_path(path)
with_procedure_call(procedure_call)
with_projection(projection)
with_quantifier(quantifier)
with_range_literal(range_literal)
with_reading(reading)
with_relationship_direction(relationship_direction)
with_relationship_pattern(relationship_pattern)
with_remove(remove)
with_set(set)
with_string(string)
with_updating(updating)
class hydra.cypher.features.DatabaseFunctionFeatures(db_name_from_element_id: Annotated[bool, 'The db.nameFromElementId() function. Resolves the database name from the given element id. Introduced in 5.12.'])

Bases: object

Database functions.

class Builder(_db_name_from_element_id: 'bool' = None)

Bases: object

build()
db_name_from_element_id(db_name_from_element_id)
DB_NAME_FROM_ELEMENT_ID = Name(value='dbNameFromElementId')
TYPE_ = Name(value='hydra.cypher.features.DatabaseFunctionFeatures')
static builder()
db_name_from_element_id: Annotated[bool, 'The db.nameFromElementId() function. Resolves the database name from the given element id. Introduced in 5.12.']
with_db_name_from_element_id(db_name_from_element_id)
class hydra.cypher.features.DeleteFeatures(delete: Annotated[bool, 'The basic DELETE clause'], detach_delete: Annotated[bool, 'The DETACH DELETE clause'])

Bases: object

Delete operations.

class Builder(_delete: 'bool' = None, _detach_delete: 'bool' = None)

Bases: object

build()
delete(delete)
detach_delete(detach_delete)
DELETE = Name(value='delete')
DETACH_DELETE = Name(value='detachDelete')
TYPE_ = Name(value='hydra.cypher.features.DeleteFeatures')
static builder()
delete: Annotated[bool, 'The basic DELETE clause']
detach_delete: Annotated[bool, 'The DETACH DELETE clause']
with_delete(delete)
with_detach_delete(detach_delete)
class hydra.cypher.features.FunctionFeatures(aggregate_function: Annotated[AggregateFunctionFeatures, 'Aggregate functions'], database_function: Annotated[DatabaseFunctionFeatures, 'Database functions'], gen_a_i_function: Annotated[GenAIFunctionFeatures, 'GenAI functions'], graph_function: Annotated[GraphFunctionFeatures, 'Graph functions'], list_function: Annotated[ListFunctionFeatures, 'List functions'], load_c_s_v_function: Annotated[LoadCSVFunctionFeatures, 'Load CSV functions'], logarithmic_function: Annotated[LogarithmicFunctionFeatures, 'Logarithmic functions'], numeric_function: Annotated[NumericFunctionFeatures, 'Numeric functions'], predicate_function: Annotated[PredicateFunctionFeatures, 'Predicate functions'], scalar_function: Annotated[ScalarFunctionFeatures, 'Scalar functions'], spatial_function: Annotated[SpatialFunctionFeatures, 'Spatial functions'], string_function: Annotated[StringFunctionFeatures, 'String functions'], temporal_duration_function: Annotated[TemporalDurationFunctionFeatures, 'Temporal duration functions'], temporal_instant_function: Annotated[TemporalInstantFunctionFeatures, 'Temporal instant functions'], trigonometric_function: Annotated[TrigonometricFunctionFeatures, 'Trigonometric functions'], vector_function: Annotated[VectorFunctionFeatures, 'Vector functions'])

Bases: object

Standard Cypher functions.

AGGREGATE_FUNCTION = Name(value='aggregateFunction')
class Builder(_aggregate_function: 'AggregateFunctionFeatures' = None, _database_function: 'DatabaseFunctionFeatures' = None, _gen_a_i_function: 'GenAIFunctionFeatures' = None, _graph_function: 'GraphFunctionFeatures' = None, _list_function: 'ListFunctionFeatures' = None, _load_c_s_v_function: 'LoadCSVFunctionFeatures' = None, _logarithmic_function: 'LogarithmicFunctionFeatures' = None, _numeric_function: 'NumericFunctionFeatures' = None, _predicate_function: 'PredicateFunctionFeatures' = None, _scalar_function: 'ScalarFunctionFeatures' = None, _spatial_function: 'SpatialFunctionFeatures' = None, _string_function: 'StringFunctionFeatures' = None, _temporal_duration_function: 'TemporalDurationFunctionFeatures' = None, _temporal_instant_function: 'TemporalInstantFunctionFeatures' = None, _trigonometric_function: 'TrigonometricFunctionFeatures' = None, _vector_function: 'VectorFunctionFeatures' = None)

Bases: object

aggregate_function(aggregate_function)
build()
database_function(database_function)
gen_a_i_function(gen_a_i_function)
graph_function(graph_function)
list_function(list_function)
load_c_s_v_function(load_c_s_v_function)
logarithmic_function(logarithmic_function)
numeric_function(numeric_function)
predicate_function(predicate_function)
scalar_function(scalar_function)
spatial_function(spatial_function)
string_function(string_function)
temporal_duration_function(temporal_duration_function)
temporal_instant_function(temporal_instant_function)
trigonometric_function(trigonometric_function)
vector_function(vector_function)
DATABASE_FUNCTION = Name(value='databaseFunction')
GEN_A_I_FUNCTION = Name(value='genAIFunction')
GRAPH_FUNCTION = Name(value='graphFunction')
LIST_FUNCTION = Name(value='listFunction')
LOAD_C_S_V_FUNCTION = Name(value='loadCSVFunction')
LOGARITHMIC_FUNCTION = Name(value='logarithmicFunction')
NUMERIC_FUNCTION = Name(value='numericFunction')
PREDICATE_FUNCTION = Name(value='predicateFunction')
SCALAR_FUNCTION = Name(value='scalarFunction')
SPATIAL_FUNCTION = Name(value='spatialFunction')
STRING_FUNCTION = Name(value='stringFunction')
TEMPORAL_DURATION_FUNCTION = Name(value='temporalDurationFunction')
TEMPORAL_INSTANT_FUNCTION = Name(value='temporalInstantFunction')
TRIGONOMETRIC_FUNCTION = Name(value='trigonometricFunction')
TYPE_ = Name(value='hydra.cypher.features.FunctionFeatures')
VECTOR_FUNCTION = Name(value='vectorFunction')
aggregate_function: Annotated[AggregateFunctionFeatures, 'Aggregate functions']
static builder()
database_function: Annotated[DatabaseFunctionFeatures, 'Database functions']
gen_a_i_function: Annotated[GenAIFunctionFeatures, 'GenAI functions']
graph_function: Annotated[GraphFunctionFeatures, 'Graph functions']
list_function: Annotated[ListFunctionFeatures, 'List functions']
load_c_s_v_function: Annotated[LoadCSVFunctionFeatures, 'Load CSV functions']
logarithmic_function: Annotated[LogarithmicFunctionFeatures, 'Logarithmic functions']
numeric_function: Annotated[NumericFunctionFeatures, 'Numeric functions']
predicate_function: Annotated[PredicateFunctionFeatures, 'Predicate functions']
scalar_function: Annotated[ScalarFunctionFeatures, 'Scalar functions']
spatial_function: Annotated[SpatialFunctionFeatures, 'Spatial functions']
string_function: Annotated[StringFunctionFeatures, 'String functions']
temporal_duration_function: Annotated[TemporalDurationFunctionFeatures, 'Temporal duration functions']
temporal_instant_function: Annotated[TemporalInstantFunctionFeatures, 'Temporal instant functions']
trigonometric_function: Annotated[TrigonometricFunctionFeatures, 'Trigonometric functions']
vector_function: Annotated[VectorFunctionFeatures, 'Vector functions']
with_aggregate_function(aggregate_function)
with_database_function(database_function)
with_gen_a_i_function(gen_a_i_function)
with_graph_function(graph_function)
with_list_function(list_function)
with_load_c_s_v_function(load_c_s_v_function)
with_logarithmic_function(logarithmic_function)
with_numeric_function(numeric_function)
with_predicate_function(predicate_function)
with_scalar_function(scalar_function)
with_spatial_function(spatial_function)
with_string_function(string_function)
with_temporal_duration_function(temporal_duration_function)
with_temporal_instant_function(temporal_instant_function)
with_trigonometric_function(trigonometric_function)
with_vector_function(vector_function)
class hydra.cypher.features.GenAIFunctionFeatures(genai_vector_encode: Annotated[bool, 'The genai.vector.encode() function. Encode a given resource as a vector using the named provider. Introduced in 5.17.'])

Bases: object

GenAI functions.

class Builder(_genai_vector_encode: 'bool' = None)

Bases: object

build()
genai_vector_encode(genai_vector_encode)
GENAI_VECTOR_ENCODE = Name(value='genaiVectorEncode')
TYPE_ = Name(value='hydra.cypher.features.GenAIFunctionFeatures')
static builder()
genai_vector_encode: Annotated[bool, 'The genai.vector.encode() function. Encode a given resource as a vector using the named provider. Introduced in 5.17.']
with_genai_vector_encode(genai_vector_encode)
class hydra.cypher.features.GraphFunctionFeatures(graph_by_element_id: Annotated[bool, 'The graph.byElementId() function. Resolves the constituent graph to which a given element id belongs. Introduced in 5.13.'], graph_by_name: Annotated[bool, 'The graph.byName() function. Resolves a constituent graph by name.'], graph_names: Annotated[bool, 'The graph.names() function. Returns a list containing the names of all graphs in the current composite database.'], graph_properties_by_name: Annotated[bool, 'The graph.propertiesByName() function. Returns a map containing the properties associated with the given graph.'])

Bases: object

Graph functions.

class Builder(_graph_by_element_id: 'bool' = None, _graph_by_name: 'bool' = None, _graph_names: 'bool' = None, _graph_properties_by_name: 'bool' = None)

Bases: object

build()
graph_by_element_id(graph_by_element_id)
graph_by_name(graph_by_name)
graph_names(graph_names)
graph_properties_by_name(graph_properties_by_name)
GRAPH_BY_ELEMENT_ID = Name(value='graphByElementId')
GRAPH_BY_NAME = Name(value='graphByName')
GRAPH_NAMES = Name(value='graphNames')
GRAPH_PROPERTIES_BY_NAME = Name(value='graphPropertiesByName')
TYPE_ = Name(value='hydra.cypher.features.GraphFunctionFeatures')
static builder()
graph_by_element_id: Annotated[bool, 'The graph.byElementId() function. Resolves the constituent graph to which a given element id belongs. Introduced in 5.13.']
graph_by_name: Annotated[bool, 'The graph.byName() function. Resolves a constituent graph by name.']
graph_names: Annotated[bool, 'The graph.names() function. Returns a list containing the names of all graphs in the current composite database.']
graph_properties_by_name: Annotated[bool, 'The graph.propertiesByName() function. Returns a map containing the properties associated with the given graph.']
with_graph_by_element_id(graph_by_element_id)
with_graph_by_name(graph_by_name)
with_graph_names(graph_names)
with_graph_properties_by_name(graph_properties_by_name)
class hydra.cypher.features.ListFeatures(list_comprehension: Annotated[bool, 'Basic list comprehensions'], list_range: Annotated[bool, 'List range comprehensions (e.g. [1..10])'])

Bases: object

List functionality.

class Builder(_list_comprehension: 'bool' = None, _list_range: 'bool' = None)

Bases: object

build()
list_comprehension(list_comprehension)
list_range(list_range)
LIST_COMPREHENSION = Name(value='listComprehension')
LIST_RANGE = Name(value='listRange')
TYPE_ = Name(value='hydra.cypher.features.ListFeatures')
static builder()
list_comprehension: Annotated[bool, 'Basic list comprehensions']
list_range: Annotated[bool, 'List range comprehensions (e.g. [1..10])']
with_list_comprehension(list_comprehension)
with_list_range(list_range)
class hydra.cypher.features.ListFunctionFeatures(keys: Annotated[bool, 'The keys() function. Returns a LIST<STRING> containing the STRING representations for all the property names of a MAP.; Returns a LIST<STRING> containing the STRING representations for all the property names of a NODE.; Returns a LIST<STRING> containing the STRING representations for all the property names of a RELATIONSHIP.'], labels: Annotated[bool, 'The labels() function. Returns a LIST<STRING> containing the STRING representations for all the labels of a NODE.'], nodes: Annotated[bool, 'The nodes() function. Returns a LIST<NODE> containing all the NODE values in a PATH.'], range_: Annotated[bool, 'The range() function. Returns a LIST<INTEGER> comprising all INTEGER values within a specified range.; Returns a LIST<INTEGER> comprising all INTEGER values within a specified range created with step length.'], reduce: Annotated[bool, 'The reduce() function. Runs an expression against individual elements of a LIST<ANY>, storing the result of the expression in an accumulator.'], relationships: Annotated[bool, 'The relationships() function. Returns a LIST<RELATIONSHIP> containing all the RELATIONSHIP values in a PATH.'], reverse: Annotated[bool, 'The reverse() function. Returns a LIST<ANY> in which the order of all elements in the given LIST<ANY> have been reversed.'], tail: Annotated[bool, 'The tail() function. Returns all but the first element in a LIST<ANY>.'], to_boolean_list: Annotated[bool, 'The toBooleanList() function. Converts a LIST<ANY> of values to a LIST<BOOLEAN> values. If any values are not convertible to BOOLEAN they will be null in the LIST<BOOLEAN> returned.'], to_float_list: Annotated[bool, 'The toFloatList() function. Converts a LIST<ANY> to a LIST<FLOAT> values. If any values are not convertible to FLOAT they will be null in the LIST<FLOAT> returned.'], to_integer_list: Annotated[bool, 'The toIntegerList() function. Converts a LIST<ANY> to a LIST<INTEGER> values. If any values are not convertible to INTEGER they will be null in the LIST<INTEGER> returned.'], to_string_list: Annotated[bool, 'The toStringList() function. Converts a LIST<ANY> to a LIST<STRING> values. If any values are not convertible to STRING they will be null in the LIST<STRING> returned.'])

Bases: object

List functions.

class Builder(_keys: 'bool' = None, _labels: 'bool' = None, _nodes: 'bool' = None, _range_: 'bool' = None, _reduce: 'bool' = None, _relationships: 'bool' = None, _reverse: 'bool' = None, _tail: 'bool' = None, _to_boolean_list: 'bool' = None, _to_float_list: 'bool' = None, _to_integer_list: 'bool' = None, _to_string_list: 'bool' = None)

Bases: object

build()
keys(keys)
labels(labels)
nodes(nodes)
range_(range_)
reduce(reduce)
relationships(relationships)
reverse(reverse)
tail(tail)
to_boolean_list(to_boolean_list)
to_float_list(to_float_list)
to_integer_list(to_integer_list)
to_string_list(to_string_list)
KEYS = Name(value='keys')
LABELS = Name(value='labels')
NODES = Name(value='nodes')
RANGE = Name(value='range')
REDUCE = Name(value='reduce')
RELATIONSHIPS = Name(value='relationships')
REVERSE = Name(value='reverse')
TAIL = Name(value='tail')
TO_BOOLEAN_LIST = Name(value='toBooleanList')
TO_FLOAT_LIST = Name(value='toFloatList')
TO_INTEGER_LIST = Name(value='toIntegerList')
TO_STRING_LIST = Name(value='toStringList')
TYPE_ = Name(value='hydra.cypher.features.ListFunctionFeatures')
static builder()
keys: Annotated[bool, 'The keys() function. Returns a LIST<STRING> containing the STRING representations for all the property names of a MAP.; Returns a LIST<STRING> containing the STRING representations for all the property names of a NODE.; Returns a LIST<STRING> containing the STRING representations for all the property names of a RELATIONSHIP.']
labels: Annotated[bool, 'The labels() function. Returns a LIST<STRING> containing the STRING representations for all the labels of a NODE.']
nodes: Annotated[bool, 'The nodes() function. Returns a LIST<NODE> containing all the NODE values in a PATH.']
range_: Annotated[bool, 'The range() function. Returns a LIST<INTEGER> comprising all INTEGER values within a specified range.; Returns a LIST<INTEGER> comprising all INTEGER values within a specified range created with step length.']
reduce: Annotated[bool, 'The reduce() function. Runs an expression against individual elements of a LIST<ANY>, storing the result of the expression in an accumulator.']
relationships: Annotated[bool, 'The relationships() function. Returns a LIST<RELATIONSHIP> containing all the RELATIONSHIP values in a PATH.']
reverse: Annotated[bool, 'The reverse() function. Returns a LIST<ANY> in which the order of all elements in the given LIST<ANY> have been reversed.']
tail: Annotated[bool, 'The tail() function. Returns all but the first element in a LIST<ANY>.']
to_boolean_list: Annotated[bool, 'The toBooleanList() function. Converts a LIST<ANY> of values to a LIST<BOOLEAN> values. If any values are not convertible to BOOLEAN they will be null in the LIST<BOOLEAN> returned.']
to_float_list: Annotated[bool, 'The toFloatList() function. Converts a LIST<ANY> to a LIST<FLOAT> values. If any values are not convertible to FLOAT they will be null in the LIST<FLOAT> returned.']
to_integer_list: Annotated[bool, 'The toIntegerList() function. Converts a LIST<ANY> to a LIST<INTEGER> values. If any values are not convertible to INTEGER they will be null in the LIST<INTEGER> returned.']
to_string_list: Annotated[bool, 'The toStringList() function. Converts a LIST<ANY> to a LIST<STRING> values. If any values are not convertible to STRING they will be null in the LIST<STRING> returned.']
with_keys(keys)
with_labels(labels)
with_nodes(nodes)
with_range_(range_)
with_reduce(reduce)
with_relationships(relationships)
with_reverse(reverse)
with_tail(tail)
with_to_boolean_list(to_boolean_list)
with_to_float_list(to_float_list)
with_to_integer_list(to_integer_list)
with_to_string_list(to_string_list)
class hydra.cypher.features.LiteralFeatures(boolean: Annotated[bool, 'Boolean literals (note: included by most if not all implementations).'], double: Annotated[bool, 'Double-precision floating-point literals'], integer: Annotated[bool, 'Integer literals'], list: Annotated[bool, 'List literals'], map: Annotated[bool, 'Map literals'], null: Annotated[bool, 'The NULL literal'], string: Annotated[bool, 'String literals (note: included by most if not all implementations).'])

Bases: object

Various types of literal values.

BOOLEAN = Name(value='boolean')
class Builder(_boolean: 'bool' = None, _double: 'bool' = None, _integer: 'bool' = None, _list: 'bool' = None, _map: 'bool' = None, _null: 'bool' = None, _string: 'bool' = None)

Bases: object

boolean(boolean)
build()
double(double)
integer(integer)
list(list)
map(map)
null(null)
string(string)
DOUBLE = Name(value='double')
INTEGER = Name(value='integer')
LIST = Name(value='list')
MAP = Name(value='map')
NULL = Name(value='null')
STRING = Name(value='string')
TYPE_ = Name(value='hydra.cypher.features.LiteralFeatures')
boolean: Annotated[bool, 'Boolean literals (note: included by most if not all implementations).']
static builder()
double: Annotated[bool, 'Double-precision floating-point literals']
integer: Annotated[bool, 'Integer literals']
list: Annotated[bool, 'List literals']
map: Annotated[bool, 'Map literals']
null: Annotated[bool, 'The NULL literal']
string: Annotated[bool, 'String literals (note: included by most if not all implementations).']
with_boolean(boolean)
with_double(double)
with_integer(integer)
with_list(list)
with_map(map)
with_null(null)
with_string(string)
class hydra.cypher.features.LoadCSVFunctionFeatures(file: Annotated[bool, 'The file() function. Returns the absolute path of the file that LOAD CSV is using.'], linenumber: Annotated[bool, 'The linenumber() function. Returns the line number that LOAD CSV is currently using.'])

Bases: object

Load CSV functions.

class Builder(_file: 'bool' = None, _linenumber: 'bool' = None)

Bases: object

build()
file(file)
linenumber(linenumber)
FILE = Name(value='file')
LINENUMBER = Name(value='linenumber')
TYPE_ = Name(value='hydra.cypher.features.LoadCSVFunctionFeatures')
static builder()
file: Annotated[bool, 'The file() function. Returns the absolute path of the file that LOAD CSV is using.']
linenumber: Annotated[bool, 'The linenumber() function. Returns the line number that LOAD CSV is currently using.']
with_file(file)
with_linenumber(linenumber)
class hydra.cypher.features.LogarithmicFunctionFeatures(e: Annotated[bool, 'The e() function. Returns the base of the natural logarithm, e.'], exp: Annotated[bool, 'The exp() function. Returns e^n, where e is the base of the natural logarithm, and n is the value of the argument expression.'], log: Annotated[bool, 'The log() function. Returns the natural logarithm of a FLOAT.'], log10: Annotated[bool, 'The log10() function. Returns the common logarithm (base 10) of a FLOAT.'], sqrt: Annotated[bool, 'The sqrt() function. Returns the square root of a FLOAT.'])

Bases: object

Logarithmic functions.

class Builder(_e: 'bool' = None, _exp: 'bool' = None, _log: 'bool' = None, _log10: 'bool' = None, _sqrt: 'bool' = None)

Bases: object

build()
e(e)
exp(exp)
log(log)
log10(log10)
sqrt(sqrt)
E = Name(value='e')
EXP = Name(value='exp')
LOG = Name(value='log')
LOG10 = Name(value='log10')
SQRT = Name(value='sqrt')
TYPE_ = Name(value='hydra.cypher.features.LogarithmicFunctionFeatures')
static builder()
e: Annotated[bool, 'The e() function. Returns the base of the natural logarithm, e.']
exp: Annotated[bool, 'The exp() function. Returns e^n, where e is the base of the natural logarithm, and n is the value of the argument expression.']
log: Annotated[bool, 'The log() function. Returns the natural logarithm of a FLOAT.']
log10: Annotated[bool, 'The log10() function. Returns the common logarithm (base 10) of a FLOAT.']
sqrt: Annotated[bool, 'The sqrt() function. Returns the square root of a FLOAT.']
with_e(e)
with_exp(exp)
with_log(log)
with_log10(log10)
with_sqrt(sqrt)
class hydra.cypher.features.LogicalFeatures(and_: Annotated[bool, 'The AND operator'], not_: Annotated[bool, 'The NOT operator'], or_: Annotated[bool, 'The OR operator'], xor: Annotated[bool, 'The XOR operator'])

Bases: object

Logical operations.

AND = Name(value='and')
class Builder(_and_: 'bool' = None, _not_: 'bool' = None, _or_: 'bool' = None, _xor: 'bool' = None)

Bases: object

and_(and_)
build()
not_(not_)
or_(or_)
xor(xor)
NOT = Name(value='not')
OR = Name(value='or')
TYPE_ = Name(value='hydra.cypher.features.LogicalFeatures')
XOR = Name(value='xor')
and_: Annotated[bool, 'The AND operator']
static builder()
not_: Annotated[bool, 'The NOT operator']
or_: Annotated[bool, 'The OR operator']
with_and_(and_)
with_not_(not_)
with_or_(or_)
with_xor(xor)
xor: Annotated[bool, 'The XOR operator']
class hydra.cypher.features.MatchFeatures(match: Annotated[bool, 'The basic (non-optional) MATCH clause'], optional_match: Annotated[bool, 'OPTIONAL MATCH'])

Bases: object

Match queries.

class Builder(_match: 'bool' = None, _optional_match: 'bool' = None)

Bases: object

build()
match(match)
optional_match(optional_match)
MATCH = Name(value='match')
OPTIONAL_MATCH = Name(value='optionalMatch')
TYPE_ = Name(value='hydra.cypher.features.MatchFeatures')
static builder()
match: Annotated[bool, 'The basic (non-optional) MATCH clause']
optional_match: Annotated[bool, 'OPTIONAL MATCH']
with_match(match)
with_optional_match(optional_match)
class hydra.cypher.features.MergeFeatures(merge: Annotated[bool, 'The basic MERGE clause'], merge_on_create: Annotated[bool, 'MERGE with the ON CREATE action'], merge_on_match: Annotated[bool, 'MERGE with the ON MATCH action'])

Bases: object

Merge operations.

class Builder(_merge: 'bool' = None, _merge_on_create: 'bool' = None, _merge_on_match: 'bool' = None)

Bases: object

build()
merge(merge)
merge_on_create(merge_on_create)
merge_on_match(merge_on_match)
MERGE = Name(value='merge')
MERGE_ON_CREATE = Name(value='mergeOnCreate')
MERGE_ON_MATCH = Name(value='mergeOnMatch')
TYPE_ = Name(value='hydra.cypher.features.MergeFeatures')
static builder()
merge: Annotated[bool, 'The basic MERGE clause']
merge_on_create: Annotated[bool, 'MERGE with the ON CREATE action']
merge_on_match: Annotated[bool, 'MERGE with the ON MATCH action']
with_merge(merge)
with_merge_on_create(merge_on_create)
with_merge_on_match(merge_on_match)
class hydra.cypher.features.NodePatternFeatures(multiple_labels: Annotated[bool, 'Specifying multiple labels in a node pattern'], parameter: Annotated[bool, 'Specifying a parameter as part of a node pattern'], property_map: Annotated[bool, 'Specifying a key/value map of properties in a node pattern'], variable_node: Annotated[bool, 'Binding a variable to a node in a node pattern (note: included by most if not all implementations).'], wildcard_label: Annotated[bool, 'Omitting labels from a node pattern'])

Bases: object

Node patterns.

class Builder(_multiple_labels: 'bool' = None, _parameter: 'bool' = None, _property_map: 'bool' = None, _variable_node: 'bool' = None, _wildcard_label: 'bool' = None)

Bases: object

build()
multiple_labels(multiple_labels)
parameter(parameter)
property_map(property_map)
variable_node(variable_node)
wildcard_label(wildcard_label)
MULTIPLE_LABELS = Name(value='multipleLabels')
PARAMETER = Name(value='parameter')
PROPERTY_MAP = Name(value='propertyMap')
TYPE_ = Name(value='hydra.cypher.features.NodePatternFeatures')
VARIABLE_NODE = Name(value='variableNode')
WILDCARD_LABEL = Name(value='wildcardLabel')
static builder()
multiple_labels: Annotated[bool, 'Specifying multiple labels in a node pattern']
parameter: Annotated[bool, 'Specifying a parameter as part of a node pattern']
property_map: Annotated[bool, 'Specifying a key/value map of properties in a node pattern']
variable_node: Annotated[bool, 'Binding a variable to a node in a node pattern (note: included by most if not all implementations).']
wildcard_label: Annotated[bool, 'Omitting labels from a node pattern']
with_multiple_labels(multiple_labels)
with_parameter(parameter)
with_property_map(property_map)
with_variable_node(variable_node)
with_wildcard_label(wildcard_label)
class hydra.cypher.features.NullFeatures(is_null: Annotated[bool, 'The IS NULL operator'], is_not_null: Annotated[bool, 'The IS NOT NULL operator'])

Bases: object

IS NULL / IS NOT NULL checks.

class Builder(_is_null: 'bool' = None, _is_not_null: 'bool' = None)

Bases: object

build()
is_not_null(is_not_null)
is_null(is_null)
IS_NOT_NULL = Name(value='isNotNull')
IS_NULL = Name(value='isNull')
TYPE_ = Name(value='hydra.cypher.features.NullFeatures')
static builder()
is_not_null: Annotated[bool, 'The IS NOT NULL operator']
is_null: Annotated[bool, 'The IS NULL operator']
with_is_not_null(is_not_null)
with_is_null(is_null)
class hydra.cypher.features.NumericFunctionFeatures(abs: Annotated[bool, 'The abs() function. Returns the absolute value of a FLOAT.; Returns the absolute value of an INTEGER.'], ceil: Annotated[bool, 'The ceil() function. Returns the smallest FLOAT that is greater than or equal to a number and equal to an INTEGER.'], floor: Annotated[bool, 'The floor() function. Returns the largest FLOAT that is less than or equal to a number and equal to an INTEGER.'], is_na_n: Annotated[bool, 'The isNaN() function. Returns true if the floating point number is NaN.; Returns true if the integer number is NaN.'], rand: Annotated[bool, 'The rand() function. Returns a random FLOAT in the range from 0 (inclusive) to 1 (exclusive).'], round: Annotated[bool, 'The round() function. Returns the value of a number rounded to the nearest INTEGER.; Returns the value of a number rounded to the specified precision using rounding mode HALF_UP.; Returns the value of a number rounded to the specified precision with the specified rounding mode.'], sign: Annotated[bool, 'The sign() function. Returns the signum of a FLOAT: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.; Returns the signum of an INTEGER: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.'])

Bases: object

Numeric functions.

ABS = Name(value='abs')
class Builder(_abs: 'bool' = None, _ceil: 'bool' = None, _floor: 'bool' = None, _is_na_n: 'bool' = None, _rand: 'bool' = None, _round: 'bool' = None, _sign: 'bool' = None)

Bases: object

abs(abs)
build()
ceil(ceil)
floor(floor)
is_na_n(is_na_n)
rand(rand)
round(round)
sign(sign)
CEIL = Name(value='ceil')
FLOOR = Name(value='floor')
IS_NA_N = Name(value='isNaN')
RAND = Name(value='rand')
ROUND = Name(value='round')
SIGN = Name(value='sign')
TYPE_ = Name(value='hydra.cypher.features.NumericFunctionFeatures')
abs: Annotated[bool, 'The abs() function. Returns the absolute value of a FLOAT.; Returns the absolute value of an INTEGER.']
static builder()
ceil: Annotated[bool, 'The ceil() function. Returns the smallest FLOAT that is greater than or equal to a number and equal to an INTEGER.']
floor: Annotated[bool, 'The floor() function. Returns the largest FLOAT that is less than or equal to a number and equal to an INTEGER.']
is_na_n: Annotated[bool, 'The isNaN() function. Returns true if the floating point number is NaN.; Returns true if the integer number is NaN.']
rand: Annotated[bool, 'The rand() function. Returns a random FLOAT in the range from 0 (inclusive) to 1 (exclusive).']
round: Annotated[bool, 'The round() function. Returns the value of a number rounded to the nearest INTEGER.; Returns the value of a number rounded to the specified precision using rounding mode HALF_UP.; Returns the value of a number rounded to the specified precision with the specified rounding mode.']
sign: Annotated[bool, 'The sign() function. Returns the signum of a FLOAT: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.; Returns the signum of an INTEGER: 0 if the number is 0, -1 for any negative number, and 1 for any positive number.']
with_abs(abs)
with_ceil(ceil)
with_floor(floor)
with_is_na_n(is_na_n)
with_rand(rand)
with_round(round)
with_sign(sign)
class hydra.cypher.features.PathFeatures(shortest_path: Annotated[bool, 'The shortestPath() function'])

Bases: object

Path functions only found in OpenCypher.

class Builder(_shortest_path: 'bool' = None)

Bases: object

build()
shortest_path(shortest_path)
SHORTEST_PATH = Name(value='shortestPath')
TYPE_ = Name(value='hydra.cypher.features.PathFeatures')
static builder()
shortest_path: Annotated[bool, 'The shortestPath() function']
with_shortest_path(shortest_path)
class hydra.cypher.features.PredicateFunctionFeatures(all: Annotated[bool, 'The all() function. Returns true if the predicate holds for all elements in the given LIST<ANY>.'], any: Annotated[bool, 'The any() function. Returns true if the predicate holds for at least one element in the given LIST<ANY>.'], exists: Annotated[bool, 'The exists() function. Returns true if a match for the pattern exists in the graph.'], is_empty: Annotated[bool, 'The isEmpty() function. Checks whether a LIST<ANY> is empty.; Checks whether a MAP is empty.; Checks whether a STRING is empty.'], none: Annotated[bool, 'The none() function. Returns true if the predicate holds for no element in the given LIST<ANY>.'], single: Annotated[bool, 'The single() function. Returns true if the predicate holds for exactly one of the elements in the given LIST<ANY>.'])

Bases: object

Predicate functions.

ALL = Name(value='all')
ANY = Name(value='any')
class Builder(_all: 'bool' = None, _any: 'bool' = None, _exists: 'bool' = None, _is_empty: 'bool' = None, _none: 'bool' = None, _single: 'bool' = None)

Bases: object

all(all)
any(any)
build()
exists(exists)
is_empty(is_empty)
none(none)
single(single)
EXISTS = Name(value='exists')
IS_EMPTY = Name(value='isEmpty')
NONE = Name(value='none')
SINGLE = Name(value='single')
TYPE_ = Name(value='hydra.cypher.features.PredicateFunctionFeatures')
all: Annotated[bool, 'The all() function. Returns true if the predicate holds for all elements in the given LIST<ANY>.']
any: Annotated[bool, 'The any() function. Returns true if the predicate holds for at least one element in the given LIST<ANY>.']
static builder()
exists: Annotated[bool, 'The exists() function. Returns true if a match for the pattern exists in the graph.']
is_empty: Annotated[bool, 'The isEmpty() function. Checks whether a LIST<ANY> is empty.; Checks whether a MAP is empty.; Checks whether a STRING is empty.']
none: Annotated[bool, 'The none() function. Returns true if the predicate holds for no element in the given LIST<ANY>.']
single: Annotated[bool, 'The single() function. Returns true if the predicate holds for exactly one of the elements in the given LIST<ANY>.']
with_all(all)
with_any(any)
with_exists(exists)
with_is_empty(is_empty)
with_none(none)
with_single(single)
class hydra.cypher.features.ProcedureCallFeatures(in_query_call: Annotated[bool, 'CALL within a query'], standalone_call: Annotated[bool, 'Standalone / top-level CALL'], yield_: Annotated[bool, 'The YIELD clause in CALL'])

Bases: object

Procedure calls.

class Builder(_in_query_call: 'bool' = None, _standalone_call: 'bool' = None, _yield_: 'bool' = None)

Bases: object

build()
in_query_call(in_query_call)
standalone_call(standalone_call)
yield_(yield_)
IN_QUERY_CALL = Name(value='inQueryCall')
STANDALONE_CALL = Name(value='standaloneCall')
TYPE_ = Name(value='hydra.cypher.features.ProcedureCallFeatures')
YIELD = Name(value='yield')
static builder()
in_query_call: Annotated[bool, 'CALL within a query']
standalone_call: Annotated[bool, 'Standalone / top-level CALL']
with_in_query_call(in_query_call)
with_standalone_call(standalone_call)
with_yield_(yield_)
yield_: Annotated[bool, 'The YIELD clause in CALL']
class hydra.cypher.features.ProjectionFeatures(limit: Annotated[bool, 'The LIMIT clause'], order_by: Annotated[bool, 'The ORDER BY clause'], project_distinct: Annotated[bool, 'The DISTINCT keyword'], project_all: Annotated[bool, 'The * projection'], project_as: Annotated[bool, 'The AS keyword'], skip: Annotated[bool, 'The SKIP clause'], sort_order: Annotated[bool, 'The ASC/ASCENDING and DESC/DESCENDING keywords'])

Bases: object

Projections.

class Builder(_limit: 'bool' = None, _order_by: 'bool' = None, _project_distinct: 'bool' = None, _project_all: 'bool' = None, _project_as: 'bool' = None, _skip: 'bool' = None, _sort_order: 'bool' = None)

Bases: object

build()
limit(limit)
order_by(order_by)
project_all(project_all)
project_as(project_as)
project_distinct(project_distinct)
skip(skip)
sort_order(sort_order)
LIMIT = Name(value='limit')
ORDER_BY = Name(value='orderBy')
PROJECT_ALL = Name(value='projectAll')
PROJECT_AS = Name(value='projectAs')
PROJECT_DISTINCT = Name(value='projectDistinct')
SKIP = Name(value='skip')
SORT_ORDER = Name(value='sortOrder')
TYPE_ = Name(value='hydra.cypher.features.ProjectionFeatures')
static builder()
limit: Annotated[bool, 'The LIMIT clause']
order_by: Annotated[bool, 'The ORDER BY clause']
project_all: Annotated[bool, 'The * projection']
project_as: Annotated[bool, 'The AS keyword']
project_distinct: Annotated[bool, 'The DISTINCT keyword']
skip: Annotated[bool, 'The SKIP clause']
sort_order: Annotated[bool, 'The ASC/ASCENDING and DESC/DESCENDING keywords']
with_limit(limit)
with_order_by(order_by)
with_project_all(project_all)
with_project_as(project_as)
with_project_distinct(project_distinct)
with_skip(skip)
with_sort_order(sort_order)
class hydra.cypher.features.QuantifierFeatures(all: Annotated[bool, 'The ALL quantifier'], any: Annotated[bool, 'The ANY quantifier'], none: Annotated[bool, 'The NONE quantifier'], single: Annotated[bool, 'The SINGLE quantifier'])

Bases: object

Quantifier expressions.

ALL = Name(value='all')
ANY = Name(value='any')
class Builder(_all: 'bool' = None, _any: 'bool' = None, _none: 'bool' = None, _single: 'bool' = None)

Bases: object

all(all)
any(any)
build()
none(none)
single(single)
NONE = Name(value='none')
SINGLE = Name(value='single')
TYPE_ = Name(value='hydra.cypher.features.QuantifierFeatures')
all: Annotated[bool, 'The ALL quantifier']
any: Annotated[bool, 'The ANY quantifier']
static builder()
none: Annotated[bool, 'The NONE quantifier']
single: Annotated[bool, 'The SINGLE quantifier']
with_all(all)
with_any(any)
with_none(none)
with_single(single)
class hydra.cypher.features.RangeLiteralFeatures(bounds: Annotated[bool, 'Range literals with both lower and upper bounds'], exact_range: Annotated[bool, 'Range literals providing an exact number of repetitions'], lower_bound: Annotated[bool, 'Range literals with a lower bound (only)'], star_range: Annotated[bool, 'The * range literal'], upper_bound: Annotated[bool, 'Range literals with an upper bound (only)'])

Bases: object

Range literals within relationship patterns.

BOUNDS = Name(value='bounds')
class Builder(_bounds: 'bool' = None, _exact_range: 'bool' = None, _lower_bound: 'bool' = None, _star_range: 'bool' = None, _upper_bound: 'bool' = None)

Bases: object

bounds(bounds)
build()
exact_range(exact_range)
lower_bound(lower_bound)
star_range(star_range)
upper_bound(upper_bound)
EXACT_RANGE = Name(value='exactRange')
LOWER_BOUND = Name(value='lowerBound')
STAR_RANGE = Name(value='starRange')
TYPE_ = Name(value='hydra.cypher.features.RangeLiteralFeatures')
UPPER_BOUND = Name(value='upperBound')
bounds: Annotated[bool, 'Range literals with both lower and upper bounds']
static builder()
exact_range: Annotated[bool, 'Range literals providing an exact number of repetitions']
lower_bound: Annotated[bool, 'Range literals with a lower bound (only)']
star_range: Annotated[bool, 'The * range literal']
upper_bound: Annotated[bool, 'Range literals with an upper bound (only)']
with_bounds(bounds)
with_exact_range(exact_range)
with_lower_bound(lower_bound)
with_star_range(star_range)
with_upper_bound(upper_bound)
class hydra.cypher.features.ReadingFeatures(union: Annotated[bool, 'The UNION operator'], union_all: Annotated[bool, 'The UNION ALL operator'], unwind: Annotated[bool, 'The UNWIND clause'])

Bases: object

Specific syntax related to reading data from the graph.

class Builder(_union: 'bool' = None, _union_all: 'bool' = None, _unwind: 'bool' = None)

Bases: object

build()
union(union)
union_all(union_all)
unwind(unwind)
TYPE_ = Name(value='hydra.cypher.features.ReadingFeatures')
UNION = Name(value='union')
UNION_ALL = Name(value='unionAll')
UNWIND = Name(value='unwind')
static builder()
union: Annotated[bool, 'The UNION operator']
union_all: Annotated[bool, 'The UNION ALL operator']
unwind: Annotated[bool, 'The UNWIND clause']
with_union(union)
with_union_all(union_all)
with_unwind(unwind)
class hydra.cypher.features.RelationshipDirectionFeatures(both: Annotated[bool, 'The two-headed arrow (<-[]->) relationship direction'], left: Annotated[bool, 'The left arrow (<-[]-) relationship direction'], neither: Annotated[bool, 'The headless arrow (-[]-) relationship direction'], right: Annotated[bool, 'The right arrow (-[]->) relationship direction'])

Bases: object

Relationship directions / arrow patterns.

BOTH = Name(value='both')
class Builder(_both: 'bool' = None, _left: 'bool' = None, _neither: 'bool' = None, _right: 'bool' = None)

Bases: object

both(both)
build()
left(left)
neither(neither)
right(right)
LEFT = Name(value='left')
NEITHER = Name(value='neither')
RIGHT = Name(value='right')
TYPE_ = Name(value='hydra.cypher.features.RelationshipDirectionFeatures')
both: Annotated[bool, 'The two-headed arrow (<-[]->) relationship direction']
static builder()
left: Annotated[bool, 'The left arrow (<-[]-) relationship direction']
neither: Annotated[bool, 'The headless arrow (-[]-) relationship direction']
right: Annotated[bool, 'The right arrow (-[]->) relationship direction']
with_both(both)
with_left(left)
with_neither(neither)
with_right(right)
class hydra.cypher.features.RelationshipPatternFeatures(multiple_types: Annotated[bool, 'Specifying a disjunction of multiple types in a relationship pattern'], variable_relationship: Annotated[bool, 'Binding a variable to a relationship in a relationship pattern (note: included by most if not all implementations).'], wildcard_type: Annotated[bool, 'Omitting types from a relationship pattern'])

Bases: object

Relationship patterns.

class Builder(_multiple_types: 'bool' = None, _variable_relationship: 'bool' = None, _wildcard_type: 'bool' = None)

Bases: object

build()
multiple_types(multiple_types)
variable_relationship(variable_relationship)
wildcard_type(wildcard_type)
MULTIPLE_TYPES = Name(value='multipleTypes')
TYPE_ = Name(value='hydra.cypher.features.RelationshipPatternFeatures')
VARIABLE_RELATIONSHIP = Name(value='variableRelationship')
WILDCARD_TYPE = Name(value='wildcardType')
static builder()
multiple_types: Annotated[bool, 'Specifying a disjunction of multiple types in a relationship pattern']
variable_relationship: Annotated[bool, 'Binding a variable to a relationship in a relationship pattern (note: included by most if not all implementations).']
wildcard_type: Annotated[bool, 'Omitting types from a relationship pattern']
with_multiple_types(multiple_types)
with_variable_relationship(variable_relationship)
with_wildcard_type(wildcard_type)
class hydra.cypher.features.RemoveFeatures(by_label: Annotated[bool, 'REMOVE Variable:NodeLabels'], by_property: Annotated[bool, 'REMOVE PropertyExpression'])

Bases: object

REMOVE operations.

BY_LABEL = Name(value='byLabel')
BY_PROPERTY = Name(value='byProperty')
class Builder(_by_label: 'bool' = None, _by_property: 'bool' = None)

Bases: object

build()
by_label(by_label)
by_property(by_property)
TYPE_ = Name(value='hydra.cypher.features.RemoveFeatures')
static builder()
by_label: Annotated[bool, 'REMOVE Variable:NodeLabels']
by_property: Annotated[bool, 'REMOVE PropertyExpression']
with_by_label(by_label)
with_by_property(by_property)
class hydra.cypher.features.ScalarFunctionFeatures(char_length: Annotated[bool, 'The char_length() function. Returns the number of Unicode characters in a STRING.'], character_length: Annotated[bool, 'The character_length() function. Returns the number of Unicode characters in a STRING.'], coalesce: Annotated[bool, 'The coalesce() function. Returns the first non-null value in a list of expressions.'], element_id: Annotated[bool, 'The elementId() function. Returns a node identifier, unique within a specific transaction and DBMS.; Returns a relationship identifier, unique within a specific transaction and DBMS.'], end_node: Annotated[bool, 'The endNode() function. Returns a relationship identifier, unique within a specific transaction and DBMS.'], head: Annotated[bool, 'The head() function. Returns the first element in a LIST<ANY>.'], id: Annotated[bool, 'The id() function. [Deprecated] Returns the id of a NODE. Replaced by elementId().; [Deprecated] Returns the id of a RELATIONSHIP. Replaced by elementId().'], last: Annotated[bool, 'The last() function. Returns the last element in a LIST<ANY>.'], length: Annotated[bool, 'The length() function. Returns the length of a PATH.'], null_if: Annotated[bool, 'The nullIf() function. Returns null if the two given parameters are equivalent, otherwise returns the value of the first parameter.'], properties: Annotated[bool, 'The properties() function. Returns a MAP containing all the properties of a MAP.; Returns a MAP containing all the properties of a NODE.; Returns a MAP containing all the properties of a RELATIONSHIP.'], random_u_u_i_d: Annotated[bool, 'The randomUUID() function. Generates a random UUID.'], size: Annotated[bool, 'The size() function. Returns the number of items in a LIST<ANY>.; Returns the number of Unicode characters in a STRING.'], start_node: Annotated[bool, 'The startNode() function. Returns the start NODE of a RELATIONSHIP.'], to_boolean: Annotated[bool, 'The toBoolean() function. Converts a STRING value to a BOOLEAN value.; Converts a BOOLEAN value to a BOOLEAN value.; Converts an INTEGER value to a BOOLEAN value.'], to_boolean_or_null: Annotated[bool, 'The toBooleanOrNull() function. Converts a value to a BOOLEAN value, or null if the value cannot be converted.'], to_float: Annotated[bool, 'The toFloat() function. Converts an INTEGER value to a FLOAT value.; Converts a STRING value to a FLOAT value.'], to_float_or_null: Annotated[bool, 'The toFloatOrNull() function. Converts a value to a FLOAT value, or null if the value cannot be converted.'], to_integer: Annotated[bool, 'The toInteger() function. Converts a FLOAT value to an INTEGER value.; Converts a BOOLEAN value to an INTEGER value.; Converts a STRING value to an INTEGER value.'], to_integer_or_null: Annotated[bool, 'The toIntegerOrNull() function. Converts a value to an INTEGER value, or null if the value cannot be converted.'], type: Annotated[bool, 'The type() function. Returns a STRING representation of the RELATIONSHIP type.'], value_type: Annotated[bool, 'The valueType() function. Returns a STRING representation of the most precise value type that the given expression evaluates to.'])

Bases: object

Scalar functions.

class Builder(_char_length: 'bool' = None, _character_length: 'bool' = None, _coalesce: 'bool' = None, _element_id: 'bool' = None, _end_node: 'bool' = None, _head: 'bool' = None, _id: 'bool' = None, _last: 'bool' = None, _length: 'bool' = None, _null_if: 'bool' = None, _properties: 'bool' = None, _random_u_u_i_d: 'bool' = None, _size: 'bool' = None, _start_node: 'bool' = None, _to_boolean: 'bool' = None, _to_boolean_or_null: 'bool' = None, _to_float: 'bool' = None, _to_float_or_null: 'bool' = None, _to_integer: 'bool' = None, _to_integer_or_null: 'bool' = None, _type: 'bool' = None, _value_type: 'bool' = None)

Bases: object

build()
char_length(char_length)
character_length(character_length)
coalesce(coalesce)
element_id(element_id)
end_node(end_node)
head(head)
id(id)
last(last)
length(length)
null_if(null_if)
properties(properties)
random_u_u_i_d(random_u_u_i_d)
size(size)
start_node(start_node)
to_boolean(to_boolean)
to_boolean_or_null(to_boolean_or_null)
to_float(to_float)
to_float_or_null(to_float_or_null)
to_integer(to_integer)
to_integer_or_null(to_integer_or_null)
type(type)
value_type(value_type)
CHARACTER_LENGTH = Name(value='character_length')
CHAR_LENGTH = Name(value='char_length')
COALESCE = Name(value='coalesce')
ELEMENT_ID = Name(value='elementId')
END_NODE = Name(value='endNode')
HEAD = Name(value='head')
ID = Name(value='id')
LAST = Name(value='last')
LENGTH = Name(value='length')
NULL_IF = Name(value='nullIf')
PROPERTIES = Name(value='properties')
RANDOM_U_U_I_D = Name(value='randomUUID')
SIZE = Name(value='size')
START_NODE = Name(value='startNode')
TO_BOOLEAN = Name(value='toBoolean')
TO_BOOLEAN_OR_NULL = Name(value='toBooleanOrNull')
TO_FLOAT = Name(value='toFloat')
TO_FLOAT_OR_NULL = Name(value='toFloatOrNull')
TO_INTEGER = Name(value='toInteger')
TO_INTEGER_OR_NULL = Name(value='toIntegerOrNull')
TYPE = Name(value='type')
TYPE_ = Name(value='hydra.cypher.features.ScalarFunctionFeatures')
VALUE_TYPE = Name(value='valueType')
static builder()
char_length: Annotated[bool, 'The char_length() function. Returns the number of Unicode characters in a STRING.']
character_length: Annotated[bool, 'The character_length() function. Returns the number of Unicode characters in a STRING.']
coalesce: Annotated[bool, 'The coalesce() function. Returns the first non-null value in a list of expressions.']
element_id: Annotated[bool, 'The elementId() function. Returns a node identifier, unique within a specific transaction and DBMS.; Returns a relationship identifier, unique within a specific transaction and DBMS.']
end_node: Annotated[bool, 'The endNode() function. Returns a relationship identifier, unique within a specific transaction and DBMS.']
head: Annotated[bool, 'The head() function. Returns the first element in a LIST<ANY>.']
id: Annotated[bool, 'The id() function. [Deprecated] Returns the id of a NODE. Replaced by elementId().; [Deprecated] Returns the id of a RELATIONSHIP. Replaced by elementId().']
last: Annotated[bool, 'The last() function. Returns the last element in a LIST<ANY>.']
length: Annotated[bool, 'The length() function. Returns the length of a PATH.']
null_if: Annotated[bool, 'The nullIf() function. Returns null if the two given parameters are equivalent, otherwise returns the value of the first parameter.']
properties: Annotated[bool, 'The properties() function. Returns a MAP containing all the properties of a MAP.; Returns a MAP containing all the properties of a NODE.; Returns a MAP containing all the properties of a RELATIONSHIP.']
random_u_u_i_d: Annotated[bool, 'The randomUUID() function. Generates a random UUID.']
size: Annotated[bool, 'The size() function. Returns the number of items in a LIST<ANY>.; Returns the number of Unicode characters in a STRING.']
start_node: Annotated[bool, 'The startNode() function. Returns the start NODE of a RELATIONSHIP.']
to_boolean: Annotated[bool, 'The toBoolean() function. Converts a STRING value to a BOOLEAN value.; Converts a BOOLEAN value to a BOOLEAN value.; Converts an INTEGER value to a BOOLEAN value.']
to_boolean_or_null: Annotated[bool, 'The toBooleanOrNull() function. Converts a value to a BOOLEAN value, or null if the value cannot be converted.']
to_float: Annotated[bool, 'The toFloat() function. Converts an INTEGER value to a FLOAT value.; Converts a STRING value to a FLOAT value.']
to_float_or_null: Annotated[bool, 'The toFloatOrNull() function. Converts a value to a FLOAT value, or null if the value cannot be converted.']
to_integer: Annotated[bool, 'The toInteger() function. Converts a FLOAT value to an INTEGER value.; Converts a BOOLEAN value to an INTEGER value.; Converts a STRING value to an INTEGER value.']
to_integer_or_null: Annotated[bool, 'The toIntegerOrNull() function. Converts a value to an INTEGER value, or null if the value cannot be converted.']
type: Annotated[bool, 'The type() function. Returns a STRING representation of the RELATIONSHIP type.']
value_type: Annotated[bool, 'The valueType() function. Returns a STRING representation of the most precise value type that the given expression evaluates to.']
with_char_length(char_length)
with_character_length(character_length)
with_coalesce(coalesce)
with_element_id(element_id)
with_end_node(end_node)
with_head(head)
with_id(id)
with_last(last)
with_length(length)
with_null_if(null_if)
with_properties(properties)
with_random_u_u_i_d(random_u_u_i_d)
with_size(size)
with_start_node(start_node)
with_to_boolean(to_boolean)
with_to_boolean_or_null(to_boolean_or_null)
with_to_float(to_float)
with_to_float_or_null(to_float_or_null)
with_to_integer(to_integer)
with_to_integer_or_null(to_integer_or_null)
with_type(type)
with_value_type(value_type)
class hydra.cypher.features.SetFeatures(property_equals: Annotated[bool, 'Defining a set using PropertyExpression = Expression'], variable_equals: Annotated[bool, 'Defining a set using Variable = Expression'], variable_plus_equals: Annotated[bool, 'Defining a set using Variable += Expression'], variable_with_node_labels: Annotated[bool, 'Defining a set using Variable:NodeLabels'])

Bases: object

Set definitions.

class Builder(_property_equals: 'bool' = None, _variable_equals: 'bool' = None, _variable_plus_equals: 'bool' = None, _variable_with_node_labels: 'bool' = None)

Bases: object

build()
property_equals(property_equals)
variable_equals(variable_equals)
variable_plus_equals(variable_plus_equals)
variable_with_node_labels(variable_with_node_labels)
PROPERTY_EQUALS = Name(value='propertyEquals')
TYPE_ = Name(value='hydra.cypher.features.SetFeatures')
VARIABLE_EQUALS = Name(value='variableEquals')
VARIABLE_PLUS_EQUALS = Name(value='variablePlusEquals')
VARIABLE_WITH_NODE_LABELS = Name(value='variableWithNodeLabels')
static builder()
property_equals: Annotated[bool, 'Defining a set using PropertyExpression = Expression']
variable_equals: Annotated[bool, 'Defining a set using Variable = Expression']
variable_plus_equals: Annotated[bool, 'Defining a set using Variable += Expression']
variable_with_node_labels: Annotated[bool, 'Defining a set using Variable:NodeLabels']
with_property_equals(property_equals)
with_variable_equals(variable_equals)
with_variable_plus_equals(variable_plus_equals)
with_variable_with_node_labels(variable_with_node_labels)
class hydra.cypher.features.SpatialFunctionFeatures(point_distance: Annotated[bool, 'The point.distance() function. Returns a FLOAT representing the geodesic distance between any two points in the same CRS.'], point: Annotated[bool, 'The point() function. Returns a 2D point object, given two coordinate values in the Cartesian coordinate system.; Returns a 3D point object, given three coordinate values in the Cartesian coordinate system.; Returns a 2D point object, given two coordinate values in the WGS 84 geographic coordinate system.; Returns a 3D point object, given three coordinate values in the WGS 84 geographic coordinate system.'], point_within_b_box: Annotated[bool, 'The point.withinBBox() function. Returns true if the provided point is within the bounding box defined by the two provided points, lowerLeft and upperRight.'])

Bases: object

Spatial functions.

class Builder(_point_distance: 'bool' = None, _point: 'bool' = None, _point_within_b_box: 'bool' = None)

Bases: object

build()
point(point)
point_distance(point_distance)
point_within_b_box(point_within_b_box)
POINT = Name(value='point')
POINT_DISTANCE = Name(value='pointDistance')
POINT_WITHIN_B_BOX = Name(value='pointWithinBBox')
TYPE_ = Name(value='hydra.cypher.features.SpatialFunctionFeatures')
static builder()
point: Annotated[bool, 'The point() function. Returns a 2D point object, given two coordinate values in the Cartesian coordinate system.; Returns a 3D point object, given three coordinate values in the Cartesian coordinate system.; Returns a 2D point object, given two coordinate values in the WGS 84 geographic coordinate system.; Returns a 3D point object, given three coordinate values in the WGS 84 geographic coordinate system.']
point_distance: Annotated[bool, 'The point.distance() function. Returns a FLOAT representing the geodesic distance between any two points in the same CRS.']
point_within_b_box: Annotated[bool, 'The point.withinBBox() function. Returns true if the provided point is within the bounding box defined by the two provided points, lowerLeft and upperRight.']
with_point(point)
with_point_distance(point_distance)
with_point_within_b_box(point_within_b_box)
class hydra.cypher.features.StringFeatures(contains: Annotated[bool, 'The contains() function / CONTAINS'], ends_with: Annotated[bool, 'The endsWith() function / ENDS WITH'], in_: Annotated[bool, 'The in() function / IN'], starts_with: Annotated[bool, 'The startsWith() function / STARTS WITH'])

Bases: object

String functions/keywords only found in OpenCypher.

class Builder(_contains: 'bool' = None, _ends_with: 'bool' = None, _in_: 'bool' = None, _starts_with: 'bool' = None)

Bases: object

build()
contains(contains)
ends_with(ends_with)
in_(in_)
starts_with(starts_with)
CONTAINS = Name(value='contains')
ENDS_WITH = Name(value='endsWith')
IN = Name(value='in')
STARTS_WITH = Name(value='startsWith')
TYPE_ = Name(value='hydra.cypher.features.StringFeatures')
static builder()
contains: Annotated[bool, 'The contains() function / CONTAINS']
ends_with: Annotated[bool, 'The endsWith() function / ENDS WITH']
in_: Annotated[bool, 'The in() function / IN']
starts_with: Annotated[bool, 'The startsWith() function / STARTS WITH']
with_contains(contains)
with_ends_with(ends_with)
with_in_(in_)
with_starts_with(starts_with)
class hydra.cypher.features.StringFunctionFeatures(btrim: Annotated[bool, 'The btrim() function. Returns the given STRING with leading and trailing whitespace removed.; Returns the given STRING with leading and trailing trimCharacterString characters removed. Introduced in 5.20.'], left: Annotated[bool, 'The left() function. Returns a STRING containing the specified number (INTEGER) of leftmost characters in the given STRING.'], lower: Annotated[bool, "The lower() function. Returns the given STRING in lowercase. This function is an alias to the toLower() function, and it was introduced as part of Cypher's GQL conformance. Introduced in 5.21."], ltrim: Annotated[bool, 'The ltrim() function. Returns the given STRING with leading whitespace removed.; Returns the given STRING with leading trimCharacterString characters removed. Introduced in 5.20.'], normalize: Annotated[bool, 'The normalize() function. Returns the given STRING normalized according to the normalization CypherFunctionForm NFC. Introduced in 5.17.; Returns the given STRING normalized according to the specified normalization CypherFunctionForm. Introduced in 5.17.'], replace: Annotated[bool, 'The replace() function. Returns a STRING in which all occurrences of a specified search STRING in the given STRING have been replaced by another (specified) replacement STRING.'], reverse: Annotated[bool, 'The reverse() function. Returns a STRING in which the order of all characters in the given STRING have been reversed.'], right: Annotated[bool, 'The right() function. Returns a STRING containing the specified number of rightmost characters in the given STRING.'], rtrim: Annotated[bool, 'The rtrim() function. Returns the given STRING with trailing whitespace removed.; Returns the given STRING with trailing trimCharacterString characters removed. Introduced in 5.20.'], split: Annotated[bool, 'The split() function. Returns a LIST<STRING> resulting from the splitting of the given STRING around matches of the given delimiter.; Returns a LIST<STRING> resulting from the splitting of the given STRING around matches of any of the given delimiters.'], substring: Annotated[bool, 'The substring() function. Returns a substring of the given STRING, beginning with a 0-based index start.; Returns a substring of a given length from the given STRING, beginning with a 0-based index start.'], to_lower: Annotated[bool, 'The toLower() function. Returns the given STRING in lowercase.'], to_string: Annotated[bool, 'The toString() function. Converts an INTEGER, FLOAT, BOOLEAN, POINT or temporal type (i.e. DATE, ZONED TIME, LOCAL TIME, ZONED DATETIME, LOCAL DATETIME or DURATION) value to a STRING.'], to_string_or_null: Annotated[bool, 'The toStringOrNull() function. Converts an INTEGER, FLOAT, BOOLEAN, POINT or temporal type (i.e. DATE, ZONED TIME, LOCAL TIME, ZONED DATETIME, LOCAL DATETIME or DURATION) value to a STRING, or null if the value cannot be converted.'], to_upper: Annotated[bool, 'The toUpper() function. Returns the given STRING in uppercase.'], trim: Annotated[bool, 'The trim() function. Returns the given STRING with leading and trailing whitespace removed.; Returns the given STRING with the leading and/or trailing trimCharacterString character removed. Introduced in 5.20.'], upper: Annotated[bool, "The upper() function. Returns the given STRING in uppercase. This function is an alias to the toUpper() function, and it was introduced as part of Cypher's GQL conformance. Introduced in 5.21."])

Bases: object

String functions.

BTRIM = Name(value='btrim')
class Builder(_btrim: 'bool' = None, _left: 'bool' = None, _lower: 'bool' = None, _ltrim: 'bool' = None, _normalize: 'bool' = None, _replace: 'bool' = None, _reverse: 'bool' = None, _right: 'bool' = None, _rtrim: 'bool' = None, _split: 'bool' = None, _substring: 'bool' = None, _to_lower: 'bool' = None, _to_string: 'bool' = None, _to_string_or_null: 'bool' = None, _to_upper: 'bool' = None, _trim: 'bool' = None, _upper: 'bool' = None)

Bases: object

btrim(btrim)
build()
left(left)
lower(lower)
ltrim(ltrim)
normalize(normalize)
replace(replace)
reverse(reverse)
right(right)
rtrim(rtrim)
split(split)
substring(substring)
to_lower(to_lower)
to_string(to_string)
to_string_or_null(to_string_or_null)
to_upper(to_upper)
trim(trim)
upper(upper)
LEFT = Name(value='left')
LOWER = Name(value='lower')
LTRIM = Name(value='ltrim')
NORMALIZE = Name(value='normalize')
REPLACE = Name(value='replace')
REVERSE = Name(value='reverse')
RIGHT = Name(value='right')
RTRIM = Name(value='rtrim')
SPLIT = Name(value='split')
SUBSTRING = Name(value='substring')
TO_LOWER = Name(value='toLower')
TO_STRING = Name(value='toString')
TO_STRING_OR_NULL = Name(value='toStringOrNull')
TO_UPPER = Name(value='toUpper')
TRIM = Name(value='trim')
TYPE_ = Name(value='hydra.cypher.features.StringFunctionFeatures')
UPPER = Name(value='upper')
btrim: Annotated[bool, 'The btrim() function. Returns the given STRING with leading and trailing whitespace removed.; Returns the given STRING with leading and trailing trimCharacterString characters removed. Introduced in 5.20.']
static builder()
left: Annotated[bool, 'The left() function. Returns a STRING containing the specified number (INTEGER) of leftmost characters in the given STRING.']
lower: Annotated[bool, "The lower() function. Returns the given STRING in lowercase. This function is an alias to the toLower() function, and it was introduced as part of Cypher's GQL conformance. Introduced in 5.21."]
ltrim: Annotated[bool, 'The ltrim() function. Returns the given STRING with leading whitespace removed.; Returns the given STRING with leading trimCharacterString characters removed. Introduced in 5.20.']
normalize: Annotated[bool, 'The normalize() function. Returns the given STRING normalized according to the normalization CypherFunctionForm NFC. Introduced in 5.17.; Returns the given STRING normalized according to the specified normalization CypherFunctionForm. Introduced in 5.17.']
replace: Annotated[bool, 'The replace() function. Returns a STRING in which all occurrences of a specified search STRING in the given STRING have been replaced by another (specified) replacement STRING.']
reverse: Annotated[bool, 'The reverse() function. Returns a STRING in which the order of all characters in the given STRING have been reversed.']
right: Annotated[bool, 'The right() function. Returns a STRING containing the specified number of rightmost characters in the given STRING.']
rtrim: Annotated[bool, 'The rtrim() function. Returns the given STRING with trailing whitespace removed.; Returns the given STRING with trailing trimCharacterString characters removed. Introduced in 5.20.']
split: Annotated[bool, 'The split() function. Returns a LIST<STRING> resulting from the splitting of the given STRING around matches of the given delimiter.; Returns a LIST<STRING> resulting from the splitting of the given STRING around matches of any of the given delimiters.']
substring: Annotated[bool, 'The substring() function. Returns a substring of the given STRING, beginning with a 0-based index start.; Returns a substring of a given length from the given STRING, beginning with a 0-based index start.']
to_lower: Annotated[bool, 'The toLower() function. Returns the given STRING in lowercase.']
to_string: Annotated[bool, 'The toString() function. Converts an INTEGER, FLOAT, BOOLEAN, POINT or temporal type (i.e. DATE, ZONED TIME, LOCAL TIME, ZONED DATETIME, LOCAL DATETIME or DURATION) value to a STRING.']
to_string_or_null: Annotated[bool, 'The toStringOrNull() function. Converts an INTEGER, FLOAT, BOOLEAN, POINT or temporal type (i.e. DATE, ZONED TIME, LOCAL TIME, ZONED DATETIME, LOCAL DATETIME or DURATION) value to a STRING, or null if the value cannot be converted.']
to_upper: Annotated[bool, 'The toUpper() function. Returns the given STRING in uppercase.']
trim: Annotated[bool, 'The trim() function. Returns the given STRING with leading and trailing whitespace removed.; Returns the given STRING with the leading and/or trailing trimCharacterString character removed. Introduced in 5.20.']
upper: Annotated[bool, "The upper() function. Returns the given STRING in uppercase. This function is an alias to the toUpper() function, and it was introduced as part of Cypher's GQL conformance. Introduced in 5.21."]
with_btrim(btrim)
with_left(left)
with_lower(lower)
with_ltrim(ltrim)
with_normalize(normalize)
with_replace(replace)
with_reverse(reverse)
with_right(right)
with_rtrim(rtrim)
with_split(split)
with_substring(substring)
with_to_lower(to_lower)
with_to_string(to_string)
with_to_string_or_null(to_string_or_null)
with_to_upper(to_upper)
with_trim(trim)
with_upper(upper)
class hydra.cypher.features.TemporalDurationFunctionFeatures(duration: Annotated[bool, 'The duration() function. Constructs a DURATION value.'], duration_between: Annotated[bool, 'The duration.between() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in logical units.'], duration_in_days: Annotated[bool, 'The duration.inDays() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in days.'], duration_in_months: Annotated[bool, 'The duration.inMonths() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in months.'], duration_in_seconds: Annotated[bool, 'The duration.inSeconds() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in seconds.'])

Bases: object

Temporal duration functions.

class Builder(_duration: 'bool' = None, _duration_between: 'bool' = None, _duration_in_days: 'bool' = None, _duration_in_months: 'bool' = None, _duration_in_seconds: 'bool' = None)

Bases: object

build()
duration(duration)
duration_between(duration_between)
duration_in_days(duration_in_days)
duration_in_months(duration_in_months)
duration_in_seconds(duration_in_seconds)
DURATION = Name(value='duration')
DURATION_BETWEEN = Name(value='durationBetween')
DURATION_IN_DAYS = Name(value='durationInDays')
DURATION_IN_MONTHS = Name(value='durationInMonths')
DURATION_IN_SECONDS = Name(value='durationInSeconds')
TYPE_ = Name(value='hydra.cypher.features.TemporalDurationFunctionFeatures')
static builder()
duration: Annotated[bool, 'The duration() function. Constructs a DURATION value.']
duration_between: Annotated[bool, 'The duration.between() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in logical units.']
duration_in_days: Annotated[bool, 'The duration.inDays() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in days.']
duration_in_months: Annotated[bool, 'The duration.inMonths() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in months.']
duration_in_seconds: Annotated[bool, 'The duration.inSeconds() function. Computes the DURATION between the from instant (inclusive) and the to instant (exclusive) in seconds.']
with_duration(duration)
with_duration_between(duration_between)
with_duration_in_days(duration_in_days)
with_duration_in_months(duration_in_months)
with_duration_in_seconds(duration_in_seconds)
class hydra.cypher.features.TemporalInstantFunctionFeatures(date: Annotated[bool, 'The date() function. Creates a DATE instant.'], date_realtime: Annotated[bool, 'The date.realtime() function. Returns the current DATE instant using the realtime clock.'], date_statement: Annotated[bool, 'The date.statement() function. Returns the current DATE instant using the statement clock.'], date_transaction: Annotated[bool, 'The date.transaction() function. Returns the current DATE instant using the transaction clock.'], date_truncate: Annotated[bool, 'The date.truncate() function. Truncates the given temporal value to a DATE instant using the specified unit.'], datetime: Annotated[bool, 'The datetime() function. Creates a ZONED DATETIME instant.'], datetime_fromepoch: Annotated[bool, 'The datetime.fromepoch() function. Creates a ZONED DATETIME given the seconds and nanoseconds since the start of the epoch.'], datetime_fromepochmillis: Annotated[bool, 'The datetime.fromepochmillis() function. Creates a ZONED DATETIME given the milliseconds since the start of the epoch.'], datetime_realtime: Annotated[bool, 'The datetime.realtime() function. Returns the current ZONED DATETIME instant using the realtime clock.'], datetime_statement: Annotated[bool, 'The datetime.statement() function. Returns the current ZONED DATETIME instant using the statement clock.'], datetime_transaction: Annotated[bool, 'The datetime.transaction() function. Returns the current ZONED DATETIME instant using the transaction clock.'], datetime_truncate: Annotated[bool, 'The datetime.truncate() function. Truncates the given temporal value to a ZONED DATETIME instant using the specified unit.'], localdatetime: Annotated[bool, 'The localdatetime() function. Creates a LOCAL DATETIME instant.'], localdatetime_realtime: Annotated[bool, 'The localdatetime.realtime() function. Returns the current LOCAL DATETIME instant using the realtime clock.'], localdatetime_statement: Annotated[bool, 'The localdatetime.statement() function. Returns the current LOCAL DATETIME instant using the statement clock.'], localdatetime_transaction: Annotated[bool, 'The localdatetime.transaction() function. Returns the current LOCAL DATETIME instant using the transaction clock.'], localdatetime_truncate: Annotated[bool, 'The localdatetime.truncate() function. Truncates the given temporal value to a LOCAL DATETIME instant using the specified unit.'], localtime: Annotated[bool, 'The localtime() function. Creates a LOCAL TIME instant.'], localtime_realtime: Annotated[bool, 'The localtime.realtime() function. Returns the current LOCAL TIME instant using the realtime clock.'], localtime_statement: Annotated[bool, 'The localtime.statement() function. Returns the current LOCAL TIME instant using the statement clock.'], localtime_transaction: Annotated[bool, 'The localtime.transaction() function. Returns the current LOCAL TIME instant using the transaction clock.'], localtime_truncate: Annotated[bool, 'The localtime.truncate() function. Truncates the given temporal value to a LOCAL TIME instant using the specified unit.'], time: Annotated[bool, 'The time() function. Creates a ZONED TIME instant.'], time_realtime: Annotated[bool, 'The time.realtime() function. Returns the current ZONED TIME instant using the realtime clock.'], time_statement: Annotated[bool, 'The time.statement() function. Returns the current ZONED TIME instant using the statement clock.'], time_transaction: Annotated[bool, 'The time.transaction() function. Returns the current ZONED TIME instant using the transaction clock.'], time_truncate: Annotated[bool, 'The time.truncate() function. Truncates the given temporal value to a ZONED TIME instant using the specified unit.'])

Bases: object

Temporal instant functions.

class Builder(_date: 'bool' = None, _date_realtime: 'bool' = None, _date_statement: 'bool' = None, _date_transaction: 'bool' = None, _date_truncate: 'bool' = None, _datetime: 'bool' = None, _datetime_fromepoch: 'bool' = None, _datetime_fromepochmillis: 'bool' = None, _datetime_realtime: 'bool' = None, _datetime_statement: 'bool' = None, _datetime_transaction: 'bool' = None, _datetime_truncate: 'bool' = None, _localdatetime: 'bool' = None, _localdatetime_realtime: 'bool' = None, _localdatetime_statement: 'bool' = None, _localdatetime_transaction: 'bool' = None, _localdatetime_truncate: 'bool' = None, _localtime: 'bool' = None, _localtime_realtime: 'bool' = None, _localtime_statement: 'bool' = None, _localtime_transaction: 'bool' = None, _localtime_truncate: 'bool' = None, _time: 'bool' = None, _time_realtime: 'bool' = None, _time_statement: 'bool' = None, _time_transaction: 'bool' = None, _time_truncate: 'bool' = None)

Bases: object

build()
date(date)
date_realtime(date_realtime)
date_statement(date_statement)
date_transaction(date_transaction)
date_truncate(date_truncate)
datetime(datetime)
datetime_fromepoch(datetime_fromepoch)
datetime_fromepochmillis(datetime_fromepochmillis)
datetime_realtime(datetime_realtime)
datetime_statement(datetime_statement)
datetime_transaction(datetime_transaction)
datetime_truncate(datetime_truncate)
localdatetime(localdatetime)
localdatetime_realtime(localdatetime_realtime)
localdatetime_statement(localdatetime_statement)
localdatetime_transaction(localdatetime_transaction)
localdatetime_truncate(localdatetime_truncate)
localtime(localtime)
localtime_realtime(localtime_realtime)
localtime_statement(localtime_statement)
localtime_transaction(localtime_transaction)
localtime_truncate(localtime_truncate)
time(time)
time_realtime(time_realtime)
time_statement(time_statement)
time_transaction(time_transaction)
time_truncate(time_truncate)
DATE = Name(value='date')
DATETIME = Name(value='datetime')
DATETIME_FROMEPOCH = Name(value='datetimeFromepoch')
DATETIME_FROMEPOCHMILLIS = Name(value='datetimeFromepochmillis')
DATETIME_REALTIME = Name(value='datetimeRealtime')
DATETIME_STATEMENT = Name(value='datetimeStatement')
DATETIME_TRANSACTION = Name(value='datetimeTransaction')
DATETIME_TRUNCATE = Name(value='datetimeTruncate')
DATE_REALTIME = Name(value='dateRealtime')
DATE_STATEMENT = Name(value='dateStatement')
DATE_TRANSACTION = Name(value='dateTransaction')
DATE_TRUNCATE = Name(value='dateTruncate')
LOCALDATETIME = Name(value='localdatetime')
LOCALDATETIME_REALTIME = Name(value='localdatetimeRealtime')
LOCALDATETIME_STATEMENT = Name(value='localdatetimeStatement')
LOCALDATETIME_TRANSACTION = Name(value='localdatetimeTransaction')
LOCALDATETIME_TRUNCATE = Name(value='localdatetimeTruncate')
LOCALTIME = Name(value='localtime')
LOCALTIME_REALTIME = Name(value='localtimeRealtime')
LOCALTIME_STATEMENT = Name(value='localtimeStatement')
LOCALTIME_TRANSACTION = Name(value='localtimeTransaction')
LOCALTIME_TRUNCATE = Name(value='localtimeTruncate')
TIME = Name(value='time')
TIME_REALTIME = Name(value='timeRealtime')
TIME_STATEMENT = Name(value='timeStatement')
TIME_TRANSACTION = Name(value='timeTransaction')
TIME_TRUNCATE = Name(value='timeTruncate')
TYPE_ = Name(value='hydra.cypher.features.TemporalInstantFunctionFeatures')
static builder()
date: Annotated[bool, 'The date() function. Creates a DATE instant.']
date_realtime: Annotated[bool, 'The date.realtime() function. Returns the current DATE instant using the realtime clock.']
date_statement: Annotated[bool, 'The date.statement() function. Returns the current DATE instant using the statement clock.']
date_transaction: Annotated[bool, 'The date.transaction() function. Returns the current DATE instant using the transaction clock.']
date_truncate: Annotated[bool, 'The date.truncate() function. Truncates the given temporal value to a DATE instant using the specified unit.']
datetime: Annotated[bool, 'The datetime() function. Creates a ZONED DATETIME instant.']
datetime_fromepoch: Annotated[bool, 'The datetime.fromepoch() function. Creates a ZONED DATETIME given the seconds and nanoseconds since the start of the epoch.']
datetime_fromepochmillis: Annotated[bool, 'The datetime.fromepochmillis() function. Creates a ZONED DATETIME given the milliseconds since the start of the epoch.']
datetime_realtime: Annotated[bool, 'The datetime.realtime() function. Returns the current ZONED DATETIME instant using the realtime clock.']
datetime_statement: Annotated[bool, 'The datetime.statement() function. Returns the current ZONED DATETIME instant using the statement clock.']
datetime_transaction: Annotated[bool, 'The datetime.transaction() function. Returns the current ZONED DATETIME instant using the transaction clock.']
datetime_truncate: Annotated[bool, 'The datetime.truncate() function. Truncates the given temporal value to a ZONED DATETIME instant using the specified unit.']
localdatetime: Annotated[bool, 'The localdatetime() function. Creates a LOCAL DATETIME instant.']
localdatetime_realtime: Annotated[bool, 'The localdatetime.realtime() function. Returns the current LOCAL DATETIME instant using the realtime clock.']
localdatetime_statement: Annotated[bool, 'The localdatetime.statement() function. Returns the current LOCAL DATETIME instant using the statement clock.']
localdatetime_transaction: Annotated[bool, 'The localdatetime.transaction() function. Returns the current LOCAL DATETIME instant using the transaction clock.']
localdatetime_truncate: Annotated[bool, 'The localdatetime.truncate() function. Truncates the given temporal value to a LOCAL DATETIME instant using the specified unit.']
localtime: Annotated[bool, 'The localtime() function. Creates a LOCAL TIME instant.']
localtime_realtime: Annotated[bool, 'The localtime.realtime() function. Returns the current LOCAL TIME instant using the realtime clock.']
localtime_statement: Annotated[bool, 'The localtime.statement() function. Returns the current LOCAL TIME instant using the statement clock.']
localtime_transaction: Annotated[bool, 'The localtime.transaction() function. Returns the current LOCAL TIME instant using the transaction clock.']
localtime_truncate: Annotated[bool, 'The localtime.truncate() function. Truncates the given temporal value to a LOCAL TIME instant using the specified unit.']
time: Annotated[bool, 'The time() function. Creates a ZONED TIME instant.']
time_realtime: Annotated[bool, 'The time.realtime() function. Returns the current ZONED TIME instant using the realtime clock.']
time_statement: Annotated[bool, 'The time.statement() function. Returns the current ZONED TIME instant using the statement clock.']
time_transaction: Annotated[bool, 'The time.transaction() function. Returns the current ZONED TIME instant using the transaction clock.']
time_truncate: Annotated[bool, 'The time.truncate() function. Truncates the given temporal value to a ZONED TIME instant using the specified unit.']
with_date(date)
with_date_realtime(date_realtime)
with_date_statement(date_statement)
with_date_transaction(date_transaction)
with_date_truncate(date_truncate)
with_datetime(datetime)
with_datetime_fromepoch(datetime_fromepoch)
with_datetime_fromepochmillis(datetime_fromepochmillis)
with_datetime_realtime(datetime_realtime)
with_datetime_statement(datetime_statement)
with_datetime_transaction(datetime_transaction)
with_datetime_truncate(datetime_truncate)
with_localdatetime(localdatetime)
with_localdatetime_realtime(localdatetime_realtime)
with_localdatetime_statement(localdatetime_statement)
with_localdatetime_transaction(localdatetime_transaction)
with_localdatetime_truncate(localdatetime_truncate)
with_localtime(localtime)
with_localtime_realtime(localtime_realtime)
with_localtime_statement(localtime_statement)
with_localtime_transaction(localtime_transaction)
with_localtime_truncate(localtime_truncate)
with_time(time)
with_time_realtime(time_realtime)
with_time_statement(time_statement)
with_time_transaction(time_transaction)
with_time_truncate(time_truncate)
class hydra.cypher.features.TrigonometricFunctionFeatures(acos: Annotated[bool, 'The acos() function. Returns the arccosine of a FLOAT in radians.'], asin: Annotated[bool, 'The asin() function. Returns the arcsine of a FLOAT in radians.'], atan: Annotated[bool, 'The atan() function. Returns the arctangent of a FLOAT in radians.'], atan2: Annotated[bool, 'The atan2() function. Returns the arctangent2 of a set of coordinates in radians.'], cos: Annotated[bool, 'The cos() function. Returns the cosine of a FLOAT.'], cot: Annotated[bool, 'The cot() function. Returns the cotangent of a FLOAT.'], degrees: Annotated[bool, 'The degrees() function. Converts radians to degrees.'], haversin: Annotated[bool, 'The haversin() function. Returns half the versine of a number.'], pi: Annotated[bool, 'The pi() function. Returns the mathematical constant pi.'], radians: Annotated[bool, 'The radians() function. Converts degrees to radians.'], sin: Annotated[bool, 'The sin() function. Returns the sine of a FLOAT.'], tan: Annotated[bool, 'The tan() function. Returns the tangent of a FLOAT.'])

Bases: object

Trigonometric functions.

ACOS = Name(value='acos')
ASIN = Name(value='asin')
ATAN = Name(value='atan')
ATAN2 = Name(value='atan2')
class Builder(_acos: 'bool' = None, _asin: 'bool' = None, _atan: 'bool' = None, _atan2: 'bool' = None, _cos: 'bool' = None, _cot: 'bool' = None, _degrees: 'bool' = None, _haversin: 'bool' = None, _pi: 'bool' = None, _radians: 'bool' = None, _sin: 'bool' = None, _tan: 'bool' = None)

Bases: object

acos(acos)
asin(asin)
atan(atan)
atan2(atan2)
build()
cos(cos)
cot(cot)
degrees(degrees)
haversin(haversin)
pi(pi)
radians(radians)
sin(sin)
tan(tan)
COS = Name(value='cos')
COT = Name(value='cot')
DEGREES = Name(value='degrees')
HAVERSIN = Name(value='haversin')
PI = Name(value='pi')
RADIANS = Name(value='radians')
SIN = Name(value='sin')
TAN = Name(value='tan')
TYPE_ = Name(value='hydra.cypher.features.TrigonometricFunctionFeatures')
acos: Annotated[bool, 'The acos() function. Returns the arccosine of a FLOAT in radians.']
asin: Annotated[bool, 'The asin() function. Returns the arcsine of a FLOAT in radians.']
atan: Annotated[bool, 'The atan() function. Returns the arctangent of a FLOAT in radians.']
atan2: Annotated[bool, 'The atan2() function. Returns the arctangent2 of a set of coordinates in radians.']
static builder()
cos: Annotated[bool, 'The cos() function. Returns the cosine of a FLOAT.']
cot: Annotated[bool, 'The cot() function. Returns the cotangent of a FLOAT.']
degrees: Annotated[bool, 'The degrees() function. Converts radians to degrees.']
haversin: Annotated[bool, 'The haversin() function. Returns half the versine of a number.']
pi: Annotated[bool, 'The pi() function. Returns the mathematical constant pi.']
radians: Annotated[bool, 'The radians() function. Converts degrees to radians.']
sin: Annotated[bool, 'The sin() function. Returns the sine of a FLOAT.']
tan: Annotated[bool, 'The tan() function. Returns the tangent of a FLOAT.']
with_acos(acos)
with_asin(asin)
with_atan(atan)
with_atan2(atan2)
with_cos(cos)
with_cot(cot)
with_degrees(degrees)
with_haversin(haversin)
with_pi(pi)
with_radians(radians)
with_sin(sin)
with_tan(tan)
class hydra.cypher.features.UpdatingFeatures(create: Annotated[bool, 'The CREATE clause'], set: Annotated[bool, 'The SET clause'], with_: Annotated[bool, 'Multi-part queries using WITH'])

Bases: object

Specific syntax related to updating data in the graph.

class Builder(_create: 'bool' = None, _set: 'bool' = None, _with_: 'bool' = None)

Bases: object

build()
create(create)
set(set)
with_(with_)
CREATE = Name(value='create')
SET = Name(value='set')
TYPE_ = Name(value='hydra.cypher.features.UpdatingFeatures')
WITH = Name(value='with')
static builder()
create: Annotated[bool, 'The CREATE clause']
set: Annotated[bool, 'The SET clause']
with_: Annotated[bool, 'Multi-part queries using WITH']
with_create(create)
with_set(set)
with_with_(with_)
class hydra.cypher.features.VectorFunctionFeatures(vector_similarity_cosine: Annotated[bool, 'The vector.similarity.cosine() function. Returns a FLOAT representing the similarity between the argument vectors based on their cosine.'], vector_similarity_euclidean: Annotated[bool, 'The vector.similarity.euclidean() function. Returns a FLOAT representing the similarity between the argument vectors based on their Euclidean distance.'])

Bases: object

Vector functions.

class Builder(_vector_similarity_cosine: 'bool' = None, _vector_similarity_euclidean: 'bool' = None)

Bases: object

build()
vector_similarity_cosine(vector_similarity_cosine)
vector_similarity_euclidean(vector_similarity_euclidean)
TYPE_ = Name(value='hydra.cypher.features.VectorFunctionFeatures')
VECTOR_SIMILARITY_COSINE = Name(value='vectorSimilarityCosine')
VECTOR_SIMILARITY_EUCLIDEAN = Name(value='vectorSimilarityEuclidean')
static builder()
vector_similarity_cosine: Annotated[bool, 'The vector.similarity.cosine() function. Returns a FLOAT representing the similarity between the argument vectors based on their cosine.']
vector_similarity_euclidean: Annotated[bool, 'The vector.similarity.euclidean() function. Returns a FLOAT representing the similarity between the argument vectors based on their Euclidean distance.']
with_vector_similarity_cosine(vector_similarity_cosine)
with_vector_similarity_euclidean(vector_similarity_euclidean)