orientdb 1.2.0

data/lib/orientdb/document.rb

@@ -0,0 +1,78 @@
+module OrientDB
+
+  class Document
+
+    def values
+      field_names.map { |field_name| [field_name, self[field_name]] }
+    end
+
+    alias :db :database
+
+    def [](field_name)
+      field field_name.to_s
+    end
+
+    def []=(field_name, value)
+      field field_name.to_s, value
+    end
+
+    def field?(name)
+      contains_field(name.to_s) || (schema_class && schema_class.exists_property?(name.to_s))
+    end
+
+    def respond_to?(method_name)
+      return true if field?(method_name.to_s)
+      match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+      return true if match[2] == '='
+      return true if match[2] == '?' && field?(match[1])
+      super
+    end
+
+    def method_missing(method_name, *args, &blk)
+      return self[method_name] if field?(method_name)
+
+      match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+      case match[2]
+        when "="
+          self[match[1]] =  args.first
+        when "?"
+          field(match[1]) ? !!self[match[1]] : super
+        else
+          super
+      end
+    end
+
+    def rid
+      identity.to_s
+    end
+
+    def inspect
+      props = values.map { |k, v| "#{k}:#{v.inspect}" }.join(' ')
+      %{#<OrientDB::Document:#{class_name}:#{rid}#{props.empty? ? '' : ' ' + props}>}
+    end
+
+    alias :to_s :inspect
+
+    class << self
+
+      alias_method :native_new, :new
+
+      def new(db, klass_name, fields = {})
+        obj = native_new db, klass_name.to_s
+        fields.each do |name, value|
+          obj.field name.to_s, value
+        end
+        obj
+      end
+
+      def create(db, klass_name, fields = {})
+        obj = new db, klass_name, fields
+        obj.save
+        obj
+      end
+
+    end
+
+  end
+
+end

data/lib/orientdb/ext.rb

@@ -0,0 +1,13 @@
+require 'date'
+
+class Date
+  def proxy_object
+    java.util.Date.new year, month - 1, day, 0, 0, 0
+  end
+end
+
+class DateTime
+  def proxy_object
+    java.util.Date.new year, month - 1, day, hour, min, sec
+  end
+end

data/lib/orientdb/oclass.rb

@@ -0,0 +1,141 @@
+module OrientDB
+
+  class OClassImpl
+
+    def type_for(value)
+      self.class.type_for value, schema
+    end
+
+    def add(property_name, type, options = { })
+      property_name = property_name.to_s
+      if exists_property(property_name)
+        puts "We already have that property name [#{property_name}]"
+        return false
+      end
+
+      type = type.oclass if type.respond_to?(:oclass)
+      case type
+        when SchemaType
+          prop = create_property property_name, type
+        when Symbol
+          prop = create_property property_name, type_for(type)
+        when OClassImpl
+          prop = create_property property_name, type_for(:link), type
+        when Array
+          type, sub_type = type_for(type.first), type_for(type.last)
+          prop = create_property property_name, type, sub_type
+        else
+          raise "ERROR! Unknown type [ #{property_name} | #{type} : #{type.class.name} ]"
+      end
+
+      prop.set_min options[:min].to_s unless options[:min].nil?
+      prop.set_max options[:max].to_s unless options[:max].nil?
+      prop.set_mandatory !!options[:mandatory] unless options[:mandatory].nil?
+      prop.set_not_null options[:not_null] unless options[:not_null].nil?
+      unless options[:index].nil?
+        index_type = options[:index] == true ? INDEX_TYPES[:notunique] : INDEX_TYPES[options[:index]]
+        prop.createIndex index_type
+      end
+
+      self
+    end
+
+    def add_index
+
+    end
+
+    def [](property_name)
+      property_name = property_name.to_s
+      exists_property(property_name) ? get_property(property_name) : nil
+    end
+
+    def db
+      document.database
+    end
+
+    def schema
+      db.metadata.schema
+    end
+
+    def inspect
+      props = properties.map { |x| "#{x.name}=#{x.type.name}#{x.is_indexed? ? '(idx)' : ''}" }.join(' ')
+      "#<OrientDB::OClassImpl:" + name +
+        (getSuperClass ? ' super=' + getSuperClass.name : '') +
+        (props.empty? ? '' : ' ' + props) +
+        ">"
+    end
+
+    alias :to_s :inspect
+
+    class << self
+
+      def type_for(value, schema)
+        value = value.oclass if value.respond_to?(:oclass)
+        type = case value
+                 when OrientDB::SchemaType, OrientDB::OClassImpl
+                   value
+                 when String
+                   if schema.exists_class?(value)
+                     schema.get_class(value)
+                   else
+                     FIELD_TYPES[value.to_sym]
+                   end
+                 when Symbol
+                   FIELD_TYPES[value]
+                 else
+                   FIELD_TYPES[value.to_s.to_sym]
+               end
+        raise "Uknown schema type for [#{value}] (#{value.class.name})" unless type
+        type
+      end
+
+      def create(db, name, fields = { })
+        name        = name.to_s
+        add_cluster = fields.delete :add_cluster
+        add_cluster = true if add_cluster.nil?
+        use_cluster = fields.delete :use_cluster
+
+        if db.schema.exists_class? name
+          klass = db.get_class name
+        else
+          if use_cluster
+            klass = db.schema.create_class name, use_cluster
+          elsif add_cluster && !db.storage.cluster_names.include?(name.downcase)
+            #debugger
+            cluster = db.storage.add_cluster STORAGE_TYPES[:physical], name.downcase, "/tmp/database", 'default', {}
+            klass   = db.schema.create_class name, cluster
+          else
+            klass = db.schema.create_class name
+          end
+        end
+
+        super_klass = fields.delete :super
+        super_klass = db.get_class(super_klass.to_s) unless super_klass.is_a?(OrientDB::OClassImpl)
+        klass.set_super_class super_klass if super_klass
+        db.schema.save
+
+        unless fields.empty?
+          fields.each do |property_name, type|
+            case type
+              when Symbol, Array, OrientDB::OClassImpl
+                klass.add property_name, type
+              when Hash
+                options = type.dup
+                type    = options.delete :type
+                klass.add property_name, type, options
+              else
+                raise "Unknown field options [#{type.inspect}]"
+            end
+          end
+          db.schema.save
+        end
+
+        klass
+      end
+
+    end
+
+  end
+
+
+end

data/lib/orientdb/property.rb

@@ -0,0 +1,37 @@
+module OrientDB
+  class PropertyImpl
+
+    def type_short
+      @type_short ||= OrientDB::FIELD_TYPES.select { |k, v| v.name == getType.name }.first.first
+    end
+
+    def linked_type_short
+      @linked_type_short ||= getLinkedType && OrientDB::FIELD_TYPES.select { |k, v| v.name == getLinkedType.name }.first.first
+    end
+
+    def info
+      {
+        :name         => name,
+        :type         => type_short,
+        :index        => indexed? ? getIndex.name : nil,
+        :min          => min,
+        :max          => max,
+        :mandatory    => is_mandatory?,
+        :not_null     => is_not_null?,
+        :linked_type  => linked_type_short,
+        :linked_class => linked_type_short ? getLinkedClass.name : nil,
+      }
+    end
+
+    def inspect
+      "#<OrientDB::Property:#{name} type=#{type_short} " +
+        "#{linked_type_short ? "linked_type=#{linked_type_short} linked_class=#{getLinkedClass.name}" : ''}" +
+        "indexed=#{is_indexed?} mandatory=#{is_mandatory?} not_null=#{is_not_null}" +
+        "#{min ? " min=#{min}" : ''}#{max ? " max=#{max}" : ''}" +
+        ">"
+    end
+
+    alias :to_s :inspect
+
+  end
+end

data/lib/orientdb/record.rb

@@ -0,0 +1,18 @@
+module OrientDB
+
+  class RecordList
+    def inspect
+      "#<OrientDB::RecordList:#{toString}>"
+    end
+
+    alias :to_s :inspect
+  end
+
+  class RecordSet
+    def inspect
+      "#<OrientDB::RecordSet:#{toString}>"
+    end
+
+    alias :to_s :inspect
+  end
+end

data/lib/orientdb/rid.rb

@@ -0,0 +1,46 @@
+class OrientDB::RID
+
+  attr_reader :cluster_id, :document_id
+
+  def initialize(rid = '#-1:-1')
+    parts = rid.to_s.gsub('#', '').split ":"
+    if parts.size == 2
+      self.cluster_id = parts.first.to_i
+      self.document_id = parts.last.to_i
+    else
+      raise "Unknown rid [#{rid}]"
+    end
+  end
+
+  def cluster_id=(value)
+    @cluster_id = value.to_s.strip.to_i
+  end
+
+  def document_id=(value)
+    @document_id = value.to_s.strip.to_i
+  end
+
+  def inspect
+    "##{cluster_id}:#{@document_id}"
+  end
+
+  alias :to_s :inspect
+
+  def unsaved?
+    to_s == '#-1:-1'
+  end
+
+  def saved?
+    cluster_id > 0 && document_id >= 0
+  end
+
+  def valid?
+    saved? || unsaved?
+  end
+end
+
+class String
+  def valid_orientdb_rid?
+    OrientDB::RID.new(self).valid?
+  end
+end

data/lib/orientdb/schema.rb

@@ -0,0 +1,33 @@
+module OrientDB
+
+  #class Schema
+  #
+  #  def inspect
+  #    "#<OrientDB::Schema:#{toString}>"
+  #  end
+  #
+  #  alias :to_s :inspect
+  #
+  #end
+  #
+  #class SchemaProxy
+  #
+  #  def inspect
+  #    "#<OrientDB::SchemaProxy:#{toString}>"
+  #  end
+  #
+  #  alias :to_s :inspect
+  #
+  #end
+  #
+  #class SchemaType
+  #
+  #  def inspect
+  #    "#<OrientDB::SchemaType:#{name}>"
+  #  end
+  #
+  #  alias :to_s :inspect
+  #
+  #end
+
+end

data/lib/orientdb/sql.rb

@@ -0,0 +1,18 @@
+module OrientDB::SQL
+  class SQLSynchQuery
+
+    def inspect
+      %{#<OrientDB::SQLSynchQuery:#{name} text="#{text}">}
+    end
+
+    alias :to_s :inspect
+
+  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,247 @@
+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)
+        when OrientDB::SQL::LiteralExpression
+          value.to_s
+        else
+          quote value.to_s
+      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 LiteralExpression
+
+    def initialize(value)
+      @value = value.to_s
+    end
+
+    def to_s
+      @value
+    end
+
+    include Comparable
+
+    def <=>(other)
+      to_s <=> other.to_s
+    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
+
+    include Comparable
+
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+  end
+
+end