sequelizer 0.1.6 → 0.2.0

data/lib/sequel/extensions/platform.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+#
+# The platform extension provides a unified interface for platform-specific
+# database behavior. It uses KVCSV configuration files to define capabilities
+# and preferences, with Ruby classes only for function translations.
+#
+#   DB.extension :platform
+#   DB.platform.supports?(:cte)           # => true (from config)
+#   DB.platform.prefers?(:cte)            # => true (from config)
+#   DB.platform[:interim_schema]          # => nil (from config)
+#   DB.platform.date_diff(from, to)       # => Sequel expression (from code)
+#
+# Configuration is loaded from CSV files in config/platforms/:
+#   - base.csv: conservative defaults
+#   - rdbms/<adapter>.csv: RDBMS-specific overrides
+#   - Additional configs can be stacked via platform_configs option
+#
+# Related module: Sequel::Platform
+
+require 'kvcsv'
+
+module Sequel
+
+  # The Platform module provides database platform abstraction through
+  # configuration-driven capabilities and code-driven function translations.
+  module Platform
+
+    # Base platform class with KVCSV config loading and default implementations.
+    # Subclasses override function translation methods for platform-specific SQL.
+    class Base
+
+      attr_reader :db, :config
+
+      # Initialize platform with database connection and config paths.
+      #
+      # @param db [Sequel::Database] The database connection
+      # @param config_paths [Array<String>] Paths to CSV config files (stacked in order)
+      def initialize(db, *config_paths)
+        @db = db
+        @config = config_paths.empty? ? {} : KVCSV::Settings.new(*config_paths)
+      end
+
+      # Check if the platform supports a feature.
+      #
+      # @param feature [Symbol] Feature name (e.g., :cte, :temp_tables)
+      # @return [Boolean] true if supported
+      #
+      # @example
+      #   platform.supports?(:cte)           # checks supports_cte in config
+      #   platform.supports?(:temp_tables)   # checks supports_temp_tables in config
+      def supports?(feature)
+        config[:"supports_#{feature}"] || false
+      end
+
+      # Check if the platform prefers a feature (may support but not prefer).
+      #
+      # @param feature [Symbol] Feature name (e.g., :cte, :parquet)
+      # @return [Boolean] true if preferred
+      #
+      # @example
+      #   platform.prefers?(:cte)      # Spark supports CTEs but doesn't prefer them
+      #   platform.prefers?(:parquet)  # Spark prefers parquet format
+      def prefers?(feature)
+        config[:"prefers_#{feature}"] || false
+      end
+
+      # Access arbitrary config values.
+      #
+      # @param key [Symbol] Config key
+      # @return [Object] Config value or nil
+      #
+      # @example
+      #   platform[:interim_schema]           # => "scratch"
+      #   platform[:schema_switching_method]  # => "use"
+      def [](key)
+        config[key]
+      end
+
+      # Fetch config value with default.
+      #
+      # @param key [Symbol] Config key
+      # @param default [Object] Default value if key not found
+      # @return [Object] Config value or default
+      def fetch(key, default = nil)
+        config.respond_to?(:fetch) ? config.fetch(key, default) : (config[key] || default)
+      end
+
+      # ---- Function translations (override in subclasses) ----
+
+      # Calculate date difference between two dates.
+      #
+      # @param from [Symbol, Sequel::SQL::Expression] Start date
+      # @param to [Symbol, Sequel::SQL::Expression] End date
+      # @return [Sequel::SQL::Expression] Date difference expression
+      def date_diff(from, to)
+        Sequel.function(:datediff, from, to)
+      end
+
+      # Cast expression to date type.
+      #
+      # @param expr [Object] Expression to cast
+      # @return [Sequel::SQL::Cast] Cast expression
+      def cast_date(expr)
+        Sequel.cast(expr, Date)
+      end
+
+      # Parse string to date with format.
+      #
+      # @param value [Object] String value to parse
+      # @param format [String] Date format string
+      # @return [Sequel::SQL::Expression] Parsed date expression
+      def str_to_date(value, format)
+        Sequel.function(:to_date, value, format)
+      end
+
+      # Calculate days between two dates.
+      #
+      # @param from [Symbol, Sequel::SQL::Expression] Start date
+      # @param to [Symbol, Sequel::SQL::Expression] End date
+      # @return [Sequel::SQL::Expression] Days between expression
+      def days_between(from, to)
+        date_diff(from, to)
+      end
+
+    end
+
+    # PostgreSQL platform with Postgres-specific function translations.
+    class Postgres < Base
+
+      def date_diff(from, to)
+        # Postgres uses date subtraction
+        Sequel.lit('(? - ?)', to, from)
+      end
+
+      def days_between(from, to)
+        # Postgres date subtraction returns integer days
+        Sequel.lit('(? - ?)', to, from)
+      end
+
+    end
+
+    # Spark platform with Spark SQL-specific function translations.
+    class Spark < Base
+
+      def date_diff(from, to)
+        # Spark datediff has reversed argument order (end, start)
+        Sequel.function(:datediff, to, from)
+      end
+
+      def str_to_date(value, format)
+        Sequel.function(:to_date, Sequel.cast_string(value), format)
+      end
+
+    end
+
+    # Snowflake platform with Snowflake-specific function translations.
+    class Snowflake < Base
+
+      def date_diff(from, to)
+        # Snowflake requires unit parameter
+        Sequel.function(:datediff, 'day', from, to)
+      end
+
+      def days_between(from, to)
+        Sequel.function(:datediff, 'day', from, to)
+      end
+
+    end
+
+    # Athena platform (Presto/Trino based) with Athena-specific function translations.
+    class Athena < Base
+
+      def date_diff(from, to)
+        # Athena/Presto uses date_diff with unit
+        Sequel.function(:date_diff, 'day', from, to)
+      end
+
+      def days_between(from, to)
+        Sequel.function(:date_diff, 'day', from, to)
+      end
+
+    end
+
+    # Map adapter schemes to platform classes
+    PLATFORM_CLASSES = {
+      postgres: Postgres,
+      postgresql: Postgres,
+      spark: Spark,
+      athena: Athena,
+      presto: Athena,
+      trino: Athena,
+      snowflake: Snowflake,
+    }.freeze
+
+    # Map adapter schemes to config file names
+    ADAPTER_CONFIG_NAMES = {
+      postgres: 'postgres',
+      postgresql: 'postgres',
+      spark: 'spark',
+      athena: 'athena',
+      presto: 'athena',
+      trino: 'athena',
+      snowflake: 'snowflake',
+    }.freeze
+
+    class << self
+
+      # Find the config directory, searching gem paths
+      def config_dir
+        @config_dir ||= find_config_dir
+      end
+
+      # Allow overriding config dir for testing
+      attr_writer :config_dir
+
+      private
+
+      def find_config_dir
+        # Check relative to this file (gem's config)
+        gem_config = File.expand_path('../../../config/platforms', __dir__)
+        return gem_config if File.directory?(gem_config)
+
+        # Fallback to working directory
+        local_config = File.join(Dir.pwd, 'config/platforms')
+        return local_config if File.directory?(local_config)
+
+        nil
+      end
+
+    end
+
+    # Build config paths for the given adapter
+    #
+    # @param adapter_scheme [Symbol] Database adapter scheme
+    # @param extra_configs [Array<String>] Additional config paths to stack
+    # @return [Array<String>] Ordered config paths
+    def self.config_paths_for(adapter_scheme, extra_configs = [])
+      paths = []
+
+      if config_dir
+        base_config = File.join(config_dir, 'base.csv')
+        paths << base_config if File.exist?(base_config)
+
+        adapter_name = ADAPTER_CONFIG_NAMES[adapter_scheme]
+        if adapter_name
+          rdbms_config = File.join(config_dir, 'rdbms', "#{adapter_name}.csv")
+          paths << rdbms_config if File.exist?(rdbms_config)
+        end
+      end
+
+      paths.concat(extra_configs.select { |p| File.exist?(p) })
+      paths
+    end
+
+    # Build platform instance for database
+    #
+    # @param db [Sequel::Database] Database connection
+    # @param extra_configs [Array<String>] Additional config paths
+    # @return [Platform::Base] Platform instance
+    def self.build_platform(db, extra_configs = [])
+      adapter = effective_adapter(db)
+      platform_class = PLATFORM_CLASSES.fetch(adapter, Base)
+      config_paths = config_paths_for(adapter, extra_configs)
+      platform_class.new(db, *config_paths)
+    end
+
+    # Detect the effective adapter for platform selection.
+    # For mock databases, use database_type or host option; otherwise use adapter_scheme.
+    #
+    # @param db [Sequel::Database] Database connection
+    # @return [Symbol] Effective adapter type
+    def self.effective_adapter(db)
+      return db.adapter_scheme unless db.adapter_scheme == :mock
+
+      # Mock databases: try database_type first (set for known types like postgres, spark)
+      db_type = db.database_type
+      return db_type if db_type && db_type != :mock
+
+      # Fall back to host option (for unknown types like snowflake, athena)
+      db.opts[:host]
+    end
+
+    # Extension hook - called when extension is loaded
+    def self.extended(db)
+      extra_configs = db.opts[:platform_configs] || []
+      db.instance_variable_set(:@platform, build_platform(db, extra_configs))
+    end
+
+    # Access the platform instance
+    #
+    # @return [Platform::Base] Platform instance for this database
+    def platform
+      @platform
+    end
+
+  end
+
+  Database.register_extension(:platform, Platform)
+
+end

data/lib/sequelizer/options.rb

@@ -1,3 +1,4 @@
+require 'uri'
 require_relative 'yaml_config'
 require_relative 'env_config'
 require_relative 'options_hash'
@@ -98,7 +99,10 @@ module Sequelizer
       opts = OptionsHash.new(passed_options || {}).to_hash
       sequelizer_options = db_config(opts).merge(opts)
 
-      if sequelizer_options[:adapter] =~ /^postgres/
+      adapter = sequelizer_options[:adapter]
+      adapter ||= URI.parse(sequelizer_options[:url].to_s).scheme if sequelizer_options[:url]
+
+      if adapter =~ /^postgres/
         sequelizer_options[:adapter] = 'postgres'
         paths = %w[search_path schema_search_path schema].map { |key| sequelizer_options.delete(key) }.compact
 

data/lib/sequelizer/version.rb

@@ -1,6 +1,6 @@
 module Sequelizer
 
   # Version for the gem
-  VERSION = '0.1.6'.freeze
+  VERSION = '0.2.0'.freeze
 
 end

data/lib/sequelizer/yaml_config.rb

@@ -1,5 +1,4 @@
 require 'psych'
-require 'pathname'
 require 'erb'
 
 module Sequelizer

data/sequelizer.gemspec

@@ -17,18 +17,21 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 3.2.0'
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'bundler', '>= 2.0'
   spec.add_development_dependency 'guard', '~> 2.0'
-  spec.add_development_dependency 'guard-minitest', '~> 2.3'
-  spec.add_development_dependency 'minitest', '~> 5.3'
+  spec.add_development_dependency 'guard-minitest', '~> 3.0'
+  spec.add_development_dependency 'minitest', '~> 6.0'
+  spec.add_development_dependency 'minitest-mock', '~> 5.27'
   spec.add_development_dependency 'pg', '~> 1.0'
-  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rake', '~> 13.3'
   spec.add_development_dependency 'rubocop', '~> 1.0'
   spec.add_development_dependency 'rubocop-minitest', '~> 0.25'
   spec.add_development_dependency 'simplecov', '~> 0.22'
-  spec.add_dependency 'activesupport', '~> 7.0'
-  spec.add_dependency 'dotenv', '~> 2.1'
-  spec.add_dependency 'hashie', '~> 3.2'
+  spec.add_dependency 'activesupport', '>= 7', '< 9'
+  spec.add_dependency 'dotenv', '>= 2.1', '< 4.0'
+  spec.add_dependency 'hashie', '>= 3.2', '< 6.0'
+  spec.add_dependency 'kvcsv', '~> 0.1'
+  spec.add_dependency 'pp'
   spec.add_dependency 'sequel', '~> 5.93'
   spec.add_dependency 'thor', '~> 1.0'
   spec.metadata['rubygems_mfa_required'] = 'true'

data/test/lib/sequel/extensions/test_cold_col.rb

@@ -19,8 +19,8 @@ describe Sequel::ColdColDatabase do
     end
 
     # Add with method to mock database to support CTEs
-    def @db.with(*args)
-      dataset.with(*args)
+    def @db.with(*)
+      dataset.with(*)
     end
 
     @db

data/test/lib/sequel/extensions/test_make_readyable.rb

@@ -1,7 +1,6 @@
 require_relative '../../../test_helper'
 require 'fileutils'
 require 'tmpdir'
-require 'pathname'
 require 'sequel'
 require 'sequel/extensions/make_readyable'
 

data/test/lib/sequel/extensions/test_platform.rb

@@ -0,0 +1,222 @@
+require_relative '../../../test_helper'
+require 'sequel'
+require 'sequel/extensions/platform'
+
+class TestPlatform < Minitest::Test
+
+  def setup
+    # Point to the gem's config directory
+    @original_config_dir = Sequel::Platform.config_dir
+    Sequel::Platform.config_dir = File.expand_path('../../../../config/platforms', __dir__)
+  end
+
+  def teardown
+    Sequel::Platform.config_dir = @original_config_dir
+  end
+
+  # --- Extension Registration ---
+
+  def test_should_register_extension
+    db = Sequel.mock(host: :postgres)
+
+    assert_respond_to db, :extension
+
+    db.extension :platform
+
+    assert_respond_to db, :platform
+  end
+
+  def test_platform_returns_platform_instance
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Base, db.platform
+  end
+
+  # --- Platform Class Selection ---
+
+  def test_selects_postgres_platform_for_postgres_adapter
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Postgres, db.platform
+  end
+
+  def test_selects_spark_platform_for_spark_adapter
+    db = Sequel.mock(host: :spark)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Spark, db.platform
+  end
+
+  def test_selects_snowflake_platform_for_snowflake_adapter
+    db = Sequel.mock(host: :snowflake)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Snowflake, db.platform
+  end
+
+  def test_selects_athena_platform_for_athena_adapter
+    db = Sequel.mock(host: :athena)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Athena, db.platform
+  end
+
+  def test_selects_athena_platform_for_presto_adapter
+    db = Sequel.mock(host: :presto)
+    db.extension :platform
+
+    assert_kind_of Sequel::Platform::Athena, db.platform
+  end
+
+  def test_selects_base_platform_for_unknown_adapter
+    db = Sequel.mock(host: :sqlite)
+    db.extension :platform
+
+    assert_instance_of Sequel::Platform::Base, db.platform
+  end
+
+  # --- Config Loading ---
+
+  def test_supports_returns_boolean_from_config
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert db.platform.supports?(:cte)
+    assert db.platform.supports?(:cte_recursive)
+  end
+
+  def test_supports_returns_false_for_unsupported_feature
+    db = Sequel.mock(host: :athena)
+    db.extension :platform
+
+    refute db.platform.supports?(:temp_tables)
+    refute db.platform.supports?(:cte_recursive)
+  end
+
+  def test_prefers_returns_boolean_from_config
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert db.platform.prefers?(:cte)
+  end
+
+  def test_prefers_returns_false_when_not_preferred
+    db = Sequel.mock(host: :spark)
+    db.extension :platform
+
+    refute db.platform.prefers?(:cte)
+    assert db.platform.prefers?(:parquet)
+  end
+
+  def test_bracket_access_returns_config_values
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert_equal 'search_path', db.platform[:schema_switching_method]
+  end
+
+  def test_config_stacking_overrides_base
+    db = Sequel.mock(host: :athena)
+    db.extension :platform
+
+    # Athena overrides base supports_temp_tables from true to false
+    refute db.platform.supports?(:temp_tables)
+    # Athena overrides drop_table_needs_unquoted from false to true
+    assert db.platform[:drop_table_needs_unquoted]
+  end
+
+  # --- Function Translations ---
+
+  def test_postgres_date_diff_uses_subtraction
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    expr = db.platform.date_diff(:start_date, :end_date)
+
+    # Should produce subtraction syntax - use dataset.literal to get SQL
+    sql = db.literal(expr)
+
+    assert_includes sql, '-'
+  end
+
+  def test_spark_date_diff_uses_datediff_function
+    db = Sequel.mock(host: :spark)
+    db.extension :platform
+
+    expr = db.platform.date_diff(:start_date, :end_date)
+
+    # Should use datediff function with reversed args
+    sql = db.literal(expr)
+
+    assert_includes sql.downcase, 'datediff'
+  end
+
+  def test_snowflake_date_diff_includes_day_unit
+    db = Sequel.mock(host: :snowflake)
+    db.extension :platform
+
+    expr = db.platform.date_diff(:start_date, :end_date)
+
+    sql = db.literal(expr)
+
+    assert_includes sql.downcase, 'datediff'
+    assert_includes sql, 'day'
+  end
+
+  def test_athena_date_diff_uses_date_diff_function
+    db = Sequel.mock(host: :athena)
+    db.extension :platform
+
+    expr = db.platform.date_diff(:start_date, :end_date)
+
+    sql = db.literal(expr)
+
+    assert_includes sql.downcase, 'date_diff'
+    assert_includes sql, 'day'
+  end
+
+  def test_cast_date_returns_cast_expression
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    expr = db.platform.cast_date(:some_column)
+
+    assert_kind_of Sequel::SQL::Cast, expr
+  end
+
+  # --- Edge Cases ---
+
+  def test_supports_unknown_feature_returns_false
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    refute db.platform.supports?(:nonexistent_feature)
+  end
+
+  def test_prefers_unknown_feature_returns_false
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    refute db.platform.prefers?(:nonexistent_feature)
+  end
+
+  def test_bracket_access_unknown_key_returns_nil
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    assert_nil db.platform[:nonexistent_key]
+  end
+
+  def test_fetch_with_default
+    db = Sequel.mock(host: :postgres)
+    db.extension :platform
+
+    # Known key
+    assert_equal 'search_path', db.platform.fetch(:schema_switching_method, 'default')
+    # Unknown key
+    assert_equal 'default', db.platform.fetch(:unknown_key, 'default')
+  end
+
+end

data/test/lib/sequelizer/test_connection_maker.rb

@@ -15,10 +15,10 @@ class TestConnectionMaker < Minitest::Test
 
   def with_ignored_yaml_config(opts = {}); end
 
-  def with_yaml_config(options = {}, &block)
+  def with_yaml_config(options = {}, &)
     yaml_config = Sequelizer::YamlConfig.new
     yaml_config.stub(:options, options) do
-      Sequelizer::YamlConfig.stub :new, yaml_config, &block
+      Sequelizer::YamlConfig.stub(:new, yaml_config, &)
     end
   end
 

data/test/lib/sequelizer/test_gemfile_modifier.rb

@@ -79,9 +79,9 @@ class TestGemfileModifier < Minitest::Test
     pn_mock.expect(:exist?, true)
   end
 
-  def stub_modifying_methods(obj, &block)
+  def stub_modifying_methods(obj, &)
     obj.stub(:system, nil) do
-      obj.stub(:puts, nil, &block)
+      obj.stub(:puts, nil, &)
     end
   end
 

data/test/lib/sequelizer/test_options.rb

@@ -72,6 +72,34 @@ class TestOptions < Minitest::Test
     assert_equal(['SELECT * FROM "table"'], db.sqls)
   end
 
+  def test_url_based_connection_processes_search_path
+    options = Sequelizer::Options.new(
+      Sequelizer::OptionsHash.new(url: 'postgres://localhost/mydb', search_path: 'my_schema'),
+    )
+
+    assert_equal('my_schema', options.search_path)
+    assert_instance_of(Proc, options.to_hash[:after_connect])
+  end
+
+  def test_url_based_connection_processes_schema_as_search_path
+    options = Sequelizer::Options.new(
+      Sequelizer::OptionsHash.new(url: 'postgresql://localhost/mydb', schema: 'my_schema'),
+    )
+
+    assert_equal('my_schema', options.search_path)
+  end
+
+  def test_url_based_connection_skips_search_path_processing_for_non_postgres
+    options = Sequelizer::Options.new(
+      Sequelizer::OptionsHash.new(url: 'mysql2://localhost/mydb', search_path: 'my_schema'),
+    )
+
+    # search_path key remains but is NOT processed (no schema creation callback)
+    assert_equal('my_schema', options.search_path)
+    # adapter should not be normalized to 'postgres'
+    assert_nil(options.adapter)
+  end
+
   def test_handles_extensions_passed_in
     options = Sequelizer::Options.new(extension_example_one: 1, extension_example_two: 1, not_an_extension_example: 1)
 

data/test/test_helper.rb

@@ -23,6 +23,7 @@ SimpleCov.start do
 end
 
 require 'minitest/autorun'
+require 'minitest/mock'
 require 'sequel'
 
 module Minitest