mem_db 0.1.0

data/lib/mem_db/idx/default.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  module Idx
+    class Default
+      include MemDB::Idx
+
+      def initialize(original, default)
+        @original = original
+        @default = default
+      end
+
+      def field
+        @original.field
+      end
+
+      def value(obj)
+        v = obj[field]
+        if v.nil?
+          @default
+        else
+          @original.value(obj)
+        end
+      end
+
+      def prepare_query(query)
+        @original.prepare_query(query)
+      end
+    end
+  end
+end

data/lib/mem_db/idx/itself.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  module Idx
+    class Itself
+      include MemDB::Idx
+
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def map_value(val)
+        val
+      end
+
+      def map_query(val)
+        val
+      end
+    end
+  end
+end

data/lib/mem_db/idx/pattern.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+class MemDB
+  module Idx
+    class Pattern
+      include MemDB::Idx
+
+      class Pattern
+        def initialize(source, min:)
+          @parts = source.split("*", -1)
+          @min = min
+        end
+
+        def value # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize, Metrics/CyclomaticComplexity
+          if @parts.length == 1
+            [:enum, @parts[0]]
+          else
+            prefix = @parts[0]
+            suffix = @parts[-1]
+
+            if prefix != "" || suffix != ""
+              if prefix.length >= @min && prefix.length >= suffix.length
+                [:prefix, prefix]
+              elsif suffix.length >= @min
+                [:suffix, suffix]
+              else
+                candidates = [
+                  [:prefix, prefix],
+                  [:suffix, suffix]
+                ]
+
+                candidates.push([:substring, substring]) if substring # rubocop:disable Metrics/BlockNesting
+
+                candidates.max_by { |v| v[1].length }
+              end
+            else
+              [:substring, substring]
+            end
+          end
+        end
+
+        private
+
+        def substring
+          return @substring if defined?(@substring)
+
+          @substring =
+            if @parts.length > 2
+              substrings = @parts[1..-2]
+              substrings.find { |p| p.length > @min } || substrings.find { |p| p.length.positive? }
+            end
+        end
+      end
+
+      attr_reader :field
+
+      def initialize(field, min: 3)
+        @field = field
+        @min = min
+      end
+
+      def map_value(pattern)
+        Pattern.new(pattern, min: @min).value
+      end
+
+      def map_query(text)
+        text
+      end
+    end
+  end
+end

data/lib/mem_db/idx/reverse.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  module Idx
+    class Reverse
+      include MemDB::Idx
+
+      def initialize(original)
+        @original = original
+      end
+
+      def field
+        @original.field
+      end
+
+      def map_value(val)
+        @original.map_value(val).reverse
+      end
+
+      def map_query(val)
+        @original.map_query(val).reverse
+      end
+    end
+  end
+end

data/lib/mem_db/idx/uniq.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class MemDB
+  module Idx
+    class Uniq
+      include MemDB::Idx
+
+      def initialize(original)
+        @original = original
+      end
+
+      def field
+        @original.field
+      end
+
+      def value(obj)
+        val = @original.value(obj)
+        return val if val == MemDB::Idx::ANY
+
+        val.uniq
+      end
+
+      def prepare_query(query)
+        @original.prepare_query(query).uniq
+      end
+
+      def map_value(raw)
+        @original.map_value(raw)
+      end
+
+      def map_query(raw)
+        @original.map_query(raw)
+      end
+    end
+  end
+end

data/lib/mem_db/index.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "mem_db/out"
+
+class MemDB
+  module Index
+    def self.compose(chain)
+      (0..chain.length - 2).each do |parent_i|
+        chain[parent_i].bucket = chain[parent_i + 1]
+      end
+      chain[0].new
+    end
+
+    def idx
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    def bucket
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    def add(_obj, _value)
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def query(_query, out: MemDB::Out.new)
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+  end
+end

data/lib/mem_db/index/any.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "mem_db/index"
+require "mem_db/index/bucket"
+require "mem_db/out"
+require "mem_db/idx"
+
+class MemDB
+  module Index
+    class Any
+      include MemDB::Index
+
+      class Bucket
+        include MemDB::Index::Bucket
+
+        def initialize(original)
+          @original = original
+        end
+
+        def new
+          MemDB::Index::Any.new(@original.new)
+        end
+
+        def bucket=(bucket)
+          @original.bucket = bucket
+        end
+      end
+
+      def initialize(original)
+        raise ArgumentError, "original must be MemDB::Index, got: #{original.class}" unless original.is_a?(MemDB::Index)
+
+        @original = original
+      end
+
+      def idx
+        @original.idx
+      end
+
+      def bucket
+        @original.bucket
+      end
+
+      def add(obj, value)
+        addr = obj.idx_value(idx)
+        if addr == MemDB::Idx::ANY
+          @any ||= bucket.new
+          @any.add(obj, value)
+        else
+          @original.add(obj, value)
+        end
+      end
+
+      def query(query, out: MemDB::Out.new)
+        @original.query(query, out: out)
+        @any&.query(query, out: out)
+        out
+      end
+    end
+  end
+end

data/lib/mem_db/index/bucket.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# TODO: move to mem_db/index.rb
+class MemDB
+  module Index
+    module Bucket
+      def new
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      def bucket=(bucket)
+        @bucket = bucket
+      end
+
+      def accept_any
+        MemDB::Index::Any::Bucket.new(self)
+      end
+    end
+  end
+end

data/lib/mem_db/index/enum.rb

@@ -0,0 +1,54 @@
+# 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 Enum
+      include MemDB::Index
+
+      class Bucket
+        include MemDB::Index::Bucket
+
+        def initialize(idx:, bucket: MemDB::Bucket)
+          @idx = idx
+          @bucket = bucket
+        end
+
+        def new
+          MemDB::Index::Enum.new(idx: @idx, bucket: @bucket)
+        end
+      end
+
+      attr_reader :idx, :bucket
+
+      def initialize(idx:, bucket: MemDB::Bucket)
+        @idx = idx
+        @bucket = bucket
+        @hash = {}
+      end
+
+      def add(obj, value)
+        enums = obj.idx_value(@idx)
+        enums.each do |enum|
+          b = @hash[enum] ||= @bucket.new
+          b.add(obj, value)
+        end
+      end
+
+      def query(query, out: MemDB::Out.new)
+        enums = query.idx_value(@idx)
+        enums.each do |enum|
+          if (b = @hash[enum])
+            b.query(query, out: out)
+          end
+        end
+
+        out
+      end
+    end
+  end
+end

data/lib/mem_db/index/pattern_match.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "mem_db/index/enum"
+require "mem_db/index/prefix_tree"
+require "mem_db/index/sequence_match"
+require "mem_db/bucket"
+require "mem_db/index/bucket"
+require "mem_db/out"
+
+class MemDB
+  module Index
+    class PatternMatch
+      include MemDB::Index
+
+      class Bucket
+        include MemDB::Index::Bucket
+
+        def initialize(idx:, bucket: MemDB::Bucket)
+          @idx = idx
+          @bucket = bucket
+        end
+
+        def new
+          MemDB::Index::PatternMatch.new(idx: @idx, bucket: @bucket)
+        end
+      end
+
+      attr_reader :idx, :bucket
+
+      def initialize(idx:, bucket: MemDB::Bucket)
+        @idx = idx
+        @bucket = bucket
+      end
+
+      def add(obj, value)
+        obj.idx_value(@idx).each do |pattern|
+          type = pattern[0]
+          sequence = pattern[1]
+          index =
+            case type
+            when :enum
+              enums
+            when :prefix
+              prefixes
+            when :suffix
+              suffixes
+            when :substring
+              substrings
+            end
+
+          obj[self] = sequence
+          index.add(obj, value)
+          obj.delete(self)
+        end
+      end
+
+      def query(query, out: MemDB::Out.new)
+        query.idx_value(@idx).each do |q|
+          query[self] = q
+
+          @enums&.query(query, out: out)
+          @suffixes&.query(query, out: out)
+          @prefixes&.query(query, out: out)
+          @substrings&.query(query, out: out)
+
+          query.delete(self)
+        end
+
+        out
+      end
+
+      private
+
+      def enums
+        @enums ||= MemDB::Index::Enum.new(
+          idx: MemDB::Idx::Itself.new(self),
+          bucket: @bucket
+        )
+      end
+
+      def prefixes
+        @prefixes ||= MemDB::Index::PrefixTree.new(
+          idx: MemDB::Idx::Bytes.new(self),
+          bucket: @bucket
+        )
+      end
+
+      def suffixes
+        @suffixes ||= MemDB::Index::PrefixTree.new(
+          idx: MemDB::Idx::Reverse.new(MemDB::Idx::Bytes.new(self)),
+          bucket: @bucket
+        )
+      end
+
+      def substrings
+        @substrings ||= MemDB::Index::SequenceMatch.new(
+          # reverse somehow make it faster
+          idx: MemDB::Idx::Reverse.new(MemDB::Idx::Bytes.new(self)),
+          bucket: @bucket
+        )
+      end
+    end
+  end
+end