mem_db 0.1.0

data/lib/mem_db/index/prefix_tree.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "mem_db/out"
+require "mem_db/index"
+require "mem_db/index/bucket"
+require "mem_db/bucket"
+
+class MemDB
+  module Index
+    class PrefixTree
+      include MemDB::Index
+
+      class Bucket
+        include MemDB::Index::Bucket
+
+        def initialize(idx:, bucket: MemDB::Bucket)
+          @idx = idx
+          @bucket = bucket
+        end
+
+        def new
+          MemDB::Index::PrefixTree.new(idx: @idx, bucket: @bucket)
+        end
+      end
+
+      class Root
+        MAX_LENGTH_DEFAULT = 2 ^ 64
+
+        def initialize(bucket:)
+          @item = Item.new(bucket: bucket)
+          @min_length = MAX_LENGTH_DEFAULT
+        end
+
+        def get(contents, query:, result:)
+          contents.each do |content|
+            next if @min_length > content.length
+
+            @item.select_values(content, 0, query: query, out: result)
+          end
+
+          result
+        end
+
+        def add(prefixes, obj, value)
+          prefixes.each do |prefix|
+            @min_length = prefix.length if @min_length > prefix.length
+            @item.add(prefix, 0, obj, value)
+          end
+        end
+      end
+
+      class Item
+        attr_reader :value
+
+        def initialize(bucket:)
+          @bucket = bucket
+        end
+
+        def select_values(content, i, query:, out:)
+          @value&.query(query, out: out)
+
+          return if content.length == i
+
+          return unless @children
+
+          if (item = @children[content[i]])
+            item.select_values(content, i + 1, query: query, out: out)
+          end
+        end
+
+        def add(prefix, i, obj, value)
+          if prefix.length == i
+            set_value(obj, value)
+          else
+            item = fetch_children(prefix[i])
+            item.add(prefix, i + 1, obj, value)
+          end
+        end
+
+        def set_value(obj, value)
+          @value ||= @bucket.new
+          @value.add(obj, value)
+        end
+
+        def fetch_children(idx)
+          @children ||= {}
+          @children[idx] ||= Item.new(bucket: @bucket)
+        end
+      end
+
+      attr_reader :idx, :bucket
+
+      def initialize(idx:, bucket: MemDB::Bucket)
+        @idx = idx
+        @bucket = bucket
+        @root = Root.new(bucket: bucket)
+      end
+
+      def add(obj, value)
+        @root.add(obj.idx_value(@idx), obj, value)
+      end
+
+      def query(query, out: MemDB::Out.new)
+        @root.get(query.idx_value(@idx), query: query, result: out)
+
+        out
+      end
+    end
+  end
+end

data/lib/mem_db/index/sequence_match.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "mem_db/index"
+require "mem_db/index/bucket"
+require "mem_db/out"
+
+class MemDB
+  module Index
+    class SequenceMatch
+      include MemDB::Index
+
+      class Bucket
+        include MemDB::Index::Bucket
+
+        def initialize(idx:, bucket: MemDB::Bucket)
+          @idx = idx
+          @bucket = bucket
+        end
+
+        def new
+          MemDB::Index::SequenceMatch.new(idx: @idx, bucket: @bucket)
+        end
+      end
+
+      # https://en.wikipedia.org/wiki/Boyer-Moore_string_search_algorithm
+      class SequenceIndex
+        def initialize(pattern)
+          @pattern = pattern
+          @pattern_length = pattern.length
+          @bad_char_skip = {}
+          @good_suffix_skip = Array.new(@pattern_length, 0)
+
+          init_tables
+        end
+
+        def index(seq)
+          i = @pattern_length - 1
+
+          while i < seq.length
+            j = @pattern_length - 1
+
+            while j >= 0 && seq[i] == @pattern[j]
+              i -= 1
+              j -= 1
+            end
+
+            return i + 1 if j.negative?
+
+            bad_skip = @bad_char_skip[seq[i]] || @pattern_length
+            good_skip = @good_suffix_skip[j]
+            i += good_skip > bad_skip ? good_skip : bad_skip
+          end
+
+          -1
+        end
+
+        def init_tables # rubocop:disable Metrics/AbcSize
+          last = @pattern_length - 1
+
+          i = 0
+          while i < last
+            @bad_char_skip[@pattern[i]] = last - i
+            i += 1
+          end
+
+          last_prefix = last
+
+          i = last
+          while i >= 0
+            last_prefix = i + 1 if pattern_suffix?(i + 1)
+
+            @good_suffix_skip[i] = last_prefix + last - i
+            i -= 1
+          end
+
+          i = 0
+          while i < last
+            len_suffix = longest_pattern_suffix(i)
+
+            if @pattern[i - len_suffix] != @pattern[last - len_suffix]
+              @good_suffix_skip[last - len_suffix] = len_suffix + last - i
+            end
+
+            i += 1
+          end
+        end
+
+        def pattern_suffix?(pos)
+          i = 0
+          while i + pos < @pattern.length
+            return false if @pattern[i] != @pattern[i + pos]
+
+            i += 1
+          end
+          true
+        end
+
+        def longest_pattern_suffix(pos)
+          i = 0
+
+          while i < @pattern.length && i < pos
+            break if @pattern[@pattern.length - 1 - i] != @pattern[pos - i]
+
+            i += 1
+          end
+
+          i
+        end
+      end
+
+      def initialize(idx:, bucket: MemDB::Bucket)
+        @idx = idx
+        @bucket = bucket
+        @patterns = {}
+        @matchers = {}
+      end
+
+      def add(obj, value)
+        obj.idx_value(@idx).each do |pattern|
+          @patterns[pattern] ||= @bucket.new
+          @patterns[pattern].add(obj, value)
+
+          @matchers[pattern] ||= SequenceIndex.new(pattern)
+        end
+      end
+
+      def query(query, out: MemDB::Out.new)
+        query.idx_value(@idx).each do |seq|
+          select_one(query, seq, out)
+        end
+
+        out
+      end
+
+      private
+
+      def select_one(query, seq, out)
+        @matchers.each do |pattern, sequence|
+          next if seq.length < pattern.length
+
+          @patterns[pattern].query(query, out: out) if sequence.index(seq) > -1
+        end
+      end
+    end
+  end
+end

data/lib/mem_db/indexation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "mem_db/indexing_object"
+
+class MemDB
+  class Indexation
+    def initialize(index)
+      @obj = MemDB::IndexingObject.new
+      @index = index
+    end
+
+    def add(raw, value)
+      @obj.assign!(raw)
+      @index.add(@obj, value)
+    end
+  end
+end

data/lib/mem_db/indexing_object.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  class IndexingObject
+    def initialize
+      @params = {}
+      @attrs = {}
+      @idx_value = {}
+    end
+
+    def assign!(params)
+      @params = params
+      @attrs.clear
+      @idx_value.clear
+
+      self
+    end
+
+    def [](attr)
+      if @attrs.key?(attr)
+        @attrs[attr]
+      else
+        @attrs[attr] ||= prepare_attr(attr)
+      end
+    end
+
+    def []=(param, value)
+      @params[param] = value
+    end
+
+    def delete(param)
+      @params.delete(param)
+      @attrs.delete(param)
+    end
+
+    def idx_value(idx)
+      if @idx_value.key?(idx)
+        @idx_value[idx]
+      else
+        @idx_value[idx] ||= idx.value(self)
+      end
+    end
+
+    def prepare_attr(attr)
+      v = @params[attr]
+
+      if v == MemDB::Idx::ANY
+        v
+      elsif v.nil? || v.is_a?(Array)
+        v
+      else
+        [v]
+      end
+    end
+  end
+end

data/lib/mem_db/out.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class MemDB
+  class Out
+    include Enumerable
+
+    def initialize
+      @arr = []
+    end
+
+    def add(res)
+      @arr.push(res)
+
+      true
+    end
+
+    def each(&block)
+      return to_enum unless block_given?
+
+      @arr.each do |values|
+        values.each(&block)
+      end
+    end
+  end
+end

data/lib/mem_db/query.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class MemDB
+  class Query
+    def initialize(params)
+      @params = params
+      @attrs = {}
+      @idx_value = {}
+    end
+
+    def using(index)
+      index.query(self)
+    end
+
+    def [](attr)
+      if @attrs.key?(attr)
+        @attrs[attr]
+      else
+        @attrs[attr] ||= prepare_attr(attr)
+      end
+    end
+
+    def []=(param, value)
+      @params[param] = value
+    end
+
+    def delete(param)
+      @params.delete(param)
+      @attrs.delete(param)
+    end
+
+    def idx_value(idx)
+      if @idx_value.key?(idx)
+        @idx_value[idx]
+      else
+        @idx_value[idx] ||= idx.prepare_query(self)
+      end
+    end
+
+    def prepare_attr(attr)
+      v = @params[attr]
+      if v.is_a?(Array)
+        v
+      else
+        [v]
+      end
+    end
+  end
+end

data/lib/mem_db/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class MemDB
+  VERSION = "0.1.0"
+end

data/mem_db.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "lib/mem_db/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mem_db"
+  spec.version       = MemDB::VERSION
+  spec.authors       = ["Dmitry Bochkarev"]
+  spec.email         = ["dimabochkarev@gmail.com"]
+
+  spec.summary       = "MemDB is embedded database"
+  spec.description   = "MemDB is embedded database"
+  spec.homepage      = "https://github.com/DmitryBochkarev/mem_db"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/DmitryBochkarev/mem_db"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end