orientdb 0.0.12-jruby → 0.0.14-jruby

data/VERSION

@@ -1 +1 @@
-0.0.12
+0.0.14

data/bin/orientdb_console

@@ -11,7 +11,7 @@ if ARGV.include?('test:db')
   puts ">> TEST_DB PATH : #{TEST_DB_PATH}"
 
   require 'fileutils'
-  FileUtils.remove_dir TEST_DB_PATH
+  FileUtils.remove_dir "#{TEMP_DIR}/databases" rescue nil
   FileUtils.mkdir_p TEST_DB_PATH
   DB = OrientDB::DocumentDatabase.new("local:#{TEST_DB_PATH}/test").create
 end

data/lib/orientdb.rb

@@ -25,6 +25,5 @@ require 'orientdb/storage'
 require 'orientdb/database'
 require 'orientdb/record'
 require 'orientdb/document'
-require 'orientdb/sql_query'
 require 'orientdb/sql'
 require 'orientdb/oclass'

data/lib/orientdb/database.rb

@@ -6,13 +6,14 @@ module OrientDB
       command(sql_command).execute(true)
     end
 
-    def prepare_sql_command(sql_command)
-      return if sql_command.nil?
-      case sql_command
+    def prepare_sql_command(command)
+      return if command.nil?
+      return command.to_sql_command if command.respond_to?(:to_sql_command)
+      case command
         when OrientDB::SQLCommand
-          sql_command
+          command
         when String
-          OrientDB::SQLCommand.new sql_command
+          OrientDB::SQLCommand.new command
         else
           raise "Unknown command type"
       end
@@ -28,15 +29,22 @@ module OrientDB
       query(sql_query).first
     end
 
-    def prepare_sql_query(sql_query)
-      return if sql_query.nil?
-      case sql_query
+    def find_by_rid(rid)
+      first "SELECT FROM #{rid}"
+    end
+
+    def find_by_rids(*rids)
+      all "SELECT FROM [#{rids.map{|x| x.to_s}.join(', ')}]"
+    end
+
+    def prepare_sql_query(query)
+      return if query.nil?
+      return query.to_sql_query if query.respond_to?(:to_sql_query)
+      case query
         when OrientDB::SQLSynchQuery
-          sql_query
-        when OrientDB::SQL::Query
-          sql_query.to_sql_synch_query
+          query
         when String
-          OrientDB::SQLSynchQuery.new(sql_query)
+          OrientDB::SQLSynchQuery.new(query)
         else
           raise "Unknown query type"
       end

data/lib/orientdb/oclass.rb

@@ -62,7 +62,7 @@ module OrientDB
     end
 
     def inspect
-      props = properties.map { |x| "#{x.name}=#{x.type.to_s.downcase}#{x.is_indexed? ? '(idx)' : ''}" }.join(' ')
+      props = properties.map { |x| "#{x.name}=#{x.type.name}#{x.is_indexed? ? '(idx)' : ''}" }.join(' ')
       "#<OrientDB::OClass:" + name +
         (getSuperClass ? ' super=' + getSuperClass.name : '') +
         (props.empty? ? '' : ' ' + props) +
@@ -83,14 +83,12 @@ module OrientDB
           klass = db.get_class name
         else
           if use_cluster
-            cluster = db.storage.get_cluster use_cluster
-            klass   = db.schema.create_class name, cluster
+            klass   = db.schema.create_class name, use_cluster
           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
           else
             klass   = db.schema.create_class name
-            cluster = db.storage.get_cluster klass.cluster_ids.first rescue nil
           end
         end
 

data/lib/orientdb/record.rb

@@ -1,10 +1,6 @@
 module OrientDB
 
   class RecordList
-    def jruby_value
-      map
-    end
-
     def inspect
       "#<OrientDB::RecordList:#{toString}>"
     end

data/lib/orientdb/sql.rb

@@ -1,267 +1,18 @@
-require 'orientdb/sql_ext'
+module OrientDB::SQL
+  class SQLSynchQuery
 
-module OrientDB
-  module SQL
-
-    class ConditionExpression
-
-      attr_reader :conditions
-
-      def initialize(type)
-        @type       = type
-        @conditions = []
-      end
-
-      def type
-        @type.to_s.upcase.gsub('_', ' ')
-      end
-
-      def add(*conds)
-        conds.each do |cond|
-          case cond
-            when ConditionExpression
-              conditions << cond.to_s
-            when Hash
-              cond.each { |k, v| conditions << "#{k} = #{Query.quote(v)}" }
-            when Array
-              cond.each { |x| conditions << x.to_s }
-            else
-              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
+    def inspect
+      %{#<OrientDB::SQLSynchQuery:#{name} text="#{text}">}
     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
+    alias :to_s :inspect
 
-      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
-
-      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
+end
+
+require 'orientdb/sql/common'
+require 'orientdb/sql/ext'
+require 'orientdb/sql/query'
+require 'orientdb/sql/insert'
+require 'orientdb/sql/update'
+require 'orientdb/sql/delete'

data/lib/orientdb/sql/common.rb

@@ -0,0 +1,217 @@
+module OrientDB::SQL
+  module UtilsMixin
+
+    def select_single_string(arg)
+      arg.to_s.split('___').join(' AS ').split('__').join('.')
+    end
+
+    def field_name(name)
+      name.to_s.split('__').join('.')
+    end
+
+    def 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 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 quote_regexp(regexp)
+      regexp      = regexp.inspect
+      left_index  = regexp.index('/') + 1
+      right_index = regexp.rindex('/') - 1
+      str         = regexp[left_index..right_index]
+      "'#{str}'"
+    end
+
+  end
+
+  module ClassClusterParametersMixin
+
+    def oclass(new_oclass)
+      @oclass = new_oclass.to_s
+      self
+    end
+
+    alias :oclass! :oclass
+
+    def cluster(new_cluster)
+      @cluster = new_cluster.to_s
+      self
+    end
+
+    alias :cluster! :cluster
+
+    private
+
+    def target_sql(command)
+      command = command.to_s.upcase.gsub('_', ' ')
+      if @oclass
+        "#{command} #{@oclass} "
+      elsif @cluster
+        "#{command} cluster:#{@cluster} "
+      else
+        raise "Missing oclass or cluster"
+      end
+    end
+
+  end
+
+  module FieldsValuesParametersMixin
+
+    def fields(*args)
+      args.each do |arg|
+        case arg
+          when String, Symbol, Integer
+            @fields << field_name(arg)
+          when Hash
+            arg.each { |k, v| @fields << field_name(k); @values << quote(v) }
+          when Array
+            arg.each { |x| @fields << field_name(x) }
+        end
+      end
+      self
+    end
+
+    def fields!(*args)
+      @fields = []
+      @values = []
+      fields *args
+    end
+
+    def values(*args)
+      args.each do |arg|
+        case arg
+          when String, Symbol, Integer
+            arg = quote(arg)
+            @values << arg
+          when Hash
+            arg.each { |k, v| @fields << field_name(k); @values << quote(v) }
+          when Array
+            arg.each { |x| @values << quote(x) }
+        end
+      end
+      self
+    end
+
+    def values!(*args)
+      @fields = []
+      @values = []
+      values *args
+    end
+
+  end
+
+  module ConditionsParametersMixin
+    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
+
+    private
+
+    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
+
+  end
+
+  class ConditionExpression
+
+    attr_reader :conditions
+
+    def initialize(type)
+      @type       = type
+      @conditions = []
+    end
+
+    def type
+      @type.to_s.upcase.gsub('_', ' ')
+    end
+
+    def add(*conds)
+      conds.each do |cond|
+        case cond
+          when ConditionExpression
+            conditions << cond.to_s
+          when Hash
+            cond.each { |k, v| conditions << "#{k} = #{Query.quote(v)}" }
+          when Array
+            cond.each { |x| conditions << x.to_s }
+          else
+            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
+end

data/lib/orientdb/sql/delete.rb

@@ -0,0 +1,23 @@
+module OrientDB::SQL
+  class Delete
+
+    include OrientDB::SQL::UtilsMixin
+    include OrientDB::SQL::ClassClusterParametersMixin
+    include OrientDB::SQL::ConditionsParametersMixin
+
+    def initialize
+      @oclass     = nil
+      @cluster    = nil
+      @conditions = []
+    end
+
+    def to_s
+      (target_sql(:delete_from) + conditions_sql).strip
+    end
+
+    def to_sql_command
+      OrientDB::SQLCommand.new to_s
+    end
+
+  end
+end

data/lib/orientdb/{sql_ext.rb → sql/ext.rb}

@@ -59,32 +59,34 @@ module OrientDB
     end
 
     module ConditionalExtension
+      include OrientDB::SQL::UtilsMixin
+
       def like(value)
-        "#{to_s} LIKE #{Query.quote(value)}"
+        "#{to_s} LIKE #{quote(value)}"
       end
 
       def eq(value)
-        "#{to_s} = #{Query.quote(value)}"
+        "#{to_s} = #{quote(value)}"
       end
 
       def lt(value)
-        "#{to_s} < #{Query.quote(value)}"
+        "#{to_s} < #{quote(value)}"
       end
 
       def lte(value)
-        "#{to_s} <= #{Query.quote(value)}"
+        "#{to_s} <= #{quote(value)}"
       end
 
       def gt(value)
-        "#{to_s} > #{Query.quote(value)}"
+        "#{to_s} > #{quote(value)}"
       end
 
       def gte(value)
-        "#{to_s} >= #{Query.quote(value)}"
+        "#{to_s} >= #{quote(value)}"
       end
 
       def ne(value)
-        "#{to_s} <> #{Query.quote(value)}"
+        "#{to_s} <> #{quote(value)}"
       end
 
       def is_null
@@ -96,35 +98,37 @@ module OrientDB
       end
 
       def in(*values)
-        "#{to_s} IN #{Query.quote(values)}"
+        "#{to_s} IN #{quote(values)}"
       end
 
       def contains(field, value)
-        "#{to_s} contains (#{field} = #{Query.quote(value)})"
+        "#{to_s} contains (#{field} = #{quote(value)})"
       end
 
       def contains_all(field, value)
-        "#{to_s} containsAll (#{field} = #{Query.quote(value)})"
+        "#{to_s} containsAll (#{field} = #{quote(value)})"
       end
 
       def contains_key(value)
-        "#{to_s} containsKey #{Query.quote(value)}"
+        "#{to_s} containsKey #{quote(value)}"
       end
 
       def contains_value(value)
-        "#{to_s} containsValue #{Query.quote(value)}"
+        "#{to_s} containsValue #{quote(value)}"
       end
 
       def contains_text(value)
-        "#{to_s} containsText #{Query.quote(value)}"
+        "#{to_s} containsText #{quote(value)}"
       end
 
       def matches(value)
-        "#{to_s} matches #{Query.quote(value)}"
+        "#{to_s} matches #{quote(value)}"
       end
     end
 
     module FieldOperatorExtension
+      include OrientDB::SQL::UtilsMixin
+
       # Avoided overriding the native method
       def odb_length
         "#{to_s}.length()"
@@ -145,29 +149,29 @@ module OrientDB
 
       # Avoided overriding the native method
       def odb_left(length)
-        "#{to_s}.left(#{Query.quote(length)})"
+        "#{to_s}.left(#{quote(length)})"
       end
 
       # Avoided overriding the native method
       def odb_right(length)
-        "#{to_s}.right(#{Query.quote(length)})"
+        "#{to_s}.right(#{quote(length)})"
       end
 
       def sub_string(start, length = nil)
-        "#{to_s}.subString(#{Query.quote(start)}#{length ? ", #{Query.quote(length)}" : ''})"
+        "#{to_s}.subString(#{quote(start)}#{length ? ", #{quote(length)}" : ''})"
       end
 
       def char_at(pos)
-        "#{to_s}.charAt(#{Query.quote(pos)})"
+        "#{to_s}.charAt(#{quote(pos)})"
       end
 
       def index_of(string, start = nil)
-        "#{to_s}.indexOf(#{Query.quote(string)}#{start ? ", #{Query.quote(start)}" : ''})"
+        "#{to_s}.indexOf(#{quote(string)}#{start ? ", #{quote(start)}" : ''})"
       end
 
       # Avoided overriding the native method
       def odb_format(frmt)
-        "#{to_s}.format(#{Query.quote(frmt)})"
+        "#{to_s}.format(#{quote(frmt)})"
       end
 
       # Avoided overriding the native method
@@ -201,6 +205,7 @@ module OrientDB
     end
 
     module BundledFunctionExtension
+      include OrientDB::SQL::UtilsMixin
 
       # Avoided overriding the native method
       def odb_count
@@ -233,7 +238,7 @@ module OrientDB
 
       # Avoided overriding the native method
       def odb_format_str(*args)
-        "format('#{to_s}', #{args.map{|x| Query.quote(x)}.join(', ')})"
+        "format('#{to_s}', #{args.map{|x| quote(x)}.join(', ')})"
       end
     end
   end

data/lib/orientdb/sql/insert.rb

@@ -0,0 +1,37 @@
+module OrientDB::SQL
+  class Insert
+
+    include OrientDB::SQL::UtilsMixin
+    include OrientDB::SQL::ClassClusterParametersMixin
+    include OrientDB::SQL::FieldsValuesParametersMixin
+
+    def initialize
+      @oclass  = nil
+      @cluster = nil
+      @fields  = []
+      @values  = []
+    end
+
+    def to_s
+      (target_sql(:insert_into) + fields_sql + values_sql).strip
+    end
+
+    def to_sql_command
+      OrientDB::SQLCommand.new to_s
+    end
+
+    private
+
+    def fields_sql
+      raise "Missing fields" if @fields.empty?
+      "(#{@fields.join(', ')}) "
+    end
+
+    def values_sql
+      raise "Missing values" if @values.empty?
+      raise "Unbalanced fields & values" unless @values.size == @fields.size
+      "VALUES (#{@values.join(', ')}) "
+    end
+
+  end
+end

data/lib/orientdb/sql/query.rb

@@ -0,0 +1,138 @@
+module OrientDB::SQL
+  class Query
+    include OrientDB::SQL::UtilsMixin
+    include OrientDB::SQL::ConditionsParametersMixin
+    extend OrientDB::SQL::UtilsMixin
+
+    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 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_query
+      OrientDB::SQLSynchQuery.new to_s
+    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 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 order_direction_for(value)
+      value.to_s.strip.downcase == 'desc' ? 'DESC' : 'ASC'
+    end
+
+  end
+end

data/lib/orientdb/sql/update.rb

@@ -0,0 +1,57 @@
+module OrientDB::SQL
+  class Update
+
+    include OrientDB::SQL::UtilsMixin
+    include OrientDB::SQL::ClassClusterParametersMixin
+    include OrientDB::SQL::FieldsValuesParametersMixin
+    include OrientDB::SQL::ConditionsParametersMixin
+
+    def initialize
+      @oclass     = nil
+      @cluster    = nil
+      @action     = "SET"
+      @fields     = []
+      @values     = []
+      @conditions = []
+    end
+
+    def action(new_action)
+      @action = new_action.to_s.upcase
+      self
+    end
+
+    alias :action! :action
+
+    def to_s
+      (target_sql(:update) + fields_sql + conditions_sql).strip
+    end
+
+    def to_sql_command
+      OrientDB::SQLCommand.new to_s
+    end
+
+    private
+
+    def fields_sql
+      raise "Missing fields" if @fields.empty?
+      str = "#{@action} "
+      if @action == "REMOVE" && @values.empty?
+        str += @fields.join(', ')
+      else
+        raise "Missing values" if @values.empty?
+        raise "Unbalanced fields & values" unless @values.size == @fields.size
+        ary = []
+        @fields.each_with_index do |field, idx|
+          ary << "#{field} = #{@values[idx]}"
+        end
+        str += ary.join(", ")
+      end
+      str + ' '
+    end
+
+    def values_sql
+      "(#{@values.join(', ')})"
+    end
+
+  end
+end

data/lib/orientdb/sql_query.rb

@@ -1,13 +0,0 @@
-module OrientDB
-
-  class SqlQuery
-
-    def inspect
-      %{#<OrientDB::SqlQuery:#{name} text="#{text}">}
-    end
-
-    alias :to_s :inspect
-
-  end
-
-end

data/orientdb.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{orientdb}
-  s.version = "0.0.12"
+  s.version = "0.0.14"
   s.platform = %q{jruby}
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adrian Madrid"]
-  s.date = %q{2011-01-20}
+  s.date = %q{2011-01-25}
   s.default_executable = %q{orientdb_console}
   s.description = %q{Simple JRuby wrapper for the OrientDB.}
   s.email = ["aemadrid@gmail.com"]
@@ -45,7 +45,12 @@ Gem::Specification.new do |s|
     "lib/orientdb/record.rb",
     "lib/orientdb/schema.rb",
     "lib/orientdb/sql.rb",
-    "lib/orientdb/sql_ext.rb",
+    "lib/orientdb/sql/common.rb",
+    "lib/orientdb/sql/delete.rb",
+    "lib/orientdb/sql/ext.rb",
+    "lib/orientdb/sql/insert.rb",
+    "lib/orientdb/sql/query.rb",
+    "lib/orientdb/sql/update.rb",
     "lib/orientdb/sql_query.rb",
     "lib/orientdb/storage.rb",
     "lib/orientdb/user.rb",

data/spec/database_spec.rb

@@ -81,10 +81,13 @@ describe "OrientDB" do
       end
 
       it "should find rows by simple field values" do
-        DB.first("SELECT * FROM employee WHERE name = 'Mark'").should == @e1
         DB.first('SELECT * FROM employee WHERE age = 37').should == @e2
       end
 
+      it "should find rows by simple field values" do
+        DB.find_by_rid(@e3.rid).rid.should == @e3.rid
+      end
+
       it "should find rows by values in arrays" do
         qry = DB.prepare_sql_query "SELECT * FROM #{@oclass} WHERE 'admin' IN groups"
         DB.all(qry).map { |x| x.name }.sort.should == [@e1, @e2, @e4].map { |x| x.name }.sort

data/spec/sql_spec.rb

@@ -4,13 +4,7 @@ describe "OrientDB" do
 
   describe "SQL" do
 
-    describe "Query" do
-
-      it "should do a blank query" do
-        @q = OrientDB::SQL::Query.new
-        @q.should be_a_kind_of OrientDB::SQL::Query
-        @q.to_s.should == 'SELECT FROM'
-      end
+    describe "Common" do
 
       describe "quote" do
         it "should quote numeric values correctly" do
@@ -49,6 +43,44 @@ describe "OrientDB" do
         end
       end
 
+      describe "select_single_string" do
+        it "should split extend and alias strings correctly" do
+          OrientDB::SQL::Query.select_single_string('a__b___c').should == 'a.b AS c'
+        end
+
+        it "should split extend strings correctly" do
+          OrientDB::SQL::Query.select_single_string('a__b').should == 'a.b'
+        end
+
+        it "should split extended strings correctly" do
+          OrientDB::SQL::Query.select_single_string('a__b__c').should == 'a.b.c'
+        end
+
+        it "should split alias strings correctly" do
+          OrientDB::SQL::Query.select_single_string('a___c').should == 'a AS c'
+        end
+      end
+
+      describe "field_name" do
+        it "should split simple names correctly" do
+          OrientDB::SQL::Query.field_name(:a__b).should == 'a.b'
+        end
+
+        it "should split longer names correctly" do
+          OrientDB::SQL::Query.field_name(:a__b__c).should == 'a.b.c'
+        end
+      end
+
+    end
+
+    describe "Query" do
+
+      it "should do a blank query" do
+        @q = OrientDB::SQL::Query.new
+        @q.should be_a_kind_of OrientDB::SQL::Query
+        @q.to_s.should == 'SELECT FROM'
+      end
+
       describe "SELECT" do
 
         before :each do
@@ -661,6 +693,132 @@ describe "OrientDB" do
         end
       end
     end
+  end
+
+  describe "INSERT" do
+
+    before :each do
+      @q = OrientDB::SQL::Insert.new
+    end
+
+    it "should handle basic oclass inserts" do
+      @q.oclass('Person').values(:name => "Martin").to_s.should == "INSERT INTO Person (name) VALUES ('Martin')"
+    end
+
+    it "should handle basic oclass inserts" do
+      @q.cluster('person').values(:name => "Martin").to_s.should == "INSERT INTO cluster:person (name) VALUES ('Martin')"
+    end
+
+    it "should handle complex oclass inserts" do
+      @q.oclass('Person').fields(:name => "Martin").values(:age => 39).to_s.should == "INSERT INTO Person (name, age) VALUES ('Martin', 39)"
+    end
+
+    it "should handle array oclass inserts" do
+      @q.oclass('Person').fields(:name, :age).values("Martin", 39).to_s.should == "INSERT INTO Person (name, age) VALUES ('Martin', 39)"
+    end
+
+  end
+
+  describe "UPDATE" do
+
+    before :each do
+      @q = OrientDB::SQL::Update.new
+    end
 
+    it "should handle basic oclass SET update" do
+      @q.oclass('Person').values(:name => "Martin").to_s.should == "UPDATE Person SET name = 'Martin'"
+    end
+
+    it "should handle basic cluster SET update" do
+      @q.cluster('person').values(:name => "Martin").to_s.should == "UPDATE cluster:person SET name = 'Martin'"
+    end
+
+    it "should handle complex oclass SET updates" do
+      @q.oclass('Person').fields(:name => "Martin").values(:age => 39).to_s.should == "UPDATE Person SET name = 'Martin', age = 39"
+    end
+
+    it "should handle array oclass REMOVE a field updates" do
+      @q.oclass('Person').action(:remove).fields(:name).to_s.should == "UPDATE Person REMOVE name"
+    end
+
+    it "should handle array oclass REMOVE many fields updates" do
+      @q.oclass('Person').action(:remove).fields(:name, :age).to_s.should == "UPDATE Person REMOVE name, age"
+    end
+
+    it "should handle basic oclass REMOVE a value from a collection update" do
+      @q.oclass('Person').action(:remove).values(:name => "Martin").to_s.should == "UPDATE Person REMOVE name = 'Martin'"
+    end
+
+    it "should handle basic oclass ADD a value into a collection update" do
+      @q.oclass('Person').action(:add).values(:name => "Martin").to_s.should == "UPDATE Person ADD name = 'Martin'"
+    end
+
+    it "should handle basic oclass ADD many values into a collection update" do
+      @q.oclass('Person').action(:add).values(:name => "Martin").values(:age => 39).to_s.should == "UPDATE Person ADD name = 'Martin', age = 39"
+    end
+
+    it "should handle simple hashes for conditions" do
+      @q.oclass('Person').values(:age => 39).where(:a => 1).to_s.should == 'UPDATE Person SET age = 39 WHERE a = 1'
+    end
+
+    it "should handle simple arrays for conditions" do
+      @q.oclass('Person').values(:age => 39).where(['a > 1', 'b < 3', 'c = 5']).to_s.should == 'UPDATE Person SET age = 39 WHERE a > 1 AND b < 3 AND c = 5'
+    end
+
+    it "should handle concatenation for conditions" do
+      @q.oclass('Person').values(:age => 39).where(:a => 1).where(:b => 2).to_s.should == 'UPDATE Person SET age = 39 WHERE a = 1 AND b = 2'
+    end
+
+    it "should handle overriding for conditions" do
+      @q.oclass('Person').values(:age => 39).where(:a => 1).where!(:b => 2).to_s.should == 'UPDATE Person SET age = 39 WHERE b = 2'
+    end
+
+    it "should handle simple joined AND conditions for conditions" do
+      @q.oclass('Person').values(:age => 39).where(:a => 1).and(:b => 2).to_s.should == 'UPDATE Person SET age = 39 WHERE a = 1 AND b = 2'
+    end
+
+    it "should handle simple joined OR conditions for conditions" do
+      @q.oclass('Person').values(:age => 39).where(:a => 1).or(:b => 2).to_s.should == 'UPDATE Person SET age = 39 WHERE a = 1 OR b = 2'
+    end
+  end
+
+  describe "DELETE" do
+
+    before :each do
+      @q = OrientDB::SQL::Delete.new
+    end
+
+    it "should handle basic oclass" do
+      @q.oclass('Person').to_s.should == "DELETE FROM Person"
+    end
+
+    it "should handle basic cluster" do
+      @q.cluster('person').to_s.should == "DELETE FROM cluster:person"
+    end
+
+    it "should handle simple hashes for conditions" do
+      @q.oclass('Person').where(:a => 1).to_s.should == 'DELETE FROM Person WHERE a = 1'
+    end
+
+    it "should handle simple arrays for conditions" do
+      @q.oclass('Person').where(['a > 1', 'b < 3', 'c = 5']).to_s.should == 'DELETE FROM Person WHERE a > 1 AND b < 3 AND c = 5'
+    end
+
+    it "should handle concatenation for conditions" do
+      @q.oclass('Person').where(:a => 1).where(:b => 2).to_s.should == 'DELETE FROM Person WHERE a = 1 AND b = 2'
+    end
+
+    it "should handle overriding for conditions" do
+      @q.oclass('Person').where(:a => 1).where!(:b => 2).to_s.should == 'DELETE FROM Person WHERE b = 2'
+    end
+
+    it "should handle simple joined AND conditions for conditions" do
+      @q.oclass('Person').where(:a => 1).and(:b => 2).to_s.should == 'DELETE FROM Person WHERE a = 1 AND b = 2'
+    end
+
+    it "should handle simple joined OR conditions for conditions" do
+      @q.oclass('Person').where(:a => 1).or(:b => 2).to_s.should == 'DELETE FROM Person WHERE a = 1 OR b = 2'
+    end
   end
+
 end

metadata

@@ -2,7 +2,7 @@
 name: orientdb
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.12
+  version: 0.0.14
 platform: jruby
 authors: 
   - Adrian Madrid
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-20 00:00:00 -07:00
+date: 2011-01-25 00:00:00 -07:00
 default_executable: orientdb_console
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -71,7 +71,12 @@ files:
   - lib/orientdb/record.rb
   - lib/orientdb/schema.rb
   - lib/orientdb/sql.rb
-  - lib/orientdb/sql_ext.rb
+  - lib/orientdb/sql/common.rb
+  - lib/orientdb/sql/delete.rb
+  - lib/orientdb/sql/ext.rb
+  - lib/orientdb/sql/insert.rb
+  - lib/orientdb/sql/query.rb
+  - lib/orientdb/sql/update.rb
   - lib/orientdb/sql_query.rb
   - lib/orientdb/storage.rb
   - lib/orientdb/user.rb