sequelizer 0.1.4 → 0.1.6

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

@@ -1,10 +1,12 @@
-require_relative "../../../test_helper"
-require "fileutils"
-require "pathname"
-require "sequel"
-require "sequel/extensions/make_readyable"
+require_relative '../../../test_helper'
+require 'fileutils'
+require 'tmpdir'
+require 'pathname'
+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 +17,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_settable.rb

@@ -0,0 +1,109 @@
+require_relative '../../../test_helper'
+require 'sequel'
+require 'sequel/extensions/settable'
+
+class TestSettable < Minitest::Test
+
+  def test_should_register_extension
+    db = Sequel.mock(host: :sqlite)
+
+    assert_respond_to db, :extension
+    db.extension :settable
+
+    assert_respond_to db, :set
+  end
+
+  def test_set_with_single_option
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(search_path: 'public')
+
+    assert_equal(['SET search_path=public'], db.sqls)
+  end
+
+  def test_set_with_multiple_options
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(search_path: 'public', timezone: 'UTC')
+
+    expected_sqls = ['SET search_path=public', 'SET timezone=UTC']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_empty_hash
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set({})
+
+    assert_empty(db.sqls)
+  end
+
+  def test_set_with_no_arguments
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set
+
+    assert_empty(db.sqls)
+  end
+
+  def test_set_with_string_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(work_mem: '256MB', statement_timeout: '30s')
+
+    expected_sqls = ['SET work_mem=256MB', 'SET statement_timeout=30s']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_numeric_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(port: 5432, max_connections: 100)
+
+    expected_sqls = ['SET port=5432', 'SET max_connections=100']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_boolean_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(autocommit: true, log_statement: false)
+
+    expected_sqls = ['SET autocommit=true', 'SET log_statement=false']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_nil_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(timezone: nil, search_path: nil)
+
+    expected_sqls = ['SET timezone=', 'SET search_path=']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_sql_private_method
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+
+    refute_respond_to db, :set_sql
+  end
+
+  def test_multiple_set_calls
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+
+    db.set(timezone: 'UTC')
+    db.set(search_path: 'public')
+
+    expected_sqls = ['SET timezone=UTC', 'SET search_path=public']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+end