jackcess-rb 0.1.0-java

data/lib/jackcess/row.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Jackcess
+  class Row
+    attr_reader :java_row, :table
+    attr_accessor :data
+
+    def initialize(java_row, table)
+      @java_row = java_row # This is actually a Map from Jackcess
+      @table = table
+      @data = {}
+      @original_data = {}
+      @dirty = false
+
+      # Convert Java map to Ruby hash
+      if java_row
+        java_row.each do |key, value|
+          converted_value = TypeConverter.from_java(value)
+          @data[key.to_s] = converted_value
+          @original_data[key.to_s] = converted_value
+        end
+      end
+    end
+
+    # Get column value by name
+    def [](column_name)
+      raise ArgumentError, "Column name cannot be nil" if column_name.nil?
+
+      @data[column_name.to_s]
+    end
+
+    # Set column value by name
+    def []=(column_name, value)
+      raise ArgumentError, "Column name cannot be nil" if column_name.nil?
+
+      column_name = column_name.to_s
+
+      # Mark as dirty if value changed
+      if @data[column_name] != value
+        @dirty = true
+      end
+
+      @data[column_name] = value
+    end
+
+    # Save changes to the database
+    def save
+      return nil unless @dirty
+
+      begin
+        # Get primary key to find the row
+        pk_index = @table.java_table.get_primary_key_index
+        raise DatabaseError, "Cannot update row: table has no primary key" if pk_index.nil?
+
+        pk_column_name = pk_index.get_columns.first.get_name
+        pk_value = @data[pk_column_name]
+
+        # Create a new cursor for this update operation
+        cursor = com.healthmarketscience.jackcess.CursorBuilder.create_cursor(@table.java_table)
+
+        while cursor.move_to_next_row
+          current_row = cursor.get_current_row
+          current_pk = TypeConverter.from_java(current_row.get(pk_column_name))
+
+          if current_pk == pk_value
+            # Update each changed column value
+            @data.each do |column_name, value|
+              # Skip if value hasn't changed
+              next if @original_data[column_name] == value
+
+              column = @table.java_table.get_column(column_name)
+              cursor.setCurrentRowValue(column, TypeConverter.to_java(value))
+            end
+
+            # Update original data to match current data
+            @original_data = @data.dup
+            @dirty = false
+
+            return true
+          end
+        end
+
+        raise DatabaseError, "Row not found for update"
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to save row: #{e.message}"
+      rescue Java::JavaLang::Exception => e
+        raise DatabaseError, "Failed to save row: #{e.message}"
+      end
+    end
+
+    # Delete this row
+    def delete
+      begin
+        # Get primary key to find the row
+        pk_index = @table.java_table.get_primary_key_index
+        raise DatabaseError, "Cannot delete row: table has no primary key" if pk_index.nil?
+
+        pk_column_name = pk_index.get_columns.first.get_name
+        pk_value = @data[pk_column_name]
+
+        # Create a new cursor for this delete operation
+        cursor = com.healthmarketscience.jackcess.CursorBuilder.create_cursor(@table.java_table)
+
+        while cursor.move_to_next_row
+          current_row = cursor.get_current_row
+          current_pk = TypeConverter.from_java(current_row.get(pk_column_name))
+
+          if current_pk == pk_value
+            cursor.deleteCurrentRow
+            return true
+          end
+        end
+
+        raise DatabaseError, "Row not found for deletion"
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to delete row: #{e.message}"
+      rescue Java::JavaLang::Exception => e
+        raise DatabaseError, "Failed to delete row: #{e.message}"
+      end
+    end
+
+    # Get all column names
+    def keys
+      @data.keys
+    end
+
+    # Get all values
+    def values
+      @data.values
+    end
+
+    # Convert to hash
+    def to_h
+      @data.dup
+    end
+
+    # Check if row has been modified
+    def dirty?
+      @dirty
+    end
+
+    # Reload row from database
+    def reload
+      begin
+        # Get primary key to find the row
+        pk_index = @table.java_table.get_primary_key_index
+        raise DatabaseError, "Cannot reload row: table has no primary key" if pk_index.nil?
+
+        pk_column_name = pk_index.get_columns.first.get_name
+        pk_value = @original_data[pk_column_name]
+
+        # Find the row again
+        reloaded_row = @table.find_by_id(pk_value)
+
+        if reloaded_row
+          @data = reloaded_row.data.dup
+          @original_data = reloaded_row.data.dup
+          @dirty = false
+        end
+
+        self
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to reload row: #{e.message}"
+      rescue Java::JavaLang::Exception => e
+        raise DatabaseError, "Failed to reload row: #{e.message}"
+      end
+    end
+
+    def inspect
+      "#<Jackcess::Row #{@data.inspect}>"
+    end
+  end
+end

data/lib/jackcess/table.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Jackcess
+  class Table
+    include Enumerable
+
+    attr_reader :java_table, :database
+
+    def initialize(java_table, database)
+      @java_table = java_table
+      @database = database
+    end
+
+    # Get table name
+    def name
+      @java_table.get_name
+    end
+
+    # Iterate through all rows
+    def each
+      return enum_for(:each) unless block_given?
+
+      begin
+        # Create a new cursor for iteration to avoid state issues
+        cursor = com.healthmarketscience.jackcess.CursorBuilder.create_cursor(@java_table)
+        while cursor.move_to_next_row
+          java_row = cursor.get_current_row
+          yield Row.new(java_row, self)
+        end
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to iterate rows: #{e.message}"
+      end
+    end
+
+    # Add a new row
+    def add_row(data)
+      raise ArgumentError, "Data cannot be nil" if data.nil?
+      raise ArgumentError, "Data must be a Hash" unless data.is_a?(Hash)
+
+      begin
+        java_row_data = java.util.HashMap.new
+        data.each do |key, value|
+          java_row_data.put(key.to_s, TypeConverter.to_java(value))
+        end
+
+        java_row = @java_table.add_row_from_map(java_row_data)
+        Row.new(java_row, self)
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to add row to table '#{name}': #{e.message}"
+      rescue Java::JavaLang::Exception => e
+        raise DatabaseError, "Failed to add row to table '#{name}': #{e.message}"
+      end
+    end
+
+    # Find row by primary key
+    def find_by_id(id)
+      begin
+        primary_key_index = @java_table.get_primary_key_index
+
+        if primary_key_index.nil?
+          # No primary key, do a linear search
+          each do |row|
+            return row if row[primary_key_columns.first] == id
+          end
+          nil
+        else
+          # Use index search
+          search_map = java.util.HashMap.new
+          search_map.put(primary_key_index.get_columns.first.get_name, TypeConverter.to_java(id))
+
+          java_row = com.healthmarketscience.jackcess.CursorBuilder.find_row(@java_table, search_map)
+          java_row ? Row.new(java_row, self) : nil
+        end
+      rescue Java::JavaIo::IOException => e
+        raise DatabaseError, "Failed to find row: #{e.message}"
+      end
+    end
+
+    # Get all columns
+    def columns
+      @java_table.get_columns.map { |java_col| Column.new(java_col) }
+    end
+
+    # Get column by name
+    def column(name)
+      raise ArgumentError, "Column name cannot be nil" if name.nil?
+      raise ArgumentError, "Column name must be a String or Symbol" unless name.is_a?(String) || name.is_a?(Symbol)
+
+      name = name.to_s
+      begin
+        java_col = @java_table.get_column(name)
+        raise ColumnNotFoundError, "Column not found: #{name}" if java_col.nil?
+
+        Column.new(java_col)
+      rescue Java::JavaLang::IllegalArgumentException => e
+        raise ColumnNotFoundError, "Column not found: #{name}"
+      end
+    end
+
+    # Get all indexes
+    def indexes
+      @java_table.get_indexes.map { |java_idx| Index.new(java_idx) }
+    end
+
+    # Get row count
+    def row_count
+      @java_table.get_row_count
+    end
+    alias size row_count
+    alias length row_count
+
+    # Find rows matching the given criteria.
+    #
+    # This method provides a simple filtering interface for finding rows.
+    # For more complex queries, iterate through rows with {#each} and filter manually.
+    #
+    # @param criteria [Hash] Column name/value pairs to match
+    #
+    # @return [Array<Row>] Array of matching rows
+    #
+    # @example Find users by name
+    #   users = table.where('Name' => 'Alice')
+    #
+    # @example Find with multiple criteria
+    #   users = table.where('Name' => 'Bob', 'Active' => true)
+    def where(criteria)
+      raise ArgumentError, "Criteria cannot be nil" if criteria.nil?
+      raise ArgumentError, "Criteria must be a Hash" unless criteria.is_a?(Hash)
+
+      select { |row| criteria.all? { |key, value| row[key.to_s] == value } }
+    end
+
+    # Find the first row matching the given criteria.
+    #
+    # @param criteria [Hash] Column name/value pairs to match
+    #
+    # @return [Row, nil] The first matching row, or nil if no match
+    #
+    # @example Find first user by name
+    #   user = table.find_first('Name' => 'Alice')
+    def find_first(criteria)
+      raise ArgumentError, "Criteria cannot be nil" if criteria.nil?
+      raise ArgumentError, "Criteria must be a Hash" unless criteria.is_a?(Hash)
+
+      detect { |row| criteria.all? { |key, value| row[key.to_s] == value } }
+    end
+
+    # Count rows matching the given criteria.
+    #
+    # @param criteria [Hash, nil] Column name/value pairs to match (nil counts all rows)
+    #
+    # @return [Integer] The number of matching rows
+    #
+    # @example Count all rows
+    #   table.count # => 100
+    #
+    # @example Count filtered rows
+    #   table.count('Active' => true) # => 75
+    def count(criteria = nil)
+      return row_count if criteria.nil?
+
+      raise ArgumentError, "Criteria must be a Hash" unless criteria.is_a?(Hash)
+
+      where(criteria).size
+    end
+
+    # Check if any rows match the given criteria.
+    #
+    # @param criteria [Hash] Column name/value pairs to match
+    #
+    # @return [Boolean] true if at least one row matches, false otherwise
+    #
+    # @example Check if any active users exist
+    #   table.any?('Active' => true) # => true
+    def any?(criteria)
+      raise ArgumentError, "Criteria cannot be nil" if criteria.nil?
+      raise ArgumentError, "Criteria must be a Hash" unless criteria.is_a?(Hash)
+
+      !find_first(criteria).nil?
+    end
+
+    private
+
+    def primary_key_columns
+      pk_index = @java_table.get_primary_key_index
+      return [] if pk_index.nil?
+
+      pk_index.get_columns.map(&:get_name)
+    end
+  end
+end

data/lib/jackcess/type_converter.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+
+module Jackcess
+  module TypeConverter
+    class << self
+      # Convert Java types to Ruby types
+      def from_java(value)
+        return nil if value.nil?
+
+        case value
+        when Java::JavaLang::String
+          value.to_s
+        when Java::JavaLang::Integer, Java::JavaLang::Short, Java::JavaLang::Byte
+          value.to_i
+        when Java::JavaLang::Long
+          value.to_i
+        when Java::JavaLang::Float, Java::JavaLang::Double
+          value.to_f
+        when Java::JavaLang::Boolean
+          value.boolean_value
+        when Java::JavaUtil::Date
+          Time.at(value.time / 1000.0)
+        when Java::JavaMath::BigDecimal
+          BigDecimal(value.to_s)
+        when Java::byte[]
+          String.from_java_bytes(value)
+        else
+          value
+        end
+      end
+
+      # Convert Ruby types to Java types
+      def to_java(value)
+        return nil if value.nil?
+
+        case value
+        when String
+          value.to_java
+        when Integer
+          # Use appropriate Java type based on value range
+          if value >= -2_147_483_648 && value <= 2_147_483_647
+            java.lang.Integer.new(value)
+          else
+            java.lang.Long.new(value)
+          end
+        when Float
+          java.lang.Double.new(value)
+        when TrueClass, FalseClass
+          java.lang.Boolean.new(value)
+        when Time
+          java.util.Date.new((value.to_f * 1000).to_i)
+        when Date
+          # Convert Ruby Date to Time first, then to Java Date
+          java.util.Date.new((value.to_time.to_f * 1000).to_i)
+        when BigDecimal
+          java.math.BigDecimal.new(value.to_s)
+        else
+          value
+        end
+      end
+
+      # Map Ruby type symbols to Jackcess DataType enums
+      def ruby_type_to_data_type(type_sym)
+        case type_sym
+        when :text
+          DataType::TEXT
+        when :memo
+          DataType::MEMO
+        when :byte
+          DataType::BYTE
+        when :int
+          DataType::INT
+        when :long
+          DataType::LONG
+        when :float
+          DataType::FLOAT
+        when :double
+          DataType::DOUBLE
+        when :currency
+          DataType::MONEY
+        when :date_time
+          DataType::SHORT_DATE_TIME
+        when :boolean
+          DataType::BOOLEAN
+        when :binary
+          DataType::BINARY
+        when :guid
+          DataType::GUID
+        else
+          raise InvalidTypeError, "Unknown type: #{type_sym}"
+        end
+      end
+
+      # Map Jackcess DataType to Ruby type symbol
+      def data_type_to_ruby_type(data_type)
+        case data_type.to_s
+        when "TEXT"
+          :text
+        when "MEMO"
+          :memo
+        when "BYTE"
+          :byte
+        when "INT"
+          :int
+        when "LONG"
+          :long
+        when "FLOAT"
+          :float
+        when "DOUBLE"
+          :double
+        when "MONEY"
+          :currency
+        when "SHORT_DATE_TIME"
+          :date_time
+        when "BOOLEAN"
+          :boolean
+        when "BINARY", "OLE"
+          :binary
+        when "GUID"
+          :guid
+        else
+          :unknown
+        end
+      end
+    end
+  end
+end

data/lib/jackcess/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jackcess
+  # The current version of the jackcess-rb gem.
+  #
+  # This follows Semantic Versioning 2.0.0 (https://semver.org/):
+  # - MAJOR version: Incompatible API changes
+  # - MINOR version: Backwards-compatible functionality additions
+  # - PATCH version: Backwards-compatible bug fixes
+  VERSION = "0.1.0"
+end

data/lib/jackcess.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+unless RUBY_PLATFORM == "java"
+  raise LoadError, "jackcess-rb requires JRuby. You are running #{RUBY_DESCRIPTION}"
+end
+
+require "java"
+
+# Load the Jackcess JAR and its dependencies
+vendor_dir = File.expand_path("../vendor", __dir__)
+require File.join(vendor_dir, "commons-logging-1.2.jar")
+require File.join(vendor_dir, "commons-lang3-3.13.0.jar")
+require File.join(vendor_dir, "jackcess-4.0.4.jar")
+
+# Import necessary Java classes
+java_import "com.healthmarketscience.jackcess.DatabaseBuilder"
+java_import "com.healthmarketscience.jackcess.Database"
+java_import "com.healthmarketscience.jackcess.Table"
+java_import "com.healthmarketscience.jackcess.Column"
+java_import "com.healthmarketscience.jackcess.Row"
+java_import "com.healthmarketscience.jackcess.DataType"
+java_import "com.healthmarketscience.jackcess.ColumnBuilder"
+java_import "com.healthmarketscience.jackcess.TableBuilder"
+
+require_relative "jackcess/version"
+require_relative "jackcess/type_converter"
+require_relative "jackcess/database"
+require_relative "jackcess/table"
+require_relative "jackcess/row"
+require_relative "jackcess/column"
+require_relative "jackcess/index"
+require_relative "jackcess/errors"
+
+module Jackcess
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: jackcess-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: java
+authors:
+- Durable Programming LLC
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies: []
+description: jackcess-rb provides a Ruby-friendly interface to the powerful Jackcess
+  Java library, enabling programmatic interaction with Access database files (.mdb
+  and .accdb) directly from JRuby.
+email:
+- commercial@durableprogramming.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/jackcess.rb
+- lib/jackcess/column.rb
+- lib/jackcess/database.rb
+- lib/jackcess/errors.rb
+- lib/jackcess/index.rb
+- lib/jackcess/row.rb
+- lib/jackcess/table.rb
+- lib/jackcess/type_converter.rb
+- lib/jackcess/version.rb
+- vendor/commons-lang3-3.13.0.jar
+- vendor/commons-logging-1.2.jar
+- vendor/jackcess-4.0.4.jar
+homepage: https://github.com/durableprogramming/jackcess-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/durableprogramming/jackcess-rb
+  source_code_uri: https://github.com/durableprogramming/jackcess-rb
+  changelog_uri: https://github.com/durableprogramming/jackcess-rb/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Java 8 or higher
+- JRuby 9.3 or higher
+rubygems_version: 3.6.9
+specification_version: 4
+summary: JRuby interface to the Jackcess library for reading and writing Microsoft
+  Access databases
+test_files: []