rubydb 0.1.0

data/lib/rubydb/indexes/hash_index.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module RubyDB
+  module Indexes
+    # Hash index implementation (for exact equality lookups)
+    class HashIndex < Index
+      def initialize(name, table_name, columns, options = {})
+        super(name, table_name, columns, options)
+        @hash_table = {}
+        @bucket_count = options[:bucket_count] || 1024
+        @max_load_factor = options[:max_load_factor] || 0.75
+        @lock = Monitor.new
+        @is_built = false
+      end
+
+      def insert(key, row_id)
+        @lock.synchronize do
+          hash_key = hash_key(key)
+          @hash_table[hash_key] ||= []
+          
+          # Check for duplicates if unique
+          if @unique
+            existing = @hash_table[hash_key].find { |entry| entry[:key] == key && entry[:row_id] == row_id }
+            return false if existing
+          end
+          
+          @hash_table[hash_key] << { key: key, row_id: row_id }
+          @entries_count += 1
+          @modified_at = Time.now
+          
+          # Rehash if load factor exceeded
+          rehash if load_factor > @max_load_factor
+          
+          true
+        end
+      end
+
+      def delete(key, row_id)
+        @lock.synchronize do
+          hash_key = hash_key(key)
+          bucket = @hash_table[hash_key]
+          return false unless bucket
+          
+          bucket.delete_if { |entry| entry[:key] == key && entry[:row_id] == row_id }
+          @hash_table.delete(hash_key) if bucket.empty?
+          @entries_count -= 1
+          @modified_at = Time.now
+          true
+        end
+      end
+
+      def search(key)
+        @lock.synchronize do
+          hash_key = hash_key(key)
+          bucket = @hash_table[hash_key]
+          return [] unless bucket
+          
+          bucket.select { |entry| entry[:key] == key }.map { |entry| entry[:row_id] }
+        end
+      end
+
+      def range_search(start_key, end_key)
+        # Hash index doesn't support efficient range queries
+        # Return all entries in the range (slow)
+        @lock.synchronize do
+          results = []
+          @hash_table.each do |_, bucket|
+            bucket.each do |entry|
+              if entry[:key] >= start_key && entry[:key] <= end_key
+                results << entry
+              end
+            end
+          end
+          results
+        end
+      end
+
+      def build(rows)
+        @lock.synchronize do
+          clear
+          
+          rows.each do |row|
+            key = extract_key(row)
+            row_id = row[:_row_id] || row["id"] || row[:id]
+            insert(key, row_id)
+          end
+          
+          @is_built = true
+          @modified_at = Time.now
+          true
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @hash_table.clear
+          @entries_count = 0
+          @is_built = false
+          true
+        end
+      end
+
+      def analyze
+        super.merge({
+          bucket_count: @bucket_count,
+          load_factor: load_factor,
+          max_load_factor: @max_load_factor,
+          is_built: @is_built
+        })
+      end
+
+      private
+
+      def hash_key(key)
+        key_hash = key.is_a?(Array) ? key.hash : key.hash
+        key_hash.abs % @bucket_count
+      end
+
+      def extract_key(row)
+        if @columns.size == 1
+          column = @columns.first
+          row.key?(column) ? row[column] : row[column.to_s]
+        else
+          @columns.map { |col| row.key?(col) ? row[col] : row[col.to_s] }
+        end
+      end
+
+      def load_factor
+        @entries_count.to_f / @bucket_count
+      end
+
+      def rehash
+        new_bucket_count = @bucket_count * 2
+        old_table = @hash_table
+        @hash_table = {}
+        @bucket_count = new_bucket_count
+        
+        old_table.each do |_, bucket|
+          bucket.each do |entry|
+            hash_key = hash_key(entry[:key])
+            @hash_table[hash_key] ||= []
+            @hash_table[hash_key] << entry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/indexes/index.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Indexes
+    # Base class for all index types
+    class Index
+      attr_reader :name, :table_name, :columns, :unique, :type, :options
+      attr_accessor :size, :entries_count
+
+      def initialize(name, table_name, columns, options = {})
+        @name = name
+        @table_name = table_name
+        @columns = columns.is_a?(Array) ? columns : [columns]
+        @unique = options[:unique] || false
+        @type = options[:type] || :btree
+        @options = options
+        @size = 0
+        @entries_count = 0
+        @created_at = Time.now
+        @modified_at = Time.now
+        @is_built = false
+      end
+
+      def insert(key, row_id)
+        raise NotImplementedError, "#{self.class} must implement #insert"
+      end
+
+      def delete(key, row_id)
+        raise NotImplementedError, "#{self.class} must implement #delete"
+      end
+
+      def search(key)
+        raise NotImplementedError, "#{self.class} must implement #search"
+      end
+
+      def range_search(start_key, end_key)
+        raise NotImplementedError, "#{self.class} must implement #range_search"
+      end
+
+      def build(rows)
+        raise NotImplementedError, "#{self.class} must implement #build"
+      end
+
+      def clear
+        raise NotImplementedError, "#{self.class} must implement #clear"
+      end
+
+      def analyze
+        {
+          name: @name,
+          table: @table_name,
+          columns: @columns,
+          type: @type,
+          unique: @unique,
+          entries: @entries_count,
+          size: @size,
+          created_at: @created_at,
+          modified_at: @modified_at
+        }
+      end
+
+      def to_s
+        "#{@type.to_s.upcase} INDEX #{@name} ON #{@table_name}(#{@columns.join(', ')})"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+  end
+end

data/lib/rubydb/indexes/index_manager.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+
+require "json"
+require "monitor"
+
+module RubyDB
+  module Indexes
+    # IndexManager - Manages all indexes for the database
+    class IndexManager
+      attr_reader :indexes, :stats
+
+      def initialize(engine)
+        @engine = engine
+        @indexes = {}
+        @table_indexes = {}
+        @stats = {
+          index_creates: 0,
+          index_drops: 0,
+          index_builds: 0,
+          index_searches: 0,
+          index_inserts: 0,
+          index_deletes: 0,
+          cache_hits: 0,
+          cache_misses: 0
+        }
+        @cache = {}
+        @cache_size = 100
+        @lock = Monitor.new
+        
+        load_indexes
+      end
+
+      def create_index(name, table_name, columns, options = {})
+        @lock.synchronize do
+          # Check if index already exists
+          if @indexes.key?(name)
+            raise DatabaseError, "Index '#{name}' already exists" unless options[:if_not_exists]
+            return false
+          end
+          
+          # Check if table exists
+          unless @engine.table_exists?(table_name)
+            raise DatabaseError, "Table '#{table_name}' does not exist"
+          end
+          
+          # Create index based on type
+          index_type = options[:type] || :btree
+          index = case index_type
+          when :btree
+            BTree.new(name, table_name, columns, options)
+          when :hash
+            HashIndex.new(name, table_name, columns, options)
+          else
+            raise ConfigurationError, "Unsupported index type: #{index_type}"
+          end
+          
+          begin
+            # Store index
+            @indexes[name] = index
+            @table_indexes[table_name] ||= []
+            @table_indexes[table_name] << name
+
+            # Build the in-memory structure first, then publish its durable
+            # definition once. A failed publication must not leave an index
+            # visible in this process but absent from the on-disk catalog.
+            build_index(name, persist: false) unless options[:skip_build]
+
+            @stats[:index_creates] += 1
+            save_indexes
+            true
+          rescue Exception
+            @indexes.delete(name)
+            if @table_indexes[table_name]
+              @table_indexes[table_name].delete(name)
+              @table_indexes.delete(table_name) if @table_indexes[table_name].empty?
+            end
+            @stats[:index_creates] -= 1 if @stats[:index_creates].positive?
+            raise
+          end
+        end
+      end
+
+      def drop_index(name, options = {})
+        @lock.synchronize do
+          unless @indexes.key?(name)
+            return false if options[:if_exists]
+            raise DatabaseError, "Index '#{name}' does not exist"
+          end
+          
+          index = @indexes[name]
+          table_name = index.table_name
+          
+          # Remove from table index list
+          if @table_indexes[table_name]
+            @table_indexes[table_name].delete(name)
+            @table_indexes.delete(table_name) if @table_indexes[table_name].empty?
+          end
+          
+          # Clear index
+          index.clear
+          
+          # Remove from cache
+          @cache.delete(name)
+          
+          @indexes.delete(name)
+          @stats[:index_drops] += 1
+          save_indexes
+          
+          true
+        end
+      end
+
+      def get_index(name)
+        @lock.synchronize do
+          @indexes[name]
+        end
+      end
+
+      def get_indexes_for_table(table_name)
+        @lock.synchronize do
+          (@table_indexes[table_name] || []).map { |name| @indexes[name] }.compact
+        end
+      end
+
+      def index_exists?(name)
+        @indexes.key?(name)
+      end
+
+      def build_index(name, persist: true)
+        @lock.synchronize do
+          index = @indexes[name]
+          return false unless index
+          
+          # Get all rows from table
+          columns = @engine.table_columns(index.table_name)
+          rows = @engine.select_rows(index.table_name, columns)
+          
+          # Build index
+          index.build(rows)
+          
+          @stats[:index_builds] += 1
+          save_indexes if persist
+          true
+        end
+      end
+
+      def rebuild_index(name)
+        @lock.synchronize do
+          index = @indexes[name]
+          raise DatabaseError, "Index '#{name}' does not exist" unless index
+
+          table_name = index.table_name
+          columns = index.columns.dup
+          options = index.options.dup
+          drop_index(name, if_exists: true)
+          create_index(name, table_name, columns, options)
+          true
+        end
+      end
+
+      def rebuild_all_indexes
+        @lock.synchronize do
+          @indexes.keys.each do |name|
+            rebuild_index(name)
+          end
+          true
+        end
+      end
+
+      def insert_row(table_name, row)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          return unless indexes.any?
+
+          validate_insert!(table_name, row)
+          row_id = row[:_row_id] || row["id"] || row[:id]
+          
+          indexes.each do |index|
+            key = extract_key(row, index.columns)
+            index.insert(key, row_id)
+            @stats[:index_inserts] += 1
+          end
+        end
+      end
+
+      def validate_insert!(table_name, row)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          row_id = row[:_row_id] || row["id"] || row[:id]
+          indexes.each do |index|
+            next unless index.unique
+            key = extract_key(row, index.columns)
+            existing = index.search(key)
+            if !existing.nil? && existing != row_id
+              raise DatabaseError, "Duplicate value for unique index '#{index.name}'"
+            end
+          end
+          true
+        end
+      end
+
+      def delete_row(table_name, row)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          return unless indexes.any?
+          
+          indexes.each do |index|
+            key = extract_key(row, index.columns)
+            row_id = row[:_row_id] || row["id"] || row[:id]
+            index.delete(key, row_id)
+            @stats[:index_deletes] += 1
+          end
+        end
+      end
+
+      def update_row(table_name, old_row, new_row)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          return unless indexes.any?
+
+          validate_update!(table_name, old_row, new_row)
+          row_id = new_row[:_row_id] || new_row["id"] || new_row[:id]
+          
+          indexes.each do |index|
+            old_key = extract_key(old_row, index.columns)
+            new_key = extract_key(new_row, index.columns)
+            
+            if old_key != new_key
+              # Update index
+              index.delete(old_key, row_id)
+              index.insert(new_key, row_id)
+            end
+          end
+        end
+      end
+
+      def validate_update!(table_name, old_row, new_row)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          row_id = new_row[:_row_id] || new_row["id"] || new_row[:id]
+          indexes.each do |index|
+            next unless index.unique
+            old_key = extract_key(old_row, index.columns)
+            new_key = extract_key(new_row, index.columns)
+            next if old_key == new_key
+            existing = index.search(new_key)
+            if !existing.nil? && existing != row_id
+              raise DatabaseError, "Duplicate value for unique index '#{index.name}'"
+            end
+          end
+          true
+        end
+      end
+
+      def find_index_for_query(table_name, conditions)
+        @lock.synchronize do
+          indexes = get_indexes_for_table(table_name)
+          return nil if indexes.empty?
+          
+          # Try to find the best index for the query
+          indexes.each do |index|
+            # Check if all columns in condition are in index
+            index_columns = index.columns
+            condition_keys = conditions.keys.map(&:to_s)
+            
+            if index_columns.all? { |col| condition_keys.include?(col.to_s) }
+              # Check if the condition has an operator that can use the index
+              if index.type == :hash
+                # Hash index works best for equality
+                return index if conditions.values.all? { |v| v[:operator] == :eq }
+              elsif index.type == :btree
+                # B-Tree works for equality, range, and prefix
+                return index
+              end
+            end
+          end
+          
+          # Return first index if no better match
+          indexes.first
+        end
+      end
+
+      def analyze_index(name)
+        @lock.synchronize do
+          index = @indexes[name]
+          return nil unless index
+          index.analyze
+        end
+      end
+
+      def analyze_all_indexes
+        @lock.synchronize do
+          @indexes.transform_values(&:analyze)
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          {
+            total_indexes: @indexes.size,
+            index_creates: @stats[:index_creates],
+            index_drops: @stats[:index_drops],
+            index_builds: @stats[:index_builds],
+            index_searches: @stats[:index_searches],
+            index_inserts: @stats[:index_inserts],
+            index_deletes: @stats[:index_deletes],
+            cache_hits: @stats[:cache_hits],
+            cache_misses: @stats[:cache_misses],
+            cache_hit_rate: cache_hit_rate,
+            by_type: index_count_by_type
+          }
+        end
+      end
+
+      private
+
+      def extract_key(row, columns)
+        if columns.size == 1
+          column = columns.first
+          row.key?(column) ? row[column] : row[column.to_s]
+        else
+          columns.map { |col| row.key?(col) ? row[col] : row[col.to_s] }
+        end
+      end
+
+      def index_count_by_type
+        counts = Hash.new(0)
+        @indexes.each do |_, index|
+          counts[index.type] += 1
+        end
+        counts
+      end
+
+      def cache_hit_rate
+        total = @stats[:cache_hits] + @stats[:cache_misses]
+        return 0.0 if total == 0
+        (@stats[:cache_hits].to_f / total * 100).round(2)
+      end
+
+      def load_indexes
+        @lock.synchronize do
+          begin
+            index_path = index_metadata_path
+            if File.exist?(index_path)
+              data = File.read(index_path)
+              parsed = JSON.parse(data, symbolize_names: true)
+              
+              parsed[:indexes]&.each do |name, index_data|
+                table_name = index_data[:table_name]
+                table_name = table_name.to_sym if table_name.respond_to?(:to_sym)
+                name = name.to_sym if name.respond_to?(:to_sym)
+                columns = Array(index_data[:columns]).map { |column| column.respond_to?(:to_sym) ? column.to_sym : column }
+                options = (index_data[:options] || {}).transform_keys(&:to_sym)
+                options[:type] = index_data[:type].to_sym if index_data[:type]
+                options[:unique] = index_data[:unique] unless index_data[:unique].nil?
+                create_index(name, table_name, columns, options)
+              end
+            end
+          rescue StandardError => error
+            @indexes.clear
+            @table_indexes.clear
+            raise DatabaseError, "Invalid persisted index metadata at #{index_metadata_path}: #{error.message}"
+          end
+        end
+      end
+
+      def save_indexes
+        @lock.synchronize do
+          data = {
+            indexes: {},
+            timestamp: Time.now.iso8601
+          }
+            
+          @indexes.each do |name, index|
+            data[:indexes][name] = {
+              table_name: index.table_name,
+              columns: index.columns,
+              type: index.type,
+              unique: index.unique,
+              options: index.options,
+              entries: index.entries_count,
+              created_at: index.instance_variable_get(:@created_at).iso8601
+            }
+          end
+
+          path = index_metadata_path
+          temporary = "#{path}.tmp-#{Process.pid}-#{Thread.current.object_id}-#{Time.now.to_f.hash.abs}"
+          File.open(temporary, "wb") do |file|
+            file.write(JSON.generate(data))
+            file.flush
+            file.fsync
+          end
+          begin
+            File.rename(temporary, path)
+          ensure
+            File.delete(temporary) if File.file?(temporary)
+          end
+        end
+      end
+
+      def index_metadata_path
+        "#{@engine.instance_variable_get(:@path)}.indexes"
+      end
+    end
+  end
+end