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

Overview

rubocop:disable Metrics/ClassLength

Defined Under Namespace

Classes: Link

Constant Summary collapse

METHODS = 
%w(where where_not rel_where rel_where_not 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

#association_tree_class, #first, #perform_query, #pluck_vars, #propagate_context, #with_associations, #with_associations_tree, #with_associations_tree=

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, #as_models, #count, #distinct, #empty?, #exists?, #find, #find_or_create_by, #find_or_initialize_by, #first, #first_or_initialize, #first_rel_to, #having_rel, #include?, #last, #limit_value, #match_to, #not_having_rel, #optional, #order_property, #propagate_context, #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, Integer, Symbol, Hash) —

    A Range, a Integer, 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



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

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



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

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.



16
17
18
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 16

def association
  @association
end

#context ⇒ Object

Returns the value of attribute context.



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

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.



16
17
18
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 16

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.



67
68
69
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 67

def node_var
  @node_var
end

#query_proxy ⇒ Object (readonly)

Returns the value of attribute query_proxy.



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

def query_proxy
  @query_proxy
end

#rel_var ⇒ Object (readonly)

The relationship identifier most recently used by the QueryProxy chain.



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

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.



16
17
18
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 16

def source_object
  @source_object
end

#start_object ⇒ Object (readonly)

Returns the value of attribute start_object.



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

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.



16
17
18
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 16

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



172
173
174
175
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 172

def <<(other_node)
  _create_relation_or_defer(other_node)
  self
end

#[](index) ⇒ Object 



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

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 



235
236
237
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 235

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.



123
124
125
126
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 123

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 



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

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 



110
111
112
113
114
115
116
117
118
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 110

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
195
196
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 188

def branch(&block)
  fail LocalJumpError, 'no block given' if block.nil?
  # `as(identity)` is here to make sure we get the right variable
  # There might be a deeper problem of the variable changing when we
  # traverse an association
  as(identity).instance_eval(&block).query.proxy_as(self.model, identity).tap do |new_query_proxy|
    propagate_context(new_query_proxy)
  end
end

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



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

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

  Neo4j::ActiveBase.run_transaction do
    other_nodes.each do |other_node|
      if other_node.neo_id
        other_node.try(:validate_reverse_has_one_core_rel, association, @start_object)
      else
        other_node.save
      end

      @start_object.association_proxy_cache.clear

      _create_relationship(other_node, properties)
    end
  end
end

#identity ⇒ Object Also known as: node_identity 



68
69
70
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 68

def identity
  @node_var || _result_string(_chain_level + 1)
end

#inspect ⇒ Object 



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

def inspect
  formatted_nodes = Neo4j::ActiveNode::NodeListFormatter.new(to_a)
  "#<QueryProxy #{@context} #{formatted_nodes.inspect}>"
end

#new_link(node_var = nil) ⇒ Object 



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

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:



259
260
261
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 259

def optional?
  @optional == true
end

#params(params) ⇒ Object 



81
82
83
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 81

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



86
87
88
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 86

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.



97
98
99
100
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 97

def query_as(var, with_labels = true)
  query_from_chain(chain, base_query(var, with_labels).params(@params), var)
    .tap { |query| query.proxy_chain_level = _chain_level }
end

#query_from_chain(chain, base_query, var) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 102

def query_from_chain(chain, base_query, var)
  chain.inject(base_query) do |query, link|
    args = link.args(var, rel_var)

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

#read_attribute_for_serialization(*args) ⇒ Object 



239
240
241
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 239

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

#rel_identity ⇒ Object 



75
76
77
78
79
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 75

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:



255
256
257
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 255

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.



139
140
141
142
143
144
145
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 139

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) 


166
167
168
169
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 166

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

#unpersisted_start_object? ⇒ Boolean

Returns:



272
273
274
 
# File 'lib/neo4j/active_node/query/query_proxy.rb', line 272

def unpersisted_start_object?
  @start_object && @start_object.new_record?
end