Class: OrientSupport::OrientQuery

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

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Support

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

Constructor Details

#initialize(**args) ⇒ OrientQuery

Returns a new instance of OrientQuery.



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
# File 'lib/support/orientquery.rb', line 334

def initialize  **args
	@q =  QueryAttributes.new args[:kind] ||	'select' ,
						[], #		 :projection 
						[], # :where ,
						[], # :let ,
						[], # :order,
						[], # :while,
						[] , # misc
						'',  # class
						'',  #  return
						[],   # aliases
						'',  # database
						[],   #set,
						[]  # remove
	  args.each{|k,v| send k, v}
		@fill = block_given? ?   yield  : 'and'
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *arg, &b) ⇒ Object

where: “r > 9” –> where r > 9

where: {a: 9, b: 's'}                   --> where a = 9 and b = 's'
where:[{ a: 2} , 'b > 3',{ c: 'ufz' }]  --> where a = 2 and b > 3 and c = 'ufz'



358
359
360
361
362
363
364
365
 
# File 'lib/support/orientquery.rb', line 358

def method_missing method, *arg, &b   # :nodoc: 
			if method ==:while || method=='while'
while_s arg.first
			else
@q[:misc] << method.to_s <<  generate_sql_list(arg) 
			end 
			self
end

Class Method Details

.mk_simple_setter(*m) ⇒ Object 



488
489
490
491
492
493
494
495
496
497
498
499
 
# File 'lib/support/orientquery.rb', line 488

def mk_simple_setter *m
	m.each do |def_m|
		define_method( def_m ) do | value=nil |
				if value.present?
					@q[def_m]  = value
					self
				elsif @q[def_m].present?
				 "#{def_m.to_s}  #{generate_sql_list(@q[def_m]){' ,'}}"
				end
		end
	end
end

.mk_std_setter(*m) ⇒ Object 



500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
 
# File 'lib/support/orientquery.rb', line 500

def mk_std_setter *m
	m.each do |def_m|
		define_method( def_m  ) do | value = nil |
			if value.present?
				@q[def_m] << case value
											when String
												value
											when ::Hash
												value.map{|k,v| "#{k} = #{v.to_or}"}.join(", ")
											else
												raise "Only String or Hash allowed in  #{def_m} statement"
											end
				self
			elsif @q[def_m].present?
				"#{def_m.to_s} #{@q[def_m].join(',')}"	
			end # branch
		end     # def_method
	end  # each
end

Instance Method Details

#compose(destination: :batch) ⇒ Object Also known as: to_s

Output the compiled query

Parameter: destination (rest, batch )
If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.



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

def compose(destination: :batch)
	if kind.to_sym == :update 
		return_statement = "return after " + ( @q[:aliases].empty? ?  "$current" : @q[:aliases].first.to_s)
		[ 'update', target, set, remove, return_statement , where, limit ].compact.join(' ')
	elsif kind.to_sym == :update!
		[ 'update', target, set,  where, limit, misc ].compact.join(' ')
	elsif kind.to_sym == :create
		[ "CREATE VERTEX", target, set ].compact.join(' ')
	#	[ kind, target, set,  return_statement ,where,  limit, misc ].compact.join(' ')
	elsif kind.to_sym == :upsert 
		return_statement = "return after " + ( @q[:aliases].empty? ?  "$current" : @q[:aliases].first.to_s)
		[ "update", target, set,"upsert",  return_statement , where, limit, misc  ].compact.join(' ')
		#[ kind,  where, return_statement ].compact.join(' ')
	elsif destination == :rest
		[ kind, projection, from, let, where, subquery,  misc, order, group_by, unwind, skip].compact.join(' ')
	else
		[ kind, projection, from, let, where, subquery,  while_s,  misc, order, group_by, limit, unwind, skip].compact.join(' ')
	end
end

#connect_with(in_or_out, via: nil) ⇒ Object

connects by adding in_or_out(‘edgeClass’)



590
591
592
 
# File 'lib/support/orientquery.rb', line 590

def connect_with in_or_out, via: nil
	 argument = " #{in_or_out}(#{via.to_or if via.present?})"
end

#database_class ⇒ Object

:nodoc:



474
475
476
 
# File 'lib/support/orientquery.rb', line 474

def database_class            # :nodoc:
   @q[:database]
end

#database_class=(arg) ⇒ Object

:nodoc:



478
479
480
 
# File 'lib/support/orientquery.rb', line 478

def database_class= arg   # :nodoc:
 @q[:database] = arg 
end

#distinct(d) ⇒ Object 



482
483
484
485
 
# File 'lib/support/orientquery.rb', line 482

def distinct d
	@q[:projection] << "distinct " +  generate_sql_list( d ){ ' as ' }
	self
end

#execute(reduce: false) ⇒ Object

returns nil if the query was not sucessfully executed



625
626
627
628
629
630
631
632
633
 
# File 'lib/support/orientquery.rb', line 625

def execute(reduce: false)
	#puts "Compose: #{compose}"
	result = V.orientdb.execute{ compose }
	return nil unless result.is_a?(::Array)
	result =  result.map{|x| yield x } if block_given?
	return  result.first if reduce && result.size == 1
	## standard case: return Array
	OrientSupport::Array.new( work_on: resolve_target, work_with: result.orient_flatten)   
end

#expand(item) ⇒ Object 



584
585
586
587
 
# File 'lib/support/orientquery.rb', line 584

def expand item
			@q[:projection] =[ " expand ( #{item.to_s} )" ]
			self
end

#from(arg = nil) ⇒ Object

from can either be a Databaseclass to operate on or a Subquery providing data to query further



444
445
446
447
448
449
450
451
 
# File 'lib/support/orientquery.rb', line 444

def from arg = nil
	if arg.present?
		@q[:database] =  arg
		self # return query-object
	elsif  @q[:database].present? # read from
		"from #{ target }"
	end
end

#get_limit ⇒ Object

:nodoc:



580
581
582
 
# File 'lib/support/orientquery.rb', line 580

def get_limit  # :nodoc: 
	@q[:limit].nil? ? -1 : @q[:limit].to_i
end

#group(value = nil) ⇒ Object Also known as: group_by 



568
569
570
571
572
573
574
575
 
# File 'lib/support/orientquery.rb', line 568

def group value = nil
			if value.present?
 	@q[:group] << value
			self
			elsif @q[:group].present?
"group by #{@q[:group].join(', ')}"
			end
end

#kind(value = nil) ⇒ Object 



376
377
378
379
380
381
382
383
 
# File 'lib/support/orientquery.rb', line 376

def kind value=nil
	if value.present?
		@q[:kind] = value
		self
	else
	@q[:kind]
	end
end

#let(value = nil) ⇒ Object 



523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
 
# File 'lib/support/orientquery.rb', line 523

def let       value = nil
	if value.present?
		@q[:let] << value
		self
	elsif @q[:let].present?
		"let " << @q[:let].map do |s|
			case s
			when String
				s
			when ::Hash  
				s.map do |x,y| 
					# if the symbol: value notation of Hash is used, add "$" to the key
					x =  "$#{x.to_s}"  unless x.is_a?(String) && x[0] == "$"
					"#{x} = #{ case y 
																when self.class
																	"(#{y.compose})"
																else
																	y.to_orient
																end }"
				end
			end
		end.join(', ')
	end
end

#misc ⇒ Object

:nodoc:



367
368
369
 
# File 'lib/support/orientquery.rb', line 367

def misc   # :nodoc:
	@q[:misc].join(' ') unless @q[:misc].empty?
end

#nodes(in_or_out = :out, via: nil, where: nil, expand: true) ⇒ Object

adds a connection

in_or_out:  :out --->  outE('edgeClass').in[where-condition] 
            :in  --->  inE('edgeClass').out[where-condition]



597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
 
# File 'lib/support/orientquery.rb', line 597

def nodes in_or_out = :out, via: nil, where: nil, expand: true
	 condition = where.present? ?  "[ #{generate_sql_list(where)} ]" : ""
	 start =  if in_or_out  == :in
							'inE'
						elsif in_or_out ==  :out
							'outE'
						else
							"both"
						end
	 the_end =  if in_or_out == :in 
								'.out' 
							elsif in_or_out == :out
								'.in'
							else
								''
							end
	 argument = " #{start}(#{[via].flatten.map(&:to_or).join(',') if via.present?})#{the_end}#{condition} "

	 if expand.present?
		 send :expand, argument
	 else
		 @q[:projection]  << argument 
	 end
	 self
end

#order(value = nil) ⇒ Object Also known as: order_by 



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/support/orientquery.rb', line 454

def order  value = nil
	if value.present?
		@q[:order] << value
		self
	elsif @q[:order].present?

		"order by " << @q[:order].compact.flatten.map do |o|
			case o
			when String, Symbol, Array
				o.to_s
			else
				o.map{|x,y| "#{x} #{y}"}.join(" ")
			end  # case
		end.join(', ')
	else
		''
	end # unless
end

#projection(value = nil) ⇒ Object

:nodoc:



548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
 
# File 'lib/support/orientquery.rb', line 548

def projection value= nil  # :nodoc:
	if value.present?
		@q[:projection] << value
		self
	elsif  @q[:projection].present?
		@q[:projection].compact.map do | s |
			case s
			when ::Array
				s.join(', ')
			when String, Symbol
				s.to_s
			when ::Hash
				s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
			end
		end.join( ', ' )
	end
end

#resolve_target ⇒ Object 



635
636
637
638
639
640
641
 
# File 'lib/support/orientquery.rb', line 635

def resolve_target
	if @q[:database].is_a? OrientSupport::OrientQuery
		@q[:database].resolve_target
	else
		@q[:database]
	end
end

#subquery ⇒ Object

:nodoc:



371
372
373
 
# File 'lib/support/orientquery.rb', line 371

def subquery  # :nodoc: 
  nil
end

#target(arg = nil) ⇒ Object 



416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
 
# File 'lib/support/orientquery.rb', line 416

def target arg =  nil
	if arg.present?
		@q[:database] =  arg
		self # return query-object
	elsif @q[:database].present? 
		the_argument =  @q[:database]
		case @q[:database]
							when ActiveOrient::Model   # a single record
								the_argument.rrid
							when self.class	      # result of a query
								' ( '+ the_argument.compose + ' ) '
							when Class
								the_argument.ref_name
							else
								if the_argument.to_s.rid?	  # a string with "#ab:cd"
									the_argument
								else		  # a database-class-name
									the_argument.to_s  
								end
							end
	else
		raise "cannot complete until a target is specified"
	end
end

#to_or ⇒ Object 



412
413
414
 
# File 'lib/support/orientquery.rb', line 412

def to_or
	compose.to_or
end