active-orient 0.4 → 0.5

data/lib/rest_disabled.rb

@@ -0,0 +1,24 @@
+=begin #nodoc#
+If properties are allocated on class-level, they can be preinitialized using
+this method.
+This is disabled for now, because it does not seem nessesary
+=end
+
+def preallocate_class_properties o_class
+  p= get_class_properties( o_class )['properties']
+  unless p.nil? || p.blank?
+    predefined_attributes = p.map do | property |
+      [ property['name'] ,
+      case property['type']
+      when 'LINKMAP'
+        Array.new
+      when 'STRING'
+        ''
+      else
+        nil
+      end  ]
+    end.to_h
+  else
+    {}
+  end
+end

data/lib/support.rb

@@ -1,347 +1,438 @@
-class String
-  def to_classname
-    if self[0] =='$'
-      self[1..-1]
-    else
-      self.camelize 
-    end
-  end
-  def to_orient
-    self.gsub /%/, '(percent)'
+require 'active_support/inflector'
+module OrientSupport
+  module Support
 
-  end
-    def rid? 
-      self =~  /\A[#]{,1}[0-9]{1,}:[0-9]{1,}\z/   
-    end
-    def from_orient
-	if rid? 
-	  ActiveOrient::Model.autoload_object  self
-	else
-	  self
-	end
+=begin
+  supports
+  where: 'string'
+  where: { property: 'value', property: value, ... }
+  where: ['string, { property: value, ... }, ... ]
+  Used by update and select
+=end
+
+## ORD.compose_where 'z=34', {u:6}
+    # => "where z=34 and u = 6" 
+    #
+    def compose_where *arg
+      arg = arg.flatten
+      return "" if arg.blank? || arg.size == 1 && arg.first.blank?
+      "where " + arg.map do |issue|
+        case issue
+        when String
+	        issue
+         else
+	        generate_sql_list issue
+        end
+      end.join(' and ')
     end
-    ## this enables the universal use of an rid-string as pseudonym for a ActiveOrient::Model
-    alias :reload! from_orient
-end
-class NilClass
-  def to_orient
-   self 
-  end
-end
-class Symbol
-  def to_orient
-    self.to_s.to_orient
-  end
-  def from_orient
-    self
-  end
-end
 
-class Numeric
-  def from_orient
-    self
-  end
-  def to_orient
-    self
+=begin
+designs a list of "Key =  Value" pairs combined by "and" or the fillword 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'"
+=end
+    def generate_sql_list attributes = {}
+      fill = block_given? ? yield : 'and'
+      attributes.map do |key, value|
+	      case value
+	      when ActiveOrient::Model
+		"#{key} = #{value.rrid}"
+	      when Numeric
+          "#{key} = #{value}"
+	      when Array
+		"#{key}= #{value.to_orient}"
+	      when Date
+		"#{key} = date(\'#{value.to_s}\',\'yyyy-MM-dd\')"
+	      else #  String, Symbol, Time, Trueclass, Falseclass ...
+          "#{key} = \'#{value.to_s}\'"
+	      end
+      end.join(" #{fill} ")
+    end
   end
-end
 
-class Time 
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-class Date
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
 
-class TrueClass
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
-class FalseClass
-  def from_orient
-    self
-  end
-  def to_orient
-    self
-  end
-end
+  class MatchConnection
+    attr_accessor :as
+    def initialize edge: nil, direction: :both, as: nil, count: 1
+      @edge = edge
+      @direction = direction  # may be :both, :in, :out
+      @as =  as
+      @count =  count
+    end
 
-class Array
-    def to_orient
-      map &:to_orient
+    def direction= dir
+      @direction =  dir
     end
-    def from_orient
-      map &:from_orient
+
+
+    def direction
+      fillup =  @edge.present? ? @edge : ''
+      case @direction
+      when :both
+	" -#{fillup}- "
+      when :in
+	" <-#{fillup}- "
+      when :out
+	" -#{fillup}-> "
+      end
+
     end
-end
-class Hash #WithIndifferentAccess
-  def from_orient
-    substitute_hash = HashWithIndifferentAccess.new
-    keys.each{ |k| puts self[k].inspect }
-    keys.each{| k | substitute_hash[k] =  self[k].from_orient  }
-    substitute_hash	      
 
-  end
-  def to_orient
-    substitute_hash = Hash.new
-    keys.each{| k | substitute_hash[k] =  self[k].to_orient  }
-    substitute_hash	      
+    def compose
+      ministatement = @as.present? ? "{ as: #{@as} } " : "" 
+     (1 .. @count).map{|x| direction }.join("{}") << ministatement
 
+    end
+    
   end
 
-    def nested_under_indifferent_access
-        HashWithIndifferentAccess.new self
+  class MatchStatement
+    include Support
+    attr_accessor :as
+    attr_accessor :where
+    def initialize match_class=nil, **args
+      @misc  = []
+      @where = []
+      @while = []
+      @maxdepth = 0
+      @as =  nil
+
+
+      @match_class = match_class
+      @as = match_class.pluralize if match_class.is_a? String
+
+      args.each do |k, v|
+        case k
+	when :as
+	  @as = v
+        when :while
+          @while << v
+        when :where
+          @where << v
+	when :class
+	  @match_class = v
+	  @as = v.pluralize
+        else
+          self.send k, v
+        end
+      end
+    end
+    
+        def while_s
+  	  compose_where( @while ).gsub( /where/, 'while:(' )<< ")" unless @while.blank?
+    end
+
+    def match_alias
+      "as: #{@as }"
+    end
+    def where_s
+  	  compose_where( @where ).gsub( /where/, 'where:(' )<< ")"  unless @where.blank?
+    end
+  
+    def maxdepth=x
+      @maxdepth = x
     end
-end
 
+    def method_missing method, *arg, &b
+      @misc << method.to_s << " " << arg.map(&:to_s).join(' ')
+    end
 
-module OrientSupport
+    def misc
+      @misc.join(' ') unless @misc.empty?
+    end
+    # used for the first compose-statement of a compose-query
+    def compose_simple
+   '{'+ [ "class: #{@match_class}", 
+	       "as: #{@as}" , 
+	       where_s ].compact.join(', ') + '}'
+    end
 
-  module Support
-=begin
-supports 
+    def compose
+
+        '{'+ [ "class: #{@match_class}", 
+	       "as: #{@as}" , 
+	       where_s, 
+	      while_s, 
+	      @maxdepth >0 ? "maxdepth: #{maxdepth}": nil  ].compact.join(', ')+'}'
+    end
+    alias :to_s :compose
+end
 
-where: 'string'
-where: { property: 'value', property: value, ... }
-where: ['string, { property: value, ... }, ... ]
+  class OrientQuery
+    include Support
 
+=begin
+  Call where without a parameter to request the saved where-string
+  To create the where-part of the query a string, a hash or an Array is supported
 
-Used by update and select
+  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 compose_where *arg
-      arg=arg.flatten
-      return "" if arg.blank? || arg.size == 1 && arg.first.blank?
-     "where " + arg.map do |issue|
-       case issue
-       when String
-	  issue
-       when Hash
-	 generate_sql_list issue
+    attr_accessor :where
+    attr_accessor :let
+    attr_accessor :projection
+    attr_accessor :order
+    attr_accessor :match_statements
+
+    def initialize  **args
+      @projection = []
+      @misc  = []
+      @let   = []
+      @where = []
+      @order = []
+      @aliases = []
+      @match_statements = []
+      @class =  nil
+      @kind  = 'select'
+      args.each do |k, v|
+        case k
+        when :projection
+          @projection << v
+        when :let
+          @let << v
+        when :order
+          @order << v
+        when :where
+          @where << v
+        when :kind
+          @kind = v
+	when :start
+	  @match_statements[0] = MatchStatement.new **v
+#  @match_statements[1] = MatchConnection.new
+	when :connection
+	  @match_statements[1] = MatchConnection.new **v
+	when :return
+	  @aliases << v
+        else
+          self.send k, v
+        end
       end
-     end.join( ' and ' )
-    end
-    def generate_sql_list attributes={}
-      attributes.map do | key, value |
-	case value
-	when Numeric
-	  key.to_s << " = " << value.to_s 
-	else #  String, Symbol, Date, Time, Trueclass, Falseclass ...
-	  key.to_s << ' = ' << "\'#{ value }\'"
-	end
-      end.join( ' and ' )
     end
-    end  # module
 
+    def method_missing method, *arg, &b
+      @misc << method.to_s << " " << arg.map(&:to_s).join(' ')
+    end
+
+    def misc
+      @misc.join(' ') unless @misc.empty?
+    end
 
-    class OrientQuery
+    def subquery
+      nil
+    end
 
-    include Support
 
-      def initialize  **args
-	@projection = []
-	@misc = []
-	@let  = []
-	@where = []
-	@order = []
-	args.each do | k,v|
-	  case k
-	   when :projection
-	    @projection << v
-	   when :let
-	    @let << v
-	   when :order
-	    @order << v
-	   when :where
-	    @where << v
-	  else
-	    self.send k, v
-	  end
-	end
-      end
 
-      def method_missing method, *arg, &b
-	@misc << method.to_s << " " << arg.map(&:to_s).join(' ')
-      end
+=begin
+(only if kind == :match): connect
 
-      def misc
-	@misc.join(' ') unless @misc.empty?
-      end
+Add a connection to the match-query
 
-      def subquery
-	nil
-      end
+A Match-Query alwas has an Entry-Stratement and maybe other Statements.
+They are connected via " -> " (outE), "<-" (inE) or "--" (both).
 
-      def compose
-	[ "select", projection_s,  from, let_s, where_s , subquery,  misc, order_s , group_by, unwind, skip ].compact.join(' ')
-      end
+The connection method adds a connection to the statement-stack. 
 
-      alias :to_s  :compose
-=begin
-from can either be a Databaseclass to operate on or a Subquery providing data to query further 
+Parameters:
+  direction: :in, :out, :both
+  edge_class: to restrict the Query on a certain Edge-Class
+  count: To repeat the connection
+  as:  Includes a micro-statement to finalize the Match-Query
+       as: defines a output-variablet, which is used later in the return-statement
+
+The method returns the OrientSupport::MatchConnection object, which can be modified further.
+It is compiled by calling compose
 =end
-      def from arg=nil
-	if arg.present?
-	  @database = case arg 
-		      when Class
-			arg.new.classname
-		      when ActiveOrient::Model
-			classname
-		      when String
-			arg
-		      when Symbol
-			arg
-		      when OrientQuery
-			arg
-		      end
-	  compose  # return the complete query
-	else # read from
-	  "from " <<  @database.to_s  unless @database.nil?
-	  end
-	end
-      alias :from= :from
-      def database_class= arg
-	@database =  arg if @database.present?
-	if @from.is_a? OrientQuery
-	  @from.database_class= arg
-	end
-      end
-      def database_class
-	if @database.present?
-	  @database
-	elsif @from.is_a? OrientQuery
-	  @from.database_class
-	else
-	  nil
-	end
-      end
 
+def connect direction, edge_class: nil, count: 1, as: nil
+  direction= :both unless [ :in, :out].include? direction
+  match_statements << m = OrientSupport::MatchConnection.new( direction: direction, count: count, as: as)
+  m
+end
 
 =begin
-Call where without a parameter to request the saved where-string
+(only if kind == :match): statement
 
-to create the where-part of the query a string, a hash or an Array is supported
+A Match Query consists of a simple start-statement
+( classname and where-condition ), a connection followd by other Statement-connection-pairs.
+It performs a sub-query starting at the given entry-point.
 
-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
-      attr_accessor :where
-      def where_s
-	compose_where @where
-      end
+Statement adds a statement to the statement-stack.
+Statement returns the created OrientSupport::MatchStatement-record for further modifications. 
+It is compiled by calling »compose«. 
 
+OrientSupport::OrientQuery collects any "as"-directive for inclusion  in the return-statement
 
-      attr_accessor :let
-      def let_s
-	unless @let.empty?
-	  "let " << @let.map do |s|
-	   case s
-	  when Hash
-	    s.map{ |x,y| "$#{x} = ( #{y} )"}.join( ', ')
-	  when Array
-	    s.join(',  ')
-	  else
-	    s
-	  end
-	  end.join(', ')
+Parameter (all optional)
+ Class: classname, :where: {}, while: {}, as: string, maxdepth: >0 , 
+
+=end
+def statement match_class= nil, **args
+  match_statements << s = OrientSupport::MatchStatement.new( mattch_class, args )
+  s
+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 == :match
+	unless @match_statements.empty?
+	match_query =  @kind.to_s.upcase + " "+ @match_statements[0].compose_simple 
+	match_query << @match_statements[1..-1].map( &:compose ).join
+	match_query << " RETURN "<< (@match_statements.map( &:as ).compact | @aliases).join(', ')
 	end
+      elsif destination == :rest
+        [@kind, projection_s, from, let_s, where_s, subquery, misc, order_s, group_by, unwind, skip].compact.join(' ')
+      else
+        [@kind, projection_s, from, let_s, where_s, subquery, misc, order_s, group_by, limit, unwind, skip].compact.join(' ')
       end
+    end
+    alias :to_s :compose
 
-      def distinct d
-	@projection << case d
-			    when String, Symbol
-			        "distinct( #{d.to_s} )"  
-			    when Array
-			        "distinct( #{d.first} ) as #{d.last}"
-			    when Hash
-			        "distinct( #{d.first.first} ) as #{d.first.last}"
-			    else
-			      ""
-			    end 
-	compose  # return the hole query
-      end
-      alias :distinct= :distinct
-
-      attr_accessor :projection
-      def projection_s
-
-	  @projection.map do | s |
-		case s
-			  when Hash
-			    s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
-			  when Array
-			    s.join(', ')
-			  else
-			    s
-			  end
-	  end.join( ', ' )
+=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?
+	@database = case arg
+		    when ActiveOrient::Model
+		      arg.rrid
+		    when OrientQuery
+		      ' ( '+ arg.to_s + ' ) '
+		    else
+		      if arg.to_s.rid?
+			arg
+		      else
+			ORD.classname(arg)
+		      end
+		    end
+	compose  # return the complete query
+      else # read from
+	"from #{@database}" unless @database.nil?
       end
+    end
+    alias :from= :from
+
+    def database_class
+  	  if @database.present?
+  	    @database
+  	  elsif @from.is_a? OrientQuery
+  	    @from.database_class
+  	  else
+  	    nil
+  	  end
+    end
 
+    def database_class= arg
+  	  @database = arg if @database.present?
+  	  if @from.is_a? OrientQuery
+  	    @from.database_class= arg
+  	  end
+    end
 
- #     def where= w
+    def where_s
+  	  compose_where @where
+    end
 
- #     end
-#        select_string = ("select " + select_string + distinct_string + ' from ' + class_name(o_class) ).squeeze(' ')
-#	where_string =  compose_where( where )
-      def group_by g=nil
-	@group = "group_by  #{g.to_s}" if g.present?
-	# only a string is allowed
-	@group  # return_value
-      end
-      def unwind u=nil
-	@unwind = "unwind  #{u.to_s}" if u.present?
-	# only a string is allowed
-	@unwind  # return_value
-      end
+    def let_s
+  	  unless @let.empty?
+  	    "let " << @let.map do |s|
+  	      case s
+  	      when String
+  	        s
+  	      when Array
+  	        s.join(',  ')
+#	      when Hash  ### is not recognized in jruby
+	      else
+  	        s.map{|x,y| "$#{x} = (#{y})"}.join(', ')
+  	      end
+  	    end.join(', ')
+  	  end
+    end
 
-      def skip n=nil
-	@skip= n if n.present?
-	"skip #{@skip}" if @skip.present?
-      end
+    def distinct d
+  	  @projection << case d
+  		when String, Symbol
+  		  "distinct( #{d.to_s} )"
+  		when Array
+  		  "distinct( #{d.first} ) as #{d.last}"
+  		when Hash
+  		  "distinct( #{d.first.first} ) as #{d.first.last}"
+  		else
+  		  ""
+  		end
+  	  compose  # return the hole query
+    end
+    alias :distinct= :distinct
+
+    def projection_s
+  	  @projection.map do | s |
+  		  case s
+  			when Array
+  			  s.join(', ')
+			when String, Symbol
+  			  s.to_s
+  			else
+  			  s.map{ |x,y| "#{x} as #{y}"}.join( ', ')
+  			end
+  	  end.join( ', ' )
+    end
 
-      attr_accessor :order
-
-      def order_s 
-	unless @order.empty?
-	 # the [@order] is nessesary to enable query.order= "..." oder query.order= { a: :b }  
-	  "order by " << [@order].flatten.map do | o |
-	    case o
-	    when  Hash 
-	      o.map{ |x,y| "#{x} #{y}" }.join( " " )
-	    else
-	      o.to_s
-	    end  # case
-	  end.join(', ')
-	else
-	  ''
-	end
-      end
-#	misc_string = if skip > 0 && limit > 0 
-#			" skip: #{skip} "
-#		      else
-#			""
-#		      end
-#	#
-#
-#      def compose
-#
-#      end
-
-    end
-  end # module
+    def limit l=nil
+  	  @limit = "limit #{l.to_s}" if l.present?
+  	# only a string is allowed
+  	  @limit  # return_value
+    end
+    alias :limit= :limit
+
+    def get_limit
+    	@limit.nil? ? -1 : @limit.split(' ').last.to_i
+    end
+
+    def group_by g = nil
+     	@group = "group by #{g.to_s}" if g.present?
+  	# only a string is allowed
+  	  @group  # return_value
+    end
+
+    def unwind u = nil
+  	  @unwind = "unwind #{u.to_s}" if u.present?
+  	# only a string is allowed
+  	  @unwind  # return_value
+    end
+
+    def skip n = nil
+  	  @skip = n if n.present?
+  	  "skip #{@skip}" if @skip.present?
+    end
+
+    def order_s
+      unless @order.empty?
+	# the [@order] is nessesary to enable query.order= "..." oder query.order= { a: :b }
+	"order by " << [@order].flatten.map do |o|
+	  #puts "CLASS : "+o.class.to_s
+	  #puts o.to_s
+	  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
+    end # class
+
+
+end # module