sequel 3.36.1 → 3.37.0

data/doc/schema_modification.rdoc

@@ -98,6 +98,10 @@ You've seen this one used already.  It's used to create an autoincrementing inte
 
   create_table(:a0){primary_key :id}
 
+If you want an autoincrementing 64-bit integer:
+
+  create_table(:a0){primary_key :id, :type=>Bignum}
+
 If you want to create a primary key column that doesn't use an autoincrementing integer, you should
 not use this method.  Instead, you should use the :primary_key option to the +column+ method or type
 method:

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

@@ -112,7 +112,7 @@ module Sequel
 
         # Treat clob as string instead of blob
         def schema_column_type(db_type)
-          db_type == 'clob' ? :string : super
+          db_type.downcase == 'clob' ? :string : super
         end
 
         # Use BIGINT IDENTITY for identity columns that use bigint, fixes

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

@@ -45,24 +45,43 @@ module Sequel
         APOS = Dataset::APOS
         
         class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
-          # Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
-          def pg_array(v)
-            _pg_array(v.array)
-          end
-
           # Convert Java::OrgPostgresqlUtil::PGobject to ruby strings
           def pg_object(v)
             v.to_string
           end
+        end
+
+        # Handle conversions of PostgreSQL array instances
+        class PGArrayConverter
+          # Set the method that will return the correct conversion
+          # proc for elements of this array.
+          def initialize(meth)
+            @conversion_proc_method = meth
+            @conversion_proc = nil
+          end
+          
+          # Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
+          def call(v)
+            _pg_array(v.array)
+          end
 
           private
 
           # Handle multi-dimensional Java arrays by recursively mapping them
-          # to ruby arrays.
+          # to ruby arrays of ruby values.
           def _pg_array(v)
             v.to_ary.map do |i|
               if i.respond_to?(:to_ary)
                 _pg_array(i)
+              elsif i
+                if @conversion_proc.nil?
+                  @conversion_proc = @conversion_proc_method.call(i)
+                end
+                if @conversion_proc
+                  @conversion_proc.call(i)
+                else
+                  i
+                end
               else
                 i
               end
@@ -70,7 +89,6 @@ module Sequel
           end
         end
 
-        PG_ARRAY_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_array)
         PG_OBJECT_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_object)
       
         # Add the shared PostgreSQL prepared statement methods
@@ -88,7 +106,7 @@ module Sequel
         def convert_type_proc(v)
           case v
           when Java::OrgPostgresqlJdbc4::Jdbc4Array
-            PG_ARRAY_METHOD
+            PGArrayConverter.new(method(:convert_type_proc))
           when Java::OrgPostgresqlUtil::PGobject
             PG_OBJECT_METHOD
           else

data/lib/sequel/adapters/mysql2.rb

@@ -47,6 +47,7 @@ module Sequel
         opts[:username] ||= opts[:user]
         opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
+        conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
 
         sqls = mysql_connection_setting_sqls
 
@@ -86,7 +87,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :symbolize_keys => true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :cast_booleans => convert_tinyint_to_bool)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -149,7 +150,7 @@ module Sequel
             cols = r.fields
             @columns = cols2 = cols.map{|c| output_identifier(c.to_s)}
             cs = cols.zip(cols2)
-            r.each(:cast_booleans => db.convert_tinyint_to_bool) do |row|
+            r.each do |row|
               h = {}
               cs.each do |a, b|
                 h[b] = row[a]
@@ -158,7 +159,7 @@ module Sequel
             end
           else
             @columns = r.fields
-            r.each(:cast_booleans => db.convert_tinyint_to_bool){|h| yield h}
+            r.each{|h| yield h}
           end
         end
         self

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

@@ -16,8 +16,8 @@ module Sequel
               log_yield(sql){conn.do(sql)}
               begin
                 s = log_yield(LAST_INSERT_ID_SQL){conn.run(LAST_INSERT_ID_SQL)}
-                if (rows = s.fetch_all) and (row = rows.first)
-                  Integer(row.first)
+                if (rows = s.fetch_all) and (row = rows.first) and (v = row.first)
+                  Integer(v)
                 end
               ensure
                 s.drop if s

data/lib/sequel/adapters/postgres.rb

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/shared/postgres'
+Sequel.require 'adapters/utils/pg_types'
 
 begin 
   require 'pg' 
@@ -87,68 +88,11 @@ module Sequel
   Dataset::NON_SQL_OPTIONS << :cursor
   module Postgres
     CONVERTED_EXCEPTIONS << PGError
-    
-    NAN             = 0.0/0.0
-    PLUS_INFINITY   = 1.0/0.0
-    MINUS_INFINITY  = -1.0/0.0
-    NAN_STR             = 'NaN'.freeze
-    PLUS_INFINITY_STR   = 'Infinity'.freeze
-    MINUS_INFINITY_STR  = '-Infinity'.freeze
-    TRUE_STR = 't'.freeze
-    DASH_STR = '-'.freeze
-    
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == TRUE_STR end
+
+    PG_TYPES[17] = Class.new do
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when NAN_STR
-          NAN
-        when PLUS_INFINITY_STR
-          PLUS_INFINITY
-        when MINUS_INFINITY_STR
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
-    end.new
-
-    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
-    # Non-builtin types that don't have fixed numbers should use this to register
-    # conversion procs.
-    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
-
-    # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {} unless defined?(PG_TYPES)
-
-    {
-      [16] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 22, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [790, 1700] => ::BigDecimal.method(:new),
-      [1083, 1266] => ::Sequel.method(:string_to_time),
-    }.each do |k,v|
-      k.each{|n| PG_TYPES[n] = v}
-    end
-    
-    class << self
-      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
-      # the date in a known format that Sequel can parse faster.  This can be turned off
-      # if you require a date style other than ISO.
-      attr_reader :use_iso_date_format
-    end
+    end.new.method(:bytea)
 
-    # Modify the type translator for the date type depending on the value given.
-    def self.use_iso_date_format=(v)
-      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
-      @use_iso_date_format = v
-    end
-    self.use_iso_date_format = true
-    
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn

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

@@ -316,7 +316,7 @@ module Sequel
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with delete from output from2 where')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with insert into columns output values')
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns into from lock join where group having order compounds')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with update table set output from where')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with update limit table set output from where')
       NOLOCK = ' WITH (NOLOCK)'.freeze
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
@@ -690,6 +690,7 @@ module Sequel
           end
         end
       end
+      alias update_limit_sql select_limit_sql
 
       # Support different types of locking styles
       def select_lock_sql(sql)

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

@@ -369,11 +369,6 @@ module Sequel
         end
       end
 
-      # MySQL treats integer primary keys as autoincrementing.
-      def schema_autoincrementing_primary_key?(schema)
-        super and schema[:db_type] =~ /int/io
-      end
-
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])

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

@@ -50,6 +50,43 @@ module Sequel
       attr_accessor :force_standard_strings
     end
 
+    class CreateTableGenerator < Sequel::Schema::Generator
+      # Add an exclusion constraint when creating the table. elements should be
+      # an array of 2 element arrays, with the first element being the column or
+      # expression the exclusion constraint is applied to, and the second element
+      # being the operator to use for the column/expression to check for exclusion.
+      #
+      # Example:
+      #
+      #   exclusion_constraint([[:col1, '&&'], [:col2, '=']])
+      #   # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
+      #
+      # Options supported:
+      #
+      # :name :: Name the constraint with the given name (useful if you may
+      #          need to drop the constraint later)
+      # :using :: Override the index_method for the exclusion constraint (defaults to gist).
+      # :where :: Create a partial exclusion constraint, which only affects
+      #           a subset of table rows, value should be a filter expression.
+      def exclude(elements, opts={})
+        constraints << {:type => :exclude, :elements => elements}.merge(opts)
+      end
+    end
+
+    class AlterTableGenerator < Sequel::Schema::AlterTableGenerator
+      # Adds an exclusion constraint to an existing table, see
+      # CreateTableGenerator#exclude.
+      def add_exclusion_constraint(elements, opts={})
+        @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge(opts)
+      end
+
+      # Validate the constraint with the given name, which should have
+      # been added previously with NOT VALID.
+      def validate_constraint(name)
+        @operations << {:op => :validate_constraint, :name => name}
+      end
+    end
+
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
       EXCLUDE_SCHEMAS = /pg_*|information_schema/i
@@ -444,7 +481,12 @@ module Sequel
 
       private
 
-      # Handle :using option for set_column_type op.
+      # Use a PostgreSQL-specific alter table generator
+      def alter_table_generator_class
+        Postgres::AlterTableGenerator
+      end
+    
+      # Handle :using option for set_column_type op, and the :validate_constraint op.
       def alter_table_sql(table, op)
         case op[:op]
         when :set_column_type
@@ -455,6 +497,8 @@ module Sequel
             s << literal(using)
           end
           s
+        when :validate_constraint
+          "ALTER TABLE #{quote_schema_table(table)} VALIDATE CONSTRAINT #{quote_identifier(op[:name])}"
         else
           super
         end
@@ -499,6 +543,23 @@ module Sequel
         sqls
       end
 
+      # Handle exclusion constraints.
+      def constraint_definition_sql(constraint)
+        case constraint[:type]
+        when :exclude
+          elements = constraint[:elements].map{|c, op| "#{literal(c)} WITH #{op}"}.join(', ')
+          "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
+        when :foreign_key
+          sql = super
+          if constraint[:not_valid]
+            sql << " NOT VALID"
+          end
+          sql
+        else
+          super
+        end
+      end
+
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts={})
         args = opts[:args]
@@ -530,6 +591,11 @@ module Sequel
         "CREATE SCHEMA #{quote_identifier(name)}"
       end
 
+      # Use a PostgreSQL-specific create table generator
+      def create_table_generator_class
+        Postgres::CreateTableGenerator
+      end
+    
       # SQL for creating a database trigger.
       def create_trigger_sql(table, name, function, opts={})
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
@@ -642,7 +708,7 @@ module Sequel
       # PostgreSQL's autoincrementing primary keys are of type integer or bigint
       # using a nextval function call as a default.
       def schema_autoincrementing_primary_key?(schema)
-        super and schema[:db_type] =~ /\A(?:integer|bigint)\z/io and schema[:default]=~/\Anextval/io
+        super && schema[:default] =~ /\Anextval/io
       end
 
       # The dataset used for parsing table schemas, using the pg_* system catalogs.

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

@@ -383,7 +383,7 @@ module Sequel
       
       # SQLite treats integer primary keys as autoincrementing (alias of rowid).
       def schema_autoincrementing_primary_key?(schema)
-        super and schema[:db_type].downcase == 'integer'
+        super && schema[:db_type].downcase == 'integer'
       end
 
       # SQLite supports schema parsing using the table_info PRAGMA, so
@@ -428,6 +428,22 @@ module Sequel
       DOUBLE_BACKTICK = '``'.freeze
       BLOB_START = "X'".freeze
       HSTAR = "H*".freeze
+      DATE_OPEN = "date(".freeze
+      DATETIME_OPEN = "datetime(".freeze
+
+      def cast_sql_append(sql, expr, type)
+        if type == Time or type == DateTime
+          sql << DATETIME_OPEN
+          literal_append(sql, expr)
+          sql << PAREN_CLOSE
+        elsif type == Date
+          sql << DATE_OPEN
+          literal_append(sql, expr)
+          sql << PAREN_CLOSE
+        else
+          super
+        end
+      end
 
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -41,7 +41,12 @@ module Sequel
     # requires an order.
     def select_sql
       return super unless o = @opts[:offset]
-      raise(Error, "#{db.database_type} requires an order be provided if using an offset") unless order = @opts[:order]
+
+      order = @opts[:order] || default_offset_order
+      if order.nil? || order.empty?
+        raise(Error, "#{db.database_type} requires an order be provided if using an offset")
+      end
+
       dsa1 = dataset_alias(1)
       rn = row_number_column
       sql = @opts[:append_sql] || ''
@@ -57,6 +62,12 @@ module Sequel
 
     private
 
+    # The default order to use for datasets with offsets, if no order is defined.
+    # By default, orders by all of the columns in the dataset.
+    def default_offset_order
+      clone(:append_sql=>'').columns
+    end
+
     # This emulation adds an extra row number column that should be
     # eliminated.
     def offset_returns_row_number_column?

data/lib/sequel/adapters/utils/pg_types.rb

@@ -0,0 +1,76 @@
+module Sequel
+  module Postgres
+    NAN             = 0.0/0.0
+    PLUS_INFINITY   = 1.0/0.0
+    MINUS_INFINITY  = -1.0/0.0
+    NAN_STR             = 'NaN'.freeze
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    TRUE_STR = 't'.freeze
+    DASH_STR = '-'.freeze
+    
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s == TRUE_STR end
+      def integer(s) s.to_i end
+      def float(s) 
+        case s
+        when NAN_STR
+          NAN
+        when PLUS_INFINITY_STR
+          PLUS_INFINITY
+        when MINUS_INFINITY_STR
+          MINUS_INFINITY
+        else
+          s.to_f 
+        end
+      end
+      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
+      def bytea(str)
+        str = if str =~ /\A\\x/
+          # PostgreSQL 9.0+ bytea hex format
+          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
+        else
+          # Historical PostgreSQL bytea escape format
+          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
+            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+          }
+        end
+        ::Sequel::SQL::Blob.new(str)
+      end
+    end.new
+
+    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+
+    # Hash with integer keys and callable values for converting PostgreSQL types.
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+    {
+      [16] => tt.method(:boolean),
+      [17] => tt.method(:bytea),
+      [20, 21, 23, 26] => tt.method(:integer),
+      [700, 701] => tt.method(:float),
+      [1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
+    }.each do |k,v|
+      k.each{|n| PG_TYPES[n] = v}
+    end
+    
+    class << self
+      # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
+      # the date in a known format that Sequel can parse faster.  This can be turned off
+      # if you require a date style other than ISO.
+      attr_reader :use_iso_date_format
+    end
+
+    # Modify the type translator for the date type depending on the value given.
+    def self.use_iso_date_format=(v)
+      PG_TYPES[1082] = v ? TYPE_TRANSLATOR.method(:date) : Sequel.method(:string_to_date)
+      @use_iso_date_format = v
+    end
+    self.use_iso_date_format = true
+  end
+end