Class: ActiveCypher::ConnectionAdapters::Neo4jAdapter

Inherits:
AbstractBoltAdapter show all
Defined in:
lib/active_cypher/connection_adapters/neo4j_adapter.rb

Defined Under Namespace

Modules: Persistence Classes: ProtocolHandler

Constant Summary collapse

ID_FUNCTION =

Use elementId() for Neo4j

'elementId'

Instance Attribute Summary

Attributes inherited from AbstractBoltAdapter

#connection

Attributes inherited from AbstractAdapter

#config

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from AbstractBoltAdapter

#active?, #connect, #create_protocol_handler, #disconnect, #raw_connection, #reset!, #run

Methods included from Instrumentation

#instrument, #instrument_connection, #instrument_query, #instrument_transaction, #sanitize_config, #sanitize_params, #sensitive_key?

Methods inherited from AbstractAdapter

#active?, #connect, #disconnect, #initialize, #inspect, #prepare_params, #process_records, #reconnect

Constructor Details

This class inherits a constructor from ActiveCypher::ConnectionAdapters::AbstractAdapter

Class Method Details

.id_function ⇒ Object 



84
85
86
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 84

def self.id_function
  'elementId'
end

.node_id_equals_value(alias_name, value) ⇒ Object 



73
74
75
76
77
78
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 73

def self.node_id_equals_value(alias_name, value)
  # Quote string values for Cypher because Neo4j is paranoid about injection attacks
  # (As it should be, have you seen what people try to inject these days?)
  quoted_value = value.is_a?(String) ? "'#{value}'" : value
  "elementId(#{alias_name}) = #{quoted_value}"
end

.node_id_where(alias_name, param_name = nil) ⇒ Object

Additional helper methods for nodes



65
66
67
68
69
70
71
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 65

def self.node_id_where(alias_name, param_name = nil)
  if param_name
    "elementId(#{alias_name}) = $#{param_name}"
  else
    "elementId(#{alias_name})"
  end
end

.return_id ⇒ Object 



60
61
62
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 60

def self.return_id
  'elementId(r) AS rid'
end

.return_node_id(alias_name, as_name = 'internal_id') ⇒ Object 



80
81
82
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 80

def self.return_node_id(alias_name, as_name = 'internal_id')
  "elementId(#{alias_name}) AS #{as_name}"
end

.with_direct_id(id) ⇒ Object

Helper methods for Cypher query generation with IDs



42
43
44
45
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 42

def self.with_direct_id(id)
  # Quote the element ID to handle special characters in Neo4j element IDs
  "elementId(r) = '#{id}'"
end

.with_direct_node_ids(a_id, b_id) ⇒ Object 



51
52
53
54
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 51

def self.with_direct_node_ids(a_id, b_id)
  # Quote the element IDs to handle special characters like colons in UUID-based IDs
  "elementId(p) = '#{a_id}' AND elementId(h) = '#{b_id}'"
end

.with_param_id ⇒ Object 



47
48
49
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 47

def self.with_param_id
  'elementId(r) = $id'
end

.with_param_node_ids ⇒ Object 



56
57
58
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 56

def self.with_param_node_ids
  'elementId(p) = $from_id AND elementId(h) = $to_id'
end

Instance Method Details

#begin_transaction ⇒ Object

Explicit TX helpers — optional but handy.



109
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 109

def begin_transaction(**) = (@tx = @connection.session.begin_transaction(**))

#commit_transaction(_) ⇒ Object 



110
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 110

def commit_transaction(_)   = @tx&.commit

#convert_access_mode(mode) ⇒ Object

Implement database-specific methods



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 115

def convert_access_mode(mode)
  case mode.to_s
  when 'r', 'read'
    'r'
  when 'w', 'write'
    'w'
  else
    'w' # Default to write
  end
end

#execute_cypher(cypher, params = {}, ctx = 'Query') ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 93

def execute_cypher(cypher, params = {}, ctx = 'Query')
  connect
  # Replace adapter-aware placeholder with Neo4j's elementId function
  cypher = cypher.gsub('__NODE_ID__', 'elementId')

  session = connection.session # thin wrapper around Bolt::Session
  result  = session.write_transaction do |tx|
    logger.debug { "[#{ctx}] #{cypher} #{params.inspect}" }
    tx.run(cypher, prepare_params(params))
  end
  process_records(result.to_a)
ensure
  session&.close
end

#hydrate_record(record, node_alias) ⇒ Hash

Hydrates attributes from a Neo4j record



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 137

def hydrate_record(record, node_alias)
  attrs = {}
  node_data = record[node_alias] || record[node_alias.to_s]

  if node_data.is_a?(Array) && node_data.length >= 2
    properties_container = node_data[1]
    if properties_container.is_a?(Array) && properties_container.length >= 3
      properties = properties_container[2]
      properties.each { |k, v| attrs[k.to_sym] = v } if properties.is_a?(Hash)
    end
  elsif node_data.is_a?(Hash)
    node_data.each { |k, v| attrs[k.to_sym] = v }
  elsif node_data.respond_to?(:properties)
    attrs = node_data.properties.symbolize_keys
  end

  attrs[:internal_id] = record[:internal_id] || record['internal_id']
  attrs
end

#id_handler ⇒ Object

Return self as id_handler for compatibility



89
90
91
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 89

def id_handler
  self.class
end

#prepare_tx_metadata(metadata, db, access_mode) ⇒ Object 



126
127
128
129
130
131
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 126

def prepare_tx_metadata(metadata, db, access_mode)
  # Handle Neo4j-specific metadata
  metadata['db'] = db if db
  metadata['mode'] = convert_access_mode(access_mode)
  metadata.compact
end

#rollback_transaction(_) ⇒ Object 



111
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 111

def rollback_transaction(_) = @tx&.rollback

#schema_catalog ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 10

def schema_catalog
  idx_rows = run('SHOW INDEXES')
  con_rows = run('SHOW CONSTRAINTS')

  idx_defs = idx_rows.map do |r|
    Schema::IndexDef.new(
      r['name'],
      r['entityType'].downcase.to_sym,
      r['labelsOrTypes'].first,
      r['properties'],
      r['uniqueness'] == 'UNIQUE',
      r['type'] == 'VECTOR' ? r['options'] : nil
    )
  end

  con_defs = con_rows.map do |r|
    Schema::ConstraintDef.new(
      r['name'],
      r['labelsOrTypes'].first,
      r['properties'],
      r['type'].split('_').first.downcase.to_sym
    )
  end

  Schema::Catalog.new(indexes: idx_defs, constraints: con_defs,
                      node_types: [], edge_types: [])
end

#vendor ⇒ Object 



8
 
# File 'lib/active_cypher/connection_adapters/neo4j_adapter.rb', line 8

def vendor = :neo4j