sequelizer 0.3.0 → 0.4.0

data/lib/sequel/extensions/platform.rb

@@ -18,18 +18,15 @@
 #
 # Related module: Sequel::Platform
 
-require 'kvcsv'
+require "kvcsv"
 
 module Sequel
-
   # The Platform module provides database platform abstraction through
   # configuration-driven capabilities and code-driven function translations.
   module Platform
-
     # Base platform class with KVCSV config loading and default implementations.
     # Subclasses override function translation methods for platform-specific SQL.
     class Base
-
       attr_reader :db, :config
 
       # Initialize platform with database connection and config paths.
@@ -122,27 +119,23 @@ module Sequel
       def days_between(from, to)
         date_diff(from, to)
       end
-
     end
 
     # PostgreSQL platform with Postgres-specific function translations.
     class Postgres < Base
-
       def date_diff(from, to)
         # Postgres uses date subtraction
-        Sequel.lit('(? - ?)', to, from)
+        Sequel.lit("(? - ?)", to, from)
       end
 
       def days_between(from, to)
         # Postgres date subtraction returns integer days
-        Sequel.lit('(? - ?)', to, from)
+        Sequel.lit("(? - ?)", to, from)
       end
-
     end
 
     # Spark platform with Spark SQL-specific function translations.
     class Spark < Base
-
       def date_diff(from, to)
         # Spark datediff has reversed argument order (end, start)
         Sequel.function(:datediff, to, from)
@@ -151,35 +144,30 @@ module Sequel
       def str_to_date(value, format)
         Sequel.function(:to_date, Sequel.cast_string(value), format)
       end
-
     end
 
     # Snowflake platform with Snowflake-specific function translations.
     class Snowflake < Base
-
       def date_diff(from, to)
         # Snowflake requires unit parameter
-        Sequel.function(:datediff, 'day', from, to)
+        Sequel.function(:datediff, "day", from, to)
       end
 
       def days_between(from, to)
-        Sequel.function(:datediff, 'day', from, to)
+        Sequel.function(:datediff, "day", from, to)
       end
-
     end
 
     # Athena platform (Presto/Trino based) with Athena-specific function translations.
     class Athena < Base
-
       def date_diff(from, to)
         # Athena/Presto uses date_diff with unit
-        Sequel.function(:date_diff, 'day', from, to)
+        Sequel.function(:date_diff, "day", from, to)
       end
 
       def days_between(from, to)
-        Sequel.function(:date_diff, 'day', from, to)
+        Sequel.function(:date_diff, "day", from, to)
       end
-
     end
 
     # Map adapter schemes to platform classes
@@ -190,22 +178,21 @@ module Sequel
       athena: Athena,
       presto: Athena,
       trino: Athena,
-      snowflake: Snowflake,
+      snowflake: Snowflake
     }.freeze
 
     # Map adapter schemes to config file names
     ADAPTER_CONFIG_NAMES = {
-      postgres: 'postgres',
-      postgresql: 'postgres',
-      spark: 'spark',
-      athena: 'athena',
-      presto: 'athena',
-      trino: 'athena',
-      snowflake: 'snowflake',
+      postgres: "postgres",
+      postgresql: "postgres",
+      spark: "spark",
+      athena: "athena",
+      presto: "athena",
+      trino: "athena",
+      snowflake: "snowflake"
     }.freeze
 
     class << self
-
       # Find the config directory, searching gem paths
       def config_dir
         @config_dir ||= find_config_dir
@@ -218,16 +205,15 @@ module Sequel
 
       def find_config_dir
         # Check relative to this file (gem's config)
-        gem_config = File.expand_path('../../../config/platforms', __dir__)
+        gem_config = File.expand_path("../../../config/platforms", __dir__)
         return gem_config if File.directory?(gem_config)
 
         # Fallback to working directory
-        local_config = File.join(Dir.pwd, 'config/platforms')
+        local_config = File.join(Dir.pwd, "config/platforms")
         return local_config if File.directory?(local_config)
 
         nil
       end
-
     end
 
     # Build config paths for the given adapter
@@ -239,12 +225,12 @@ module Sequel
       paths = []
 
       if config_dir
-        base_config = File.join(config_dir, 'base.csv')
+        base_config = File.join(config_dir, "base.csv")
         paths << base_config if File.exist?(base_config)
 
         adapter_name = ADAPTER_CONFIG_NAMES[adapter_scheme]
         if adapter_name
-          rdbms_config = File.join(config_dir, 'rdbms', "#{adapter_name}.csv")
+          rdbms_config = File.join(config_dir, "rdbms", "#{adapter_name}.csv")
           paths << rdbms_config if File.exist?(rdbms_config)
         end
       end
@@ -292,9 +278,7 @@ module Sequel
     def platform
       @platform
     end
-
   end
 
   Database.register_extension(:platform, Platform)
-
 end

data/lib/sequel/extensions/settable.rb

@@ -13,18 +13,26 @@
 #   DB.set(work_mem: '256MB')
 #   # Executes: SET work_mem=256MB
 #
+#   DB.set(memory_limit: Sequel.expr('1GB'))
+#   # Executes: SET memory_limit='1GB'
+#
+# Plain values are interpolated raw into the SET statement, so
+# <tt>search_path: 'a,b,public'</tt> stays a list of schemas. When the database
+# needs an SQL literal (for example DuckDB string settings), the caller wraps
+# the value in +Sequel.expr+, and the extension passes it through +literal+.
+#
+# The +set_sql+ method returns the SET statements without executing them.
+#
 # The extension works with any database adapter and supports various value types
 # including strings, numbers, booleans, and nil values.
 #
 # Related module: Sequel::Settable
 
 module Sequel
-
   # The Settable module provides database configuration functionality through
-  # SET statements. When loaded as an extension, it adds the +set+ method to
-  # database connections.
+  # SET statements. When loaded as an extension, it adds the +set+ and
+  # +set_sql+ methods to database connections.
   module Settable
-
     # Execute SET statements for the given options hash.
     #
     # Each key-value pair in the options hash is converted to a SET statement
@@ -50,6 +58,10 @@ module Sequel
     #   #           SET autocommit=true
     #   #           SET custom_setting=
     #
+    # @example Caller-quoted value
+    #   DB.set(memory_limit: Sequel.expr('1GB'))
+    #   # Executes: SET memory_limit='1GB'
+    #
     # @return [void]
     def set(opts = {})
       set_sql(opts).each do |sql|
@@ -57,25 +69,26 @@ module Sequel
       end
     end
 
-    private
-
-    # Generate SET SQL statements from options hash.
+    # Generate SET SQL statements from options hash, without executing them.
     #
     # Converts each key-value pair in the options hash into a SET SQL statement
-    # string. This is a private helper method used internally by the +set+ method.
+    # string. A value that is a +Sequel::SQL::Expression+ is passed through
+    # +literal+. Every other value is interpolated raw.
     #
     # @param opts [Hash] Hash of options to convert to SET statements
     # @return [Array<String>] Array of SET SQL statement strings
     #
     # @example
-    #   set_sql(timezone: 'UTC', port: 5432)
+    #   DB.set_sql(timezone: 'UTC', port: 5432)
     #   # => ["SET timezone=UTC", "SET port=5432"]
+    #
+    # @example Caller-quoted value
+    #   DB.set_sql(memory_limit: Sequel.expr('1GB'))
+    #   # => ["SET memory_limit='1GB'"]
     def set_sql(opts)
-      opts.map { |k, v| "SET #{k}=#{v}" }
+      opts.map { |k, v| "SET #{k}=#{v.is_a?(Sequel::SQL::Expression) ? literal(v) : v}" }
     end
-
   end
 
   Database.register_extension(:settable, Settable)
-
 end

data/lib/sequel/extensions/smart_select_remove.rb

@@ -8,9 +8,18 @@
 #
 # 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.
+# inspecting the dataset's own SELECT list, or walking through from_self
+# chains to an inner SELECT list, this extension can determine which
+# columns to keep without touching the database.
+#
+# When static resolution fails and the database returns no columns (for
+# example on Sequel.mock), select_remove raises
+# Sequel::SmartSelectRemove::NoColumnsError instead of producing
+# SELECT *, which would still contain the removed columns.
+#
+# When the columns are known but every one of them is removed, the result
+# would also be SELECT *, so select_remove raises
+# Sequel::SmartSelectRemove::AllColumnsRemovedError.
 #
 # You should load this extension into all of a database's datasets:
 #
@@ -21,37 +30,85 @@
 # Related module: Sequel::SmartSelectRemove
 
 module Sequel
-
   module SmartSelectRemove
+    # Raised when select_remove cannot determine the dataset's columns, so
+    # the result would be SELECT * and would still contain the removed columns.
+    class NoColumnsError < Sequel::Error
+      def initialize(dataset)
+        super("select_remove could not determine the columns of #{dataset.sql}; " \
+              "it would produce SELECT * and keep the removed columns")
+      end
+    end
+
+    # Raised when select_remove would remove every column, so the result
+    # would be SELECT * and would still contain the removed columns.
+    class AllColumnsRemovedError < Sequel::Error
+      def initialize(dataset, cols)
+        super("select_remove(#{cols.map(&:inspect).join(', ')}) would remove every column of " \
+              "#{dataset.sql}; the result would be SELECT * and keep the removed columns")
+      end
+    end
 
     # 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.
+    # When the dataset has an explicit SELECT clause, resolves the output
+    # name of each entry and keeps the original expressions whose names
+    # are not removed, as the original select_remove does with the
+    # names that columns returns. 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. Both
+    # avoid the columns! call that the original select_remove uses,
+    # which would execute SQL.
+    #
+    # If any entry cannot be resolved (for example a literal string or a
+    # star), the original select_remove is used. Every such fallback
+    # first checks columns, and raises NoColumnsError when it is empty.
+    #
+    # On every path, if the result would have an empty select list because
+    # every column is removed, raises AllColumnsRemovedError. An empty
+    # select list renders as SELECT * and keeps the removed columns.
     #
     # @param cols [Array<Symbol>] columns to remove
     # @return [Sequel::Dataset] dataset with columns removed
+    # @raise [NoColumnsError] if the fallback finds no columns
+    # @raise [AllColumnsRemovedError] if every column would be 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)
+      sel = @opts[:select]
+      if sel && !sel.empty?
+        names = sel.map { |c| resolve_outer_column_name(c) }
+        unless names.any?(&:nil?)
+          kept = names.zip(sel).reject { |name, _| cols.include?(name) }.map(&:last)
+          return ensure_columns_remain(select(*(kept - cols)), cols)
+        end
+      elsif (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))
+        return ensure_columns_remain(select(*(outer_cols - cols)), cols) unless outer_cols.any?(&:nil?)
       end
 
-      super
+      # Every fallback reaches this point. With no columns, the original
+      # select_remove would call select() and produce SELECT *.
+      raise NoColumnsError, self if columns.empty?
+
+      ensure_columns_remain(super, cols)
     end
 
     private
 
+    # Return ds unless its select list is empty or nil. Either renders as
+    # SELECT *, which would keep the removed columns.
+    #
+    # @param ds [Sequel::Dataset] the dataset select_remove would return
+    # @param cols [Array<Symbol>] the columns that were removed
+    # @return [Sequel::Dataset] ds
+    # @raise [AllColumnsRemovedError] if ds selects no columns
+    def ensure_columns_remain(ds, cols)
+      sel = ds.opts[:select]
+      raise AllColumnsRemovedError.new(self, cols) if sel.nil? || sel.empty?
+
+      ds
+    end
+
     # Walk through from_self chains to find the innermost explicit
     # SELECT list. Returns nil if no explicit selection is found.
     #
@@ -75,12 +132,15 @@ module Sequel
     # After from_self, inner expressions become subquery output columns
     # referenced by their alias or base name in the outer scope.
     #
+    # A star (:* or a qualified :*) selects every column of a table, so
+    # it has no single name and is unresolvable.
+    #
     # @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
+        col unless col == :*
       when Sequel::SQL::AliasedExpression
         a = col.alias
         a.is_a?(Symbol) ? a : a.to_sym
@@ -90,12 +150,10 @@ module Sequel
         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/sequel/extensions/sql_recorder.rb

@@ -32,12 +32,10 @@
 # Related module: Sequel::SqlRecorder
 
 module Sequel
-
   # Extension module that adds SQL recording capabilities to Sequel databases.
   # When included, it provides a +sql_recorder+ method that returns an array
   # of all SQL statements executed against the database.
   module SqlRecorder
-
     # Returns the array of recorded SQL statements.
     #
     # The array accumulates all SQL statements sent to the database since the
@@ -77,9 +75,7 @@ module Sequel
         @sql_recorder ||= []
       end
     end
-
   end
 
   Database.register_extension(:sql_recorder, SqlRecorder)
-
 end

data/lib/sequel/extensions/unionize.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Sequel
-
   # Provides efficient handling of large UNION operations.
   #
   # The unionize extension allows combining many datasets through UNION operations
@@ -20,14 +19,12 @@ module Sequel
   # @example With options
   #   DB.unionize(datasets, chunk_size: 50, all: true, temp_table_prefix: 'my_union')
   module Unionize
-
     # Handles the chunking and union of multiple datasets.
     #
     # This class manages the process of splitting a large collection of datasets
     # into smaller chunks, creating temporary tables/views for each chunk, and
     # then recursively combining them until a single unified dataset is produced.
     class Unionizer
-
       # Default number of datasets to combine in each chunk
       DEFAULT_CHUNK_SIZE = 100
 
@@ -36,7 +33,6 @@ module Sequel
       # Each chunk handles a subset of datasets, creates a temporary table/view
       # for the combined result, and provides access to the unified dataset.
       class Chunk
-
         # @!attribute [r] db
         #   @return [Sequel::Database] The database connection
         # @!attribute [r] dses
@@ -90,7 +86,6 @@ module Sequel
             raise "Unsupported database type: #{db.database_type}"
           end
         end
-
       end
 
       # @!attribute [r] db
@@ -111,7 +106,7 @@ module Sequel
         @ds_set = ds_set
         @opts = opts
         opts[:chunk_size] ||= DEFAULT_CHUNK_SIZE
-        opts[:temp_table_prefix] ||= 'temp_union'
+        opts[:temp_table_prefix] ||= "temp_union"
         opts[:all] ||= false
         opts[:from_self] = opts.fetch(:from_self, true)
       end
@@ -132,7 +127,6 @@ module Sequel
 
         unionize(chunks.each(&:create).map { |chunk| db[chunk.name] })
       end
-
     end
 
     # Efficiently combines multiple datasets using UNION operations.
@@ -161,9 +155,7 @@ module Sequel
     def unionize(ds_set, opts = {})
       Unionizer.new(self, ds_set, opts).unionize
     end
-
   end
 
   Database.register_extension(:unionize, Unionize)
-
 end

data/lib/sequel/extensions/usable.rb

@@ -1,5 +1,4 @@
 module Sequel
-
   # = Usable
   #
   # Sequel extension that provides a convenient +use+ method for switching
@@ -12,7 +11,6 @@ module Sequel
   #   db.use(:my_schema)
   #   # Executes: USE `my_schema`
   module Usable
-
     # Switches to the specified database or schema.
     #
     # Executes a USE statement to change the current database context.
@@ -36,9 +34,7 @@ module Sequel
     def use_sql(schema_name)
       "USE #{literal(schema_name)}"
     end
-
   end
 
   Database.register_extension(:usable, Usable)
-
 end

data/lib/sequelizer/cli.rb

@@ -1,6 +1,5 @@
-require 'thor'
-require 'pp'
-require_relative 'gemfile_modifier'
+require "thor"
+require_relative "options"
 
 module Sequelizer
   # = CLI
@@ -8,57 +7,38 @@ module Sequelizer
   # Command line interface for Sequelizer gem using Thor.
   # Provides commands for:
   #
-  # * Updating Gemfile with database adapters
   # * Initializing .env files with database configuration
   # * Displaying current configuration
   #
   # @example
-  #   sequelizer update_gemfile
   #   sequelizer init_env --adapter postgres --host localhost
   #   sequelizer config
   class CLI < Thor
-
-    desc 'update_gemfile',
-         'adds or replaces a line in your Gemfile to include the correct database adapter to work with Sequel'
-    option 'dry-run', type: :boolean, desc: 'Only prints out what it would do, but makes no changes'
-    option 'skip-bundle', type: :boolean, desc: "Don't run `bundle install` after modifying Gemfile"
-    # Updates the Gemfile to include the appropriate database adapter gem.
-    #
-    # This command analyzes your current database configuration and adds or updates
-    # the corresponding database adapter gem in your Gemfile. It supports various
-    # adapters including PostgreSQL, MySQL, SQLite, and JDBC-based adapters.
-    #
-    # @option options [Boolean] dry-run Only prints what would be done without making changes
-    # @option options [Boolean] skip-bundle Skip running `bundle install` after modification
-    def update_gemfile
-      GemfileModifier.new(options).modify
-    end
-
-    desc 'init_env', 'creates a .env file with the parameters listed'
+    desc "init_env", "creates a .env file with the parameters listed"
     option :adapter,
            aliases: :a,
-           desc: 'adapter for database'
+           desc: "adapter for database"
     option :host,
            aliases: :h,
-           banner: 'localhost',
-           desc: 'host for database'
+           banner: "localhost",
+           desc: "host for database"
     option :username,
            aliases: :u,
-           desc: 'username for database'
+           desc: "username for database"
     option :password,
            aliases: :P,
-           desc: 'password for database'
+           desc: "password for database"
     option :port,
            aliases: :p,
            type: :numeric,
-           banner: '5432',
-           desc: 'port for database'
+           banner: "5432",
+           desc: "port for database"
     option :database,
            aliases: :d,
-           desc: 'database for database'
+           desc: "database for database"
     option :search_path,
            aliases: :s,
-           desc: 'schema for database (PostgreSQL only)'
+           desc: "schema for database (PostgreSQL only)"
     # Creates a .env file with database configuration parameters.
     #
     # This command generates a .env file with SEQUELIZER_* environment variables
@@ -73,18 +53,18 @@ module Sequelizer
     # @option options [String] :search_path PostgreSQL schema search path
     # @raise [SystemExit] if .env file already exists
     def init_env
-      if File.exist?('.env')
+      if File.exist?(".env")
         puts ".env already exists!  I'm too cowardly to overwrite it!"
         puts "Here's what I would have put in there:"
         puts make_env(options)
         exit(1)
       end
-      File.open('.env', 'w') do |file|
+      File.open(".env", "w") do |file|
         file.puts make_env(options)
       end
     end
 
-    desc 'config', 'prints out the connection parameters'
+    desc "config", "prints out the connection parameters"
     # Displays the current database configuration and extensions.
     #
     # This command shows the resolved configuration options that would be used
@@ -103,6 +83,5 @@ module Sequelizer
         "SEQUELIZER_#{key.upcase}=#{value}"
       end.join("\n")
     end
-
   end
 end