sequelizer 0.1.6 → 0.3.0

data/sequelizer.gemspec

@@ -1,35 +0,0 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'sequelizer/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'sequelizer'
-  spec.version       = Sequelizer::VERSION
-  spec.authors       = ['Ryan Duryea']
-  spec.email         = ['aguynamedryan@gmail.com']
-  spec.summary       = 'Sequel database connections via config/database.yml or .env'
-  spec.description   = 'Easily establish a connection to a database via Sequel gem using options specified in config/database.yml or .env files'
-  spec.homepage      = 'https://github.com/outcomesinsights/sequelizer'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 3.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 'pg', '~> 1.0'
-  spec.add_development_dependency 'rake', '~> 12.0'
-  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 'sequel', '~> 5.93'
-  spec.add_dependency 'thor', '~> 1.0'
-  spec.metadata['rubygems_mfa_required'] = 'true'
-end

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

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../test_helper'
-require_relative '../../../../lib/sequel/extensions/cold_col'
-
-describe Sequel::ColdColDatabase do
-  let(:db) do
-    @db = Sequel.mock.extension(:cold_col)
-    @db.cold_col_registry.set_schemas({
-                                        Sequel.lit('tab1') => [[:col1]],
-                                        Sequel.lit('tab2') => [[:col2]],
-                                        Sequel.lit('tab3') => [[:col3], [:col4]],
-                                        Sequel.lit('q.tab4') => [[:col5]],
-                                      })
-    @db.extend_datasets do
-      def supports_cte?
-        true
-      end
-    end
-
-    # Add with method to mock database to support CTEs
-    def @db.with(*args)
-      dataset.with(*args)
-    end
-
-    @db
-  end
-
-  def expect_columns(ds, *cols)
-    _(ds.columns).must_equal(cols)
-  end
-
-  it 'should know columns from select * FROM tab' do
-    expect_columns(db[:tab1], :col1)
-  end
-
-  it 'should know columns after append' do
-    expect_columns(db[:tab1].select_append(Sequel.function(:min, :col1).as(:mini)), :col1, :mini)
-  end
-
-  it 'should know columns after select_all' do
-    expect_columns(db[:tab1].select_all, :col1)
-  end
-
-  it 'should know columns after select_all(:tab1)' do
-    expect_columns(db[:tab1].select_all(:tab1), :col1)
-  end
-
-  it 'should know columns after from_self' do
-    expect_columns(db[:tab1].from_self, :col1)
-  end
-
-  it 'should know columns after a CTE' do
-    ds = db[:cte1]
-         .with(:cte1, db[:tab1])
-    expect_columns(ds, :col1)
-  end
-
-  it 'should know columns after a JOIN' do
-    ds = db[:tab1]
-         .join(:tab2)
-    expect_columns(ds, :col1, :col2)
-  end
-
-  it 'should know columns after a different kind of JOIN' do
-    ds = db[:tab1]
-         .join(db[:tab2])
-    expect_columns(ds, :col1, :col2)
-  end
-
-  it 'should know columns from a JOIN and CTE' do
-    ds = db[:tab1]
-         .with(:cte1, db[:tab2])
-         .join(db[:cte1])
-    expect_columns(ds, :col1, :col2)
-  end
-
-  it 'should know columns from a select_all JOIN' do
-    ds = db[:tab1]
-         .join(db[:tab2], { Sequel[:tab1][:col1] => Sequel[:tab2][:col3] })
-         .select_all(:tab1)
-    expect_columns(ds, :col1)
-  end
-
-  it 'should know columns from an aliased select_all JOIN' do
-    ds = db[:tab1].from_self(alias: :l)
-                  .join(db[:tab2], { col3: :col1 })
-                  .select_all(:l)
-    expect_columns(ds, :col1)
-  end
-
-  it 'should know columns from an aliased select_all and added rhs column JOIN' do
-    ds = db[:tab1].from_self(alias: :l)
-                  .join(db[:tab2], { col3: :col1 }, table_alias: :r)
-                  .select_all(:l)
-                  .select_append(Sequel[:r][:col4])
-    expect_columns(ds, :col1, :col4)
-  end
-
-  it 'should know columns from an aliased select_all rhs JOIN' do
-    ds = db[:tab1].from_self(alias: :l)
-                  .join(db[:tab2], { col3: :col1 }, table_alias: :r)
-                  .select_all(:r)
-    expect_columns(ds, :col2)
-  end
-
-  it 'should know columns from a directly aliased select_all rhs JOIN' do
-    ds = db[:tab1].from_self(alias: :l)
-                  .join(:tab2, { col3: :col1 }, table_alias: :r)
-                  .select_all(:r)
-    expect_columns(ds, :col2)
-  end
-
-  it 'should know columns from a a qualified JOIN' do
-    ds = db[:tab1].from_self(alias: :l)
-                  .join(Sequel[:q][:tab4], { col3: :col1 }, table_alias: :r)
-                  .select_all(:r)
-    expect_columns(ds, :col5)
-  end
-  it 'should remember columns from ctas' do
-    db.create_table(:ctas_table, as: db.select(Sequel[1].as(:a)))
-    ds = db[:ctas_table]
-    expect_columns(ds, :a)
-  end
-
-  it 'should remember columns from create table' do
-    db.create_table(:ddl_table) do
-      String :a
-    end
-    ds = db[:ddl_table]
-    expect_columns(ds, :a)
-  end
-
-  it 'should remember columns from view' do
-    db.create_view(:ctas_view, db.select(Sequel[1].as(:a)))
-    ds = db[:ctas_view]
-    expect_columns(ds, :a)
-  end
-
-  it 'should ignore columns when asked, thus avoiding an issue with string-only SQL' do
-    assert_raises(NoMethodError) { db.create_view(:ctas_view, 'SELECT 1 AS A') }
-    db.create_view(:ctas_view, 'SELECT 1 AS A', dont_record: true)
-  end
-
-  it 'should handle load_schema with empty file' do
-    require 'tempfile'
-    require 'yaml'
-
-    Tempfile.create(['schema', '.yml']) do |f|
-      f.write({}.to_yaml)
-      f.flush
-
-      db.load_schema(f.path)
-      # Should not raise error and schemas should remain unchanged
-      expect_columns(db[:tab1], :col1)
-    end
-  end
-
-  it 'should handle add_table_schema with symbol and string table names' do
-    db.add_table_schema(:new_table, [[:col_a, {}], [:col_b, {}]])
-    db.add_table_schema('string_table', [[:col_c, {}]])
-
-    expect_columns(db[:new_table], :col_a, :col_b)
-    expect_columns(db[:string_table], :col_c)
-  end
-
-  it 'should handle complex nested CTEs' do
-    ds = db.with(:cte1, db[:tab1])
-           .with(:cte2, db[:cte1].select(:col1))
-           .from(:cte2)
-    expect_columns(ds, :col1)
-  end
-
-  it 'should handle qualified table names in schema' do
-    expect_columns(db[Sequel[:q][:tab4]], :col5)
-  end
-
-  it 'should handle aliased expressions in select' do
-    ds = db[:tab1].select(Sequel[:col1].as(:renamed_col))
-    expect_columns(ds, :renamed_col)
-  end
-
-  it 'should handle function calls with aliases' do
-    ds = db[:tab1].select(Sequel.function(:count, :col1).as(:count_col1))
-    expect_columns(ds, :count_col1)
-  end
-
-  it 'should handle multiple table joins with mixed syntax' do
-    ds = db[:tab1]
-         .join(:tab2, { col2: :col1 })
-         .join(db[:tab3].as(:t3), { col3: :col1 })
-    expect_columns(ds, :col1, :col2, :col3, :col4)
-  end
-
-  it 'should handle recursive schema merging with load_schema' do
-    require 'tempfile'
-    require 'yaml'
-
-    # First schema file
-    Tempfile.create(['schema1', '.yml']) do |f1|
-      f1.write({ 'initial_table' => { columns: { 'col_x' => {} } } }.to_yaml)
-      f1.flush
-      db.load_schema(f1.path)
-
-      # Second schema file
-      Tempfile.create(['schema2', '.yml']) do |f2|
-        f2.write({ 'second_table' => { columns: { 'col_y' => {} } } }.to_yaml)
-        f2.flush
-        db.load_schema(f2.path)
-
-        # Both schemas should be available
-        expect_columns(db[:initial_table], :col_x)
-        expect_columns(db[:second_table], :col_y)
-      end
-    end
-  end
-
-  # Additional tests to ensure refactoring preserves behavior
-  describe 'Internal schema lookup behavior' do
-    it 'should prioritize created tables over schemas' do
-      db.add_table_schema(:priority_test, [[:schema_col, {}]])
-      db.create_table(:priority_test) do
-        String :created_col
-      end
-      expect_columns(db[:priority_test], :created_col)
-    end
-
-    it 'should handle deeply nested WITH clauses' do
-      ds = db[:cte1]
-           .with(:cte1, db[:tab1])
-           .with(:cte2, db[:cte1])
-           .with(:cte3, db[:cte2])
-           .from(:cte3)
-      expect_columns(ds, :col1)
-    end
-
-    it 'should handle mixed aliased and non-aliased sources' do
-      ds = db[:tab1].from_self(alias: :t1)
-                    .join(:tab2, { col2: :col1 })
-                    .join(db[:tab3].as(:t3), { col3: :col1 })
-                    .select_all(:t1)
-                    .select_append(Sequel[:t3][:col4])
-      expect_columns(ds, :col1, :col4)
-    end
-
-    it 'should handle column lookup with empty select lists' do
-      ds = db.from(db[:tab1].where(id: 1))
-      expect_columns(ds, :col1)
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require_relative '../../../test_helper'
-require 'sequel'
-require 'sequel/extensions/db_opts'
-
-class TestDbOpts < Minitest::Test
-
-  def with_fake_database_type_and_options(db_type, opts = {})
-    db = Sequel.mock
-    db.define_singleton_method(:database_type) { db_type }
-    db.define_singleton_method(:opts) { opts }
-    db.extension :db_opts
-    yield db
-  end
-
-  def sql_for(db_type, options)
-    with_fake_database_type_and_options(db_type, options) do |db|
-      db.synchronize do |conn|
-        db.db_opts.apply(conn)
-        return db.sqls
-      end
-    end
-  end
-
-  def test_should_detect_options_for_appropriate_db
-    assert_equal(['SET flim=flam'], sql_for(:postgres, postgres_db_opt_flim: :flam))
-  end
-
-  def test_should_ignore_options_for_inappropriate_db
-    assert_equal(['SET flim=flam'], sql_for(:postgres, postgres_db_opt_flim: :flam, other_db_opt_foo: :bar))
-  end
-
-  def test_should_ignore_non_db_opts
-    assert_empty(sql_for(:postgres, postgres_flim: :flam))
-  end
-
-  def test_should_properly_quote_awkward_values
-    assert_equal(["SET str='hello there'", "SET hyphen='i-like-hyphens-though-they-are-dumb'"],
-                 sql_for(:postgres, postgres_db_opt_str: 'hello there',
-                                    postgres_db_opt_hyphen: 'i-like-hyphens-though-they-are-dumb'))
-  end
-
-end

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

@@ -1,259 +0,0 @@
-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
-    @db = Sequel.mock(host: :spark)
-    @db.extension :make_readyable
-    def @db.tables(opts = {})
-      case opts[:schema]
-      when :schema1
-        [:a]
-      when :schema2
-        %i[a b]
-      when :schema3
-        %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)
-  end
-
-  def test_should_create_views_based_on_tables_in_search_paths
-    @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)
-  end
-
-  def test_should_create_views_based_on_tables_in_search_paths_passed_as_strings
-    @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)
-  end
-
-  def test_should_create_views_based_on_tables_in_search_paths_accepts_except
-    @db.make_ready(search_path: %i[schema1 schema2 schema3], except: :a)
-
-    assert_equal([
-                   '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: %i[schema1 schema2 schema3], only: :b)
-
-    assert_equal([
-                   '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.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_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.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