sequelizer 0.1.4 → 0.2.0

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

@@ -1,10 +1,11 @@
-require_relative "../../../test_helper"
-require "fileutils"
-require "pathname"
-require "sequel"
-require "sequel/extensions/make_readyable"
+require_relative '../../../test_helper'
+require 'fileutils'
+require 'tmpdir'
+require 'sequel'
+require 'sequel/extensions/make_readyable'
 
 class TestUsable < Minitest::Test
+
   def setup
     # These features are mostly intended for Spark, but sqlite is a close enough
     # mock that we'll just roll with it
@@ -15,74 +16,243 @@ class TestUsable < Minitest::Test
       when :schema1
         [:a]
       when :schema2
-        [:a, :b]
+        %i[a b]
       when :schema3
-        [:a, :b]
+        %i[a b]
       end
     end
   end
 
   def test_should_call_use_schema
     @db.make_ready(use_schema: :some_schema)
-    assert_equal(["USE `some_schema`"], @db.sqls)
+
+    assert_equal(['USE `some_schema`'], @db.sqls)
   end
 
   def test_should_create_views_based_on_tables_in_search_paths
-    @db.make_ready(search_path: [:schema1, :schema2, :schema3])
+    @db.make_ready(search_path: %i[schema1 schema2 schema3])
+
     assert_equal([
-      "CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`",
-      "CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`"
-    ], @db.sqls)
+                   'CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`',
+                   'CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`',
+                 ], @db.sqls)
   end
 
   def test_should_create_views_based_on_tables_in_search_paths_passed_as_strings
-    @db.make_ready(search_path: ["schema1", "schema2", "schema3"])
+    @db.make_ready(search_path: %w[schema1 schema2 schema3])
+
     assert_equal([
-      "CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`",
-      "CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`"
-    ], @db.sqls)
+                   'CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`',
+                   'CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`',
+                 ], @db.sqls)
   end
 
   def test_should_create_views_based_on_tables_in_search_paths_accepts_except
-    @db.make_ready(search_path: [:schema1, :schema2, :schema3], except: :a)
+    @db.make_ready(search_path: %i[schema1 schema2 schema3], except: :a)
+
     assert_equal([
-      "CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`"
-    ], @db.sqls)
+                   'CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`',
+                 ], @db.sqls)
   end
 
   def test_should_create_views_based_on_tables_in_search_paths_accepts_only
-    @db.make_ready(search_path: [:schema1, :schema2, :schema3], only: :b)
+    @db.make_ready(search_path: %i[schema1 schema2 schema3], only: :b)
+
     assert_equal([
-      "CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`"
-    ], @db.sqls)
+                   'CREATE TEMPORARY VIEW `b` AS SELECT * FROM `schema2`.`b`',
+                 ], @db.sqls)
   end
 
   def test_should_create_views_based_on_path
     dir = Pathname.new(Dir.mktmpdir)
-    a_file = dir + "a.parquet"
-    b_file = dir + "b.parquet"
+    a_file = dir.join('a.parquet')
+    b_file = dir.join('b.parquet')
     FileUtils.touch(a_file.to_s)
     FileUtils.touch(b_file.to_s)
 
     @db.make_ready(search_path: [:schema1, a_file, b_file, :schema2])
     sqls = @db.sqls.dup
-    assert_equal("CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`", sqls[0])
+
+    assert_equal('CREATE TEMPORARY VIEW `a` AS SELECT * FROM `schema1`.`a`', sqls[0])
     assert_match(%r{CREATE TEMPORARY VIEW `b` USING parquet OPTIONS \('path'='/tmp/[^/]+/b.parquet'\)}, sqls[1])
   end
 
   def test_should_create_views_format_based_on_path
     dir = Pathname.new(Dir.mktmpdir)
-    a_file = dir + "a.parquet"
-    b_file = dir + "b.delta"
-    c_file = dir + "c.csv"
+    a_file = dir.join('a.parquet')
+    b_file = dir.join('b.delta')
+    c_file = dir.join('c.csv')
     FileUtils.touch(a_file.to_s)
     FileUtils.touch(b_file.to_s)
     FileUtils.touch(c_file.to_s)
 
     @db.make_ready(search_path: [a_file, b_file, c_file])
     sqls = @db.sqls.dup
+
     assert_match(%r{CREATE TEMPORARY VIEW `a` USING parquet OPTIONS \('path'='/tmp/[^/]+/a.parquet'\)}, sqls[0])
     assert_match(%r{CREATE TEMPORARY VIEW `b` USING delta OPTIONS \('path'='/tmp/[^/]+/b.delta'\)}, sqls[1])
     assert_match(%r{CREATE TEMPORARY VIEW `c` USING csv OPTIONS \('path'='/tmp/[^/]+/c.csv'\)}, sqls[2])
   end
+
+  def test_should_create_a_single_view_if_multiple_files_have_the_same_name
+    dir = Pathname.new(Dir.mktmpdir)
+    a_file = dir.join('a.parquet')
+    b_file = dir.join('a.delta')
+    c_file = dir.join('a.csv')
+    FileUtils.touch(a_file.to_s)
+    FileUtils.touch(b_file.to_s)
+    FileUtils.touch(c_file.to_s)
+
+    @db.make_ready(search_path: [a_file, b_file, c_file])
+    sqls = @db.sqls.dup
+
+    assert_equal(1, sqls.size)
+    assert_match(%r{CREATE TEMPORARY VIEW `a` USING parquet OPTIONS \('path'='/tmp/[^/]+/a.parquet'\)}, sqls[0])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING delta OPTIONS \('path'='/tmp/[^/]+/a.delta'\)}, sqls[1])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING csv OPTIONS \('path'='/tmp/[^/]+/a.csv'\)}, sqls[2])
+  end
+
+  def test_should_create_a_single_view_if_multiple_files_have_the_same_name_and_are_in_different_directories
+    dir = Pathname.new(Dir.mktmpdir)
+    a_file = dir / 'one' / 'a.parquet'
+    b_file = dir / 'two' / 'a.delta'
+    c_file = dir / 'three' / 'a.csv'
+    FileUtils.mkdir_p(a_file.dirname)
+    FileUtils.mkdir_p(b_file.dirname)
+    FileUtils.mkdir_p(c_file.dirname)
+    FileUtils.touch(a_file.to_s)
+    FileUtils.touch(b_file.to_s)
+    FileUtils.touch(c_file.to_s)
+
+    @db.make_ready(search_path: [a_file, b_file, c_file])
+    sqls = @db.sqls.dup
+
+    assert_equal(1, sqls.size)
+    assert_match(%r{CREATE TEMPORARY VIEW `a` USING parquet OPTIONS \('path'='/tmp/[^/]+/one/a.parquet'\)}, sqls[0])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING delta OPTIONS \('path'='/tmp/[^/]+/two/a.delta'\)}, sqls[1])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING csv OPTIONS \('path'='/tmp/[^/]+/three/a.csv'\)}, sqls[2])
+  end
+
+  def test_should_create_view_from_compact_style_path
+    dir = Pathname.new(Dir.mktmpdir)
+    a_file = dir / 'one' / 'a.parquet'
+    b_file = dir / 'two' / 'b.delta'
+    c_file = dir / 'three' / 'c.csv'
+    FileUtils.mkdir_p(a_file.dirname)
+    FileUtils.mkdir_p(b_file.dirname)
+    FileUtils.mkdir_p(c_file.dirname)
+    FileUtils.touch(a_file.to_s)
+    FileUtils.touch(b_file.to_s)
+    FileUtils.touch(c_file.to_s)
+
+    @db.make_ready(search_path: [Dir["#{dir}/{one,two,three}"].map { |path| Pathname.new(path).glob('*') }])
+    sqls = @db.sqls.dup
+
+    assert_equal(3, sqls.size)
+    assert_match(%r{CREATE TEMPORARY VIEW `a` USING parquet OPTIONS \('path'='/tmp/[^/]+/one/a.parquet'\)}, sqls[0])
+    assert_match(%r{CREATE TEMPORARY VIEW `b` USING delta OPTIONS \('path'='/tmp/[^/]+/two/b.delta'\)}, sqls[1])
+    assert_match(%r{CREATE TEMPORARY VIEW `c` USING csv OPTIONS \('path'='/tmp/[^/]+/three/c.csv'\)}, sqls[2])
+  end
+
+  def test_should_create_view_from_compact_style_path_with_multiple_files
+    dir = Pathname.new(Dir.mktmpdir)
+    a_file = dir / 'one' / 'a.parquet'
+    b_file = dir / 'two' / 'a.delta'
+    c_file = dir / 'three' / 'a.csv'
+    FileUtils.mkdir_p(a_file.dirname)
+    FileUtils.mkdir_p(b_file.dirname)
+    FileUtils.mkdir_p(c_file.dirname)
+    FileUtils.touch(a_file.to_s)
+    FileUtils.touch(b_file.to_s)
+    FileUtils.touch(c_file.to_s)
+
+    @db.make_ready(search_path: [Dir["#{dir}/{one,two,three}"].map { |path| Pathname.new(path).glob('*') }])
+    sqls = @db.sqls.dup
+
+    assert_equal(1, sqls.size)
+    assert_match(%r{CREATE TEMPORARY VIEW `a` USING parquet OPTIONS \('path'='/tmp/[^/]+/one/a.parquet'\)}, sqls[0])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING delta OPTIONS \('path'='/tmp/[^/]+/two/a.delta'\)}, sqls[1])
+    refute_match(%r{CREATE TEMPORARY VIEW `a` USING csv OPTIONS \('path'='/tmp/[^/]+/three/a.csv'\)}, sqls[2])
+  end
+
+  def test_duckdb_external_file_support
+    # Test DuckDB - uses read_* functions for external files
+    duckdb_db = Sequel.mock
+    duckdb_db.extension :make_readyable
+    def duckdb_db.database_type
+      :duckdb
+    end
+
+    dir = Pathname.new(Dir.mktmpdir)
+    parquet_file = dir / 'test.parquet'
+    csv_file = dir / 'test.csv'
+    json_file = dir / 'test.json'
+    FileUtils.touch(parquet_file.to_s)
+    FileUtils.touch(csv_file.to_s)
+    FileUtils.touch(json_file.to_s)
+
+    # Test parquet file
+    duckdb_db.make_ready(search_path: [parquet_file])
+
+    assert_match(/CREATE VIEW \w*test\w* AS SELECT \* FROM read_parquet\('.*test\.parquet'\)/, duckdb_db.sqls.last)
+
+    # Test CSV file
+    duckdb_db.sqls.clear
+    duckdb_db.make_ready(search_path: [csv_file])
+
+    assert_match(/CREATE VIEW \w*test\w* AS SELECT \* FROM read_csv_auto\('.*test\.csv'\)/, duckdb_db.sqls.last)
+
+    # Test JSON file
+    duckdb_db.sqls.clear
+    duckdb_db.make_ready(search_path: [json_file])
+
+    assert_match(/CREATE VIEW \w*test\w* AS SELECT \* FROM read_json_auto\('.*test\.json'\)/, duckdb_db.sqls.last)
+  end
+
+  def test_unsupported_file_format_for_duckdb
+    # Test unsupported file format for DuckDB
+    duckdb_db = Sequel.mock
+    duckdb_db.extension :make_readyable
+    def duckdb_db.database_type
+      :duckdb
+    end
+
+    dir = Pathname.new(Dir.mktmpdir)
+    orc_file = dir / 'test.orc'
+    FileUtils.touch(orc_file.to_s)
+
+    error = assert_raises(Sequel::Error) do
+      duckdb_db.make_ready(search_path: [orc_file])
+    end
+    assert_match(/Unsupported file format 'orc' for DuckDB/, error.message)
+  end
+
+  def test_duckdb_directory_support
+    # Test DuckDB with directory paths (globbing)
+    duckdb_db = Sequel.mock
+    duckdb_db.extension :make_readyable
+    def duckdb_db.database_type
+      :duckdb
+    end
+
+    # Mock directory? to return true
+    dir = Pathname.new(Dir.mktmpdir)
+    def dir.directory?
+      true
+    end
+
+    file_sourcerer = Sequel::ReadyMaker::FileSourcerer.new(duckdb_db, dir)
+
+    # Override format to return parquet
+    def file_sourcerer.format
+      'parquet'
+    end
+
+    # For directory support, DuckDB should use globbing pattern
+    file_sourcerer.create_view(:test_table)
+
+    assert_match(%r{CREATE VIEW \w*test_table\w* AS SELECT \* FROM read_parquet\('.*/\*\*/\*\.parquet'\)},
+                 duckdb_db.sqls.last)
+  end
+
 end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'sequel'
+require 'sequel/extensions/more_sql'
+
+class TestMoreSql < Minitest::Test
+
+  def setup
+    @db = Sequel.mock
+    @db.extension :more_sql
+  end
+
+  def test_create_schema_with_symbol_name
+    @db.create_schema(:test_schema)
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA test_schema', sqls.first
+  end
+
+  def test_create_schema_with_string_name
+    @db.create_schema('my_schema')
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal "CREATE SCHEMA 'my_schema'", sqls.first
+  end
+
+  def test_create_schema_with_if_not_exists_option
+    @db.create_schema(:analytics, if_not_exists: true)
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA IF NOT EXISTS analytics', sqls.first
+  end
+
+  def test_create_schema_without_if_not_exists_option
+    @db.create_schema(:reports, if_not_exists: false)
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA reports', sqls.first
+  end
+
+  def test_create_schema_with_empty_options
+    @db.create_schema(:staging, {})
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA staging', sqls.first
+  end
+
+  def test_create_schema_with_special_characters_in_name
+    @db.create_schema('schema-with-dashes')
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal "CREATE SCHEMA 'schema-with-dashes'", sqls.first
+  end
+
+  def test_create_schema_returns_nil
+    result = @db.create_schema(:test)
+
+    assert_nil result
+  end
+
+  def test_create_schema_multiple_calls
+    @db.create_schema(:first_schema)
+    @db.create_schema(:second_schema, if_not_exists: true)
+    @db.create_schema('third_schema')
+
+    sqls = @db.sqls
+
+    assert_equal 3, sqls.length
+    assert_equal 'CREATE SCHEMA first_schema', sqls[0]
+    assert_equal 'CREATE SCHEMA IF NOT EXISTS second_schema', sqls[1]
+    assert_equal "CREATE SCHEMA 'third_schema'", sqls[2]
+  end
+
+  def test_extension_registration
+    assert_respond_to Sequel::Database, :extension
+
+    db = Sequel.mock
+
+    assert_respond_to db, :extension
+
+    db.extension :more_sql
+
+    assert_respond_to db, :create_schema
+  end
+
+  def test_create_schema_with_qualified_name
+    @db.create_schema(Sequel[:public][:my_schema])
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_match(/CREATE SCHEMA/, sqls.first)
+  end
+
+  def test_create_schema_with_identifier
+    @db.create_schema(Sequel.identifier(:test_schema))
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA test_schema', sqls.first
+  end
+
+  def test_create_schema_handles_nil_options
+    @db.create_schema(:test_schema)
+
+    sqls = @db.sqls
+
+    assert_equal 1, sqls.length
+    assert_equal 'CREATE SCHEMA test_schema', sqls.first
+  end
+
+  def test_private_create_schema_sql_method_not_accessible
+    assert_raises(NoMethodError) do
+      @db.create_schema_sql(:test, {})
+    end
+  end
+
+end

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