active-orient 0.4 → 0.80

data/lib/support/orientquery.rb

@@ -0,0 +1,647 @@
+require 'active_support/inflector'
+
+module OrientSupport
+  module Support
+
+=begin
+supports
+  where: 'string'
+  where: { property: 'value', property: value, ... }
+  where: ['string, { property: value, ... }, ... ]
+
+Used by update and select
+
+_Usecase:_
+ ORD.compose_where 'z=34', {u:6}
+  => "where z=34 and u = 6" 
+=end
+
+    #
+		def compose_where *arg , &b
+			arg = arg.flatten.compact
+
+			unless arg.blank? 
+				g= generate_sql_list( arg , &b)
+				"where #{g}" unless g.empty?
+			end
+    end
+
+=begin
+designs a list of "Key =  Value" pairs combined by "and" or the binding  provided by the block
+   ORD.generate_sql_list  where: 25 , upper: '65' 
+    => "where = 25 and upper = '65'"
+   ORD.generate_sql_list(  con_id: 25 , symbol: :G) { ',' } 
+    => "con_id = 25 , symbol = 'G'"
+
+If »NULL« should be addressed, { key: nil } is translated to "key = NULL"  (used by set:  in update and upsert),
+{ key: [nil]  } is translated to "key is NULL" ( used by where )
+
+=end
+		def generate_sql_list attributes = {},  &b
+			fill = block_given? ? yield : 'and'
+			case attributes 
+			when ::Hash
+				attributes.map do |key, value|
+					case value
+					when nil
+						"#{key} =  NULL"
+					when ::Array
+						if value == [nil]
+						"#{key} is NULL"
+						else	
+						"#{key} in #{value.to_orient}"
+						end
+					when Range
+						"#{key} between #{value.first} and #{value.last} " 
+					else #  String, Symbol, Time, Trueclass, Falseclass ...
+						"#{key} = #{value.to_or}"
+					end
+				end.join(" #{fill} ")
+			when ::Array
+				attributes.map{|y| generate_sql_list y, &b }.join( " #{fill} " )
+			when String
+				attributes
+			when Symbol, Numeric
+				attributes.to_s
+			end		
+		end
+
+
+    # used both in OrientQuery and MatchConnect
+		# while and where depend on @q, a struct
+		def while_s  value=nil     # :nodoc:
+			if value.present?
+				@q[:while] << value
+				self
+			elsif @q[:while].present?
+				"while #{ generate_sql_list( @q[:while] ) }"
+			end
+		end
+		def where  value=nil     # :nodoc:
+			if value.present?
+				if value.is_a?( Hash ) && value.size >1
+												value.each {| a,b| where( {a => b} ) }
+				else
+					@q[:where] <<  value
+				end
+				self
+			elsif @q[:where].present?
+				"where #{ generate_sql_list( @q[:where] ){ @fill || 'and' } }"
+			end
+		end
+
+		def as a=nil
+			if a
+				@q[:as] = a   # subsequent calls overwrite older entries
+			else
+				if @q[:as].blank?
+					nil
+				else
+					"as: #{ @q[:as] }"
+				end
+			end
+		end
+	end  # module 
+
+	######################## MatchConnection ###############################
+
+	MatchAttributes = Struct.new(:edge, :direction, :as, :count, :where, :while, :max_depth , :depth_alias, :path_alias, :optional )
+
+	# where and while can be composed incremental
+	# direction, as, connect and edge cannot be changed after initialisation
+  class MatchConnection
+    include Support
+
+    def initialize edge= nil, direction: :both, as: nil, count: 1, **args
+
+      the_edge = edge.is_a?( Class ) ?  edge.ref_name : edge.to_s   unless edge.nil? || edge == E
+			@q =  MatchAttributes.new  the_edge ,  # class
+								direction, #		  may be :both, :in, :out
+								as,				 #      a string
+								count,     #      a number 
+								args[:where],
+								args[:while],
+								args[:max_depth],
+								args[:depth_alias],      # not implemented
+								args[:path_alias],       # not implemented
+								args[:optional]          # not implemented
+    end
+
+    def direction= dir
+      @q[:direction] =  dir
+    end
+
+
+		def direction
+			fillup =  @q[:edge].present? ? @q[:edge] : ''
+			case @q[:direction]
+			when :both
+				".both(#{fillup})"
+			when :in
+				".in(#{fillup})"
+			when :out
+				".out(#{fillup})"
+      when :both_vertex, :bothV
+				".bothV()"
+			when :out_vertex, :outV
+				".outV()"
+			when :in_vertex, :inV
+				".inV()"
+     when :both_edge, :bothE
+			 ".bothE(#{fillup})"
+			when :out_edge, :outE
+				".outE(#{fillup})"
+			when :in_edge, :outE
+				".inE(#{fillup})"
+			end
+
+		end
+
+		def count c=nil
+			if c
+				@q[:count] = c
+			else
+				@q[:count]
+			end
+		end
+
+		def max_depth d=nil
+			if d.nil?
+				@q[:max_depth].present? ? "maxDepth: #{@q[:max_depth] }" : nil
+			else
+				@q[:max_depth] = d
+			end
+		end
+		def edge
+			@q[:edge]
+		end
+
+		def compose
+				where_statement =( where.nil? || where.size <5 ) ? nil : "where: ( #{ generate_sql_list( @q[:where] ) })"
+				while_statement =( while_s.nil? || while_s.size <5) ? nil : "while: ( #{ generate_sql_list( @q[:while] )})"
+				
+				ministatement = "{"+ [ as, where_statement, while_statement, max_depth].compact.join(', ') + "}"
+				ministatement = "" if ministatement=="{}"
+
+     (1 .. count).map{|x| direction }.join("") + ministatement
+
+    end
+		alias :to_s :compose
+    
+  end  # class
+
+
+	######################## MatchStatement ################################
+
+	MatchSAttributes = Struct.new(:match_class, :as, :where )
+  class MatchStatement
+    include Support
+    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
+
+		def match_alias
+			"as: #{@q[:as]}"
+		end
+
+
+
+		# used for the first compose-statement of a compose-query
+		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
+
+
+		def << connection
+			@query_stack << connection
+			self  # return MatchStatement
+		end
+		#
+		def compile &b
+     "match " + @query_stack.map( &:to_s ).join + return_statement( &b )
+		end
+
+
+		# 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 {class 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 {class 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 https://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"
+		#
+		#    
+		#
+		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
+#		def compose
+#
+#			'{'+ [ "class: #{@q[:match_class]}", 
+#					"as: #{@as}" , where, while_s, 
+#						@maxdepth >0 ? "maxdepth: #{maxdepth}": nil  ].compact.join(', ')+'}'
+#		end
+
+		alias :to_s :compose_simple
+
+
+##  return_statement
+		#
+		# summarizes defined as-statements ready to be included as last parameter
+		# in the match-statement-stack
+		#
+		# They can be modified through a block.
+		#
+		# i.e
+		#
+		# t= TestQuery.match(  where: {a: 9, b: 's'}, as: nil ) << E.connect("<-", as: :test) 
+		# t.return_statement{|y| "#{y.last}.name"} 
+		#
+		# =>> " return  test.name"
+		#
+		#return_statement is always called through compile
+		#
+		# t.compile{|y| "#{y.last}.name"} 
+
+ private		
+		def return_statement
+			resolve_as = ->{  		@query_stack.map{|s| s.as.split(':').last unless s.as.nil? }.compact }
+			" return " + statement = if block_given? 
+										a= yield resolve_as[] 
+										a.is_a?(Array) ? a.join(', ') :  a
+									else
+										resolve_as[].join(', ')
+									end
+
+			
+		end
+		
+	end  # class
+
+
+	######################## OrientQuery ###################################
+
+	QueryAttributes =  Struct.new( :kind,  :projection, :where, :let, :order, :while, :misc, 
+																:class, :return,  :aliases, :database, 
+																:set, :remove, :group, :skip, :limit, :unwind )
+	
+	class OrientQuery
+    include Support
+
+
+#
+    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
+		
+
+=begin
+  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'
+=end
+		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
+
+		def misc   # :nodoc:
+			@q[:misc].join(' ') unless @q[:misc].empty?
+		end
+
+    def subquery  # :nodoc: 
+      nil
+    end
+
+	
+		def kind value=nil
+			if value.present?
+				@q[:kind] = value
+				self
+			else
+			@q[:kind]
+			end
+		end
+=begin
+  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.
+=end
+
+		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
+		alias :to_s :compose
+
+
+		def to_or
+			compose.to_or
+		end
+
+		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
+
+=begin
+	from can either be a Databaseclass to operate on or a Subquery providing data to query further
+=end
+		def from arg = nil
+			if arg.present?
+				@q[:database] =  arg
+				self # return query-object
+			elsif  @q[:database].present? # read from
+				"from #{ target }"
+			end
+		end
+
+
+		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	  # def
+
+
+    def database_class            # :nodoc:
+  	    @q[:database]
+    end
+
+    def database_class= arg   # :nodoc:
+  	  @q[:database] = arg 
+    end
+
+		def distinct d
+			@q[:projection] << "distinct " +  generate_sql_list( d ){ ' as ' }
+			self
+		end
+
+class << self
+		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
+		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  #  def
+end # class << self
+		mk_simple_setter :limit, :skip, :unwind 
+		mk_std_setter :set, :remove
+
+		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
+#
+		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
+
+			
+		
+	  def group value = nil
+			if value.present?
+     	@q[:group] << value
+			self
+			elsif @q[:group].present?
+			 "group by #{@q[:group].join(', ')}"
+			end
+    end
+ 
+		alias order_by order 
+		alias group_by group
+		
+		def get_limit  # :nodoc: 
+    	@q[:limit].nil? ? -1 : @q[:limit].to_i
+    end
+
+		def expand item
+			@q[:projection] =[ " expand ( #{item.to_s} )" ]
+			self
+    end
+
+		# connects by adding {in_or_out}('edgeClass')
+		def connect_with in_or_out, via: nil
+			 argument = " #{in_or_out}(#{via.to_or if via.present?})"
+		end
+		# adds a connection
+		#  in_or_out:  :out --->  outE('edgeClass').in[where-condition] 
+		#              :in  --->  inE('edgeClass').out[where-condition]
+
+		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
+
+
+		# returns nil if the query was not sucessfully executed
+		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
+:protected
+		def resolve_target
+			if @q[:database].is_a? OrientSupport::OrientQuery
+				@q[:database].resolve_target
+			else
+				@q[:database]
+			end
+		end
+
+	#	end
+	end # class
+
+
+end # module