Class: Neo4j::ActiveNode::Query::QueryProxy

Inherits:
Object
  • Object
show all
Includes:
Dependent::QueryProxyMethods, QueryProxyEagerLoading, QueryProxyEnumerable, QueryProxyFindInBatches, QueryProxyMethods, QueryProxyMethodsOfMassUpdating
Defined in:
lib/neo4j/active_node/query/query_proxy.rb,
lib/neo4j/active_node/query/query_proxy_link.rb

Defined Under Namespace

Classes: Link

Constant Summary collapse

METHODS = 
%w(where where_not rel_where rel_order order skip limit)

Constants included from QueryProxyMethods

Neo4j::ActiveNode::Query::QueryProxyMethods::FIRST, Neo4j::ActiveNode::Query::QueryProxyMethods::LAST

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Dependent::QueryProxyMethods

#each_for_destruction, #unique_nodes

Methods included from QueryProxyEagerLoading

#each, #with_associations, #with_associations_spec

Methods included from QueryProxyFindInBatches

#find_each, #find_in_batches

Methods included from QueryProxyMethodsOfMassUpdating

#delete, #delete_all, #delete_all_rels, #destroy, #replace_with, #update_all, #update_all_rels

Methods included from QueryProxyMethods

#as_models, #count, #empty?, #exists?, #find, #find_or_create_by, #first, #first_rel_to, #include?, #last, #limit_value, #match_to, #optional, #order_property, #rel, #rels, #rels_to, #size

Methods included from QueryProxyEnumerable

#==, #each, #each_rel, #each_with_rel, #fetch_result_cache, #pluck, #result, #result_cache?, #result_cache_for

Constructor Details

#initialize(model, association = nil, options = {}) ⇒ QueryProxy

QueryProxy is ActiveNode’s Cypher DSL. While the name might imply that it creates queries in a general sense, it is actually referring to Neo4j::Core::Query, which is a pure Ruby Cypher DSL provided by the neo4j-core gem. QueryProxy provides ActiveRecord-like methods for common patterns. When it’s not handling CRUD for relationships and queries, it provides ActiveNode’s association chaining (‘student.lessons.teachers.where(age: 30).hobbies`) and enjoys long walks on the beach.

It should not ever be necessary to instantiate a new QueryProxy object directly, it always happens as a result of calling a method that makes use of it.

originated. has_many) that created this object. QueryProxy objects are evaluated lazily.

Parameters:

  • model (Constant) —

    The class which included ActiveNode (typically a model, hence the name) from which the query

  • association (Neo4j::ActiveNode::HasN::Association) (defaults to: nil) —

    The ActiveNode association (an object created by a has_one or

  • options (Hash) (defaults to: {}) —

    Additional options pertaining to the QueryProxy object. These may include:

Options Hash (options):

  • :node_var (String, Symbol) —

    A string or symbol to be used by Cypher within its query string as an identifier

  • :rel_var (String, Symbol) —

    Same as above but pertaining to a relationship identifier

  • :rel_length (Range, Fixnum, Symbol, Hash) —

    A Range, a Fixnum, a Hash or a Symbol to indicate the variable-length/fixed-length qualifier of the relationship. See neo4jrb.readthedocs.org/en/latest/Querying.html#variable-length-relationships.

  • :session (Neo4j::Session) —

    The session to be used for this query

  • :source_object (Neo4j::ActiveNode) —

    The node instance at the start of the QueryProxy chain

  • :query_proxy (QueryProxy) —

    An existing QueryProxy chain upon which this new object should be built



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 39

def initialize(model, association = nil, options = {})
  @model = model
  @association = association
  @context = options.delete(:context)
  @options = options
  @associations_spec = []

  instance_vars_from_options!(options)

  @match_type = @optional ? :optional_match : :match

  @rel_var = options[:rel] || _rel_chain_var

  @chain = []
  @params = @query_proxy ? @query_proxy.instance_variable_get('@params') : {}
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object

QueryProxy objects act as a representation of a model at the class level so we pass through calls This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing



245
246
247
248
249
250
251
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 245

def method_missing(method_name, *args, &block)
  if @model && @model.respond_to?(method_name)
    scoping { @model.public_send(method_name, *args, &block) }
  else
    super
  end
end

Instance Attribute Details

#association ⇒ Object (readonly)

The most recent node to start a QueryProxy chain. Will be nil when using QueryProxy chains on class methods.



14
15
16
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 14

def association
  @association
end

#context ⇒ Object

Returns the value of attribute context.



261
262
263
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 261

def context
  @context
end

#model ⇒ Object (readonly)

The most recent node to start a QueryProxy chain. Will be nil when using QueryProxy chains on class methods.



14
15
16
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 14

def model
  @model
end

#node_var ⇒ Object (readonly)

The current node identifier on deck, so to speak. It is the object that will be returned by calling ‘each` and the last node link in the QueryProxy chain.



64
65
66
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 64

def node_var
  @node_var
end

#query_proxy ⇒ Object (readonly)

Returns the value of attribute query_proxy.



60
61
62
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 60

def query_proxy
  @query_proxy
end

#rel_var ⇒ Object (readonly)

The relationship identifier most recently used by the QueryProxy chain.



71
72
73
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 71

def rel_var
  @rel_var
end

#source_object ⇒ Object (readonly)

The most recent node to start a QueryProxy chain. Will be nil when using QueryProxy chains on class methods.



14
15
16
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 14

def source_object
  @source_object
end

#start_object ⇒ Object (readonly)

Returns the value of attribute start_object.



60
61
62
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 60

def start_object
  @start_object
end

#starting_query ⇒ Object (readonly)

The most recent node to start a QueryProxy chain. Will be nil when using QueryProxy chains on class methods.



14
15
16
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 14

def starting_query
  @starting_query
end

Instance Method Details

#<<(other_node) ⇒ Object

To add a relationship for the node for the association on this QueryProxy



166
167
168
169
170
171
172
173
174
175
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 166

def <<(other_node)
  if @start_object._persisted_obj
    create(other_node, {})
  elsif @association
    @start_object.defer_create(@association.name, other_node)
  else
    fail 'Another crazy error!'
  end
  self
end

#[](index) ⇒ Object 



196
197
198
199
200
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 196

def [](index)
  # TODO: Maybe for this and other methods, use array if already loaded, otherwise
  # use OFFSET and LIMIT 1?
  self.to_a[index]
end

#_create_relationship(other_node_or_nodes, properties) ⇒ Object 



233
234
235
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 233

def _create_relationship(other_node_or_nodes, properties)
  association._create_relationship(@start_object, other_node_or_nodes, properties)
end

#_model_label_string(with_labels = true) ⇒ Object

param [TrueClass, FalseClass] with_labels This param is used by certain QueryProxy methods that already have the neo_id and therefore do not need labels. The @association_labels instance var is set during init and used during association chaining to keep labels out of Cypher queries.



117
118
119
120
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 117

def _model_label_string(with_labels = true)
  return if !@model || (!with_labels || @association_labels == false)
  @model.mapped_label_names.map { |label_name| ":`#{label_name}`" }.join
end

#_nodeify!(*args) ⇒ Object 



221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 221

def _nodeify!(*args)
  other_nodes = [args].flatten!.map! do |arg|
    (arg.is_a?(Integer) || arg.is_a?(String)) ? @model.find_by(id: arg) : arg
  end.compact

  if @model && other_nodes.any? { |other_node| !other_node.class.mapped_label_names.include?(@model.mapped_label_name) }
    fail ArgumentError, "Node must be of the association's class when model is specified"
  end

  other_nodes
end

#base_query(var, with_labels = true) ⇒ Object 



104
105
106
107
108
109
110
111
112
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 104

def base_query(var, with_labels = true)
  if @association
    chain_var = _association_chain_var
    (_association_query_start(chain_var) & _query).break.send(@match_type,
                                                              "(#{chain_var})#{_association_arrow}(#{var}#{_model_label_string})")
  else
    starting_query ? starting_query : _query_model_as(var, with_labels)
  end
end

#branch { ... } ⇒ QueryProxy

Executes the relation chain specified in the block, while keeping the current scope

Examples:

Load all people that have friends

Person.all.branch { friends }.to_a # => Returns a list of `Person`

Load all people that has old friends

Person.all.branch { friends.where('age > 70') }.to_a # => Returns a list of `Person`

Yields:

  • the block that will be evaluated starting from the current scope

Returns:



188
189
190
191
192
193
194
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 188

def branch(&block)
  if block
    instance_eval(&block).query.proxy_as(self.model, identity)
  else
    fail LocalJumpError, 'no block given'
  end
end

#create(other_nodes, properties = {}) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 202

def create(other_nodes, properties = {})
  fail 'Can only create relationships on associations' if !@association
  other_nodes = _nodeify!(*other_nodes)

  Neo4j::Transaction.run do
    other_nodes.each do |other_node|
      other_node.save unless other_node.neo_id

      return false if @association.perform_callback(@start_object, other_node, :before) == false

      @start_object.association_proxy_cache.clear

      _create_relationship(other_node, properties)

      @association.perform_callback(@start_object, other_node, :after)
    end
  end
end

#identity ⇒ Object Also known as: node_identity 



65
66
67
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 65

def identity
  @node_var || _result_string
end

#inspect ⇒ Object 



56
57
58
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 56

def inspect
  "#<QueryProxy #{@context} CYPHER: #{self.to_cypher.inspect}>"
end

#new_link(node_var = nil) ⇒ Object 



263
264
265
266
267
268
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 263

def new_link(node_var = nil)
  self.clone.tap do |new_query_proxy|
    new_query_proxy.instance_variable_set('@result_cache', nil)
    new_query_proxy.instance_variable_set('@node_var', node_var) if node_var
  end
end

#optional? ⇒ Boolean

Returns:



257
258
259
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 257

def optional?
  @optional == true
end

#params(params) ⇒ Object 



78
79
80
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 78

def params(params)
  new_link.tap { |new_query| new_query._add_params(params) }
end

#query ⇒ Object

Like calling #query_as, but for when you don’t care about the variable name



83
84
85
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 83

def query
  query_as(identity)
end

#query_as(var, with_labels = true) ⇒ Object

Build a Neo4j::Core::Query object for the QueryProxy. This is necessary when you want to take an existing QueryProxy chain and work with it from the more powerful (but less friendly) Neo4j::Core::Query.

.. code-block

ruby

student.lessons.query_as(:l).with('your cypher here...')

Parameters:

  • var (String, Symbol) —

    The identifier to use for node at this link of the QueryProxy chain.



94
95
96
97
98
99
100
101
102
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 94

def query_as(var, with_labels = true)
  result_query = @chain.inject(base_query(var, with_labels).params(@params)) do |query, link|
    args = link.args(var, rel_var)

    args.is_a?(Array) ? query.send(link.clause, *args) : query.send(link.clause, args)
  end

  result_query.tap { |query| query.proxy_chain_level = _chain_level }
end

#read_attribute_for_serialization(*args) ⇒ Object 



237
238
239
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 237

def read_attribute_for_serialization(*args)
  to_a.map { |o| o.read_attribute_for_serialization(*args) }
end

#rel_identity ⇒ Object 



72
73
74
75
76
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 72

def rel_identity
  ActiveSupport::Deprecation.warn 'rel_identity is deprecated and may be removed from future releases, use rel_var instead.', caller

  @rel_var
end

#respond_to_missing?(method_name, include_all = false) ⇒ Boolean

Returns:



253
254
255
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 253

def respond_to_missing?(method_name, include_all = false)
  (@model && @model.respond_to?(method_name, include_all)) || super
end

#scoping ⇒ Object

Scope all queries to the current scope.

.. code-block

ruby

Comment.where(post_id: 1).scoping do
  Comment.first
end

TODO: unscoped Please check unscoped if you want to remove all previous scopes (including the default_scope) during the execution of a block.



133
134
135
136
137
138
139
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 133

def scoping
  previous = @model.current_scope
  @model.current_scope = self
  yield
ensure
  @model.current_scope = previous
end

#to_cypher_with_params(columns = [self.identity]) ⇒ String

Returns a string of the cypher query with return objects and params

Parameters:

  • columns (Array) (defaults to: [self.identity]) —

    array containing symbols of identifiers used in the query

Returns:

  • (String) 


160
161
162
163
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 160

def to_cypher_with_params(columns = [self.identity])
  final_query = query.return_query(columns)
  "#{final_query.to_cypher} | params: #{final_query.send(:merge_params)}"
end