Class: OrientSupport::MatchStatement

Inherits:
Object
  • Object
show all
Includes:
Support
Defined in:
lib/support/orientquery.rb

Instance Method Summary collapse

Methods included from Support

#as, #compose_where, #generate_sql_list, #where, #while_s

Constructor Details

#initialize(match_class, as: 0, **args) ⇒ MatchStatement

Returns a new instance of MatchStatement.



199
200
201
202
203
204
205
206
207
 
# File 'lib/support/orientquery.rb', line 199

def initialize match_class, as: 0,  **args
  reduce_class = ->(c){ c.is_a?(Class) ? c.ref_name : c.to_s }

  @q =  MatchSAttributes.new( reduce_class[match_class],  # class
            as.respond_to?(:zero?) && as.zero? ?  reduce_class[match_class].pluralize : as  ,      
            args[ :where ])

  @query_stack = [ self ]
end

Instance Method Details

#<<(connection) ⇒ Object 



222
223
224
225
 
# File 'lib/support/orientquery.rb', line 222

def << connection
  @query_stack << connection
  self  # return MatchStatement
end

#compile(&b) ⇒ Object 



227
228
229
 
# File 'lib/support/orientquery.rb', line 227

def compile &b
   "match " + @query_stack.map( &:to_s ).join + return_statement( &b )
end

#compose_simple ⇒ Object Also known as: to_s

used for the first compose-statement of a compose-query



216
217
218
219
 
# File 'lib/support/orientquery.rb', line 216

def compose_simple
    where_statement = where.is_a?(String) && where.size <3 ?  nil :  "where: ( #{ generate_sql_list( @q[:where] ) })"
  '{'+ [ "class: #{@q[:match_class]}",  as , where_statement].compact.join(', ') + '}'
end

#execute(as: :hash, &b) ⇒ Object

executes the standard-case. returns

* as: :hash   : an array of  hashes
* as: :array  : an array of hash-values 
* as  :flatten: a simple array of hash-values

The optional block is used to customize the output. All previously defiend »as«-Statements are provided though the control variable.

Background A match query “Match aaa, as: ‘aa’ return aa ”

returns [ aa: { result of the query, a Vertex or a value-item }, aa: {}…}, …] ] (The standard case)

A match query “Match aaa, as: ‘aa’ return aa.name ”

returns [ aa.name: { name }, aa.name: { name }., …] ]

Now, execute( as: :flatten){ “aa.name” } returns

[name1, name2 ,. ...]

Return statements (examples from orientdb.org/docs/3.0.x/sql/SQL-Match.html)

"person.name as name, friendship.since as since, friend.name as friend"

" person.name + \" is a friend of \" + friend.name as friends"

"$matches"
"$elements"
"$paths"
"$pathElements"



266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'lib/support/orientquery.rb', line 266

def execute as: :hash, &b 
  r = V.db.execute{ compile &b }
  case as
  when :hash
    r
  when :array
   r.map{|y| y.values}
  when :flatten
   r.map{|y| y.values}.orient_flatten 
  else
    raise ArgumentError, "Specify parameter «as:» with :hash, :array, :flatten"
 end
end

#match_alias ⇒ Object 



209
210
211
 
# File 'lib/support/orientquery.rb', line 209

def match_alias
  "as: #{@q[:as]}"
end