orientdb 0.0.8-jruby → 0.0.9-jruby

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.9

data/lib/orientdb.rb

@@ -26,4 +26,5 @@ require 'orientdb/database'
 require 'orientdb/record'
 require 'orientdb/document'
 require 'orientdb/sql_query'
+require 'orientdb/sql'
 require 'orientdb/oclass'

data/lib/orientdb/constants.rb

@@ -16,7 +16,7 @@ module OrientDB
   RemoteStorage  = com.orientechnologies.orient.client.remote.OStorageRemote
   Schema         = com.orientechnologies.orient.core.metadata.schema.OSchema
   SchemaType     = com.orientechnologies.orient.core.metadata.schema.OType
-  SQLQuery       = com.orientechnologies.orient.core.sql.query.OSQLSynchQuery
+  SQLSynchQuery       = com.orientechnologies.orient.core.sql.query.OSQLSynchQuery
   SQLCommand     = com.orientechnologies.orient.core.sql.OCommandSQL
   User           = com.orientechnologies.orient.core.metadata.security.OUser
 

data/lib/orientdb/database.rb

@@ -31,9 +31,6 @@ class OrientDB::Database
     native_query sql_query
   end
 
-  alias :find :query
-  alias :all :query
-
   def first(sql_query = nil)
     sql_query = prepare_sql_query(sql_query).setLimit(1)
     query(sql_query).first
@@ -42,57 +39,17 @@ class OrientDB::Database
   def prepare_sql_query(sql_query)
     return if sql_query.nil?
     case sql_query
-      when com.orientechnologies.orient.core.sql.query.OSQLSynchQuery
+      when OrientDB::SQLSynchQuery
         sql_query
+      when OrientDB::SQL::Query
+        sql_query.to_sql_synch_query
       when String
-        com.orientechnologies.orient.core.sql.query.OSQLSynchQuery.new sql_query
-      when Hash
-        com.orientechnologies.orient.core.sql.query.OSQLSynchQuery.new sql_query_from_hash(sql_query)
+        OrientDB::SQLSynchQuery.new(sql_query)
       else
         raise "Unknown query type"
     end
   end
 
-  def sql_query_from_hash(options = {})
-    target = options.delete :oclass
-    raise "Missing oclass name" unless target
-
-    columns    = options.delete(:columns) || '*'
-    order      = options.delete :order
-    order_sql  = order ? " ORDER BY #{order}" : ''
-    limit      = options.delete :limit
-    limit_sql  = limit ? " LIMIT #{limit}" : ''
-    range_low  = options.delete(:range_low) || options.delete(:range)
-    range_high = options.delete :range_high
-    range_sql  = range_low ? " RANGE #{range_low}#{range_high ? ",#{range_high}" : ''}" : ''
-    fields     = options.map { |field, value| "#{field} #{operator_for(value)} #{quote(value)}" }
-    where_sql  = fields.size > 0 ? " WHERE #{fields.join(' AND ')}" : ''
-
-    "SELECT #{columns} FROM #{target}" + where_sql + order_sql + limit_sql + range_sql
-  end
-
-  def operator_for(value)
-    case value
-      when Integer, Float, Symbol
-        "="
-      when String
-        value.index('%') ? "LIKE" : "="
-      when Array
-        "IN"
-    end
-  end
-
-  def quote(value)
-    case value
-      when Integer, Float, Symbol
-        value.to_s
-      when String
-        "'#{value}'"
-      when Array
-        "[" + value.map { |x| quote(x) }.join(", ") + "]"
-    end
-  end
-
   def schema
     metadata.schema
   end

data/lib/orientdb/document.rb

@@ -58,7 +58,6 @@ module OrientDB
       alias_method :native_new, :new
 
       def new(db, klass_name, fields = {})
-        puts "new : #{db} : #{klass_name} : #{fields.inspect}"
         obj = native_new db, klass_name.to_s
         fields.each do |name, value|
           obj.field name.to_s, value

data/lib/orientdb/oclass.rb

@@ -4,13 +4,13 @@ module OrientDB
 
     def type_for(value)
       type = case value
-        when SchemaType
+        when OrientDB::SchemaType, OrientDB::OClass
           value
         when Symbol
           FIELD_TYPES[value]
         else
           FIELD_TYPES[value.to_s.to_sym]
-             end
+        end
       raise "Uknown schema type for [#{value}]" unless type
       type
     end
@@ -74,12 +74,10 @@ module OrientDB
     class << self
 
       def create(db, name, fields = {})
-        puts "create [#{name}], #{fields.inspect}"
         name        = name.to_s
         add_cluster = fields.delete :add_cluster
         add_cluster = true if add_cluster.nil?
         use_cluster = fields.delete :use_cluster
-        puts "use_cluster : #{use_cluster}"
 
         if db.schema.exists_class? name
           klass = db.get_class name
@@ -87,15 +85,12 @@ module OrientDB
           if use_cluster
             cluster = db.storage.get_cluster use_cluster
             klass   = db.schema.create_class name, use_cluster
-            puts "created and used cluster [#{cluster}] for [#{klass}]"
           elsif add_cluster && !db.storage.cluster_names.include?(name.downcase)
             cluster = db.storage.add_cluster name.downcase, STORAGE_TYPES[:physical]
             klass   = db.schema.create_class name, cluster
-            puts "created and added cluster [#{cluster}] for [#{klass}]"
           else
             klass   = db.schema.create_class name
             cluster = db.storage.get_cluster klass.cluster_ids.first
-            puts "created and got cluster [#{cluster}] for [#{klass}]"
           end
         end
 

data/lib/orientdb/sql.rb

@@ -0,0 +1,277 @@
+require 'orientdb/sql_ext'
+
+module OrientDB
+  module SQL
+
+    class ConditionExpression
+
+      attr_reader :conditions
+
+      def initialize(type)
+        @type       = type
+        @conditions = []
+        add(conds) if conds
+      end
+
+      def type
+        @type.to_s.upcase.gsub('_', ' ')
+      end
+
+      def add(*conds)
+        puts "add : #{conds.inspect}"
+        conds.each do |cond|
+          case cond
+            when ConditionExpression
+              puts "ConditionExpression : #{cond.class.name} : #{cond.inspect}"
+              conditions << cond.to_s
+            when Hash
+              puts "Hash : #{cond.class.name} : #{cond.inspect}"
+              cond.each { |k, v| conditions << "#{k} = #{Query.quote(v)}" }
+            when Array
+              puts "Array : #{cond.class.name} : #{cond.inspect}"
+              cond.each { |x| conditions << x.to_s }
+            else
+              puts "else : #{cond.class.name} : #{cond.inspect}"
+              conditions << cond.to_s
+          end
+        end
+      end
+
+      def clear
+        @conditions = []
+      end
+
+      def conditions_str
+        conditions.join(' AND ')
+      end
+
+      def parens_conditions_str
+        conditions.size > 1 ? "(#{conditions_str})" : conditions_str
+      end
+
+      def to_s
+        "#{type} #{parens_conditions_str} "
+      end
+    end
+
+    class Query
+
+      attr_reader :projections, :targets, :conditions, :order, :limit, :lower_range, :upper_range, :plan
+
+      def initialize
+        @projections = []
+        @targets     = []
+        @conditions  = []
+        @order       = []
+        @limit       = nil
+        @lower_range = nil
+        @upper_range = nil
+        @plan        = nil
+      end
+
+      def select(*args)
+        args.each do |arg|
+          case arg
+            when String, Symbol, Integer
+              arg = select_single_string(arg)
+              @projections << arg
+            when Hash
+              arg.each { |k, v| @projections << "#{k} AS #{v}" }
+            when Array
+              if arg.size == 2
+                @projections << "#{arg.first} AS #{arg.last}"
+              else
+                arg.each { |x| @projections << select_single_string(x) }
+              end
+          end
+        end
+        self
+      end
+
+      alias :columns :select
+
+      def select!(*args)
+        @projections = []
+        select *args
+      end
+
+      def from(*args)
+        args.each { |x| @targets << x.to_s }
+        self
+      end
+
+      def from!(*args)
+        @targets = []
+        from *args
+      end
+
+      def where(*args)
+        @conditions << ConditionExpression.new(:and) if @conditions.empty?
+        @conditions.last.add *args
+        self
+      end
+
+      def where!(*args)
+        @conditions = []
+        where *args
+      end
+
+      def and(*args)
+        @conditions << ConditionExpression.new(:and)
+        @conditions.last.add *args
+        self
+      end
+
+      def or(*args)
+        @conditions << ConditionExpression.new(:or)
+        @conditions.last.add *args
+        self
+      end
+
+      def and_not(*args)
+        @conditions << ConditionExpression.new(:and_not)
+        @conditions.last.add *args
+        self
+      end
+
+      def or_not(*args)
+        @conditions << ConditionExpression.new(:or_not)
+        @conditions.last.add *args
+        self
+      end
+
+      def order(*args)
+        args.each do |arg|
+          case arg
+            when Hash
+              arg.each { |k, v| @order << "#{k} #{order_direction_for(v)}" }
+            when Array
+              case arg.size
+                when 2
+                  @order << "#{arg[0]} #{order_direction_for(arg[1])}"
+                else
+                  arg.each { |x| @order << x.to_s }
+              end
+            else
+              @order << arg.to_s
+          end
+        end
+        self
+      end
+
+      def order!(*args)
+        @order = []
+        order *args
+      end
+
+      def limit(max_records)
+        @limit = max_records.to_s.to_i
+        self
+      end
+
+      alias :limit! :limit
+
+      def range(lower_rid, upper_rid = nil)
+        @lower_range = lower_rid.to_s
+        @upper_range = upper_rid ? upper_rid.to_s : nil
+        self
+      end
+
+      alias :range! :range
+
+      def to_s
+        (select_sql + target_sql + conditions_sql + order_sql + limit_sql + range_sql).strip
+      end
+
+      def to_sql_synch_query
+        OrientDB::SQLSynchQuery.new to_s
+      end
+
+      def self.quote(value)
+        case value
+          when Numeric, Symbol
+            value.to_s
+          when String
+            quote_string(value)
+          when Array
+            "[" + value.map { |x| quote(x) }.join(", ") + "]"
+          when Regexp
+            quote_regexp(value)
+        end
+      end
+
+      def self.quote_string(str)
+        str = str.dup
+        return str if str[0, 1] == "'" && str[-1, 1] == "'"
+        last_pos = 0
+        while (pos = str.index("'", last_pos))
+          str.insert(pos, "\\") if pos > 0 && str[pos - 1, 1] != "\\"
+          last_pos = pos + 1
+        end
+        "'#{str}'"
+      end
+
+      def self.quote_regexp(regexp)
+        regexp      = regexp.inspect
+        left_index  = regexp.index('/') + 1
+        right_index = regexp.rindex('/') - 1
+        str         = regexp[left_index..right_index]
+        "'#{str}'"
+      end
+
+      def quote(value)
+        self.class.quote value
+      end
+
+      private
+
+      def select_sql
+        str = @projections.empty? ? '' : @projections.map { |x| x.to_s }.join(', ') + ' '
+        "SELECT #{str}"
+      end
+
+      def target_sql
+        case @targets.size
+          when 0
+            "FROM "
+          when 1
+            "FROM #{@targets.first} "
+          else
+            "FROM [#{@targets.map { |x| x.to_s }.join(", ")}] "
+        end
+      end
+
+      def conditions_sql
+        case @conditions.size
+          when 0
+            ''
+          when 1
+            "WHERE #{@conditions.first.conditions_str} "
+          else
+            "WHERE #{@conditions.first.parens_conditions_str} #{@conditions[1..-1].map { |x| x.to_s }.join('')}"
+        end
+      end
+
+      def order_sql
+        @order.empty? ? '' : "ORDER BY #{@order.map { |x| x.to_s }.join(', ')} "
+      end
+
+      def limit_sql
+        @limit.nil? ? '' : "LIMIT #{@limit} "
+      end
+
+      def range_sql
+        @lower_range.nil? ? '' : "RANGE #{@lower_range}#{@upper_range ? ", #{@upper_range}" : ''} "
+      end
+
+      def select_single_string(arg)
+        arg.to_s.split('___').join(' AS ').split('__').join('.')
+      end
+
+      def order_direction_for(value)
+        value.to_s.strip.downcase == 'desc' ? 'DESC' : 'ASC'
+      end
+
+    end
+  end
+end

data/lib/orientdb/sql_ext.rb

@@ -0,0 +1,240 @@
+module OrientDB
+  module SQL
+
+    def monkey_patched
+      @monkey_patched ||= []
+    end
+
+    module_function :monkey_patched
+
+    def monkey_patched?(name)
+      monkey_patched.include? name.to_s.downcase.to_sym
+    end
+
+    module_function :monkey_patched?
+
+    # Extend strings and/or symbols to create queries easier
+    def monkey_patch!(*args)
+      args = %w{ symbol string } if args.empty?
+      args.each do |arg|
+        case arg.to_s.downcase.to_sym
+          when :symbol
+            if monkey_patched?(:symbol)
+              puts "Symbol has already been monkey patched!"
+              false
+            else
+              Symbol.send :include, OrderExtension
+              Symbol.send :include, ConditionalExtension
+              Symbol.send :include, FieldOperatorExtension
+              Symbol.send :include, BundledFunctionExtension
+              monkey_patched << :symbol
+              true
+            end
+          when :string
+            if monkey_patched?(:string)
+              puts "String has already been monkey patched!"
+              false
+            else
+              String.send :include, OrderExtension
+              String.send :include, ConditionalExtension
+              String.send :include, FieldOperatorExtension
+              String.send :include, BundledFunctionExtension
+              monkey_patched << :string
+              true
+            end
+        end
+      end
+    end
+
+    module_function :monkey_patch!
+
+    module OrderExtension
+      def asc
+        "#{to_s} ASC"
+      end
+
+      def desc
+        "#{to_s} DESC"
+      end
+    end
+
+    module ConditionalExtension
+      def like(value)
+        "#{to_s} LIKE #{Query.quote(value)}"
+      end
+
+      def eq(value)
+        "#{to_s} = #{Query.quote(value)}"
+      end
+
+      def lt(value)
+        "#{to_s} < #{Query.quote(value)}"
+      end
+
+      def lte(value)
+        "#{to_s} <= #{Query.quote(value)}"
+      end
+
+      def gt(value)
+        "#{to_s} > #{Query.quote(value)}"
+      end
+
+      def gte(value)
+        "#{to_s} >= #{Query.quote(value)}"
+      end
+
+      def ne(value)
+        "#{to_s} <> #{Query.quote(value)}"
+      end
+
+      def is_null
+        "#{to_s} IS null"
+      end
+
+      def is_not_null
+        "#{to_s} IS NOT null"
+      end
+
+      def in(*values)
+        "#{to_s} IN #{Query.quote(values)}"
+      end
+
+      def contains(field, value)
+        "#{to_s} contains (#{field} = #{Query.quote(value)})"
+      end
+
+      def contains_all(field, value)
+        "#{to_s} containsAll (#{field} = #{Query.quote(value)})"
+      end
+
+      def contains_key(value)
+        "#{to_s} containsKey #{Query.quote(value)}"
+      end
+
+      def contains_value(value)
+        "#{to_s} containsValue #{Query.quote(value)}"
+      end
+
+      def contains_text(value)
+        "#{to_s} containsText #{Query.quote(value)}"
+      end
+
+      def matches(value)
+        "#{to_s} matches #{Query.quote(value)}"
+      end
+    end
+
+    module FieldOperatorExtension
+      # Avoided overriding the native method
+      def odb_length
+        "#{to_s}.length()"
+      end
+
+      # Avoided overriding the native method
+      def odb_trim
+        "#{to_s}.trim()"
+      end
+
+      def to_upper_case
+        "#{to_s}.toUpperCase()"
+      end
+
+      def to_lower_case
+        "#{to_s}.toLowerCase()"
+      end
+
+      # Avoided overriding the native method
+      def odb_left(length)
+        "#{to_s}.left(#{Query.quote(length)})"
+      end
+
+      # Avoided overriding the native method
+      def odb_right(length)
+        "#{to_s}.right(#{Query.quote(length)})"
+      end
+
+      def sub_string(start, length = nil)
+        "#{to_s}.subString(#{Query.quote(start)}#{length ? ", #{Query.quote(length)}" : ''})"
+      end
+
+      def char_at(pos)
+        "#{to_s}.charAt(#{Query.quote(pos)})"
+      end
+
+      def index_of(string, start = nil)
+        "#{to_s}.indexOf(#{Query.quote(string)}#{start ? ", #{Query.quote(start)}" : ''})"
+      end
+
+      # Avoided overriding the native method
+      def odb_format(frmt)
+        "#{to_s}.format(#{Query.quote(frmt)})"
+      end
+
+      # Avoided overriding the native method
+      def odb_size
+        "#{to_s}.size()"
+      end
+
+      def as_string
+        "#{to_s}.asString()"
+      end
+
+      def as_integer
+        "#{to_s}.asInteger()"
+      end
+
+      def as_float
+        "#{to_s}.asFloat()"
+      end
+
+      def as_date
+        "#{to_s}.asDate()"
+      end
+
+      def as_date_time
+        "#{to_s}.asDateTime()"
+      end
+
+      def as_boolean
+        "#{to_s}.asBoolean()"
+      end
+    end
+
+    module BundledFunctionExtension
+
+      # Avoided overriding the native method
+      def odb_count
+        "count(#{to_s})"
+      end
+
+      # Avoided overriding the native method
+      def odb_min
+        "min(#{to_s})"
+      end
+
+      # Avoided overriding the native method
+      def odb_max
+        "max(#{to_s})"
+      end
+
+      # Avoided overriding the native method
+      def odb_avg
+        "avg(#{to_s})"
+      end
+
+      # Avoided overriding the native method
+      def odb_sum
+        "sum(#{to_s})"
+      end
+
+      def sysdate
+        "sysdate('#{to_s}')"
+      end
+
+      # Avoided overriding the native method
+      def odb_format_str(*args)
+        "format('#{to_s}', #{args.map{|x| Query.quote(x)}.join(', ')})"
+      end
+    end
+  end
+end