Compactor workshop viable impl (#13)

geeksilva97 · web-flow · commit f7a34ed73e21 · 2023-09-14T23:39:16.000-03:00
* add base compactor

* fix deletion for multiple segments

* ahead

* finish compactor
diff --git a/lib/amnesia.rb b/lib/amnesia.rb
@@ -1,7 +1,10 @@
 require_relative 'amnesia/cli'
+require_relative 'amnesia/compactor'
 
 dir = './_data'
 
 segment_files = Dir.each_child(dir).map { |f| "#{dir}/#{f}" }.sort_by { |f| File::Stat.new(f).mtime }
 
+# Amnesia::Compactor.call(*segment_files.take(2))
+
 Amnesia::CLI.new(segment_files, populate_index: true).start
diff --git a/lib/amnesia/cli.rb b/lib/amnesia/cli.rb
@@ -19,6 +19,8 @@ def initialize(segment_files, populate_index: nil)
     end
 
     def start
+      segment_handler.compact
+
       puts "Welcome to AmnesiaDB - Version 0.1.0\n\n"
 
       loop do
diff --git a/lib/amnesia/compactor.rb b/lib/amnesia/compactor.rb
@@ -0,0 +1,56 @@
+module Amnesia
+  class Compactor
+    def self.call(sstable1, sstable2)
+      # todos itens de sstable1 e sstable2
+      sstable_items1 = sstable1.all
+      sstable_items2 = sstable2.all
+
+      pp sstable_items1
+      pp sstable_items2
+
+      puts ''
+
+      # ponteiro 1, ponteiro 2 -> 0
+      p1 = p2 = 0
+
+      result = []
+
+      # loop ate que eu termine os registros de ambos os arquivos
+      loop do
+        item1 = sstable_items1[p1] # item é uma tupla ['name', 'mateus']
+        item2 = sstable_items2[p2]
+
+        break if item1.nil? && item2.nil?
+
+        # TODO: o que acontece se uma das keys for nil ?
+        key1 = item1[0] unless item1.nil?
+        key2 = item2[0] unless item2.nil?
+
+        min_key = [key1, key2].compact.min
+
+        if key1 == key2
+          p1 += 1
+          p2 += 1
+
+          result << item1
+
+          next
+        end
+
+        if min_key == key1
+          p1 += 1
+
+          result << item1
+        else
+          p2 += 1
+
+          result << item2
+        end
+      end
+
+      pp result
+
+      result.reject { |(_key, value)| value.nil? || value.empty? }
+    end
+  end
+end
diff --git a/lib/amnesia/memtable_handler.rb b/lib/amnesia/memtable_handler.rb
@@ -1,6 +1,6 @@
 module Amnesia
   class MemtableHandler
-    def initialize(segment_handler, max_items_threshold = 5)
+    def initialize(segment_handler, max_items_threshold = 2)
       @segment_handler = segment_handler
       @max_items_threshold = max_items_threshold
 
diff --git a/lib/amnesia/segment.rb b/lib/amnesia/segment.rb
@@ -2,9 +2,9 @@ module Amnesia
   class Segment
     attr_reader :index_structure
 
-    def initialize(filename, index_structure: Amnesia::Indexes::HashIndex.new)
+    def initialize(filename, items: nil, index_structure: Amnesia::Indexes::HashIndex.new)
       @filename = filename
-      @storage = Amnesia::Storage.new(filename)
+      @storage = Amnesia::Storage.new(filename, items: items)
       @storage.create_db_file unless @storage.file_exists?
       @index_structure = index_structure
     end
@@ -13,6 +13,14 @@ def name
       @filename
     end
 
+    def destroy
+      File.delete(@filename)
+    end
+
+    def all
+      @storage.all
+    end
+
     def retrieve(key)
       index_entry = @index_structure.get(key)
 
diff --git a/lib/amnesia/segment_handler.rb b/lib/amnesia/segment_handler.rb
@@ -9,6 +9,28 @@ def current_segment
       @segments.first
     end
 
+    def segments
+      @segments ||= []
+    end
+
+    def compact
+      segments_to_compact = segments[-2..]
+
+      return if segments_to_compact.nil?
+
+      pp segments_to_compact
+
+      filename = "./_data/#{Time.now.to_i}.c.segment"
+
+      compaction_result = Amnesia::Compactor.call(*segments_to_compact)
+
+      new_segment = Amnesia::Segment.new(filename, items: compaction_result)
+
+      @segments.unshift(new_segment)
+
+      segments.pop(2).each(&:destroy)
+    end
+
     def flush(items)
       # TODO: Use the storage class for that
       filename = "./_data/#{Time.now.to_i}.segment"
@@ -17,7 +39,9 @@ def flush(items)
         items.each { |(key, value)| f.write("#{key},#{value}\n") }
       end
 
-      @segments << Amnesia::Segment.new(filename)
+      @segments.unshift(Amnesia::Segment.new(filename))
+
+      compact if @segments.length == 2
 
       :finished_flushing
     end
diff --git a/lib/amnesia/storage.rb b/lib/amnesia/storage.rb
@@ -2,8 +2,9 @@ module Amnesia
   class Storage
     attr_reader :filename
 
-    def initialize(filename)
+    def initialize(filename, items: nil)
       @filename = filename
+      populate_data(items) unless items.nil? || items.empty?
     end
 
     def size
@@ -16,6 +17,14 @@ def set(key, value)
       File.write(filename, entry, mode: 'a+')
     end
 
+    def all
+      File.readlines(filename).map do |record|
+        key, value = record.chomp.split(',')
+
+        [key, value]
+      end
+    end
+
     def delete(key)
       set(key, '')
     end
@@ -27,19 +36,15 @@ def get(key, index_entry: nil)
     end
 
     def parse_record(raw_record)
-      value = raw_record_value(raw_record)
-
-      return nil if value.nil? || value.empty?
-
-      value
+      raw_record_value(raw_record)
     end
 
     def raw_record_value(raw_record)
       (raw_record || '').chomp.split(',', 2)[1]
     end
 
-    def create_db_file
-      File.write(filename, '') unless file_exists?
+    def create_db_file(content = '')
+      File.write(filename, content) unless file_exists?
     end
 
     def file_exists?
@@ -48,6 +53,12 @@ def file_exists?
 
     private
 
+    def populate_data(items)
+      data_block = items.map { |(key, value)| "#{key},#{value}\n" }.join('')
+
+      create_db_file(data_block)
+    end
+
     def record_from_scan(key)
       lines = File.readlines(filename)
 
