orientdb 1.2.0

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

@@ -0,0 +1,249 @@
+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
+      include OrientDB::SQL::UtilsMixin
+
+      def lit
+        OrientDB::SQL::LiteralExpression.new to_s
+      end
+
+      def like(value)
+        "#{to_s} LIKE #{quote(value)}"
+      end
+
+      def eq(value)
+        "#{to_s} = #{quote(value)}"
+      end
+
+      def lt(value)
+        "#{to_s} < #{quote(value)}"
+      end
+
+      def lte(value)
+        "#{to_s} <= #{quote(value)}"
+      end
+
+      def gt(value)
+        "#{to_s} > #{quote(value)}"
+      end
+
+      def gte(value)
+        "#{to_s} >= #{quote(value)}"
+      end
+
+      def ne(value)
+        "#{to_s} <> #{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 #{quote(values)}"
+      end
+
+      def contains(field, value)
+        "#{to_s} contains (#{field} = #{quote(value)})"
+      end
+
+      def contains_all(field, value)
+        "#{to_s} containsAll (#{field} = #{quote(value)})"
+      end
+
+      def contains_key(value)
+        "#{to_s} containsKey #{quote(value)}"
+      end
+
+      def contains_value(value)
+        "#{to_s} containsValue #{quote(value)}"
+      end
+
+      def contains_text(value)
+        "#{to_s} containsText #{quote(value)}"
+      end
+
+      def matches(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()"
+      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(#{quote(length)})"
+      end
+
+      # Avoided overriding the native method
+      def odb_right(length)
+        "#{to_s}.right(#{quote(length)})"
+      end
+
+      def sub_string(start, length = nil)
+        "#{to_s}.subString(#{quote(start)}#{length ? ", #{quote(length)}" : ''})"
+      end
+
+      def char_at(pos)
+        "#{to_s}.charAt(#{quote(pos)})"
+      end
+
+      def index_of(string, start = nil)
+        "#{to_s}.indexOf(#{quote(string)}#{start ? ", #{quote(start)}" : ''})"
+      end
+
+      # Avoided overriding the native method
+      def odb_format(frmt)
+        "#{to_s}.format(#{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
+      include OrientDB::SQL::UtilsMixin
+
+      # 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| quote(x)}.join(', ')})"
+      end
+    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