sequel 5.82.0 → 5.84.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f09a139a164322e0a0e52e9a58c79b2f463972363509c41bf50e7082c1f542b7
-  data.tar.gz: e7222b81a79111b9853565160f81cb18c72b341f18bec839046c9b49a4b199ea
+  metadata.gz: 5677b07054121f55f100f0629d8102cabdd9db454263c5199a8f401bea891992
+  data.tar.gz: ca57e632e3e66c3a4003f988e5240da6a6eed0de9a143ac3985bd0603e0d9073
 SHA512:
-  metadata.gz: d9f16395ad855ccbc4494bd2e1436b6b78f15ddbfd1c9b80d356040d99415a46a352f50042b2fc9ab23d29b65567dafec2fceb35c709498159b00a1402991ee6
-  data.tar.gz: a5693c2f3c3791c0216a5af9e933edaa41b0eeb030a3523e52a6951c666e720d0b12ec48ae3f46777ce617b27857f6519d7ce98ec1768a0c8226c4b494e501c1
+  metadata.gz: 2ea8e58679c4ae2455588b584b959b3be691c177823cf336b77fa7b5910e716d9ca88e54024bbef44ec58d3fa8d66070acbf94e8c32a4294126ab2e618f4285e
+  data.tar.gz: acf4e565dd754b16ea0c07a11fe67cd21c9d5833ac1cf70c384a8da2c1b7c9ffd324358dbab9a8196d5a249365cc11870e6c807d07dbc631d359b413977f14ed

data/bin/sequel

@@ -18,21 +18,6 @@ load_dirs = []
 exclusive_options = []
 loggers = []
 
-logger_class = Class.new do
-  def initialize(device)
-    @device = device
-  end
-
-  def debug(msg)
-  end
-
-  [:info, :warn, :error].each do |meth|
-    define_method(meth) do |msg|
-      @device.puts("#{Time.now.strftime('%Y-%m-%d %T')} #{meth.to_s.upcase}: #{msg}")
-    end
-  end
-end
-
 options = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
   opts.define_head "Usage: sequel [options] <uri|path> [file]"
@@ -76,7 +61,7 @@ options = OptionParser.new do |opts|
   end
   
   opts.on("-E", "--echo", "echo SQL statements") do
-    loggers << logger_class.new($stdout)
+    loggers << $stdout
   end
   
   opts.on("-I", "--include dir", "specify $LOAD_PATH directory") do |v|
@@ -84,7 +69,9 @@ options = OptionParser.new do |opts|
   end
 
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
-    loggers << logger_class.new(File.open(v, 'a'))
+    file = File.open(v, 'a')
+    file.sync = true
+    loggers << file
   end
   
   opts.on("-L", "--load-dir DIR", "loads all *.rb under specifed directory") do |v|
@@ -168,6 +155,11 @@ begin
     end
   end
 
+  unless loggers.empty?
+    Sequel.extension :stdio_logger
+    loggers.map!{|io| Sequel::StdioLogger.new(io)}
+  end
+
   DB = connect_proc[db]
   load_dirs.each{|d| d.is_a?(Array) ? require(d.first) : Dir["#{d}/**/*.rb"].each{|f| load(f)}}
   if migrate_dir

data/lib/sequel/adapters/jdbc/derby.rb

@@ -115,7 +115,7 @@ module Sequel
         # Temporary table creation on Derby uses DECLARE instead of CREATE.
         def create_table_prefix_sql(name, options)
           if options[:temp]
-            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
+            "DECLARE GLOBAL TEMPORARY TABLE #{create_table_table_name_sql(name, options)}"
           else
             super
           end

data/lib/sequel/adapters/shared/db2.rb

@@ -198,7 +198,7 @@ module Sequel
       # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
       def create_table_prefix_sql(name, options)
         if options[:temp]
-          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
+          "DECLARE GLOBAL TEMPORARY TABLE #{create_table_table_name_sql(name, options)}"
         else
           super
         end

data/lib/sequel/adapters/shared/mssql.rb

@@ -379,9 +379,21 @@ module Sequel
       # a regular and temporary table, with temporary table names starting with
       # a #.
       def create_table_prefix_sql(name, options)
-        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)}"
+        "CREATE TABLE #{create_table_table_name_sql(name, options)}"
       end
-      
+
+      # The SQL to use for the table name for a temporary table.
+      def create_table_temp_table_name_sql(name, _options)
+        case name
+        when String, Symbol
+          "##{name}"
+        when SQL::Identifier
+          "##{name.value}"
+        else
+          raise Error, "temporary table names must be strings, symbols, or Sequel::SQL::Identifier instances on Microsoft SQL Server"
+        end
+      end
+
       # MSSQL doesn't support CREATE TABLE AS, it only supports SELECT INTO.
       # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
       # is given as the argument, it can't work with a string, so raise an

data/lib/sequel/adapters/shared/postgres.rb

@@ -1429,7 +1429,7 @@ module Sequel
           'UNLOGGED '
         end
 
-        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+        "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
       end
 
       # SQL for creating a table with PostgreSQL specific options
@@ -2068,6 +2068,19 @@ module Sequel
         end
       end
 
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DELETE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_delete_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DELETE
+      #
+      #   merge_delete_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DELETE
+      def merge_delete_when_not_matched_by_source(&block)
+        _merge_when(:type=>:delete_not_matched_by_source, &block)
+      end
+
       # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
       # MERGE statement.  If a block is passed, treat it as a virtual row and
       # use it as additional conditions for the match.
@@ -2094,6 +2107,19 @@ module Sequel
         _merge_when(:type=>:not_matched, &block)
       end
 
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN DO NOTHING clause added to the
+      # MERGE BY SOURCE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_not_matched_by_source
+      #   # WHEN NOT MATCHED BY SOURCE THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched_by_source{a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched_by_source(&block)
+        _merge_when(:type=>:not_matched_by_source, &block)
+      end
+
       # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
       def merge_insert(*values, &block)
         h = {:type=>:insert, :values=>values}
@@ -2103,6 +2129,19 @@ module Sequel
         _merge_when(h, &block)
       end
     
+      # Return a dataset with a WHEN NOT MATCHED BY SOURCE THEN UPDATE clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_update_not_matched_by_source(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+      #   # WHEN NOT MATCHED BY SOURCE THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+      #
+      #   merge_update_not_matched_by_source(i1: :i2){a > 30}
+      #   # WHEN NOT MATCHED BY SOURCE AND (a > 30) THEN UPDATE SET i1 = i2
+      def merge_update_when_not_matched_by_source(values, &block)
+        _merge_when(:type=>:update_not_matched_by_source, :values=>values, &block)
+      end
+
       # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
       # always use the user supplied value, and an error is not raised for identity
       # columns that are GENERATED ALWAYS.
@@ -2296,7 +2335,7 @@ module Sequel
 
       # Append the INSERT sql used in a MERGE
       def _merge_insert_sql(sql, data)
-        sql << " THEN INSERT "
+        sql << " THEN INSERT"
         columns, values = _parse_insert_sql_args(data[:values])
         _insert_columns_sql(sql, columns)
         if override = data[:override]
@@ -2305,10 +2344,9 @@ module Sequel
         _insert_values_sql(sql, values)
       end
 
-      def _merge_matched_sql(sql, data)
+      def _merge_do_nothing_sql(sql, data)
         sql << " THEN DO NOTHING"
       end
-      alias _merge_not_matched_sql _merge_matched_sql
 
       # Support MERGE RETURNING on PostgreSQL 17+.
       def _merge_when_sql(sql)

data/lib/sequel/adapters/shared/sqlite.rb

@@ -349,7 +349,7 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options, and VIRTUAL tables with :using option.
       def create_table_sql(name, generator, options)
         if options[:strict] && options[:without_rowid]
           "#{super} STRICT, WITHOUT ROWID"
@@ -357,6 +357,8 @@ module Sequel
           "#{super} STRICT"
         elsif options[:without_rowid]
           "#{super} WITHOUT ROWID"
+        elsif options[:using]
+          "CREATE VIRTUAL TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)} USING #{options[:using]}"
         else
           super
         end

data/lib/sequel/database/connecting.rb

@@ -34,10 +34,7 @@ module Sequel
           uri = URI.parse(conn_string)
           scheme = uri.scheme
           c = adapter_class(scheme)
-          uri_options = c.send(:uri_to_options, uri)
-          uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
-          uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
-          opts = uri_options.merge(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
+          opts = c.send(:options_from_uri, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
         opts = conn_string.merge(opts)

data/lib/sequel/database/misc.rb

@@ -82,6 +82,14 @@ module Sequel
     end
     private_class_method :uri_to_options
 
+    def self.options_from_uri(uri)
+      uri_options = uri_to_options(uri)
+      uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
+      uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
+      uri_options
+    end
+    private_class_method :options_from_uri
+
     # The options hash for this database
     attr_reader :opts
     
@@ -253,15 +261,27 @@ module Sequel
       Sequel.convert_output_timestamp(v, timezone)
     end
 
-    # Returns a string representation of the database object including the
-    # class name and connection URI and options used when connecting (if any).
+    # Returns a string representation of the Database object, including
+    # the database type, host, database, and user, if present.
     def inspect
-      a = []
-      a << uri.inspect if uri
-      if (oo = opts[:orig_opts]) && !oo.empty?
-        a << oo.inspect
+      s = String.new
+      s << "#<#{self.class}"
+      s << " database_type=#{database_type}" if database_type && database_type != adapter_scheme
+
+      keys = [:host, :database, :user]
+      opts = self.opts
+      if !keys.any?{|k| opts[k]} && opts[:uri]
+        opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
+      end
+
+      keys.each do |key|
+        val = opts[key]
+        if val && val != ''
+          s << " #{key}=#{val}"
+        end
       end
-      "#<#{self.class}: #{a.join(' ')}>"
+
+      s << ">"
     end
 
     # Proxy the literal call to the dataset.

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,8 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :using :: Create a VIRTUAL table with the given USING clause. The value should be
+    #           a string, as it is used directly in the SQL query.
     # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
     #                   'rowid' column, that uniquely identifies that row within the table.
     #                   If this option is used, the 'rowid' column is omitted, which can
@@ -775,7 +777,21 @@ module Sequel
 
     # SQL fragment for initial part of CREATE TABLE statement
     def create_table_prefix_sql(name, options)
-      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)}"
+    end
+
+    # The SQL to use for a table name when creating a table.
+    # Use of the :temp option can result in different SQL,
+    # because the rules for temp table naming can differ
+    # between databases, and temp tables should not use the
+    # default_schema.
+    def create_table_table_name_sql(name, options)
+      options[:temp] ? create_table_temp_table_name_sql(name, options) : quote_schema_table(name)
+    end
+
+    # The SQL to use for the table name for a temporary table.
+    def create_table_temp_table_name_sql(name, _options)
+      name.is_a?(String) ? quote_identifier(name) : literal(name)
     end
 
     # SQL fragment for initial part of CREATE VIEW statement

data/lib/sequel/dataset/sql.rb

@@ -901,18 +901,31 @@ module Sequel
     MERGE_TYPE_SQL = {
       :insert => ' WHEN NOT MATCHED',
       :delete => ' WHEN MATCHED',
+      :delete_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :update => ' WHEN MATCHED',
+      :update_not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
       :matched => ' WHEN MATCHED',
       :not_matched => ' WHEN NOT MATCHED',
+      :not_matched_by_source => ' WHEN NOT MATCHED BY SOURCE',
     }.freeze
     private_constant :MERGE_TYPE_SQL
 
+    MERGE_NORMALIZE_TYPE_MAP = {
+      :delete_not_matched_by_source => :delete,
+      :update_not_matched_by_source => :update,
+      :matched => :do_nothing,
+      :not_matched => :do_nothing,
+      :not_matched_by_source => :do_nothing,
+    }.freeze
+    private_constant :MERGE_NORMALIZE_TYPE_MAP
+
     # Add the WHEN clauses to the MERGE SQL
     def _merge_when_sql(sql)
       raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
       merge_when.each do |data|
         type = data[:type]
         sql << MERGE_TYPE_SQL[type]
+        type = MERGE_NORMALIZE_TYPE_MAP[type] || type
         _merge_when_conditions_sql(sql, data)
         send(:"_merge_#{type}_sql", sql, data)
       end