sequel 4.39.0 → 4.40.0

data/lib/sequel/database/connecting.rb

@@ -135,13 +135,14 @@ module Sequel
     #
     #   # in file sequel/adapters/shared/mydb.rb
     #   module Sequel::MyDB
-    #     Sequel::Database.set_shared_adapter_scheme :mydb, :self
+    #     Sequel::Database.set_shared_adapter_scheme :mydb, self
     #
     #     def self.mock_adapter_setup(db)
     #       # ...
     #     end
     #
     #     module DatabaseMethods
+    #       extend Sequel::Database::ResetIdentifierMangling
     #       # ...
     #     end
     #

data/lib/sequel/database/features.rb

@@ -108,6 +108,13 @@ module Sequel
 
     private
 
+    # Whether the database supports adding primary key constraints on NULLable columns,
+    # automatically making them NOT NULL.  If false, the columns must be set NOT NULL
+    # before the primary key constraint is added.
+    def can_add_primary_key_constraint_on_nullable_columns?
+      true
+    end
+
     # Whether the database supports combining multiple alter table
     # operations into a single query, false by default.
     def supports_combining_alter_table_ops?

data/lib/sequel/database/query.rb

@@ -159,7 +159,7 @@ module Sequel
       end
 
       cols = schema_parse_table(table_name, opts)
-      raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+      raise(Error, "schema parsing returned no columns, table #{table_name.inspect} probably doesn't exist") if cols.nil? || cols.empty?
 
       primary_keys = 0
       auto_increment_set = false

data/lib/sequel/database/schema_methods.rb

@@ -422,7 +422,15 @@ module Sequel
     
     # Apply the operations in the given generator to the table given by name.
     def apply_alter_table_generator(name, generator)
-      apply_alter_table(name, generator.operations)
+      ops = generator.operations
+
+      unless can_add_primary_key_constraint_on_nullable_columns?
+        if add_pk = ops.find{|op| op[:op] == :add_constraint && op[:type] == :primary_key}
+          ops = add_pk[:columns].map{|column| {:op => :set_column_null, :name => column, :null => false}} + ops
+        end
+      end
+
+      apply_alter_table(name, ops)
     end
 
     # The class used for alter_table generators.
@@ -558,8 +566,16 @@ module Sequel
     # Add null/not null SQL fragment to column creation SQL.
     def column_definition_null_sql(sql, column)
       null = column.fetch(:null, column[:allow_null])
-      sql << NOT_NULL if null == false
-      sql << NULL if null == true
+      if null.nil? && !can_add_primary_key_constraint_on_nullable_columns? && column[:primary_key]
+        null = false
+      end
+
+      case null
+      when false
+        sql << NOT_NULL
+      when true
+        sql << NULL
+      end
     end
     
     # Add primary key SQL fragment to column creation SQL.
@@ -702,6 +718,17 @@ module Sequel
           end
         end
       end
+
+      unless can_add_primary_key_constraint_on_nullable_columns?
+        if pk = generator.constraints.find{|op| op[:type] == :primary_key}
+          pk[:columns].each do |column|
+            if matched_column = generator.columns.find{|gc| gc[:name] == column}
+              matched_column[:null] = false
+            end
+          end
+        end
+      end
+
       "#{create_table_prefix_sql(name, options)} (#{column_list_sql(generator)})"
     end
 

data/lib/sequel/database/transactions.rb

@@ -80,7 +80,7 @@ module Sequel
     def rollback_checker(opts=OPTS)
       synchronize(opts[:server]) do |conn|
         raise Error, "not in a transaction" unless t = _trans(conn)
-        t[:rollback_checker] ||= proc{t[:rolled_back]}
+        t[:rollback_checker] ||= proc{Sequel.synchronize{t[:rolled_back]}}
       end
     end
 
@@ -382,7 +382,9 @@ module Sequel
       callbacks = transaction_hooks(conn, committed)
 
       if transaction_finished?(conn)
-        @transactions[conn][:rolled_back] = !committed
+        h = @transactions[conn]
+        rolled_back = !committed
+        Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
       end
 

data/lib/sequel/dataset/actions.rb

@@ -10,7 +10,7 @@ module Sequel
     # ---------------------
     
     # Action methods defined by Sequel that execute code on the database.
-    ACTION_METHODS = (<<-METHS).split.map(&:to_sym)
+    ACTION_METHODS = (<<-METHS).split.map(&:to_sym).freeze
       << [] all avg count columns columns! delete each
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map

data/lib/sequel/dataset/graph.rb

@@ -246,8 +246,13 @@ module Sequel
     # double embedded underscores which would be considered an implicit qualified identifier
     # if not wrapped in an SQL::Identifier.
     def qualifier_from_alias_symbol(aliaz, identifier)
-      identifier = identifier.column if identifier.is_a?(SQL::QualifiedIdentifier)
       case identifier
+      when SQL::QualifiedIdentifier
+        if identifier.column.is_a?(String)
+          Sequel.identifier(aliaz)
+        else
+          aliaz
+        end
       when SQL::Identifier
         Sequel.identifier(aliaz)
       else

data/lib/sequel/dataset/query.rb

@@ -18,23 +18,23 @@ module Sequel
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :defaults, :overrides, :graph, :eager, :eager_graph, :graph_aliases]
+    NON_SQL_OPTIONS = [:server, :graph, :eager, :eager_graph, :graph_aliases].freeze
     
     # These symbols have _join methods created (e.g. inner_join) that
     # call join_table with the symbol, passing along the arguments and
     # block from the method call.
-    CONDITIONED_JOIN_TYPES = [:inner, :full_outer, :right_outer, :left_outer, :full, :right, :left]
+    CONDITIONED_JOIN_TYPES = [:inner, :full_outer, :right_outer, :left_outer, :full, :right, :left].freeze
 
     # These symbols have _join methods created (e.g. natural_join).
     # They accept a table argument and options hash which is passed to join_table,
     # and they raise an error if called with a block.
-    UNCONDITIONED_JOIN_TYPES = [:natural, :natural_left, :natural_right, :natural_full, :cross]
+    UNCONDITIONED_JOIN_TYPES = [:natural, :natural_left, :natural_right, :natural_full, :cross].freeze
     
     # All methods that return modified datasets with a joined table added.
-    JOIN_METHODS = (CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]
+    JOIN_METHODS = ((CONDITIONED_JOIN_TYPES + UNCONDITIONED_JOIN_TYPES).map{|x| "#{x}_join".to_sym} + [:join, :join_table]).freeze
     
     # Methods that return modified datasets
-    QUERY_METHODS = (<<-METHS).split.map(&:to_sym) + JOIN_METHODS
+    QUERY_METHODS = ((<<-METHS).split.map(&:to_sym) + JOIN_METHODS).freeze
       add_graph_aliases and distinct except exclude exclude_having exclude_where
       filter for_update from from_self graph grep group group_and_count group_append group_by having intersect invert
       limit lock_style naked offset or order order_append order_by order_more order_prepend qualify
@@ -221,7 +221,8 @@ module Sequel
     #   # SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo(c1, c2)
     def from_self(opts=OPTS)
       fs = {}
-      @opts.keys.each{|k| fs[k] = nil unless NON_SQL_OPTIONS.include?(k)}
+      non_sql = non_sql_options
+      @opts.keys.each{|k| fs[k] = nil unless non_sql.include?(k)}
       clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
     end
 
@@ -1043,7 +1044,8 @@ module Sequel
     #   SELECT * FROM table
     #   SELECT table.* FROM table
     def simple_select_all?
-      o = @opts.reject{|k,v| v.nil? || NON_SQL_OPTIONS.include?(k)}
+      non_sql = non_sql_options
+      o = @opts.reject{|k,v| v.nil? || non_sql.include?(k)}
       if (f = o[:from]) && f.length == 1 && (f.first.is_a?(Symbol) || f.first.is_a?(SQL::AliasedExpression))
         case o.length
         when 1
@@ -1161,6 +1163,11 @@ module Sequel
       server?(:default)
     end
 
+    # Dataset options that do not affect the generated SQL.
+    def non_sql_options
+      NON_SQL_OPTIONS
+    end
+
     # Treat the +block+ as a virtual_row block if not +nil+ and
     # add the resulting columns to the +columns+ array (modifies +columns+).
     def virtual_row_columns(columns, block)

data/lib/sequel/dataset/sql.rb

@@ -761,8 +761,8 @@ module Sequel
     #
     #   ds.split_qualifiers(:s) # ['s']
     #   ds.split_qualifiers(:t__s) # ['t', 's']
-    #   ds.split_qualifiers(Sequel.qualify(:d, :t__s)) # ['d', 't', 's']
-    #   ds.split_qualifiers(Sequel.qualify(:h__d, :t__s)) # ['h', 'd', 't', 's']
+    #   ds.split_qualifiers(Sequel[:d][:t__s]) # ['d', 't', 's']
+    #   ds.split_qualifiers(Sequel[:h__d][:t__s]) # ['h', 'd', 't', 's']
     def split_qualifiers(table_name, *args)
       case table_name
       when SQL::QualifiedIdentifier

data/lib/sequel/extensions/core_extensions.rb

@@ -12,6 +12,8 @@ def Sequel.core_extensions?
   true
 end
 
+Sequel.extension :symbol_as
+
 # Sequel extends +Array+ to add methods to implement the SQL DSL.
 # Most of these methods require that the array not be empty and that it
 # must consist solely of other arrays that have exactly two elements.
@@ -195,7 +197,6 @@ end
 
 # Sequel extends +Symbol+ to add methods to implement the SQL DSL.
 class Symbol
-  include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
   include Sequel::SQL::OrderMethods
   include Sequel::SQL::BooleanMethods

data/lib/sequel/extensions/pg_row.rb

@@ -432,7 +432,7 @@ module Sequel
 
           # Get basic oid information for the composite type.
           ds = from(:pg_type).
-            select(:pg_type__oid, :typrelid, :typarray).
+            select{[pg_type[:oid], :typrelid, :typarray]}.
             where([[:typtype, 'c'], [:typname, type_name.to_s]])
           if type_schema
             ds = ds.join(:pg_namespace, [[:oid, :typnamespace], [:nspname, type_schema.to_s]])
@@ -454,7 +454,7 @@ module Sequel
             where{attnum > 0}.
             exclude(:attisdropped).
             order(:attnum).
-            select_map([:attname, Sequel.case({0=>:atttypid}, :pg_type__typbasetype, :pg_type__typbasetype).as(:atttypid)])
+            select_map{[:attname, Sequel.case({0=>:atttypid}, pg_type[:typbasetype], pg_type[:typbasetype]).as(:atttypid)]}
           if res.empty?
             raise Error, "no columns for row type #{db_type.inspect} in database"
           end

data/lib/sequel/extensions/s.rb

@@ -0,0 +1,57 @@
+# frozen-string-literal: true
+#
+# The s extension adds Sequel::S, a module containing a private #S
+# method that calls Sequel.expr.  It's designed as a shortcut so
+# that instead of:
+#
+#   Sequel.expr(:column) + 1
+#   # or
+#   Sequel.expr{column + 1}
+#
+# you can just write:
+#
+#   S(:column) + 1
+#   # or
+#   S{column + 1}
+#
+# To load the extension:
+#
+#   Sequel.extension :s
+#
+# Then you can include the Sequel::S module into whatever classes or
+# objects you care about:
+#
+#   Sequel::Model.send(:include, Sequel::S)   # available in model instance methods
+#   Sequel::Model.extend(Sequel::S)           # available in model class methods
+#   Sequel::Dataset.send(:include, Sequel::S) # available in dataset methods
+#
+# or just into Object if you want it available everywhere:
+#
+#   Object.send(:include, Sequel::SQL)
+#
+# If you are using Ruby 2+, and you would like to use refinements, you
+# can use Sequel::S as a refinement, in which case the private #S method
+# will be available on all objects while the refinement is active.
+#
+#   using Sequel::S
+#
+#   S(:column) + 1
+#
+# Related module: Sequel::S
+
+
+# 
+module Sequel::S
+  private
+
+  # Delegate to Sequel.expr
+  def S(*a, &block)
+    Sequel.expr(*a, &block)
+  end
+
+  if RUBY_VERSION >= '2.0.0'
+    refine Object do
+      include Sequel::S
+    end
+  end
+end

data/lib/sequel/extensions/set_overrides.rb

@@ -21,7 +21,6 @@
 #
 module Sequel
   module SetOverrides
-    Dataset::NON_SQL_OPTIONS.concat([:defaults, :overrides])
     Dataset.def_mutation_method(:set_defaults, :set_overrides, :module=>self)
 
     # Set overrides/defaults for insert hashes
@@ -70,6 +69,11 @@ module Sequel
       vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
       vals
     end
+
+    # Dataset options that do not affect the generated SQL.
+    def non_sql_options
+      super + [:defaults, :overrides]
+    end
   end
 
   Dataset.register_extension(:set_overrides, SetOverrides)

data/lib/sequel/extensions/sql_expr.rb

@@ -14,6 +14,7 @@
 #
 #   Sequel.extension :sql_expr
 
+#
 class Object
   # Return the object wrapper in an appropriate Sequel expression object.
   def sql_expr

data/lib/sequel/extensions/symbol_aref.rb

@@ -0,0 +1,71 @@
+# frozen-string-literal: true
+#
+# The symbol_aref extension makes Symbol#[] support Symbol,
+# Sequel::SQL::Indentifier, and Sequel::SQL::QualifiedIdentifier instances,
+# returning appropriate Sequel::SQL::QualifiedIdentifier instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_aref_refinement extension.
+#
+# If you are using the ruby18_symbol_extensions, and would like symbol_aref
+# to take affect, load the symbol_aref extension after the
+# ruby18_symbol_extensions.
+#
+# Related module: Sequel::SymbolAref
+
+if RUBY_VERSION >= '2.0'
+  module Sequel::SymbolAref
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+
+  class Symbol
+    prepend Sequel::SymbolAref
+  end
+else
+  class Symbol
+    if method_defined?(:[])
+      alias_method :aref_before_sequel, :[] 
+    end
+
+    if RUBY_VERSION >= '1.9'
+      # 
+      def [](v)
+        case v
+        when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+          Sequel::SQL::QualifiedIdentifier.new(self, v)
+        else
+          aref_before_sequel(v)
+        end
+      end
+    else
+      def [](*v)
+        arg = v.first if v.length == 1
+
+        case arg
+        when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+          Sequel::SQL::QualifiedIdentifier.new(self, arg)
+        else
+          respond_to?(:aref_before_sequel) ? aref_before_sequel(*v) : super(*v)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/extensions/symbol_aref_refinement.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# The symbol_aref_refinement extension adds a refinement that makes
+# Symbol#[] support Symbol, #Sequel::SQL::Indentifier, and
+# Sequel::SQL::QualifiedIdentifier instances, returning appropriate
+# Sequel::SQL::QualifiedIdentifier instances.  It's designed as a
+# shortcut so that instead of:
+#
+#   Sequel[:table][:column] # table.column
+#
+# you can just write:
+#   
+#   :table[:column] # table.column
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_aref_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAref
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_aref extension.
+#
+# Related module: Sequel::SymbolAref
+
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+
+module Sequel::SymbolAref
+  refine Symbol do
+    def [](v)
+      case v
+      when Symbol, Sequel::SQL::Identifier, Sequel::SQL::QualifiedIdentifier
+        Sequel::SQL::QualifiedIdentifier.new(self, v)
+      else
+        super
+      end
+    end
+  end
+end