sequelizer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f067d6d5a8661d14249493213e942d02a9a9d8b2aca1148915ee02acf5062c1f
-  data.tar.gz: eb913ecf490d79fe57fa6d0d8dfb3321703b4e852bd8cac6e2745610cbd48370
+  metadata.gz: 348bea43e8571c35056619a31d45731f55b48a24cb4b93e94f23ecf7eba3a4af
+  data.tar.gz: 170ae6de8d06dc7f8030fd97151b1ff7b5666a6d94849a4fe3e056a863938a65
 SHA512:
-  metadata.gz: 34060489fcade8850421f28c0ee062ab6f134fab779b0925ffa55e7078468f7bc4a70bcdc38e9e29fecc4c7a01acdbd11aedf56d315d8e8fa04da0d82692b09e
-  data.tar.gz: 635178a3e8c60a531885b2df7e4ad468c8301ea67d55a4d64c7ded78268f66a38e13cc901c5550ca1d00b239539400e3212496a248e388b4d9d632eed6914220
+  metadata.gz: 497923374b34e892918aa86dea037c0b25323dc8d829398bb0e97d77386c13e248b68d47f4c7c31650d099fdf85d9cf62203703c2576f31310054f9937df9119
+  data.tar.gz: f6a8dd133701a962fab9b16a0c0df30a4897d9c08526db07ec7ddef9029eb7140adcfbbab44974be7da2d970f2203308aa419b7112baad046947a50ad4ad93f5

data/CHANGELOG.md

@@ -2,14 +2,42 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.0] - 2026-10-01
+
+### Breaking changes
+
+- Drop support for Ruby 3.2 ([feef6de](https://github.com/outcomesinsights/sequelizer/commit/feef6de5c155dc0dd39642ad1686ff9bab0211de)): sequelizer now requires Ruby >= 3.3.0.
+
+### Added
+
+- Add smart_select_remove Sequel extension ([a1366ec](https://github.com/outcomesinsights/sequelizer/commit/a1366ec8f68e64728b3c794de15c2fd78cfa9e2e))
+- DuckDB support in make_readyable and cold_col extensions ([9433d98](https://github.com/outcomesinsights/sequelizer/commit/9433d982bc0855df11ac6f48a915e861fd78a572))
+
+### Changed
+
+- Extract available_tables to fix AbcSize in ReadyMaker#run ([60c6a68](https://github.com/outcomesinsights/sequelizer/commit/60c6a6803afbfde2b0747fd19e3bcd346bf2d1ef))
+- Simplify cold_col find_columns and remove rescue nil guards ([752eab1](https://github.com/outcomesinsights/sequelizer/commit/752eab14595af23974ea56a976dd99e29d9d5552))
+- Remove OptionalAdapterSupport, add sequel-duckdb to bundle ([74d6d16](https://github.com/outcomesinsights/sequelizer/commit/74d6d16f564742138a32e111d7b6107289abec75))
+- Let Sequel handle adapter loading, remove pre-require ([c2b592d](https://github.com/outcomesinsights/sequelizer/commit/c2b592d1965e24370dae2f5cfb515097358cd3da))
+- Ship only runtime files in the gem: lib/, the sequelizer executable, the platform CSVs, and the docs and licence ([1cc49b6](https://github.com/outcomesinsights/sequelizer/commit/1cc49b69dec0c6c879a469f0774c1196c467ed17))
+
+### Fixed
+
+- Fall back to database query in cold_col for unregistered tables ([d07f7c5](https://github.com/outcomesinsights/sequelizer/commit/d07f7c5e482074e631828afbf558a767d6695b66))
+- Replace rescue modifier with explicit begin/rescue in cold_col ([6fced2b](https://github.com/outcomesinsights/sequelizer/commit/6fced2b4957277b5c6d45fabf11e89d0b476a8e5))
+- Handle string SQL in cold_col create_table_as and create_view_sql ([8f30602](https://github.com/outcomesinsights/sequelizer/commit/8f306028857e3838370fc623cd619a9a79c8c06f))
+- Handle Array search_path in after_connect ([c376825](https://github.com/outcomesinsights/sequelizer/commit/c3768251695286668ca49dcbb84aa12c3bbb7f69))
+
 ## 0.2.0
 
 ### Added
+
 - funky Sequel extension for database-specific function abstraction
 - kvcsv as a runtime dependency
 - Platform configuration fixtures in config/platforms/
 
 ### Changed
+
 - Broadened activesupport dependency from ~> 7.0 to >= 7, < 9
 - Broadened hashie dependency from ~> 3.2 to >= 3.2, < 6.0
 - Broadened dotenv dependency from ~> 2.1 to >= 2.1, < 4.0
@@ -17,11 +45,13 @@ All notable changes to this project will be documented in this file.
 - Added multi-Ruby CI matrix (3.2, 3.3, 3.4, 4.0) with separate lint job
 
 ### Fixed
+
 - Adapter extraction from URL scheme for search_path processing
 
 ## 0.1.6
 
 ### Removed
+
 - JDBC adapter support (jdbc_hive2, jdbc_impala, jdbc_postgres) - not needed for foreseeable future
 - Native Impala adapter support - not needed for foreseeable future
 - Kerberos authentication functionality for enterprise databases
@@ -29,9 +59,11 @@ All notable changes to this project will be documented in this file.
 - 16 test methods related to JDBC and Impala adapters
 
 ### Added
+
 - pg gem as development dependency to support PostgreSQL testing
 
 ### Changed
+
 - Simplified ConnectionMaker class by removing adapter-specific configuration methods
 - Improved test coverage from 84.95% to 93.54% by removing unused code paths
 - Updated documentation to reflect focus on standard Sequel adapters
@@ -45,11 +77,13 @@ All notable changes to this project will be documented in this file.
 ## [0.1.0] - 2016-11-08
 
 ### Added
+
 - Connections are cached by options to avoid over-allocation
 - URL or URI option represent connection string
 - sequelizer.yml is passed through ERB
 
 ### Changed
+
 - Format of this [CHANGELOG](http://keepachangelog.com/en/0.3.0/)
 - Prefer environment variables over other options
 - Use config/sequelizer.yml instead of config/database.yml
@@ -57,34 +91,41 @@ All notable changes to this project will be documented in this file.
 ## [0.0.6] - 2015-08-21
 
 ### Added
+
 - Support for ruby-oci8 (Oracle) in update_gemfile command
 - Read user-level configuration from ~/.config/sequelizer/database.yml
 
 ### Fixed
+
 - Bug where options passed as symbols where sometimes ignored.
 
 ## [0.0.5] - 2014-08-29
 
 ### Added
+
 - Support for TinyTDS (SQL Server) in update_gemfile command
 
 ### Fixed
+
 - timeout is always converted to integer before passing to Sequel.connect
 
 ## [0.0.4] - 2014-08-18
 
 ### Added
+
 - `init_env` command to bin/sequelizer
 - Prefer `search_path` over `schema_search_path` option
 
 ## [0.0.3] - 2014-07-10
 
 ### Added
+
 - Ability to view configuration by running `sequelizer config`
 
 ## [0.0.2] - 2014-07-10
 
 ### Added
+
 - This [CHANGELOG](http://keepachangelog.com/)
 - Behavior to merge options from all sources (#3)
 - Dependency on hashie gem
@@ -93,9 +134,11 @@ All notable changes to this project will be documented in this file.
 - Reference to issues #1, #3 in README
 
 ### Fixed
+
 - Prevented TestEnvConfig from polluting environment variables
 
 ## [0.0.1] - 2014-07-10
 
 ### Added
+
 - The project itself

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2026 Outcomes Insights, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -12,35 +12,46 @@ I normally use this gem when I'm writing a quick script or a Thor-based command
 
 Add this line to your application's Gemfile:
 
-    gem 'sequelizer'
+```
+gem 'sequelizer'
+```
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install sequelizer
+```
+$ gem install sequelizer
+```
 
 ## Usage
 
 To get the most out of Sequelizer, you'll need to create a config/database.yml file or a .env file and specify your database configuration options in that file.
 
-Sequelizer comes with a handy command that will print out your connection parameters.  Just run:
+Sequelizer comes with a handy command that will print out your connection parameters. Just run:
 
-    bundle exec sequelizer config
+```
+bundle exec sequelizer config
+```
 
-You'll also need to make sure the gem for your database is installed.  You can do this by adding the gem to your application's Gemfile.
+You'll also need to make sure the gem for your database is installed. You can do this by adding the gem to your application's Gemfile.
 
-Sequelizer comes with a handy command that will update your Gemfile for you.  Once you've specified your database configuration, run
+Sequelizer comes with a handy command that will update your Gemfile for you. Once you've specified your database configuration, run
 
-    bundle exec sequelizer update_gemfile
+```
+bundle exec sequelizer update_gemfile
+```
 
 The command will look up the right gem to use with the adapter you've specified, add a line to your Gemfile specifying that gem, and run `bundle install` to install the gem for you.
 
 Once you've specified your options and made sure your database's gem is installed, simply include the Sequelizer module in any class that needs a database connection and you'll get two handy-dandy methods: `db` and `new_db`
 
 Observe:
+
 ```ruby
 require 'sequelizer'
 
@@ -59,17 +70,19 @@ end
 
 `new_db` will create a new connection to the database on each call.
 
-Both take a hash of database options if you don't want to create a config/database.yml or .env file, or simply wish to override those options.  Options are merged together from all sources with the following precedence:
+Both take a hash of database options if you don't want to create a config/database.yml or .env file, or simply wish to override those options. Options are merged together from all sources with the following precedence:
 
-    passed_options > .env > manually defined environment variables > config/database.yml > ~/.config/sequelizer/database.yml
+```
+passed_options > .env > manually defined environment variables > config/database.yml > ~/.config/sequelizer/database.yml
+```
 
-So if config/database.yml specifies a connection, you can set an environment variable (either manually, or through .env) to override one of those options.  Similarly, if you pass an option to the method directly, that option will override the YAML and ENV-based options.  See #3 for further discussion.
+So if config/database.yml specifies a connection, you can set an environment variable (either manually, or through .env) to override one of those options. Similarly, if you pass an option to the method directly, that option will override the YAML and ENV-based options. See #3 for further discussion.
 
 Take a look at the examples directory for a few ways you can specify your database configuration options.
 
 ## Frustrations
 
-I can't seem to figure out a way to avoid having to specify the database gem in the a user's bundler file.  If anyone has ideas on how to automagically load the correct database gem based on the database options fed to Sequelizer, please let me know (#1)!
+I can't seem to figure out a way to avoid having to specify the database gem in the a user's bundler file. If anyone has ideas on how to automagically load the correct database gem based on the database options fed to Sequelizer, please let me know (#1)!
 
 ## Contributing
 
@@ -82,9 +95,10 @@ I can't seem to figure out a way to avoid having to specify the database gem in
 ## Thanks
 
 - [Outcomes Insights, Inc.](http://outins.com)
-    - Many thanks for allowing me to release a portion of my work as Open Source Software!
+  - Many thanks for allowing me to release a portion of my work as Open Source Software!
 - Jeremy Evans
-    - For writing Sequel!
+  - For writing Sequel!
 
 ## License
+
 Released under the MIT license, Copyright (c) 2014 Outcomes Insights, Inc.

data/lib/sequel/extensions/cold_col.rb

@@ -88,37 +88,27 @@ module Sequel
       end
 
       # Find column information for a given table/view name.
-      # This method searches through all available registries in priority order:
+      # Searches all registries in priority order:
       # 1. Created views (highest priority - most recent)
       # 2. Created tables (medium priority - session specific)
       # 3. Loaded schemas (lowest priority - external definitions)
       #
-      # @param name [String, Symbol] the table/view name to look up
+      # @param name [String, Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier]
       # @return [Array<Symbol>, nil] array of column names as symbols, or nil if not found
       def find_columns(name)
-        table_name = name.to_s
         literal_name = @db.literal(name)
+        table_name = name_to_string(name)
 
-        # Search through registries in priority order
         [@created_views, @created_tables, @schemas].each do |registry|
           next unless registry
 
-          # Try literal representation first (most common for created tables/views)
           if (columns = Sequel.synchronize { registry[literal_name] })
             return columns.map { |c, _| c }
           end
 
-          # Try string representation (for manually added schemas)
           if (columns = Sequel.synchronize { registry[table_name] })
             return columns.map { |c, _| c }
           end
-
-          # Try finding by Sequel::LiteralString key (for test setup compatibility)
-          registry.each_key do |key|
-            if key.respond_to?(:to_s) && key.to_s == literal_name && (columns = Sequel.synchronize { registry[key] })
-              return columns.map { |c, _| c }
-            end
-          end
         end
 
         nil
@@ -140,6 +130,22 @@ module Sequel
         Sequel.synchronize { @schemas = schemas_hash }
       end
 
+      private
+
+      # Extract a plain string name from any Sequel name type.
+      # Sequel::SQL::Identifier#to_s returns an inspect-like string, not the value,
+      # so we must unwrap expression types to get a usable lookup key.
+      def name_to_string(name)
+        case name
+        when Sequel::SQL::QualifiedIdentifier
+          "#{name_to_string(name.table)}.#{name_to_string(name.column)}"
+        when Sequel::SQL::Identifier
+          name.value.to_s
+        else
+          name.to_s
+        end
+      end
+
     end
 
     # Sets up the cold column tracking when the extension is loaded
@@ -172,7 +178,12 @@ module Sequel
 
     def create_table_as(name, sql, options = {})
       super.tap do |_|
-        record_table(name, columns_from_sql(sql))
+        columns = begin
+          columns_from_sql(sql)
+        rescue StandardError
+          nil
+        end
+        record_table(name, columns) if columns
       end
     end
 
@@ -190,7 +201,12 @@ module Sequel
 
     def create_view_sql(name, source, options)
       super.tap do |_|
-        record_view(name, columns_from_sql(source)) unless options[:dont_record]
+        columns = begin
+          columns_from_sql(source)
+        rescue StandardError
+          nil
+        end
+        record_view(name, columns) if columns && !options[:dont_record]
       end
     end
 
@@ -348,6 +364,14 @@ module Sequel
         return columns
       end
 
+      # Fall back to database query for real tables cold_col doesn't know about
+      begin
+        columns = db[name].columns!
+        return columns if columns && !columns.empty?
+      rescue StandardError
+        nil
+      end
+
       raise("Failed to find columns for #{literal(name)}")
     end
 

data/lib/sequel/extensions/funky.rb

@@ -89,7 +89,7 @@ module Sequel
       def make_json_column(ds, key_column, value_column)
         json_object_col = Sequel.function(
           :json_object,
-          key_column,
+          Sequel.cast_string(key_column),
           value_column,
         ).then do |json_object_col|
           Sequel.function(

data/lib/sequel/extensions/make_readyable.rb

@@ -87,13 +87,9 @@ module Sequel
       only_tables = Array(opts[:only])
       created_views = Array(opts[:except]) || []
       (opts[:search_path] || []).flatten.each do |schema|
-        schema = schema.to_sym unless schema.is_a?(Pathname)
+        schema = schema.to_sym unless schema.is_a?(Pathname) || schema.is_a?(Sequel::SQL::QualifiedIdentifier)
         source = get_source(db, schema)
-        tables = if schema.is_a?(Pathname)
-                   source.tables - created_views
-                 else
-                   source.tables(schema: schema) - created_views
-                 end
+        tables = available_tables(source, schema, created_views)
         tables &= only_tables unless only_tables.empty?
         tables.each do |table|
           create_view(source, table, schema)
@@ -102,6 +98,20 @@ module Sequel
       end
     end
 
+    # Returns tables (and views) from the source that haven't already been created.
+    #
+    # @param source [Sequel::Database, FileSourcerer] the source handler
+    # @param schema [Symbol, Pathname] the schema or file path
+    # @param created_views [Array<Symbol>] tables/views already created
+    # @return [Array<Symbol>] available table names
+    def available_tables(source, schema, created_views)
+      if schema.is_a?(Pathname)
+        source.tables - created_views
+      else
+        (source.tables(schema: schema) + source.views(schema: schema)) - created_views
+      end
+    end
+
     # Creates a temporary view for the given table.
     #
     # @param source [Object] the source (database or FileSourcerer)
@@ -110,9 +120,9 @@ module Sequel
     def create_view(source, table, schema)
       if schema.to_s =~ %r{/}
         source.create_view(table, temp: true)
+      elsif db.database_type == :duckdb
+        source.create_or_replace_view(table, db[Sequel.qualify(schema, table)], temp: true)
       else
-        # For schema-based tables, just create temporary views
-        # This extension is primarily for Spark SQL-based databases
         source.create_view(table, db[Sequel.qualify(schema, table)], temp: true)
       end
     end

data/lib/sequel/extensions/platform.rb

@@ -265,20 +265,19 @@ module Sequel
       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.
+    # Returns the effective database type for platform selection.
+    #
+    # For real connections, database_type is authoritative.  For mock
+    # connections whose shared adapter isn't installed (e.g. snowflake,
+    # athena), database_type returns :mock; fall back to opts[:host].
     #
     # @param db [Sequel::Database] Database connection
-    # @return [Symbol] Effective adapter type
+    # @return [Symbol] Effective database 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
+      return db_type unless db_type == :mock
 
-      # Fall back to host option (for unknown types like snowflake, athena)
-      db.opts[:host]
+      db.opts[:host]&.to_sym
     end
 
     # Extension hook - called when extension is loaded

data/lib/sequel/extensions/smart_select_remove.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+#
+# The smart_select_remove extension overrides select_remove to resolve
+# column information from the dataset's expression tree before falling
+# back to the original select_remove behavior (which executes SQL via
+# columns!).
+#
+# This is essential for lazy query building patterns where datasets
+# reference tables that may not exist yet at query-build time. By
+# walking through from_self chains and inspecting inner SELECT lists,
+# this extension can determine which columns to keep without touching
+# the database.
+#
+# You should load this extension into all of a database's datasets:
+#
+#   DB.extension(:smart_select_remove)
+#
+# This automatically loads the select_remove extension as well.
+#
+# Related module: Sequel::SmartSelectRemove
+
+module Sequel
+
+  module SmartSelectRemove
+
+    # Override select_remove to attempt static column resolution before
+    # falling back to the original implementation.
+    #
+    # When the dataset has no explicit SELECT clause, walks through
+    # from_self chains to find inner column expressions and resolves
+    # them to outer-scope symbol names. This avoids the columns! call
+    # that the original select_remove uses, which would execute SQL.
+    #
+    # @param cols [Array<Symbol>] columns to remove
+    # @return [Sequel::Dataset] dataset with columns removed
+    def select_remove(*cols)
+      # If there's an explicit select, original behavior handles it
+      return super if @opts[:select] && !@opts[:select].empty?
+
+      # Try to resolve columns by walking the from_self chain
+      if (inner_cols = resolve_selected_columns)
+        outer_cols = inner_cols.map { |c| resolve_outer_column_name(c) }
+        # All columns must be resolvable; bail to super if any are opaque
+        return super if outer_cols.any?(&:nil?)
+
+        return select(*(outer_cols - cols))
+      end
+
+      super
+    end
+
+    private
+
+    # Walk through from_self chains to find the innermost explicit
+    # SELECT list. Returns nil if no explicit selection is found.
+    #
+    # @param ds [Sequel::Dataset] the dataset to inspect
+    # @return [Array, nil] the inner SELECT expressions, or nil
+    def resolve_selected_columns(ds = self)
+      opts = ds.opts
+      if (sel = opts[:select]) && !sel.empty?
+        sel
+      elsif (from = opts[:from]&.first)
+        case from
+        when Sequel::Dataset
+          resolve_selected_columns(from)
+        when Sequel::SQL::AliasedExpression
+          resolve_selected_columns(from.expression) if from.expression.is_a?(Sequel::Dataset)
+        end
+      end
+    end
+
+    # Map an inner SELECT expression to its outer-scope column name.
+    # After from_self, inner expressions become subquery output columns
+    # referenced by their alias or base name in the outer scope.
+    #
+    # @param col [Object] a column expression from the inner SELECT
+    # @return [Symbol, nil] the outer column name, or nil if unresolvable
+    def resolve_outer_column_name(col)
+      case col
+      when Symbol
+        col
+      when Sequel::SQL::AliasedExpression
+        a = col.alias
+        a.is_a?(Symbol) ? a : a.to_sym
+      when Sequel::SQL::QualifiedIdentifier
+        resolve_outer_column_name(col.column)
+      when Sequel::SQL::Identifier
+        col.value.to_sym
+      end
+    end
+
+  end
+
+  Database.register_extension(:smart_select_remove) do |db|
+    db.extension(:select_remove)
+    db.extend_datasets(SmartSelectRemove)
+  end
+
+end

data/lib/sequelizer/options.rb

@@ -147,17 +147,22 @@ module Sequelizer
     # 1. Create each schema in the search path if it doesn't exist
     # 2. Set the search_path for the connection
     #
-    # @param search_path [String] comma-separated list of PostgreSQL schemas
+    # @param search_path [String, Array<String>] PostgreSQL schema names as a
+    #   comma-separated string, an Array of schema names, or a mixed Array
+    #   containing comma-separated strings
     # @return [Proc] callback to execute after connection
-    # @example
+    # @example String input
     #   callback = after_connect('public,app_schema')
-    #   # When called, creates schemas and sets search_path
+    # @example Array input
+    #   callback = after_connect(['public', 'app_schema'])
     def after_connect(search_path)
+      schemas = Array(search_path).flat_map { |p| p.to_s.split(',') }.map(&:strip)
+      path_string = schemas.join(', ')
       proc do |conn|
-        search_path.split(',').map(&:strip).each do |schema|
+        schemas.each do |schema|
           conn.execute("CREATE SCHEMA IF NOT EXISTS #{schema}")
         end
-        conn.execute("SET search_path TO #{search_path}")
+        conn.execute("SET search_path TO #{path_string}")
       end
     end
 

data/lib/sequelizer/version.rb

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