sequel 4.14.0 → 4.15.0

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

@@ -809,27 +809,40 @@ module Sequel
 
       # DDL statement for creating a table with the given name, columns, and options
       def create_table_prefix_sql(name, options)
-        if on_commit = options[:on_commit]
-          raise(Error, "can't provide :on_commit without :temp to create_table") unless options[:temp]
-          raise(Error, "unsupported on_commit option: #{on_commit.inspect}") unless ON_COMMIT.has_key? on_commit
+        prefix_sql = if options[:temp]
+          raise(Error, "can't provide both :temp and :unlogged to create_table") if options[:unlogged]
+          raise(Error, "can't provide both :temp and :foreign to create_table") if options[:foreign]
+          temporary_table_sql
+        elsif options[:foreign]
+          raise(Error, "can't provide both :foreign and :unlogged to create_table") if options[:unlogged]
+          'FOREIGN '
+        elsif options[:unlogged]
+          UNLOGGED
         end
-        temp_or_unlogged_sql = if options[:temp]
-         raise(Error, "can't provide both :temp and :unlogged to create_table") if options[:unlogged]
-         temporary_table_sql
-       elsif options[:unlogged]
-         UNLOGGED
-       end
-        "CREATE #{temp_or_unlogged_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]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
       end
 
       def create_table_sql(name, generator, options)
         sql = super
+
         if inherits = options[:inherits]
           sql << " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
         end
+
         if on_commit = options[:on_commit]
+          raise(Error, "can't provide :on_commit without :temp to create_table") unless options[:temp]
+          raise(Error, "unsupported on_commit option: #{on_commit.inspect}") unless ON_COMMIT.has_key?(on_commit)
           sql << " ON COMMIT #{ON_COMMIT[on_commit]}"
         end
+
+        if server = options[:foreign]
+          sql << " SERVER #{quote_identifier(server)}"
+          if foreign_opts = options[:options]
+            sql << " OPTIONS (#{foreign_opts.map{|k, v| "#{k} #{literal(v.to_s)}"}.join(', ')})"
+          end
+        end
+
         sql
       end
 

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlanywhere sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do fdbsql firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlanywhere sqlite swift tinytds'.collect{|x| x.to_sym}
 
     @single_threaded = false
 

data/lib/sequel/database/schema_methods.rb

@@ -171,10 +171,17 @@ module Sequel
     # :engine :: The table engine to use for the table.
     #
     # PostgreSQL specific options:
-    # :on_commit :: Either :preserve_rows (default), :drop or :delete_rows.
-    # :unlogged :: Create the table as an unlogged table.
-    # :inherits :: Inherit from a different tables.  An array can be
+    # :on_commit :: Either :preserve_rows (default), :drop or :delete_rows. Should
+    #               only be specified when creating a temporary table.
+    # :foreign :: Create a foreign table.  The value should be the name of the
+    #             foreign server that was specified in CREATE SERVER.
+    # :inherits :: Inherit from a different table.  An array can be
     #              specified to inherit from multiple tables.
+    # :unlogged :: Create the table as an unlogged table.
+    # :options :: The OPTIONS clause to use for foreign tables.  Should be a hash
+    #             where keys are option names and values are option values.  Note
+    #             that option names are unquoted, so you should not use untrusted
+    #             keys.
     #
     # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -125,6 +125,13 @@ module Sequel
         @arity = arity
       end
 
+      # Return a new PlaceholderLiteralizer with a modified dataset.  This yields the
+      # receiver's dataset to the block, and the block should return the new dataset
+      # to use.
+      def with_dataset
+        dup.instance_exec{@dataset = yield @dataset; self}
+      end
+
       # Return an array of all objects by running the SQL query for the given arguments.
       # If a block is given, yields all objects to the block after loading them.
       def all(*args, &block)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -62,6 +62,7 @@ module Sequel
         DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map{|s| s.freeze}).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
+        FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
@@ -122,6 +123,10 @@ module Sequel
               expr = Sequel.+(expr, Sequel.lit(["", " "], value, sql_unit))
             end
             false
+          when :fdbsql
+            each_valid_interval_unit(h, FDBSQL_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.+(expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
+            end
           else
             raise Error, "date arithmetic is not implemented on #{db.database_type}"
           end

data/lib/sequel/extensions/migration.rb

@@ -207,8 +207,8 @@ module Sequel
       @actions << [:drop_table, args.first]
     end
 
-    def create_view(*args)
-      @actions << [:drop_view, args.first]
+    def create_view(name, _, options={})
+      @actions << [:drop_view, name, options]
     end
 
     def rename_column(table, name, new_name)

data/lib/sequel/extensions/pg_array.rb

@@ -203,7 +203,7 @@ module Sequel
             procs = conversion_procs
             procs[1115] = Creator.new("timestamp without time zone", procs[1114])
             procs[1185] = Creator.new("timestamp with time zone", procs[1184])
-            copy_conversion_procs([1009, 1007, 1016, 1231, 1022, 1000, 1001, 1182, 1183, 1270, 1005, 1028, 1021, 1014, 1015])
+            copy_conversion_procs([143, 791, 1000, 1001, 1003, 1005, 1006, 1007, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1021, 1022, 1028, 1182, 1183, 1231, 1270, 1561, 1563, 2951])
             [:string_array, :integer_array, :decimal_array, :float_array, :boolean_array, :blob_array, :date_array, :time_array, :datetime_array].each do |v|
               @schema_type_classes[v] = PGArray
             end
@@ -542,6 +542,20 @@ module Sequel
       register('real', :oid=>1021, :scalar_oid=>700, :scalar_typecast=>:float)
       register('character', :oid=>1014, :array_type=>:text, :scalar_typecast=>:string)
       register('character varying', :oid=>1015, :scalar_typecast=>:string, :type_symbol=>:varchar)
+
+      register('xml', :oid=>143, :scalar_oid=>142)
+      register('money', :oid=>791, :scalar_oid=>790)
+      register('bit', :oid=>1561, :scalar_oid=>1560)
+      register('bit varying', :oid=>1563, :scalar_oid=>1562, :type_symbol=>:varbit)
+      register('uuid', :oid=>2951, :scalar_oid=>2950)
+
+      register('xid', :oid=>1011, :scalar_oid=>28)
+      register('cid', :oid=>1012, :scalar_oid=>29)
+
+      register('name', :oid=>1003, :scalar_oid=>19)
+      register('tid', :oid=>1010, :scalar_oid=>27)
+      register('int2vector', :oid=>1006, :scalar_oid=>22)
+      register('oidvector', :oid=>1013, :scalar_oid=>30)
     end
   end
 

data/lib/sequel/extensions/pg_json.rb

@@ -56,6 +56,9 @@
 #
 #   DB.extension :pg_array, :pg_json
 #
+# Note that when accessing json hashes, you should always use strings for keys.
+# Attempting to use other values (such as symbols) will not work correctly.
+#
 # This extension requires both the json and delegate libraries.
 
 require 'delegate'

data/lib/sequel/extensions/pg_json_ops.rb

@@ -188,16 +188,16 @@ module Sequel
       # structure of the record using #as on the resulting object:
       #
       #   json_op.to_record.as(:x, [Sequel.lit('a integer'), Sequel.lit('b text')]) # json_to_record(json) AS x(a integer, b text)
-      def to_record(nested_as_text=false)
-        function(:to_record, nested_as_text)
+      def to_record
+        function(:to_record)
       end
 
       # Builds arbitrary set of records from json array of objects.  You need to define the
       # structure of the records using #as on the resulting object:
       #
       #   json_op.to_recordset.as(:x, [Sequel.lit('a integer'), Sequel.lit('b text')]) # json_to_recordset(json) AS x(a integer, b text)
-      def to_recordset(nested_as_text=false)
-        function(:to_recordset, nested_as_text)
+      def to_recordset
+        function(:to_recordset)
       end
 
       # Returns the type of the outermost json value as text.

data/lib/sequel/extensions/schema_dumper.rb

@@ -171,7 +171,15 @@ END_MIG
           gen.primary_key(name, type_hash)
         end
       else
-        col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        col_opts = if options[:same_db]
+          h = {:type=>schema[:db_type]}
+          if database_type == :mysql && h[:type] =~ /\Atimestamp/
+            h[:null] = true
+          end
+          h
+        else
+          column_schema_to_ruby_type(schema)
+        end
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
         col_opts[:default] = if schema[:ruby_default].nil?

data/lib/sequel/model/associations.rb

@@ -8,8 +8,11 @@ module Sequel
     
       # Set an empty association reflection hash in the model
       def self.apply(model)
-        model.instance_variable_set(:@association_reflections, {})
-        model.instance_variable_set(:@autoreloading_associations, {})
+        model.instance_eval do
+          @association_reflections = {}
+          @autoreloading_associations = {}
+          @cache_associations = true
+        end
       end
 
       # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
@@ -244,7 +247,6 @@ module Sequel
           if eo[:eager_block] || eo[:loader] == false
             strategy = true_eager_graph_limit_strategy if strategy == :union
             objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
-            cascade = nil
           elsif strategy == :union
             objects = []
             ds = associated_dataset
@@ -253,12 +255,12 @@ module Sequel
             eo[:id_map].keys.each_slice(subqueries_per_union).each do |slice|
               objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
             end
+            ds = ds.eager(cascade) if cascade
+            ds.send(:post_load, objects)
           else
-            objects = placeholder_eager_loader.all(eo[:id_map].keys)
-          end
-
-          if cascade && !(cascade = associated_dataset.send(:eager_options_for_associations, [cascade])).empty?
-            associated_eager_dataset.send(:eager_load, objects, cascade)
+            loader = placeholder_eager_loader
+            loader = loader.with_dataset{|ds| ds.eager(cascade)} if cascade
+            objects = loader.all(eo[:id_map].keys)
           end
 
           objects.each(&block)
@@ -397,7 +399,7 @@ module Sequel
             end
 
             if possible_recips.length == 1
-              cached_set(:reciprocal_type, possible_recips.first[:type]) if reciprocal_type.is_a?(Array)
+              cached_set(:reciprocal_type, possible_recips.first[:type]) if ambiguous_reciprocal_type?
               possible_recips.first[:name]
             end
           end
@@ -468,7 +470,7 @@ module Sequel
           # in a special sub-hash that always uses this method to synchronize access.
           def cached_fetch(key)
             fetch(key) do
-              h = self[:cache]
+              return yield unless h = self[:cache]
               Sequel.synchronize{return h[key] if h.has_key?(key)}
               value = yield
               Sequel.synchronize{h[key] = value}
@@ -477,7 +479,7 @@ module Sequel
 
           # Cache the value at the given key, synchronizing access.
           def cached_set(key, value)
-            h = self[:cache]
+            return unless h = self[:cache]
             Sequel.synchronize{h[key] = value}
           end
         # :nocov:
@@ -485,7 +487,7 @@ module Sequel
           # On MRI, use a plain fetch, since the GVL will synchronize access.
           def cached_fetch(key)
             fetch(key) do 
-              h = self[:cache]
+              return yield unless h = self[:cache]
               h.fetch(key){h[key] = yield}
             end
           end
@@ -493,7 +495,8 @@ module Sequel
           # On MRI, just set the value at the key in the cache, since the GVL
           # will synchronize access.
           def cached_set(key, value)
-            self[:cache][key] = value
+            return unless h = self[:cache]
+            h[key] = value
           end
         end
 
@@ -503,6 +506,12 @@ module Sequel
           associated_class.dataset.clone
         end
 
+        # Whether for the reciprocal type for the given association can not be
+        # known in advantage, false by default.
+        def ambiguous_reciprocal_type?
+          false
+        end
+
         # Apply a limit strategy to the given dataset so that filter by
         # associations works with a limited dataset.
         def apply_filter_by_associations_limit_strategy(ds)
@@ -645,11 +654,17 @@ module Sequel
           end
         end
 
+        # The reciprocal type as an array, should be overridden in reflection subclasses that
+        # have ambiguous reciprocal types.
+        def possible_reciprocal_types
+          [reciprocal_type]
+        end
+
         # Whether the given association reflection is possible reciprocal
         # association for the current association reflection.
         def reciprocal_association?(assoc_reflect)
-          Array(reciprocal_type).include?(assoc_reflect[:type]) &&
-            assoc_reflect.associated_class == self[:model] &&
+          possible_reciprocal_types.include?(assoc_reflect[:type]) &&
+            (begin; assoc_reflect.associated_class; rescue NameError; end) == self[:model] &&
             assoc_reflect[:conditions].nil? &&
             assoc_reflect[:block].nil?
         end
@@ -759,7 +774,7 @@ module Sequel
 
         # The column(s) in the associated table that the key in the current table references (either a symbol or an array).
         def primary_key
-         cached_fetch(:primary_key){associated_class.primary_key}
+         cached_fetch(:primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
         end
        
         # The columns in the associated table that the key in the current table references (always an array).
@@ -804,6 +819,12 @@ module Sequel
     
         private
     
+        # Reciprocals of many_to_one associations could be either one_to_many or one_to_one,
+        # and which is not known in advance.
+        def ambiguous_reciprocal_type?
+          true
+        end
+
         def filter_by_associations_conditions_associated_keys
           qualify(associated_class.table_name, primary_keys)
         end
@@ -822,14 +843,36 @@ module Sequel
           self[:keys]
         end
     
+        # The reciprocal type of a many_to_one association is either
+        # a one_to_many or a one_to_one association.
+        def possible_reciprocal_types
+          [:one_to_many, :one_to_one]
+        end
+
+        # Whether the given association reflection is possible reciprocal
         def reciprocal_association?(assoc_reflect)
           super && self[:keys] == assoc_reflect[:keys] && primary_key == assoc_reflect.primary_key
         end
 
         # The reciprocal type of a many_to_one association is either
-        # a one_to_many or a one_to_one association.
+        # a one_to_many or a one_to_one association, look in the associated class
+        # to try to figure out which.
         def reciprocal_type
-          cached_fetch(:reciprocal_type){[:one_to_many, :one_to_one]}
+          cached_fetch(:reciprocal_type) do
+            possible_recips = []
+
+            associated_class.all_association_reflections.each do |assoc_reflect|
+              if reciprocal_association?(assoc_reflect)
+                possible_recips << assoc_reflect
+              end
+            end
+
+            if possible_recips.length == 1
+              possible_recips.first[:type]
+            else
+              possible_reciprocal_types
+            end
+          end
         end
       end
     
@@ -1184,7 +1227,7 @@ module Sequel
     
         # The primary key column(s) to use in the associated table (can be symbol or array).
         def right_primary_key
-          cached_fetch(:right_primary_key){associated_class.primary_key}
+          cached_fetch(:right_primary_key){associated_class.primary_key || raise(Error, "no primary key specified for #{associated_class.inspect}")}
         end
         
         # The primary key columns to use in the associated table (always array).
@@ -1367,6 +1410,12 @@ module Sequel
         # value changes.
         attr_reader :autoreloading_associations
 
+        # Whether association metadata should be cached in the association reflection.  If not cached, it will be computed
+        # on demand.  In general you only want to set this to default when using code reloading.  When using code reloading,
+        # setting this will make sure that if an associated class is removed or modified, this class will not hang on to
+        # the previous class.
+        attr_accessor :cache_associations
+
         # The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel
         # to use what it considers the most appropriate strategy).
         attr_accessor :default_eager_limit_strategy
@@ -1600,7 +1649,7 @@ module Sequel
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
           end
 
-          opts = orig_opts.merge(:type => type, :name => name, :cache=>{}, :model => self)
+          opts = orig_opts.merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
           opts[:block] = block if block
           if block || orig_opts[:block] || orig_opts[:dataset]
             # It's possible the association is instance specific, in that it depends on
@@ -1683,7 +1732,7 @@ module Sequel
           associate(:one_to_one, name, opts, &block)
         end
 
-        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_eager_limit_strategy=>nil)
+        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private

data/lib/sequel/plugins/active_model.rb

@@ -4,7 +4,7 @@ module Sequel
     # The ActiveModel plugin makes Sequel::Model objects
     # pass the ActiveModel::Lint tests, which should
     # hopefully mean full ActiveModel compliance.  This should
-    # allow the full support of Sequel::Model objects in Rails 3.
+    # allow the full support of Sequel::Model objects in Rails 3+.
     # This plugin requires active_model in order to use
     # ActiveModel::Naming.
     # 
@@ -43,7 +43,12 @@ module Sequel
           super
           @destroyed = true
         end
-        
+
+        # Return ::ActiveModel::Name instance for the class.
+        def model_name
+          model.model_name
+        end
+
         # False if the object is new? or has been destroyed, true otherwise.
         def persisted?
           !new? && @destroyed != true

data/lib/sequel/plugins/many_through_many.rb

@@ -229,6 +229,7 @@ module Sequel
           opts[:left_keys] = Array(left_key)
           opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          raise(Error, "no primary key specified for #{inspect}") unless left_pk
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk