sequel 5.55.0 → 5.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfed01eed8d575d13963be4568c8935f82c47a59b2be32d382439d50153f032d
-  data.tar.gz: 9ac182c00cdc1f54c26626005f990c5e0a05eebaae3b3c5b88bac0fcd770cd8e
+  metadata.gz: 2f02f6a35677e8af2ea2b164f655cc869213864e5b27f67cdd3e17c7db28c546
+  data.tar.gz: ee09f1b4d5b3f4decbf4d4af3b8ae16ef7e488af40011808dac94f8ca05da89f
 SHA512:
-  metadata.gz: c9aceee8528a749c541f74eeb07610b520e4342ac8d11abda3222fd0d760e2ff2a16e1b08b7931f5d24cb0ae9fced020ef695798ffac6c4b4af15508e8927468
-  data.tar.gz: 19e40f6386373bdbba07b5a65faf5ffc99a5693e81b0eaeaf1abffc9b07cc29c2688ea658629f633eb36a3427f74857cab28216d18cfb208cca97a75ea10788e
+  metadata.gz: 89efe5f1a7f2c2eedba5ac1cf336adee1abf489278f79413756e70a41e4ba073ea818562aaf176c1f092e7ab9e763693473a0d96edc6782d9da037c759afd05d
+  data.tar.gz: 84986009ccb30a7a0fd15a555262631f539b95ef9ec8d74d6ca2a4078bd07c33ffda725092bad5afbc93b27901e67dc6d06ca735481448174ac695ef14b6ee99

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 5.58.0 (2022-07-01)
+
+* Support :disable_split_materialized Database option on MySQL to work around optimizer bug in MariaDB 10.5+ affecting association tests (jeremyevans)
+
+* Add Dataset#merge* methods to support MERGE statement on PostgreSQL 15+, MSSQL, Oracle, DB2, H2, HSQLDB, and Derby (jeremyevans)
+
+=== 5.57.0 (2022-06-01)
+
+* Make Database#create_function on PostgreSQL accept :parallel option (bananarne) (#1870)
+
+* Add support for :on_update_current_timestamp column option on MySQL (jeremyevans)
+
+* Add is_distinct_from extension with support for the IS DISTINCT FROM operator (jeremyevans)
+
+=== 5.56.0 (2022-05-01)
+
+* Make alter_table add_column/add_foreign_key methods support :index option to create an index on the column (jeremyevans)
+
+* Support creation of STRICT tables on SQLite 3.37.0+ via create_table :strict option (jeremyevans)
+
+* Add sqlite_json_ops extension for DSL support for JSON functions and operators added in SQLite 3.38.0 (jeremyevans)
+
+* Recognize "INTEGER" type same as "integer" type in the schema dumper, helpful on SQLite 3.37.0+ (jeremyevans)
+
 === 5.55.0 (2022-04-01)
 
 * Support :setup_regexp_function Database option in the sqlite adapter to allow the use of regexps when querying (jeremyevans)

data/README.rdoc

@@ -414,6 +414,31 @@ As with +delete+, +update+ affects all rows in the dataset, so +where+ first,
   # NOT THIS:
   posts.update(:state => 'archived').where(Sequel[:stamp] < Date.today - 7)
 
+=== Merging records
+
+Merging records using the SQL MERGE statment is done using <tt>merge*</tt> methods.
+You use +merge_using+ to specify the merge source and join conditions.
+You can use +merge_insert+, +merge_delete+, and/or +merge_update+ to set the
+INSERT, DELETE, and UPDATE clauses for the merge. +merge_insert+ takes the same
+arguments as +insert+, and +merge_update+ takes the same arguments as +update+.
++merge_insert+, +merge_delete+, and +merge_update+ can all be called with blocks,
+to set the conditions for the related INSERT, DELETE, or UPDATE.
+
+Finally, after calling all of the other <tt>merge_*</tt> methods, you call +merge+
+to run the MERGE statement on the database.
+
+  ds = DB[:m1]
+    merge_using(:m2, i1: :i2).
+    merge_insert(i1: :i2, a: Sequel[:b]+11).
+    merge_delete{a > 30}.
+    merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+
+  ds.merge
+  # MERGE INTO m1 USING m2 ON (i1 = i2)
+  # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+  # WHEN MATCHED AND (a > 30) THEN DELETE
+  # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+
 === Transactions
 
 You can wrap a block of code in a database transaction using the <tt>Database#transaction</tt> method:

data/doc/cheat_sheet.rdoc

@@ -57,6 +57,14 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.where{price < 100}.update(:active => true)
   dataset.where(:active).update(:price => Sequel[:price] * 0.90)
 
+= Merge rows
+
+  dataset.
+    merge_using(:table, col1: :col2).
+    merge_insert(col3: :col4).
+    merge_delete{col5 > 30}.
+    merge_update(col3: Sequel[:col3] + :col4)
+
 == Datasets are Enumerable
 
   dataset.map{|r| r[:name]}

data/doc/opening_databases.rdoc

@@ -102,6 +102,7 @@ The following options can be specified and are passed to the database's internal
 :after_connect :: A callable object called after each new connection is made, with the
                   connection object (and server argument if the callable accepts 2 arguments),
                   useful for customizations that you want to apply to all connections (nil by default).
+:connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
 :max_connections :: The maximum size of the connection pool (4 connections by default on most databases)
 :pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (5 seconds by default)
 :single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
@@ -258,6 +259,8 @@ The following additional options are supported:
 :compress :: Whether to compress data sent/received via the socket connection.
 :config_default_group :: The default group to read from the in the MySQL config file, defaults to "client")
 :config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
+:disable_split_materialized :: Set split_materialized=off in the optimizer settings.  Necessary to pass the associations
+                               integration tests in MariaDB 10.5+, due to a unfixed bug in the optimizer.
 :encoding :: Specify the encoding/character set to use for the connection.
 :fractional_seconds :: On MySQL 5.6.5+, this option is recognized and will include fractional seconds in
                        time/timestamp values, as well as have the schema method create columns that can contain
@@ -278,7 +281,9 @@ if either the :sslca or :sslkey option is given.
 
 This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
 mysql adapter.  The options given are passed to Mysql2::Client.new, see the mysql2 documentation
-for details on what options are supported.
+for details on what options are supported. The :timeout, :auto_is_null, :sql_mode, and :disable_split_materialized
+options supported by the mysql adapter are also supported for mysql2 adapter (and any other adapters connecting to
+mysql, such as the jdbc/mysql adapter).
 
 === odbc 
 

data/doc/release_notes/5.56.0.txt

@@ -0,0 +1,51 @@
+= New Features
+
+* On SQLite, Database#create_table now supports a :strict option to
+  use the STRICT keyword when creating the table.  When this option
+  is used, SQLite will enforce the types for each column. When using
+  this option, you are limited to using the following column types:
+  int, integer, real, text, blob, and any (any allows for dynamic
+  types).
+
+* An sqlite_json_ops extension has been added, providing DSL support
+  for JSON functions and operators supported in SQLite 3.38.0. Usage
+  is similar to the pg_json_ops extension.  First, you create an
+  appropriate object:
+
+    j = Sequel.sqlite_json_op(:json_column)
+    # or:
+    j = Sequel[:json_column].sqlite_json_op
+
+  Then, you call methods on that object to create expressions for the
+  JSON functions and operators:
+
+    j[1]                 # (json_column ->> 1)
+    j.get_text(1)        # (json_column -> 1)
+    j.extract('$.a')     # json_extract(json_column, '$.a')
+ 
+    j.array_length       # json_array_length(json_column)
+    j.type               # json_type(json_column)
+    j.valid              # json_valid(json_column)
+    j.json               # json(json_column)
+ 
+    j.insert('$.a', 1)   # json_insert(json_column, '$.a', 1)
+    j.set('$.a', 1)      # json_set(json_column, '$.a', 1)
+    j.replace('$.a', 1)  # json_replace(json_column, '$.a', 1)
+    j.remove('$.a')      # json_remove(json_column, '$.a')
+    j.patch('{"a":2}')   # json_patch(json_column, '{"a":2}')
+ 
+    j.each               # json_each(json_column)
+    j.tree               # json_tree(json_column)
+
+= Other Improvements
+
+* The alter_table add_column and add_foreign_key methods now support
+  the :index option to create an index on the added column, for
+  compatibility with the :index option on the create_table column and
+  foreign_key methods.
+
+* The schema_dumper extension now treats the "INTEGER" type the same
+  as the "integer" type.  This fixes some behavior when using SQLite
+  3.37.0+.
+
+* Sequel's website has a much improved visual design.

data/doc/release_notes/5.57.0.txt

@@ -0,0 +1,23 @@
+= New Features
+
+* An is_distinct_from extension has been added with support for the
+  SQL IS DISTINCT FROM operator.  This operator is similar to the
+  not equals operator, except in terms of NULL handling.  It returns
+  true if only one side is NULL, and false if both sides are NULL.
+  You can call is_distinct_from on Sequel itself or on Sequel objects:
+
+    Sequel.is_distinct_from(:column_a, :column_b)
+    Sequel[:column_a].is_distinct_from(:column_b)
+    # (column_a IS DISTINCT FROM column_b)
+
+  On databases not supporting IS DISTINCT FROM, support is emulated
+  using a CASE statement.
+
+* Column definitions on MySQL can use the :on_update_current_timestamp
+  option for ON UPDATE CURRENT_TIMESTAMP, which creates a column that
+  will automatically have its value set to CURRENT_TIMESTAMP on every
+  update.
+
+* Database#create_function on PostgreSQL now supports a :parallel
+  option to set the thread safety of the funciton.  The value should
+  be :safe, :unsafe, or :restricted.

data/doc/release_notes/5.58.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* Dataset#merge and related #merge_* methods have been added for the
+  MERGE statement.  MERGE is supported on PostgreSQL 15+, Oracle,
+  Microsoft SQL Server, DB2, H2, HSQLDB, and Derby. You can use MERGE
+  to insert, update, and/or delete in a single query.  You call
+  the #merge_* methods to setup the MERGE statement, and #merge to
+  execute it on the database:
+
+    ds = DB[:m1]
+      merge_using(:m2, i1: :i2).
+      merge_insert(i1: :i2, a: Sequel[:b]+11).
+      merge_delete{a > 30}.
+      merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+
+    ds.merge
+    # MERGE INTO m1 USING m2 ON (i1 = i2)
+    # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    # WHEN MATCHED AND (a > 30) THEN DELETE
+    # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+
+  On PostgreSQL, the following additional MERGE related methods are
+  available:
+
+  * #merge_do_nothing_when_matched
+  * #merge_do_nothing_when_not_matched
+
+* A :disable_split_materialized Database option is now supported on
+  MySQL. This disables split_materialized support in the optimizer,
+  working around a bug in MariaDB 10.5+ that causes failures in
+  Sequel's association tests.

data/doc/testing.rdoc

@@ -113,7 +113,7 @@ The order in which you delete/truncate the tables is important if you are using
 
 = Testing Sequel Itself
 
-Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks, minitest-global_expectations, and minitest-shared_description extensions.  To install the dependencies necessary to test Sequel, run <tt>gem install --development sequel</tt>.
+Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks and minitest-global_expectations extensions.  To install the dependencies necessary to test Sequel, run <tt>gem install --development sequel</tt>.
 
 == rake
 

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

@@ -235,6 +235,11 @@ module Sequel
           false
         end
 
+        # Derby 10.11+ supports MERGE.
+        def supports_merge?
+          db.svn_version >= 1616546
+        end
+
         # Derby does not support IN/NOT IN with multiple columns
         def supports_multiple_column_in?
           false

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

@@ -229,6 +229,11 @@ module Sequel
           false
         end
         
+        # H2 supports MERGE
+        def supports_merge?
+          true
+        end
+
         # H2 doesn't support multiple columns in IN/NOT IN
         def supports_multiple_column_in?
           false

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

@@ -179,6 +179,12 @@ module Sequel
           true
         end
 
+        # HSQLDB 2.3.4+ supports MERGE.  Older versions also support MERGE, but not all
+        # features that are in Sequel's tests.
+        def supports_merge?
+          db.db_version >= 20304
+        end
+
         private
 
         def empty_from_sql

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

@@ -338,6 +338,11 @@ module Sequel
         true
       end
       
+      # DB2 supports MERGE
+      def supports_merge?
+        true
+      end
+
       # DB2 does not support multiple columns in IN.
       def supports_multiple_column_in?
         false
@@ -360,6 +365,29 @@ module Sequel
 
       private
 
+      # Normalize conditions for MERGE WHEN.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " AND "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
       def empty_from_sql
         ' FROM "SYSIBM"."SYSDUMMY1"'
       end

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

@@ -734,6 +734,11 @@ module Sequel
         false
       end
 
+      # MSSQL 2008+ supports MERGE
+      def supports_merge?
+        is_2008_or_later?
+      end
+
       # MSSQL 2005+ supports modifying joined datasets
       def supports_modifying_joins?
         is_2005_or_later?
@@ -824,6 +829,35 @@ module Sequel
 
       private
 
+      # Normalize conditions for MERGE WHEN.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " AND "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
+      # MSSQL requires a semicolon at the end of MERGE.
+      def _merge_when_sql(sql)
+        super
+        sql << ';'
+      end
+
       # MSSQL does not allow ordering in sub-clauses unless TOP (limit) is specified
       def aggregate_dataset
         (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super

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

@@ -333,6 +333,12 @@ module Sequel
           sqls <<  "SET sql_mode = '#{sql_mode}'"
         end
 
+        # Disable the use of split_materialized in the optimizer. This is
+        # needed to pass association tests on MariaDB 10.5+.
+        if opts[:disable_split_materialized] && typecast_value_boolean(opts[:disable_split_materialized])
+          sqls <<  "SET SESSION optimizer_switch='split_materialized=off'"
+        end
+
         sqls
       end
       
@@ -356,6 +362,12 @@ module Sequel
         end
       end
 
+      # Support :on_update_current_timestamp option.
+      def column_definition_default_sql(sql, column)
+        super
+        sql << " ON UPDATE CURRENT_TIMESTAMP" if column[:on_update_current_timestamp]
+      end
+
       # Add generation clause SQL fragment to column creation SQL.
       def column_definition_generated_sql(sql, column)
         if (generated_expression = column[:generated_always_as])

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

@@ -478,6 +478,11 @@ module Sequel
         false
       end
     
+      # Oracle supports MERGE
+      def supports_merge?
+        true
+      end
+
       # Oracle supports NOWAIT.
       def supports_nowait?
         true
@@ -525,6 +530,70 @@ module Sequel
 
       private
 
+      # Handle nil, false, and true MERGE WHEN conditions to avoid non-boolean
+      # type error.
+      def _normalize_merge_when_conditions(conditions)
+        case conditions
+        when nil, false
+          {1=>0}
+        when true
+          {1=>1}
+        when Sequel::SQL::DelayedEvaluation
+          Sequel.delay{_normalize_merge_when_conditions(conditions.call(self))}
+        else
+          conditions
+        end
+      end
+
+      # Handle Oracle's non standard MERGE syntax
+      def _merge_when_sql(sql)
+        raise Error, "no WHEN [NOT] MATCHED clauses provided for MERGE" unless merge_when = @opts[:merge_when]
+        insert = update = delete = nil
+        types = merge_when.map{|d| d[:type]}
+        raise Error, "Oracle does not support multiple INSERT, UPDATE, or DELETE clauses in MERGE" if types != types.uniq
+
+        merge_when.each do |data|
+          case data[:type]
+          when :insert
+            insert = data
+          when :update
+            update = data
+          else # when :delete
+            delete = data
+          end
+        end
+
+        if delete
+          raise Error, "Oracle does not support DELETE without UPDATE clause in MERGE" unless update
+          raise Error, "Oracle does not support DELETE without conditions clause in MERGE" unless delete.has_key?(:conditions)
+        end
+
+        if update
+          sql << " WHEN MATCHED"
+          _merge_update_sql(sql, update)
+          _merge_when_conditions_sql(sql, update)
+
+          if delete
+            sql << " DELETE"
+            _merge_when_conditions_sql(sql, delete)
+          end
+        end
+
+        if insert
+          sql << " WHEN NOT MATCHED"
+          _merge_insert_sql(sql, insert)
+          _merge_when_conditions_sql(sql, insert)
+        end
+      end
+
+      # Handle Oracle's non-standard MERGE WHEN condition syntax.
+      def _merge_when_conditions_sql(sql, data)
+        if data.has_key?(:conditions)
+          sql << " WHERE "
+          literal_append(sql, _normalize_merge_when_conditions(data[:conditions]))
+        end
+      end
+
       # Allow preparing prepared statements, since determining the prepared sql to use for
       # a prepared statement requires calling prepare on that statement.
       def allow_preparing_prepared_statements?

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

@@ -414,6 +414,7 @@ module Sequel
       #                  2 :: argument name
       #                  3 :: argument mode (e.g. in, out, inout)
       #         :behavior :: Should be IMMUTABLE, STABLE, or VOLATILE.  PostgreSQL assumes VOLATILE by default.
+      #         :parallel :: The thread safety attribute of the function. Should be SAFE, UNSAFE, RESTRICTED. PostgreSQL assumes UNSAFE by default.
       #         :cost :: The estimated cost of the function, used by the query planner.
       #         :language :: The language the function uses.  SQL is the default.
       #         :link_symbol :: For a dynamically loaded see function, the function's link symbol if different from the definition argument.
@@ -1117,6 +1118,7 @@ module Sequel
         #{opts[:behavior].to_s.upcase if opts[:behavior]}
         #{'STRICT' if opts[:strict]}
         #{'SECURITY DEFINER' if opts[:security_definer]}
+        #{"PARALLEL #{opts[:parallel].to_s.upcase}" if opts[:parallel]}
         #{"COST #{opts[:cost]}" if opts[:cost]}
         #{"ROWS #{opts[:rows]}" if opts[:rows]}
         #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
@@ -1525,7 +1527,7 @@ module Sequel
       LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze).freeze
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
-      Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
+      Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns override values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if server_version >= 90100', %w'with update table set from where returning'], ['else', %w'update table set from where returning']])
 
@@ -1758,6 +1760,41 @@ module Sequel
         nil
       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.
+      #
+      #   merge_do_nothing_when_matched
+      #   # WHEN MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_matched{a > 30}
+      #   # WHEN MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_matched(&block)
+        _merge_when(:type=>:matched, &block)
+      end
+
+      # Return a dataset with a WHEN NOT 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.
+      #
+      #   merge_do_nothing_when_not_matched
+      #   # WHEN NOT MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched{a > 30}
+      #   # WHEN NOT MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched(&block)
+        _merge_when(:type=>:not_matched, &block)
+      end
+
+      # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
+      def merge_insert(*values, &block)
+        h = {:type=>:insert, :values=>values}
+        if override = @opts[:override]
+          h[:override] = insert_override_sql(String.new)
+        end
+        _merge_when(h, &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.
@@ -1825,6 +1862,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL 15+ supports MERGE.
+      def supports_merge?
+        server_version >= 150000
+      end
+
       # PostgreSQL supports NOWAIT.
       def supports_nowait?
         true
@@ -1935,6 +1977,22 @@ module Sequel
 
       private
 
+      # Append the INSERT sql used in a MERGE
+      def _merge_insert_sql(sql, data)
+        sql << " THEN INSERT "
+        columns, values = _parse_insert_sql_args(data[:values])
+        _insert_columns_sql(sql, columns)
+        if override = data[:override]
+          sql << override
+        end
+        _insert_values_sql(sql, values)
+      end
+
+      def _merge_matched_sql(sql, data)
+        sql << " THEN DO NOTHING"
+      end
+      alias _merge_not_matched_sql _merge_matched_sql
+
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
         to = @opts[:truncate_opts] || OPTS
@@ -2011,14 +2069,13 @@ module Sequel
       end
 
       # Support OVERRIDING SYSTEM|USER VALUE in insert statements
-      def insert_values_sql(sql)
+      def insert_override_sql(sql)
         case opts[:override]
         when :system
           sql << " OVERRIDING SYSTEM VALUE"
         when :user
           sql << " OVERRIDING USER VALUE"
         end
-        super
       end
 
       # For multiple table support, PostgreSQL requires at least

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

@@ -337,6 +337,11 @@ module Sequel
         ps
       end
 
+      # Support creating STRICT tables via :strict option
+      def create_table_sql(name, generator, options)
+        "#{super}#{' STRICT' if options[:strict]}"
+      end
+
       # SQLite support creating temporary views.
       def create_view_prefix_sql(name, options)
         create_view_sql_append_columns("CREATE #{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}", options[:columns])
@@ -347,6 +352,7 @@ module Sequel
         /foreign key constraint failed\z/i => ForeignKeyConstraintViolation,
         /\A(SQLITE ERROR 275 \(CONSTRAINT_CHECK\) : )?CHECK constraint failed/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed\z/ => ConstraintViolation,
+        /\Acannot store [A-Z]+ value in [A-Z]+ column / => ConstraintViolation,
         /may not be NULL\z|NOT NULL constraint failed: .+\z/ => NotNullConstraintViolation,
         /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
       }.freeze

data/lib/sequel/database/schema_generator.rb

@@ -146,6 +146,9 @@ module Sequel
       #
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
+      # :on_update_current_timestamp :: Use ON UPDATE CURRENT TIMESTAMP when defining the column,
+      #                                 which will update the column value to CURRENT_TIMESTAMP
+      #                                 on every UPDATE.
       #
       # Microsoft SQL Server specific options:
       #
@@ -387,8 +390,7 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       #
@@ -401,7 +403,10 @@ module Sequel
       # :after :: The name of an existing column that the new column should be positioned after
       # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
-        @operations << {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        op = {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        index_opts = op.delete(:index)
+        @operations << op
+        add_index(name, index_opts.is_a?(Hash) ? index_opts : OPTS) if index_opts
         nil
       end
       
@@ -430,8 +435,7 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add