Class: Cyrel::AST::Compiler

Inherits:
Object
  • Object
show all
Defined in:
lib/cyrel/ast/compiler.rb

Overview

Compiles AST nodes into Cypher queries with optional thread-safety It’s like Google Translate, but for graph databases and with more reliable results

Direct Known Subclasses

QueryIntegratedCompiler

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Compiler

Returns a new instance of Compiler.



12
13
14
15
16
17
18
 
# File 'lib/cyrel/ast/compiler.rb', line 12

def initialize
  @output = StringIO.new
  @parameters = {}
  @param_counter = 0
  @first_clause = true
  @loop_variables = Set.new # Track loop variables that shouldn't be parameterized
end

Instance Attribute Details

#output ⇒ Object (readonly)

Returns the value of attribute output.



10
11
12
 
# File 'lib/cyrel/ast/compiler.rb', line 10

def output
  @output
end

#parameters ⇒ Object (readonly)

Returns the value of attribute parameters.



10
11
12
 
# File 'lib/cyrel/ast/compiler.rb', line 10

def parameters
  @parameters
end

Instance Method Details

#compile(node_or_nodes) ⇒ Object

Compile an AST node or array of nodes Returns [cypher_string, parameters_hash]



22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/cyrel/ast/compiler.rb', line 22

def compile(node_or_nodes)
  nodes = Array(node_or_nodes)

  nodes.each do |node|
    add_clause_separator unless @first_clause
    node.accept(self)
    @first_clause = false
  end

  [@output.string, @parameters]
end

#visit_call_node(node) ⇒ Object

Visit a CALL clause node (procedure call) Invoking the stored procedures of the graph database



217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/cyrel/ast/compiler.rb', line 217

def visit_call_node(node)
  @output << "CALL #{node.procedure_name}"

  if node.arguments.any?
    @output << '('
    node.arguments.each_with_index do |arg, i|
      @output << ', ' if i.positive?
      render_expression(Expression.coerce(arg))
    end
    @output << ')'
  end

  return unless node.yield_items

  @output << ' YIELD '
  if node.yield_items.is_a?(Hash)
    # YIELD items with aliases
    node.yield_items.each_with_index do |(item, alias_name), i|
      @output << ', ' if i.positive?
      @output << item.to_s
      @output << " AS #{alias_name}" if alias_name && alias_name != item
    end
  else
    # Simple yield list
    Array(node.yield_items).each_with_index do |item, i|
      @output << ', ' if i.positive?
      @output << item.to_s
    end
  end
end

#visit_call_subquery_node(node) ⇒ Object

Visit a CALL subquery node Queries all the way down



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/cyrel/ast/compiler.rb', line 250

def visit_call_subquery_node(node)
  @output << "CALL {\n"

  # Render subquery clauses directly without going through the cache
  # to avoid recursive locking issues
  subquery = node.subquery
  subquery_clauses = subquery.clauses.sort_by { |clause| subquery.send(:clause_order, clause) }

  subquery_clauses.each_with_index do |clause, index|
    @output << "\n" if index.positive? # Add newline between clauses

    if clause.is_a?(AST::ClauseAdapter)
      # For AST-based clauses, compile directly without cache
      # Create a proxy object that forwards parameter registration to this compiler
      parameter_proxy = Object.new
      parent_compiler = self
      parameter_proxy.define_singleton_method(:register_parameter) do |value|
        parent_compiler.send(:register_parameter, value)
      end

      subquery_compiler = QueryIntegratedCompiler.new(parameter_proxy)
      clause_cypher, = subquery_compiler.compile(clause.ast_node)
      @output << indent_block(clause_cypher)
    else
      # For legacy clauses, render normally
      clause_output = clause.render(subquery)
      @output << indent_block(clause_output) unless clause_output.blank?

      # Merge subquery parameters
      subquery.parameters.each_value do |value|
        register_parameter(value)
      end
    end
  end

  @output << "\n}"
end

#visit_create_node(node) ⇒ Object

Visit a CREATE clause node Making nodes and relationships appear out of thin air



157
158
159
160
 
# File 'lib/cyrel/ast/compiler.rb', line 157

def visit_create_node(node)
  @output << 'CREATE '
  render_pattern(node.pattern)
end

#visit_delete_node(node) ⇒ Object

Visit a DELETE clause node Making nodes disappear, potentially with their relationships



183
184
185
186
187
188
189
190
191
 
# File 'lib/cyrel/ast/compiler.rb', line 183

def visit_delete_node(node)
  @output << 'DETACH ' if node.detach
  @output << 'DELETE '

  node.variables.each_with_index do |var, i|
    @output << ', ' if i.positive?
    @output << var.to_s
  end
end

#visit_foreach_node(node) ⇒ Object

Visit a FOREACH node Iterating through lists like a database therapist



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/cyrel/ast/compiler.rb', line 335

def visit_foreach_node(node)
  @output << "FOREACH (#{node.variable} IN "

  # Handle the expression - could be an array literal or an expression.
  # An array is parameterized whole; everything else defers to the shared helper.
  if node.expression.is_a?(Array)
    @output << "$#{register_parameter(node.expression)}"
  else
    render_param_or_expression(node.expression)
  end

  @output << ' | '

  # Track the loop variable so it doesn't get parameterized in inner clauses
  old_loop_variables = @loop_variables.dup
  @loop_variables.add(node.variable.to_sym)

  # Render update clauses without duplication
  node.update_clauses.each_with_index do |clause, index|
    @output << ' ' if index.positive?

    raise "Unexpected clause type in FOREACH: #{clause.class}" unless clause.is_a?(AST::ClauseAdapter)

    # For AST-based clauses, compile just the inner content
    # Create a proxy object that forwards parameter registration to this compiler
    # and inherits the loop variable context
    parameter_proxy = Object.new
    parent_compiler = self
    current_loop_variables = @loop_variables.dup
    parameter_proxy.define_singleton_method(:register_parameter) do |value|
      # Check if this is a loop variable that shouldn't be parameterized
      if value.is_a?(Symbol) && current_loop_variables.include?(value)
        value # Return the symbol itself, not a parameter key
      else
        parent_compiler.send(:register_parameter, value)
      end
    end

    inner_compiler = QueryIntegratedCompiler.new(parameter_proxy)
    # Pass the loop variables context to the inner compiler
    inner_compiler.instance_variable_set(:@loop_variables, @loop_variables.dup)
    clause_cypher, = inner_compiler.compile([clause.ast_node])
    @output << clause_cypher
  end

  # Restore previous loop variables context
  @loop_variables = old_loop_variables

  @output << ')'
end

#visit_limit_node(node) ⇒ Object

Visit a LIMIT node Because sometimes less is more, except in this comment



36
37
38
39
 
# File 'lib/cyrel/ast/compiler.rb', line 36

def visit_limit_node(node)
  @output << 'LIMIT '
  render_expression(node.expression)
end

#visit_literal_node(node) ⇒ Object

Visit a literal value node The most honest node in the entire tree



412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/cyrel/ast/compiler.rb', line 412

def visit_literal_node(node)
  if node.value.is_a?(Symbol)
    # Check if this symbol is a loop variable
    @output << if @loop_variables.include?(node.value)
                 # Loop variables are rendered as-is, not as parameters
                 node.value.to_s
               else
                 # Symbols are parameter references, not values to be parameterized
                 "$#{node.value}"
               end
  else
    # All other literals become parameters for consistency with existing behavior
    param_key = register_parameter(node.value)
    @output << "$#{param_key}"
  end
end

#visit_load_csv_node(node) ⇒ Object

Visit a LOAD CSV node Reading CSV files like it’s 1999



388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
# File 'lib/cyrel/ast/compiler.rb', line 388

def visit_load_csv_node(node)
  @output << 'LOAD CSV'
  @output << ' WITH HEADERS' if node.with_headers
  @output << ' FROM '

  # URL can be a string or expression
  if node.url.is_a?(String)
    param_key = register_parameter(node.url)
    @output << "$#{param_key}"
  else
    render_expression(node.url)
  end

  @output << " AS #{node.variable}"

  return unless node.fieldterminator

  @output << ' FIELDTERMINATOR '
  param_key = register_parameter(node.fieldterminator)
  @output << "$#{param_key}"
end

#visit_match_node(node) ⇒ Object

Visit a MATCH clause node Finding nodes in the graph, one pattern at a time



145
146
147
148
149
150
151
152
153
 
# File 'lib/cyrel/ast/compiler.rb', line 145

def visit_match_node(node)
  @output << (node.optional ? 'OPTIONAL MATCH ' : 'MATCH ')

  # Handle path variable assignment if present
  @output << "#{node.path_variable} = " if node.path_variable

  # Render the pattern
  render_pattern(node.pattern)
end

#visit_merge_node(node) ⇒ Object

Visit a MERGE clause node Finding or creating, because commitment issues



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/cyrel/ast/compiler.rb', line 164

def visit_merge_node(node)
  @output << 'MERGE '
  render_pattern(node.pattern)

  # Handle ON CREATE SET
  if node.on_create
    @output << "\nON CREATE SET "
    render_merge_assignments(node.on_create)
  end

  # Handle ON MATCH SET
  return unless node.on_match

  @output << "\nON MATCH SET "
  render_merge_assignments(node.on_match)
end

#visit_order_by_node(node) ⇒ Object

Visit an ORDER BY node Because even chaos needs some structure sometimes



50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/cyrel/ast/compiler.rb', line 50

def visit_order_by_node(node)
  @output << 'ORDER BY '
  @in_order_by = true

  node.items.each_with_index do |(expr, direction), index|
    @output << ', ' if index.positive?
    render_expression(expr)
    @output << " #{direction.to_s.upcase}" if direction && direction != :asc
  end

  @in_order_by = false
end

#visit_remove_node(node) ⇒ Object

Visit a REMOVE clause node Tidying up properties and labels



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/cyrel/ast/compiler.rb', line 195

def visit_remove_node(node)
  @output << 'REMOVE '

  node.items.each_with_index do |item, i|
    @output << ', ' if i.positive?

    case item
    when Expression::PropertyAccess
      # Remove property
      render_expression(item)
    when Array
      # Remove label [variable, label]
      variable, label = item
      @output << "#{variable}:#{label}"
    else
      raise "Unknown REMOVE item type: #{item.class}"
    end
  end
end

#visit_return_node(node) ⇒ Object

Visit a RETURN node Where your data comes home to roost



83
84
85
86
87
88
 
# File 'lib/cyrel/ast/compiler.rb', line 83

def visit_return_node(node)
  @output << 'RETURN '
  @output << 'DISTINCT ' if node.distinct

  render_comma_separated(node.items)
end

#visit_set_node(node) ⇒ Object

Visit a SET node Where change happens, one property at a time



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/cyrel/ast/compiler.rb', line 92

def visit_set_node(node)
  return if node.assignments.empty?

  @output << 'SET '

  node.assignments.each_with_index do |assignment, index|
    @output << ', ' if index.positive?
    render_assignment(assignment)
  end
end

#visit_skip_node(node) ⇒ Object

Visit a SKIP node For when you want to jump ahead in your results



43
44
45
46
 
# File 'lib/cyrel/ast/compiler.rb', line 43

def visit_skip_node(node)
  @output << 'SKIP '
  render_expression(node.amount)
end

#visit_union_node(node) ⇒ Object

Visit a UNION node Combining queries like a Cypher mixologist



290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/cyrel/ast/compiler.rb', line 290

def visit_union_node(node)
  # UNION is special - it combines complete queries
  # We need to render each query's clauses directly to avoid recursive locking
  node.queries.each_with_index do |query, index|
    if index.positive?
      @output << "\n"
      @output << 'UNION'
      @output << ' ALL' if node.all
      @output << "\n"
    end

    # Render query clauses directly without going through cache
    query_clauses = query.clauses.sort_by { |clause| query.send(:clause_order, clause) }

    query_clauses.each_with_index do |clause, clause_index|
      @output << "\n" if clause_index.positive?

      if clause.is_a?(AST::ClauseAdapter)
        # For AST-based clauses, compile directly without cache
        # Create a proxy object that forwards parameter registration to this compiler
        parameter_proxy = Object.new
        parent_compiler = self
        parameter_proxy.define_singleton_method(:register_parameter) do |value|
          parent_compiler.send(:register_parameter, value)
        end

        clause_compiler = QueryIntegratedCompiler.new(parameter_proxy)
        clause_cypher, = clause_compiler.compile(clause.ast_node)
        @output << clause_cypher
      else
        # For legacy clauses, render normally
        clause_output = clause.render(query)
        @output << clause_output unless clause_output.blank?

        # Merge query parameters
        query.parameters.each_value do |value|
          register_parameter(value)
        end
      end
    end
  end
end

#visit_unwind_node(node) ⇒ Object

Visit an UNWIND node Unpacking arrays like unwrapping presents



129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/cyrel/ast/compiler.rb', line 129

def visit_unwind_node(node)
  @output << 'UNWIND '

  # Render the expression to unwind
  if node.expression.is_a?(Array)
    # Array literal
    @output << format_array_literal(node.expression)
  else
    render_param_or_expression(node.expression)
  end

  @output << " AS #{node.alias_name}"
end

#visit_where_node(node) ⇒ Object

Visit a WHERE node Because sometimes you need to be selective about your relationships



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/cyrel/ast/compiler.rb', line 65

def visit_where_node(node)
  return if node.conditions.empty?

  @output << 'WHERE '

  if node.conditions.length == 1
    render_expression(node.conditions.first)
  else
    # Combine multiple conditions with AND
    node.conditions.each_with_index do |condition, index|
      @output << ' AND ' if index.positive?
      render_expression(condition)
    end
  end
end

#visit_with_node(node) ⇒ Object

Visit a WITH node Because sometimes you need to pass data along for the next part of your journey



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/cyrel/ast/compiler.rb', line 105

def visit_with_node(node)
  @output << 'WITH '
  @output << 'DISTINCT ' if node.distinct

  render_comma_separated(node.items)

  # Add WHERE clause if present
  return unless node.where_conditions && !node.where_conditions.empty?

  @output << "\nWHERE "

  if node.where_conditions.length == 1
    render_expression(node.where_conditions.first)
  else
    # Combine multiple conditions with AND
    node.where_conditions.each_with_index do |condition, index|
      @output << ' AND ' if index.positive?
      render_expression(condition)
    end
  end
end