pacer-orient 2.1.0.pre-java → 2.1.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6fceac4558001cdd09ca2e020f1ff972e114783
-  data.tar.gz: a1c777ad26b1bc1b8ade637f911d4e55b4d5a7ce
+  metadata.gz: c2fdd8ddfc4598b083a169ccb43bc73bd5fbeb71
+  data.tar.gz: 927e24d2325d80d8c43bf5dbb02960e9985be2c6
 SHA512:
-  metadata.gz: 04cb179c0c0e519a062a5e60edc26c63f049bbc28df0db4b644a4064805aebe41c91cf07b9366e89cfeda6a6880c36e5f268c535d5eab169865c945b6b03404f
-  data.tar.gz: 59f73d70eead2816e4935871cc37e8ca71e91b3d4e23c4887b49bfd4bd332e1975707d731dcb18d29d5dd85af498525ee68fe38fa8ea4670829c838a7925f3a6
+  metadata.gz: 4d4f1593a4cbc034406287fe45365626a41a8ed6acea60210927d38a0f0329cf8f01c2ff79016adb31cd4e26f3b3acf086878c04b953dfaed3fc2d97856394b2
+  data.tar.gz: 1df25c40515d3ea6413e77c3f3d23cdc8d89508f383f8338eb0aee770d81998eb78ba5b51e2e7ed2b71d51c5e05572bd765f9ef6ec7adef23266f99f1eb4a634

data/lib/pacer-orient.rb

@@ -26,8 +26,14 @@ module Pacer
       elsif url.is_a? String and url !~ /^(plocal|local|remote|memory):/
         url = "plocal:#{ url }"
       end
-      username = args.delete :username if args
-      password = args.delete :password if args
+      if args
+        username          = args.delete :username
+        password          = args.delete :password
+        transactional     = args.delete :transactional
+        lightweight_edges = args.delete :lightweight_edges
+        edge_classes      = args.delete :edge_classes
+        vertex_classes    = args.delete :vertex_classes
+      end
       if url.is_a? String
         open = proc do
           # TODO: can / should I cache connections? Is it essential to shut down Orient?
@@ -41,19 +47,26 @@ module Pacer
               end
             Pacer.open_graphs[[url, username]] = Pacer::Orient::FactoryContainer.new(factory)
           end
-          graph = factory.get()
-          graph.setAutoStartTx false
+          if transactional == false
+            graph = factory.getNoTx()
+          else
+            graph = factory.getTx()
+          end
+          graph.useLightweightEdges = lightweight_edges if lightweight_edges == false
+          graph.useClassForEdgeLabel = edge_classes if edge_classes == false
+          graph.useClassForVertexLabel = vertex_classes if vertex_classes == false
+          #graph.setAutoStartTx false
           graph
         end
         shutdown = proc do |g|
           factory = Pacer.open_graphs.delete [url, username]
           factory.shutdown if factory
         end
-        Orient::Graph.new(Pacer::YamlEncoder, open, shutdown)
+        Orient::Graph.new(Pacer::Orient::Encoder, open, shutdown)
       else
         # Don't register the new graph so that it won't be automatically closed.
         graph = url
-        Orient::Graph.new Pacer::YamlEncoder, proc { graph }
+        Orient::Graph.new Pacer::Orient::Encoder, proc { graph }
       end
     end
 

data/lib/pacer-orient/encoder.rb

@@ -3,6 +3,9 @@ require 'java'
 module Pacer::Orient
   class Encoder
     JavaDate = java.util.Date
+    JavaSet = java.util.Set
+    JavaMap = java.util.Map
+    JavaList = java.util.List
 
     def self.encode_property(value)
       case value
@@ -20,7 +23,24 @@ module Pacer::Orient
         end
       when true, false
         value.to_java
-      when JavaDate, Date, Time, DateTime
+      when JavaDate
+        value
+      when Time
+        value.to_java
+      when DateTime
+        value.to_time.to_java
+      when Date
+        t = value.to_time
+        (t + Time.zone_offset(t.zone)).utc.to_java
+      when Set
+        value.map { |x| encode_property(x) }.to_hashset
+      when Hash
+        value.to_hash_map { |k, v| [encode_property(k), encode_property(v)] }
+      when Enumerable
+        value.map { |x| encode_property(x) }.to_list
+      when JavaSet, JavaMap, JavaList
+        value
+      when ArrayJavaProxy
         value
       else
         Marshal.dump(value).to_java_bytes
@@ -28,11 +48,106 @@ module Pacer::Orient
     end
 
     def self.decode_property(value)
-      if value.is_a? ArrayJavaProxy
-        Marshal.load String.from_java_bytes(value)
+      case value
+      when ArrayJavaProxy
+        if value[0] == 4 and value[1] == 8
+          begin
+            Marshal.load String.from_java_bytes(value)
+          rescue TypeError
+            value
+          end
+        else
+          value
+        end
+      when JavaDate
+        Time.at(value.getTime() / 1000.0).utc
+      when Time
+        value.utc
+      when JavaSet
+        s = Set[]
+        value.each do |v|
+          s.add decode_property(v)
+        end
+        s
+      when JavaMap
+        h = {}
+        value.each do |k, v|
+          h[decode_property(k)] = decode_property(v)
+        end
+        h
+      when JavaList
+        a = []
+        value.each do |v|
+          a.push decode_property(v)
+        end
+        a
       else
         value
       end
     end
   end
+
+
+  # This is an alternate encoder that uses a binary representation of Dates and DateTimes that allows the database to return the correct type and has
+  # much better handling of timezones than the standard approach which turns all dates into basic java.util.Date objects.
+  class BinaryDateEncoder
+    JavaDate = java.util.Date
+
+    def self.encode_property(value)
+      case value
+      when DateTime, Time, JavaDate
+        f = if value.is_a? JavaDate
+              value.getTime / 1000.0
+            else
+              value.to_time.to_f
+            end
+        i = f.truncate
+        r = (f.remainder(1) * 10000).round
+        if value.is_a? DateTime
+          c = 1
+        elsif value.is_a? Time and value.utc?
+          c = 2
+        else
+          c = 3
+        end
+        ["D", i, r, c].pack("ANnc").to_java_bytes
+      when Date
+        ["D", value.to_time.to_i].pack("AN").to_java_bytes
+      else
+        Encoder.encode_property(value)
+      end
+    end
+
+    def self.decode_property(value)
+      case value
+      when ArrayJavaProxy
+        str = String.from_java_bytes(value)
+        flag = str[0]
+        case flag
+        when 'D'
+          data = str.unpack("ANnc")
+          i = data[1]
+          r = data[2]
+          c = data[3]
+          if r
+            t = Time.at(i + (r / 10000.0))
+            case c
+            when 1
+              t.utc.to_datetime
+            when 2
+              t.utc
+            else
+              t
+            end
+          else
+            Time.at(i).utc.to_date
+          end
+        else
+          Encoder.decode_property value
+        end
+      else
+        Encoder.decode_property value
+      end
+    end
+  end
 end

data/lib/pacer-orient/factory_container.rb

@@ -0,0 +1,26 @@
+module Pacer::Orient
+  class FactoryContainer
+    attr_reader :factory
+
+    def initialize(f)
+      @factory = f
+    end
+
+    def get
+      factory.get
+    end
+
+    def getTx
+      factory.getTx
+    end
+
+    def getNoTx
+      factory.getNoTx
+    end
+
+    # Pacer calls shutdown on all cached graphs when it exits. Orient caches this factory.
+    def shutdown
+      factory.close
+    end
+  end
+end

data/lib/pacer-orient/graph.rb

@@ -1,8 +1,68 @@
 require 'set'
 
+require 'pacer-orient/orient_type'
+require 'pacer-orient/property'
+require 'pacer-orient/encoder'
+require 'pacer-orient/record_id'
+require 'pacer-orient/factory_container'
+
 module Pacer
   module Orient
     class Graph < PacerGraph
+      import com.orientechnologies.orient.core.sql.OCommandSQL
+      import com.orientechnologies.orient.core.metadata.schema.OType
+      import com.orientechnologies.orient.core.metadata.schema.OClass
+
+      # Marked the types that should be most commonly used.
+      OTYPES = {
+        :any          => OType::ANY,
+        :boolean      => OType::BOOLEAN,      # use this one
+        :bool         => OType::BOOLEAN,
+        :short        => OType::SHORT,
+        :integer      => OType::INTEGER,
+        :int          => OType::INTEGER,
+        :long         => OType::LONG,         # use this one
+        :float        => OType::FLOAT,
+        :double       => OType::DOUBLE,       # use this one
+        :decimal      => OType::DECIMAL,      # use this one
+        :date         => OType::DATE,         # use this one
+        :datetime     => OType::DATETIME,     # use this one
+        :date_time    => OType::DATETIME,
+        :byte         => OType::BYTE,
+        :string       => OType::STRING,       # use this one
+        :binary       => OType::BINARY,
+        :embedded     => OType::EMBEDDED,
+        :embeddedlist => OType::EMBEDDEDLIST,
+        :embeddedset  => OType::EMBEDDEDSET,
+        :embeddedmap  => OType::EMBEDDEDMAP,
+        :link         => OType::LINK,
+        :linklist     => OType::LINKLIST,
+        :linkset      => OType::LINKSET,
+        :linkmap      => OType::LINKMAP,
+        :linkbag      => OType::LINKBAG,
+        :transient    => OType::TRANSIENT,
+        :custom       => OType::CUSTOM
+      }
+
+
+      ITYPES = {
+        :range_dictionary => OClass::INDEX_TYPE::DICTIONARY,
+        :range_fulltext   => OClass::INDEX_TYPE::FULLTEXT,
+        :range_full_text  => OClass::INDEX_TYPE::FULLTEXT,
+        :range_notunique  => OClass::INDEX_TYPE::NOTUNIQUE,
+        :range_not_unique => OClass::INDEX_TYPE::NOTUNIQUE,
+        :range_unique     => OClass::INDEX_TYPE::UNIQUE,
+        :proxy            => OClass::INDEX_TYPE::PROXY,
+        :dictionary       => OClass::INDEX_TYPE::DICTIONARY_HASH_INDEX,
+        :fulltext         => OClass::INDEX_TYPE::FULLTEXT_HASH_INDEX,
+        :full_text        => OClass::INDEX_TYPE::FULLTEXT_HASH_INDEX,
+        :notunique        => OClass::INDEX_TYPE::NOTUNIQUE_HASH_INDEX,
+        :not_unique       => OClass::INDEX_TYPE::NOTUNIQUE_HASH_INDEX,
+        :spatial          => OClass::INDEX_TYPE::SPATIAL,
+        :unique           => OClass::INDEX_TYPE::UNIQUE_HASH_INDEX
+      }
+
+
       def orient_graph
         blueprints_graph.raw_graph
       end
@@ -33,22 +93,149 @@ module Pacer
       def drop_handler(h)
         # todo
       end
-    end
 
-    class FactoryContainer
-      attr_reader :factory
+      # NOTE: if you use lightweight edges (they are on by default), g.e will only return edges that have been reified by having properties added to
+      # them.
+      def lightweight_edges
+        blueprints_graph.useLightweightEdges
+      end
+
+      alias lightweight_edges? lightweight_edges
+
+      def lightweight_edges=(b)
+        blueprints_graph.useLightweightEdges = b
+      end
+
+      def use_class_for_edge_label
+        blueprints_graph.useClassForEdgeLabel
+      end
+
+      def use_class_for_edge_label=(b)
+        blueprints_graph.useClassForEdgeLabel = b
+      end
+
+      def use_class_for_vertex_label
+        blueprints_graph.useClassForVertexLabel
+      end
+
+      def use_class_for_vertex_label=(b)
+        blueprints_graph.useClassForVertexLabel = b
+      end
+
+      def sql(extensions, sql = nil, args)
+        if extensions.is_a? String
+          args = sql
+          sql = extensions
+          extensions = []
+        end
+        sql_command(sql, args).iterator.to_route(based_on: self.v(extensions))
+      end
+
+      def sql_e(extensions, sql = nil, args)
+        if extensions.is_a? String
+          args = sql
+          sql = extensions
+          extensions = []
+        end
+        sql_command(sql, args).iterator.to_route(based_on: self.e(extensions))
+      end
+
+      def sql_command(sql, args)
+        unless args.frozen?
+          args = args.map { |a| encoder.encode_property(a) }
+        end
+        blueprints_graph.command(OCommandSQL.new(sql)).execute(*args)
+      end
+
+      # Find or create a vertex or edge class
+      def orient_type!(t, element_type = :vertex)
+        r = orient_type(t, element_type)
+        if r
+          r
+        else
+          in_pure_transaction do
+            t = if element_type == :vertex
+                  blueprints_graph.createVertexType(t.to_s)
+                elsif element_type == :edge
+                  blueprints_graph.createEdgeType(t.to_s)
+                end
+            OrientType.new self, element_type, t if t
+          end
+        end
+      end
 
-      def initialize(f)
-        @factory = f
+      def orient_type(t = nil, element_type = :vertex)
+        t ||= :V if element_type == :vertex
+        t ||= :E if element_type == :edge
+        if t.is_a? String or t.is_a? Symbol
+          t = if element_type == :vertex
+                blueprints_graph.getVertexType(t.to_s)
+              elsif element_type == :edge
+                blueprints_graph.getEdgeType(t.to_s)
+              end
+          OrientType.new self, element_type, t if t
+        elsif t.is_a? OrientType
+          t
+        end
       end
 
-      def get
-        factory.get
+      def property_type(t)
+        if t.is_a? String or t.is_a? Symbol
+          OTYPES[t.to_sym]
+        else
+          t
+        end
       end
 
-      # Pacer calls shutdown on all cached graphs when it exits. Orient caches this factory.
-      def shutdown
-        factory.close
+      def index_type(t)
+        if t.is_a? String or t.is_a? Symbol
+          ITYPES[t.to_sym]
+        else
+          t
+        end
+      end
+
+      def add_vertex_types(*types)
+        in_pure_transaction do
+          types.map do |t|
+            existing = orient_type(t, :vertex)
+            if existing
+              existing
+            else
+              t = blueprints_graph.createVertexType(t.to_s)
+              OrientType.new(self, :vertex, t) if t
+            end
+          end
+        end
+      end
+
+      def create_key_index(name, element_type = :vertex, itype = :non_unique)
+        type = orient_type(nil, element_type)
+        type.property!(name).create_index!(itype) if type
+      end
+
+      def drop_key_index(name, element_type = :vertex)
+        in_pure_transaction do
+          super
+        end
+      end
+
+      private
+
+      def in_pure_transaction
+        if @in_pure_transaction
+          yield
+        else
+          begin
+            @in_pure_transaction = true
+            transaction do
+              orient_graph.rollback
+              yield
+            end
+          ensure
+            @in_pure_transaction = false
+          end
+        end
       end
     end
   end

data/lib/pacer-orient/orient_type.rb

@@ -0,0 +1,88 @@
+module Pacer::Orient
+  class OrientType
+    extend Forwardable
+
+    attr_reader :graph, :element_type, :type
+
+    # TODO: setters like in Property, once I figure out what these settings do.
+
+    def_delegators :@type,
+      :name, :short_name, :type_name, :abstract?, :strict_mode?,
+      :base_classes,
+      :class_indexes, :indexes, :involved_indexes,
+      :size, :over_size,
+      :cluster_selection, :cluster_ids,
+      :custom_keys, :custom
+
+    alias class_indices class_indexes
+    alias indices indexes
+    alias involved_indices involved_indexes
+
+    def initialize(graph, element_type, type)
+      @graph = graph
+      @element_type = type
+      @type = type
+    end
+
+    def raw_property(name)
+      if name.is_a? Symbol or name.is_a? String
+        type.getProperty name.to_s
+      else
+        name
+      end
+    end
+
+    def indexed?(name)
+      p = property(name)
+      p.indexed? if p
+    end
+
+    def property(name)
+      p = raw_property(name)
+      Property.new self, p if p
+    end
+
+    def property!(name, otype)
+      p = raw_property(name)
+      unless p
+        p = graph.send(:in_pure_transaction) do
+          type.createProperty(name.to_s, graph.property_type(otype))
+        end
+      end
+      Property.new self, p
+    end
+
+    def super_class
+      if base_classes.any?
+        OrientType.new graph, type.getSuperClass
+      end
+    end
+
+    def set_super_class(sc)
+      graph.send(:in_pure_transaction) do
+        type.setSuperClass graph.orient_type(element_type, sc)
+      end
+      self
+    end
+
+    def drop_property!(name)
+      graph.send(:in_pure_transaction) do
+        type.dropProperty name
+      end
+    end
+
+    def properties
+      type.properties.map { |p| Property.new self, p }
+    end
+
+    def indexed_properties
+      type.indexedProperties.map { |p| Property.new self, p }
+    end
+
+    def inspect
+      abs = "Abstract" if abstract?
+      strict = " (strict)" if strict_mode?
+      "#<#{ abs }#{ type_name.capitalize }Type #{ name }#{ strict }>"
+    end
+  end
+end

data/lib/pacer-orient/property.rb

@@ -0,0 +1,60 @@
+module Pacer::Orient
+  class Property
+    extend Forwardable
+
+    attr_reader :el_type, :property
+
+    def_delegators :@property,
+      :name, :full_name, :not_null?, :collate,
+      :mandatory?, :readonly?, :min, :max, :index,
+      :indexed?, :regexp, :type, :custom, :custom_keys
+
+    def initialize(el_type, property)
+      @el_type = el_type
+      @property = property
+    end
+
+    def graph
+      el_type.graph
+    end
+
+    def create_index!(index_type = :not_unique)
+      unless indexed?
+        graph.send(:in_pure_transaction) do
+          property.createIndex graph.index_type(index_type)
+        end
+      end
+      self
+    end
+
+    def drop_index!
+      graph.drop_key_index name if indexed?
+      self
+    end
+
+    def set_type!(t)
+      # Not implemented as of 1.7.8
+      fail Pacer::InternalError.new("Type migration is a planned Orient 2.x feature")
+    end
+
+    def drop!
+      el_type.drop_property! name
+      nil
+    end
+
+    [ :set_name, :set_not_null, :set_collate,
+      :set_mandatory, :set_readonly, :set_min, :set_max,
+      :set_regexp, :set_custom, :remove_custom, :clear_custom
+    ].each do |setter|
+      define_method(setter) do |*args|
+        property.send setter, *args
+        self
+      end
+    end
+
+    def inspect
+      "#<#{ el_type.type_name.capitalize }Property #{ el_type.name }.#{ property.name } (#{ type })>"
+    end
+  end
+end
+

data/lib/pacer-orient/record_id.rb

@@ -0,0 +1,5 @@
+class Java::ComOrientechnologiesOrientCoreId::ORecordId
+  def inspect
+    "<'#{to_s}'>"
+  end
+end

data/lib/pacer-orient/rspec.rb

@@ -13,17 +13,24 @@ class RSpec::GraphRunner
 
     def orient_graph
       return @orient_graph if @orient_graph
-      @orient_graph = Pacer.orient
+      path1 = File.expand_path('/tmp/spec.orient')
+      dir = Pathname.new(path1)
+      dir.rmtree if dir.exist?
+      @orient_graph = Pacer.orient(path1, lightweight_edges: false, edge_classes: false)
     end
 
+    # Can't use 2 graphs on 1 thread.
     def orient_graph2
       return @orient_graph2 if @orient_graph2
-      @orient_graph2 = Pacer.orient
+      @orient_graph2 = Pacer.tg
     end
 
     def orient_graph_no_indices
       return @orient_graph_no_indices if @orient_graph_no_indices
-      @orient_graph_no_indices = Pacer.orient
+      path3 = File.expand_path('/tmp/spec.orient.3')
+      dir = Pathname.new(path3)
+      dir.rmtree if dir.exist?
+      @orient_graph_no_indices = Pacer.orient(path3, lightweight_edges: false, edge_classes: false)
     end
   end
 end

data/lib/pacer-orient/version.rb

@@ -1,10 +1,10 @@
 module Pacer
   module Orient
-    VERSION = "2.1.0.pre"
+    VERSION = "2.1.1"
     JAR = "pacer-orient-#{ VERSION }-standalone.jar"
     JAR_PATH = "lib/#{ JAR }"
     ORIENT_VERSION = "1.7.8"
     PIPES_VERSION = "2.5.0"
-    PACER_REQ = ">= 1.5.0"
+    PACER_REQ = ">= 1.5.2"
   end
 end

data/pom.xml

@@ -8,7 +8,7 @@
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-orient/version.rb -->
     <properties>
       <orient.version>1.7.8</orient.version>
-      <gem.version>2.1.0.pre</gem.version>
+      <gem.version>2.1.1</gem.version>
       <pipes.version>2.5.0</pipes.version>
     </properties>
     <!-- NOTE: the following properties are automatically updated based on the values in lib/pacer-orient/version.rb -->

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pacer-orient
 version: !ruby/object:Gem::Version
-  version: 2.1.0.pre
+  version: 2.1.1
 platform: java
 authors:
 - Darrick Wiebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pacer
@@ -16,12 +16,12 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.2
   prerelease: false
   type: :runtime
 description: Orient jars and related code for Pacer
@@ -37,13 +37,17 @@ files:
 - Rakefile
 - lib/pacer-orient.rb
 - lib/pacer-orient/encoder.rb
+- lib/pacer-orient/factory_container.rb
 - lib/pacer-orient/graph.rb
+- lib/pacer-orient/orient_type.rb
+- lib/pacer-orient/property.rb
+- lib/pacer-orient/record_id.rb
 - lib/pacer-orient/rspec.rb
 - lib/pacer-orient/version.rb
 - pacer-orient.gemspec
 - pom.xml
 - pom/standalone.xml
-- lib/pacer-orient-2.1.0.pre-standalone.jar
+- lib/pacer-orient-2.1.1-standalone.jar
 homepage: http://orientechnologies.com
 licenses: []
 metadata: {}
@@ -58,9 +62,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: pacer-orient
 rubygems_version: 2.1.9