sequelizer 0.1.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd4b9fbda8a56b5f1f9f83787e9fd0abbd76850d30447624ee513669fab9a5ed
-  data.tar.gz: 51905a6233ab05fb60560b0542f2078de9f26cee1e6a1cb6d7e9cfdd6599b71f
+  metadata.gz: 348bea43e8571c35056619a31d45731f55b48a24cb4b93e94f23ecf7eba3a4af
+  data.tar.gz: 170ae6de8d06dc7f8030fd97151b1ff7b5666a6d94849a4fe3e056a863938a65
 SHA512:
-  metadata.gz: a589e19ca1c6a7bc8b3d5ff125becf56f2b19336560286d937210efbbd075785f065ae8cd90cd248d0721bcae2af7cf99449a2ca78c5dc19fc338364db32c23b
-  data.tar.gz: c697540e63315616982acfaed7a3488dea5abd6482bec1de8402cb6ac208144b0932511fbf39535a65498499e83bcf91bfbab4c530b5ed1a70541889769baa03
+  metadata.gz: 497923374b34e892918aa86dea037c0b25323dc8d829398bb0e97d77386c13e248b68d47f4c7c31650d099fdf85d9cf62203703c2576f31310054f9937df9119
+  data.tar.gz: f6a8dd133701a962fab9b16a0c0df30a4897d9c08526db07ec7ddef9029eb7140adcfbbab44974be7da2d970f2203308aa419b7112baad046947a50ad4ad93f5

data/CHANGELOG.md

@@ -2,9 +2,56 @@
 
 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
+- Bumped sequel from 5.93.0 to 5.101.0
+- 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
@@ -12,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
@@ -28,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
@@ -40,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
@@ -76,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/config/platforms/base.csv

@@ -0,0 +1,5 @@
+key,value
+supports_cte,true
+supports_cte_recursive,true
+supports_temp_tables,true
+drop_table_needs_unquoted,false

data/config/platforms/rdbms/athena.csv

@@ -0,0 +1,4 @@
+key,value
+supports_temp_tables,false
+supports_cte_recursive,false
+drop_table_needs_unquoted,true

data/config/platforms/rdbms/postgres.csv

@@ -0,0 +1,3 @@
+key,value
+prefers_cte,true
+schema_switching_method,search_path

data/config/platforms/rdbms/snowflake.csv

@@ -0,0 +1 @@
+key,value

data/config/platforms/rdbms/spark.csv

@@ -0,0 +1,3 @@
+key,value
+prefers_cte,false
+prefers_parquet,true

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
 
@@ -292,7 +308,7 @@ module Sequel
     # @param opts_chain [Hash] the dataset's query options
     # @return [Array<Symbol>] array of column names from table.* expressions
     def extract_table_star_columns(cols, opts_chain)
-      cols.select { |c| c.is_a?(Sequel::SQL::ColumnAll) }
+      cols.grep(Sequel::SQL::ColumnAll)
           .flat_map { |c| from_named_sources(c.table, opts_chain) }
     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
 
@@ -359,7 +383,7 @@ module Sequel
     # @return [Array<Symbol>, nil] column names if found, nil otherwise
     def find_from_alias(name, opts_chain)
       from = (opts_chain[:from] || [])
-             .select { |f| f.is_a?(Sequel::SQL::AliasedExpression) }
+             .grep(Sequel::SQL::AliasedExpression)
              .detect { |f| literal(f.alias) == literal(name) }
 
       from&.expression&.columns_search(opts_chain)

data/lib/sequel/extensions/funky.rb

@@ -0,0 +1,136 @@
+module Sequel
+
+  module Funky
+
+    class FunkyBase
+
+      def initialize(db)
+        @db = db
+      end
+
+      def to_strptime(format)
+        return format if format =~ /%/
+
+        format.gsub('yyyy', '%Y').gsub('MM', '%m').gsub('dd', '%d')
+      end
+
+      def from_strptime(format)
+        return format unless format =~ /%/
+
+        format.gsub('%Y', 'yyyy').gsub('%m', 'MM').gsub('%d', 'dd')
+      end
+
+    end
+
+    class FunkySpark < FunkyBase
+
+      def str_to_date(value, format, try: false) # rubocop:disable Lint/UnusedMethodArgument
+        Sequel.function(:to_date, Sequel.cast_string(value), format)
+      end
+
+      def hash(*)
+        Sequel.function(:xxhash64, *)
+      end
+
+      def make_json_column(ds, key_column, value_column)
+        json_object_col = Sequel.function(
+          :named_struct,
+          'key',
+          key_column,
+          'value',
+          value_column,
+        ).then do |json_object_col|
+          Sequel.function(
+            :collect_list,
+            json_object_col,
+          )
+        end.then do |list_col|
+          Sequel.function(
+            :map_from_entries,
+            list_col,
+          )
+        end.then do |map_from_entries_col|
+          Sequel.function(
+            :to_json,
+            map_from_entries_col,
+          )
+        end
+        ds.from_self
+          .select(json_object_col)
+          .limit(1)
+      end
+
+      def collect_list(column)
+        Sequel.function(:collect_list, column)
+      end
+
+    end
+
+    class FunkyDuckDB < FunkyBase
+
+      def str_to_date(value, format, try: false)
+        strptime_func = try ? :try_strptime : :strptime
+        Sequel.function(strptime_func, Sequel.cast_string(value), to_strptime(format))
+      end
+
+      def hash(*)
+        Sequel.function(:hash, concat(*)).then do |hash_val|
+          Sequel.case(
+            { hash_val <= 9_223_372_036_854_775_807 => hash_val },
+            hash_val - 18_446_744_073_709_551_616,
+          ).cast(:bigint)
+        end
+      end
+
+      def concat(*)
+        Sequel.function(:concat, *)
+      end
+
+      def make_json_column(ds, key_column, value_column)
+        json_object_col = Sequel.function(
+          :json_object,
+          Sequel.cast_string(key_column),
+          value_column,
+        ).then do |json_object_col|
+          Sequel.function(
+            :list,
+            json_object_col,
+          )
+        end
+        ds.from_self
+          .select(json_object_col)
+          .limit(1)
+      end
+
+      def collect_list(column)
+        Sequel.function(:list, column)
+      end
+
+    end
+
+    def self.extended(db)
+      db.instance_exec do
+        @funky = get_funky(db.database_type)
+      end
+    end
+
+    def funky
+      @funky
+    end
+
+    def get_funky(database_type)
+      case database_type
+      when :spark
+        FunkySpark.new(self)
+      when :duckdb
+        FunkyDuckDB.new(self)
+      else
+        raise "No known functions for #{database_type}"
+      end
+    end
+
+  end
+
+  Database.register_extension(:funky, Funky)
+
+end

data/lib/sequel/extensions/make_readyable.rb

@@ -1,5 +1,3 @@
-require 'pathname'
-
 module Sequel
 
   # = MakeReadyable
@@ -89,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)
@@ -104,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)
@@ -112,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