orientdb-binary 0.6.0

data/lib/orientdb_binary/database_operations/data_segment.rb

@@ -0,0 +1,31 @@
+require 'orientdb_binary/protocols/datasegment_add'
+require 'orientdb_binary/protocols/datasegment_drop'
+
+module OrientdbBinary
+  module DatabaseOperations
+    module DataSegment
+
+      # name: string
+      # location: string
+      # Usage:
+      # db.add_datasegment(name: "posts")
+      # db.add_datasegment(name: "posts", location: "posts_segments")
+      #
+      def add_datasegment(args)
+        default = {
+          location: args[:name] + "_segments"
+        }
+        options = default.merge(args)
+        OrientdbBinary::Protocols::DatasegmentAdd.new(params(options)).process(socket)
+      end
+
+      # name: string
+      # Usage:
+      # db.drop_datasegment(name: 'posts')
+      #
+      def drop_datasegment(args)
+        OrientdbBinary::Protocols::DatasegmentDrop.new(params(args)).process(socket)
+      end
+    end
+  end
+end

data/lib/orientdb_binary/database_operations/query.rb

@@ -0,0 +1,58 @@
+require 'orientdb_binary/protocols/command'
+
+module OrientdbBinary
+  module DatabaseOperations
+    module Query
+      def query(text, params, fetch_plan="*:0")
+        class_name = 'com.orientechnologies.orient.core.sql.query.OSQLSynchQuery'
+        serialized_params = OrientdbBinary::Parser::Serializer.new.serialize_document({params: params})
+        q = OrientdbBinary::Protocols::SqlCommandPayload.new text: text, serialized_params: serialized_params,
+                                                            fetch_plan: fetch_plan,
+                                                            class_name: class_name
+        _command(q.to_binary_s, class_name)
+      end
+
+      # def script(text)
+      #   class_name = 'com.orientechnologies.orient.core.sql.OCommandSQL'
+      # end
+
+      def command(text, params={})
+        class_name = 'com.orientechnologies.orient.core.sql.OCommandSQL'
+        fetch_plan = nil
+        serialized_params = OrientdbBinary::Parser::Serializer.new.serialize_document({params: params})
+        q = OrientdbBinary::Protocols::SqlCommandPayload.new text: text, serialized_params: serialized_params,
+                                                            fetch_plan: fetch_plan,
+                                                            class_name: class_name
+        _command(q.to_binary_s, class_name)
+      end
+
+      # def command(text)
+      #   mode = 's'.ord
+      #   class_name = 'com.orientechnologies.orient.core.sql.query.OSQLSynchQuery'
+      #   fetchplan = "*0"
+
+      #   query = OrientdbBinary::Protocols::SqlCommandPayload.new text: text, non_text_limit: -1, fetchplan: fetchplan
+      #   p query
+
+      #   # command = OrientdbBinary::Protocols::Command.new session: session, mode: mode, clazz_name: class_name, command_payload_length: query.to_binary_s.length, command_payload: query.to_binary_s
+      #   command = OrientdbBinary::Protocols::Command.new session: session, mode: mode, text: text, command_payload: query.to_binary_s
+      #   command.write(socket)
+
+      #   status = BinData::Int8.read(socket).to_i
+      #   process_errors(status)
+
+      #   p OrientdbBinary::Protocols::CommandAnswer.read(socket)
+      # end
+
+      private
+      def _command(binary_query, class_name)
+        mode = 's'.ord
+        OrientdbBinary::Protocols::Command.new(
+                                                session: session, mode: mode,
+                                                command_payload_length: binary_query.length,
+                                                command_payload: binary_query
+                                              ).process(socket)
+      end
+    end
+  end
+end

data/lib/orientdb_binary/database_operations/record.rb

@@ -0,0 +1,105 @@
+require 'orientdb_binary/protocols/record_load'
+require 'orientdb_binary/protocols/record_create'
+require 'orientdb_binary/protocols/record_update'
+require 'orientdb_binary/protocols/record_delete'
+require 'orientdb_binary/protocols/db_countrecords'
+
+module OrientdbBinary
+  module DatabaseOperations
+    module Record
+
+      # rid: #id:position / id:position
+      # or
+      # cluster_id: int
+      # cluster:position: int
+      # optional
+      # fetch_plan: string (by default used "*:0")
+      # ignore_cache: int (0-1, by default 1)
+      # load_tombstones: int (0-1, by default 0)
+      # Usage:
+      # db.load_record("#5:2")
+      # db.load_record("#5:2", fetch_plan: "*:-1")
+      # db.load_record(5, 2, fetch_plan: "*:-1", ignore_cache: 0, load_tombstones: 1)
+      #
+      def load_record(args)
+        if args[:rid]
+          match = args[:rid].match(/#*(?<id>\d+):(?<position>\d+)/)
+          args[:cluster_id] = match[:id].to_i
+          args[:cluster_position] = match[:position].to_i
+        end
+        defaults = {
+          fetch_plan: "*:0",
+          ignore_cache: 1,
+          load_tombstones: 0
+        }
+        options = defaults.merge(args)
+        answer = OrientdbBinary::Protocols::RecordLoad.new(params(options)).process(socket)
+        answer.process(options)
+      end
+
+      # Create record from object
+      # Usage:
+      # record = {
+      #   :@class => "Posts",
+      #   :@type => "d",
+      #   :@cluster => "posts"
+      #   name: "some name"
+      #   param: "some param"
+      # }
+      # Usage:
+      # db.create_record_from_object(record)
+      #
+      def create_record_from_object(record)
+        record_type = record[:@type] ? record[:@type].ord : "d".ord
+        cluster_id = (cluster = find_datacluster_by(cluster_name: 'default')) ? cluster[:cluster_id] : nil
+
+        if record[:@cluster]
+          if record[:@cluster].is_a? Integer
+            cluster_id = record[:@cluster]
+          else
+            cluster_id = (cluster = find_datacluster_by(cluster_name: record[:@cluster])) ? cluster[:cluster_id] : cluster_id
+          end
+        elsif record[:@class]
+          cluster_id = (cluster = find_datacluster_by(cluster_name: record[:@class])) ? cluster[:cluster_id] : cluster_id
+        end
+
+        record_content = OrientdbBinary::Parser::Serializer.new.serialize_document(record)
+        create_record(record_type: record_type, cluster_id: cluster_id, record_content: record_content)
+      end
+
+      # Create record
+      # cluster_id: int or cluster_name: string
+      # record_content: string -> it's serialized document; use create_record_from_object which serialize hash into string accepted by Orientdb
+      # Usage:
+      # db.create_record(cluster_id: 5, record_content: "Post@title=\"Post title\"")
+      #
+      def create_record(args)
+        if args[:cluster_name] and not args[:cluster_id]
+          args[:cluster_id] = (cluster = find_datacluster_by(cluster_name: args[:cluster_name])) ? cluster_id : nil
+        end
+
+        defaults = {
+          datasegment_id: -1,
+          record_type: "d".ord,
+          mode: 0
+        }
+
+        options = defaults.merge(args)
+        answer = OrientdbBinary::Protocols::RecordCreate.new(params(args)).process(socket)
+        answer.process(options)
+      end
+
+      def update_record(args)
+        OrientdbBinary::Protocols::RecordUpdate.new(params(args)).process(socket)
+      end
+
+      def delete_record(args)
+        OrientdbBinary::Protocols::RecordDelete.new(params(args)).process(socket)
+      end
+
+      def count_records
+        OrientdbBinary::Protocols::DbCountRecords.new(params).process(socket)
+      end
+    end
+  end
+end

data/lib/orientdb_binary/database_operations/transaction.rb

@@ -0,0 +1,8 @@
+module OrientdbBinary
+  module DatabaseOperations
+    module Transaction
+      def tx_commit(args)
+      end
+    end
+  end
+end

data/lib/orientdb_binary/operation_types.rb

@@ -0,0 +1,51 @@
+module OrientdbBinary
+  module OperationTypes
+    NEW_SESSION                             = -1
+    REQUEST_SHUTDOWN                        =  1
+    REQUEST_CONNECT                         =  2
+    REQUEST_DB_OPEN                         =  3
+    REQUEST_DB_CREATE                       =  4
+    REQUEST_DB_CLOSE                        =  5
+    REQUEST_DB_EXIST                        =  6
+    REQUEST_DB_DROP                         =  7
+    REQUEST_DB_SIZE                         =  8
+    REQUEST_DB_COUNTRECORDS                 =  9
+    REQUEST_DATACLUSTER_ADD                 = 10
+    REQUEST_DATACLUSTER_DROP                = 11
+    REQUEST_DATACLUSTER_COUNT               = 12
+    REQUEST_DATACLUSTER_DATARANGE           = 13
+    REQUEST_DATACLUSTER_COPY                = 14
+    REQUEST_DATACLUSTER_LH_CLUSTER_IS_USED  = 16
+    REQUEST_DATASEGMENT_ADD                 = 20
+    REQUEST_DATASEGMENT_DROP                = 21
+    REQUEST_RECORD_METADATA                 = 29
+    REQUEST_RECORD_LOAD                     = 30
+    REQUEST_RECORD_CREATE                   = 31
+    REQUEST_RECORD_UPDATE                   = 32
+    REQUEST_RECORD_DELETE                   = 33
+    REQUEST_RECORD_COPY                     = 34
+    REQUEST_POSITIONS_HIGHER                = 36
+    REQUEST_POSITIONS_LOWER                 = 37
+    REQUEST_RECORD_CLEAN_OUT                = 38
+    REQUEST_POSITIONS_FLOOR                 = 39
+    REQUEST_COUNT                           = 40 #  (DEPRECATED: USE REQUEST_DATACLUSTER_COUNT)
+    REQUEST_COMMAND                         = 41
+    REQUEST_POSITIONS_CEILING               = 42
+    REQUEST_TX_COMMIT                       = 60
+    REQUEST_CONFIG_GET                      = 70
+    REQUEST_CONFIG_SET                      = 71
+    REQUEST_CONFIG_LIST                     = 72
+    REQUEST_DB_RELOAD                       = 73
+    REQUEST_DB_LIST                         = 74
+    REQUEST_PUSH_RECORD                     = 79
+    REQUEST_PUSH_DISTRIB_CONFIG             = 80
+    REQUEST_DB_COPY                         = 90
+    REQUEST_REPLICATION                     = 91
+    REQUEST_CLUSTER                         = 92
+    REQUEST_DB_TRANSFER                     = 93
+    REQUEST_DB_FREEZE                       = 94
+    REQUEST_DB_RELEASE                      = 95
+    REQUEST_DATACLUSTER_FREEZE              = 96
+    REQUEST_DATACLUSTER_RELEASE             = 97
+  end
+end

data/lib/orientdb_binary/parser/deserializer.rb

@@ -0,0 +1,161 @@
+module OrientdbBinary
+  module Parser
+    class Deserializer
+      attr_accessor :record
+
+      def initialize()
+        @record = {}
+      end
+
+      def split(serialized, position)
+        first = serialized[0...position]
+        second = serialized[position+1..-1]
+        return first, second
+      end
+
+      def deserialize(document, params={})
+        @record = deserialize_document(document)
+        params.each do |k,v|
+          @record[k] = v
+        end
+        @record
+      end
+
+      def deserialize_document(serialized, document={}, is_map=false)
+        serialized = serialized.strip
+        class_index = serialized.index('@')
+        colon_index = serialized.index(':')
+        if class_index && (!colon_index || colon_index > class_index)
+          document[:@class], serialized = split(serialized, class_index)
+        end
+        document[:@type] = "d" unless is_map
+
+        while (serialized and field_index = serialized.index(':')) do
+          field, serialized = split(serialized, field_index)
+
+          if field[0] == "\"" and field[-1] == "\""
+            field = field[1..-2]
+          end
+
+          comma_index = look_for_comma_index(serialized)
+          value, serialized = split(serialized, comma_index)
+          value = deserialize_field_value(value)
+          document[field.to_sym] = value
+        end
+        document
+      end
+
+      def deserialize_field_value(value)
+        return nil if value.empty?
+
+        if ["true", "false"].include? value
+          return value == "true"
+        end
+
+        first_char = value[0]
+        last_char = value[-1]
+
+        if "\"" == first_char
+          val = value[1..-2]
+          val = val.gsub(/\\"/, "\"")
+          val = val.sub(/\\\\/, "\\")
+          return val
+        end
+
+        # split for date and datetime
+        if ["t", "a"].include? last_char
+          date = DateTime.strptime(value[0..-1],'%s')
+          date = date.to_date if last_char == "a"
+          return date
+        end
+
+        if "(" == first_char
+          return deserialize_document(value[1..-2])
+        end
+
+        if "{" == first_char
+          return deserialize_document(value[1..-2], {}, true)
+        end
+
+        if ["[", "<"].include? first_char
+          ret = [] if first_char == "["
+          ret = Set.new if first_char == "<"
+
+          values = split_values_from(value[1..-2])
+          values.each { |val| ret << deserialize_field_value(val) }
+          return ret
+        end
+
+        if "b" == last_char
+          return value[0..-2].to_i
+        end
+
+        # split for long/short?
+        if ["l", "s"].include? last_char
+          return value[0..-2].to_i
+        end
+
+        if "c" == last_char
+          return BigDecimal.new(value[0..-2].to_i)
+        end
+
+        if ["f", "d"].include? last_char
+          return value[0..-2].to_f
+        end
+
+        return value.to_i if value.to_i.to_s == value
+
+        return value
+      end
+
+      private
+
+      def split_values_from(value)
+        result = []
+        while value do
+          comma_at = look_for_comma_index(value)
+          res, value = split(value, comma_at)
+          result << res
+        end
+        result
+      end
+
+      def look_for_comma_index(serialized)
+        delimiters = []
+        (0...serialized.length).each do |idx|
+          current = serialized[idx]
+          if current == "," and delimiters.length == 0
+            return idx
+          elsif start_delimiter?(current) and delimiters[-1] != "\""
+            delimiters << current
+          elsif end_delimiter?(current) and delimiters[-1] != "\"" and current == opposite_delimiter_of(delimiters[-1])
+            delimiters.pop
+          elsif current == "\"" and delimiters[-1] == "\"" and idx > 0 and serialized[idx-1] != "\\"
+            delimiters.pop
+          elsif current == "\"" and delimiters[-1] != "\""
+            delimiters << current
+          end
+        end
+        return serialized.length
+      end
+
+      def start_delimiter?(c)
+        ["(", "[", "{", "<"].include? c
+      end
+
+      def end_delimiter?(c)
+        [")", "]", "}", ">"].include? c
+      end
+
+      def opposite_delimiter_of(c)
+        case c
+        when "[" then return "]"
+        when "{" then return "}"
+        when "(" then return ")"
+        when "<" then return ">"
+        else return "\""
+        end
+      end
+    end
+  end
+end

data/lib/orientdb_binary/parser/serializer.rb

@@ -0,0 +1,83 @@
+module OrientdbBinary
+  module Parser
+    class Serializer
+      def initialize()
+      end
+
+      def serialize_field_value(value)
+
+        if value.is_a? String
+          val = /^#\-{0,1}[\d]+:\-{0,1}[\d]+$/.match(value)
+          return value if val
+          value = value.sub(/\\/, "\\\\")
+          value = value.gsub(/"/, "\\\"")
+          return "\"#{value}\""
+        end
+
+        if value.is_a? Integer
+          return value.to_s
+        end
+
+        if value.is_a? Float
+          return value.to_s + "f"
+        end
+
+        if value.is_a? Bignum
+          return value.to_s + "l"
+        end
+
+        if value.is_a? BigDecimal
+          return value.to_s + "d"
+        end
+
+        if value.is_a? Array or value.is_a? Set
+          type = value.class.to_s.downcase == "set" ? "<$>" : "[$]"
+          result = []
+
+          value.each do |el|
+            result << serialize_field_value(el)
+          end
+          return type.gsub("$", result.join(','))
+        end
+
+        if value.is_a?(TrueClass) or value.is_a?(FalseClass)
+          return value.to_s
+        end
+
+        if value.is_a? Hash
+          type = value[:@type] == "d" ? "($)" : "{$}"
+          return type.gsub("$", serialize_document(value, value[:@type] != "d"))
+        end
+
+        if value.is_a? Date
+          value.to_datetime.to_time.to_i + "a"
+        end
+
+        if value.is_a? DateTime
+          value.to_time.to_i + "t"
+        end
+
+        if value.is_a? Time
+          value.to_i + "t"
+        end
+      end
+
+      def serialize_document(document, is_map=false)
+        klass = ""
+        result = []
+        document.each do |key, value|
+          unless [:@version, :@rid, :@type, :@cluster].include? key
+            if key == :@class
+              klass = value
+            else
+              field_wrap = is_map ? "\"" : ""
+              result << "#{key.to_s}:#{serialize_field_value(value)}"
+            end
+          end
+        end
+        return klass.empty? ? result.join(',') : klass + "@" + result.join(',')
+      end
+    end
+  end
+end
+