sequel 3.35.0 → 3.36.0

data/lib/sequel/extensions/pg_json.rb

@@ -0,0 +1,178 @@
+# The pg_json extension adds support for Sequel to handle
+# PostgreSQL's json type.  It is slightly more strict than the
+# PostgreSQL json type in that the object returned must be an
+# array or object (PostgreSQL's json type considers plain numbers
+# and strings as valid).  This is because Sequel relies completely
+# on the ruby JSON library for parsing, and ruby's JSON library
+# does not accept the values.
+#
+# This extension integrates with Sequel's native postgres adapter, so
+# that when json fields are retrieved, they are parsed and returned
+# as instances of Sequel::Postgres::JSONArray or
+# Sequel::Postgres::JSONHash.  JSONArray and JSONHash are
+# DelegateClasses of Array and Hash, so they mostly act the same, but
+# not completely (json_array.is_a?(Array) is false).  If you want
+# the actual array for a JSONArray, call JSONArray#to_a.  If you want
+# the actual hash for a JSONHash, call JSONHash#to_hash.
+# This is done so that Sequel does not treat JSONArray and JSONHash
+# like Array and Hash by default, which would cause issues.
+#
+# To turn an existing Array or Hash into a JSONArray or JSONHash:
+#
+#   array.pg_json
+#   hash.pg_json
+#
+# So if you want to insert an array or hash into an json database column:
+#
+#   DB[:table].insert(:column=>[1, 2, 3].pg_json)
+#   DB[:table].insert(:column=>{'a'=>1, 'b'=>2}.pg_json)
+#
+# If you would like to use PostgreSQL json columns in your model
+# objects, you probably want to modify the schema parsing/typecasting
+# so that it recognizes and correctly handles the json type, which
+# you can do by:
+#
+#   DB.extend Sequel::Postgres::JSONDatabaseMethods
+#
+# If you are not using the native postgres adapter, you probably
+# also want to use the typecast_on_load plugin in the model, and
+# set it to typecast the json column(s) on load.
+#
+# The extension is designed to be used with the json type natively
+# supported by PostgreSQL 9.2+.  There was also a PostgreSQL extension released
+# that allowed the json type to be used on PostgreSQL 9.1.  To make
+# this extension support that type in the native adapter, do the
+# following after loading this extension:
+#
+#   Sequel::Postgres::PG_NAMED_TYPES = {} unless defined?(Sequel::Postgres::PG_NAMED_TYPES)
+#   Sequel::Postgres::PG_NAMED_TYPES[:json] = Sequel::Postgres::PG_TYPES[114]
+#
+# This extension requires both the json and delegate libraries.
+
+require 'delegate'
+require 'json'
+
+module Sequel
+  module Postgres
+    CAST_JSON = '::json'.freeze
+
+    # Class representating PostgreSQL JSON column array values.
+    class JSONArray < DelegateClass(Array)
+      # Convert the array to a string using to_json, append a
+      # literalized version of the string to the sql, and explicitly
+      # cast the string to json.
+      def sql_literal_append(ds, sql)
+        ds.literal_append(sql, to_json)
+        sql << CAST_JSON
+      end
+    end
+
+    # Class representating PostgreSQL JSON column hash/object values.
+    class JSONHash < DelegateClass(Hash)
+      # Convert the array to a string using to_json, append a
+      # literalized version of the string to the sql, and explicitly
+      # cast the string to json.
+      def sql_literal_append(ds, sql)
+        ds.literal_append(sql, to_json)
+        sql << CAST_JSON
+      end
+
+      # Return the object being delegated to.
+      alias to_hash __getobj__
+    end
+
+    # Methods enabling Database object integration with the json type.
+    module JSONDatabaseMethods
+      # Parse the given string as json, returning either a JSONArray
+      # or JSONHash instance, and raising an error if the JSON
+      # parsing does not yield an array or hash.
+      def self.parse_json(s)
+        begin
+          value = JSON.parse(s)
+        rescue JSON::ParserError=>e
+          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
+        end
+
+        case value
+        when Array
+          JSONArray.new(value)
+        when Hash 
+          JSONHash.new(value)
+        else
+          raise Sequel::InvalidValue, "unhandled json value: #{value.inspect} (from #{s.inspect})"
+        end
+      end
+
+      # Reset the conversion procs when extending the Database object, so
+      # it will pick up the json convertor.  This is only done for the native
+      # postgres adapter.
+      def self.extended(db)
+        db.reset_conversion_procs if db.respond_to?(:reset_conversion_procs)
+      end
+
+      # Handle JSONArray and JSONHash in bound variables
+      def bound_variable_arg(arg, conn)
+        case arg
+        when JSONArray, JSONHash
+          arg.to_json
+        else
+          super
+        end
+      end
+
+      # Make the column type detection recognize the json type.
+      def schema_column_type(db_type)
+        case db_type
+        when 'json'
+          :json
+        else
+          super
+        end
+      end
+
+      private
+
+      # Given a value to typecast to the json column
+      # * If given a JSONArray or JSONHash, just return the value
+      # * If given an Array, return a JSONArray
+      # * If given a Hash, return a JSONHash
+      # * If given a String, parse it as would be done during
+      #   database retrieval.
+      def typecast_value_json(value)
+        case value
+        when JSONArray, JSONHash
+          value
+        when Array
+          JSONArray.new(value)
+        when Hash 
+          JSONHash.new(value)
+        when String
+          JSONDatabaseMethods.parse_json(value)
+        else
+          raise Sequel::InvalidValue, "invalid value for json: #{value.inspect}"
+        end
+      end
+    end
+
+    PG_TYPES = {} unless defined?(PG_TYPES)
+    PG_TYPES[114] = JSONDatabaseMethods.method(:parse_json)
+  end
+end
+
+class Array
+  # Return a Sequel::Postgres::JSONArray proxy to the receiver.
+  # This is mostly useful as a short cut for creating JSONArray
+  # objects that didn't come from the database.
+  def pg_json
+    Sequel::Postgres::JSONArray.new(self)
+  end
+end
+
+class Hash
+  # Return a Sequel::Postgres::JSONHash proxy to the receiver.
+  # This is mostly useful as a short cut for creating JSONHash
+  # objects that didn't come from the database.
+  def pg_json
+    Sequel::Postgres::JSONHash.new(self)
+  end
+end

data/lib/sequel/extensions/schema_dumper.rb

@@ -28,6 +28,9 @@ END_MIG
     # the :indexes=>false option to dump_schema_migration. Options:
     # * :same_db - Create a dump for the same database type, so
     #   don't ignore errors if the index statements fail.
+    # * :index_names - If set to false, don't record names of indexes. If
+    #   set to :namespace, prepend the table name to the index name if the
+    #   database does not use a global index namespace.
     def dump_indexes_migration(options={})
       ts = tables(options)
       <<END_MIG
@@ -53,6 +56,8 @@ END_MIG
     # * :foreign_keys - If set to false, don't dump foreign_keys
     # * :indexes - If set to false, don't dump indexes (they can be added
     #   later via dump_index_migration).
+    # * :index_names - If set to false, don't record names of indexes. If
+    #   set to :namespace, prepend the table name to the index name.
     def dump_schema_migration(options={})
       options = options.dup
       if options[:indexes] == false && !options.has_key?(:foreign_keys)
@@ -144,8 +149,14 @@ END_MIG
     # database type is not recognized, return it as a String type.
     def column_schema_to_ruby_type(schema)
       case t = schema[:db_type].downcase
-      when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?(?: unsigned)?\z/o
-        {:type=>Integer}
+      when /\A(medium|small)?int(?:eger)?(?:\((\d+)\))?( unsigned)?\z/o
+        if !$1 && $2 && $2.to_i >= 10 && $3
+          # Unsigned integer type with 10 digits can potentially contain values which
+          # don't fit signed integer type, so use bigint type in target database.
+          {:type=>Bignum}
+        else
+          {:type=>Integer}
+        end
       when /\Atinyint(?:\((\d+)\))?(?: unsigned)?\z/o
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/o
@@ -261,7 +272,7 @@ END_MIG
       Schema::Generator.new(self) do
         s.each{|name, info| send(*m.call(name, info, options))}
         primary_key(pks) if !@primary_key && pks.length > 0
-        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))} if indexes
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))} if indexes
         composite_fks.each{|fk| send(:foreign_key, fk[:columns], fk)} if composite_fks
       end
     end
@@ -276,15 +287,21 @@ END_MIG
       end
       im = method(:index_to_generator_opts)
       gen = Schema::Generator.new(self) do
-        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))}
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts, options))}
       end
       gen.dump_indexes(meth=>table, :ignore_errors=>!options[:same_db])
     end
 
     # Convert the parsed index information into options to the Generators index method. 
-    def index_to_generator_opts(table, name, index_opts)
+    def index_to_generator_opts(table, name, index_opts, options={})
       h = {}
-      h[:name] = name unless default_index_name(table, index_opts[:columns]) == name.to_s
+      if options[:index_names] != false && default_index_name(table, index_opts[:columns]) != name.to_s
+        if options[:index_names] == :namespace && !global_index_namespace?
+          h[:name] = "#{table}_#{name}".to_sym
+        else
+          h[:name] = name
+        end
+      end
       h[:unique] = true if index_opts[:unique]
       h
     end
@@ -444,6 +461,7 @@ END_MIG
             "index #{cols.inspect}#{opts_inspect(c)}"
           end
         end
+        is = is.reverse if options[:drop_index]
         is.join("\n")
       end
 

data/lib/sequel/model/associations.rb

@@ -1644,32 +1644,36 @@ module Sequel
           end
         end
 
-        # Set the given object as the associated object for the given many_to_one association reflection
-        def set_associated_object(opts, o)
-          raise(Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
+        # Set the given object as the associated object for the given *_to_one association reflection
+        def _set_associated_object(opts, o)
+          a = associations[opts[:name]]
+          return if a && a == o && !set_associated_object_if_same?
           run_association_callbacks(opts, :before_set, o)
-          if a = associations[opts[:name]]
-            remove_reciprocal_object(opts, a)
-          end
+          remove_reciprocal_object(opts, a) if a
           send(opts._setter_method, o)
           associations[opts[:name]] = o
           add_reciprocal_object(opts, o) if o
           run_association_callbacks(opts, :after_set, o)
           o
         end
+
+        # Whether run the associated object setter code if passed the same object as the one already
+        # cached in the association.  Usually not set (so nil), can be set on a per-object basis
+        # if necessary.
+        def set_associated_object_if_same?
+          @set_associated_object_if_same
+        end
         
+        # Set the given object as the associated object for the given many_to_one association reflection
+        def set_associated_object(opts, o)
+          raise(Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
+          _set_associated_object(opts, o)
+        end
+
         # Set the given object as the associated object for the given one_to_one association reflection
         def set_one_to_one_associated_object(opts, o)
           raise(Error, "object #{inspect} does not have a primary key") unless pk
-          run_association_callbacks(opts, :before_set, o)
-          if a = associations[opts[:name]]
-            remove_reciprocal_object(opts, a)
-          end
-          send(opts._setter_method, o)
-          associations[opts[:name]] = o
-          add_reciprocal_object(opts, o) if o
-          run_association_callbacks(opts, :after_set, o)
-          o
+          _set_associated_object(opts, o)
         end
       end
 

data/lib/sequel/model/base.rb

@@ -350,16 +350,14 @@ module Sequel
           subclass.instance_variable_set(iv, sup_class_value)
         end
         unless ivs.include?("@dataset")
-          db
-          begin
-            if self == Model || !@dataset
-              n = subclass.name
-              subclass.set_dataset(subclass.implicit_table_name) unless n.nil? || n.empty?
-            elsif @dataset
-              subclass.set_dataset(@dataset.clone, :inherited=>true)
+          if self == Model || !@dataset
+            n = subclass.name
+            unless n.nil? || n.empty?
+              db
+              subclass.set_dataset(subclass.implicit_table_name) rescue nil
             end
-          rescue
-            nil
+          elsif @dataset
+            subclass.set_dataset(@dataset.clone, :inherited=>true) rescue nil
           end
         end
       end
@@ -1106,7 +1104,8 @@ module Sequel
       #     a.update(...)
       #   end
       def lock!
-        new? ? self : _refresh(this.for_update)
+        _refresh(this.for_update) unless new?
+        self
       end
       
       # Remove elements of the model object that make marshalling fail. Returns self.
@@ -1185,6 +1184,7 @@ module Sequel
       def refresh
         raise Sequel::Error, "can't refresh frozen object" if frozen?
         _refresh(this)
+        self
       end
 
       # Alias of refresh, but not aliased directly to make overriding in a plugin easier.
@@ -1532,7 +1532,6 @@ module Sequel
       def _refresh(dataset)
         set_values(_refresh_get(dataset) || raise(Error, "Record not found"))
         changed_columns.clear
-        self
       end
 
       # Get the row of column data from the database.
@@ -1809,7 +1808,7 @@ module Sequel
       # for database specific column types.
       def typecast_value(column, value)
         return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column])
-        value = nil if value == '' and typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type])
+        value = nil if '' == value and typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type])
         raise(InvalidValue, "nil/NULL is not allowed for the #{column} column") if raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false)
         begin
           model.db.typecast_value(col_schema[:type], value)

data/lib/sequel/plugins/composition.rb

@@ -150,9 +150,8 @@ module Sequel
       module InstanceMethods
         # Clear the cached compositions when refreshing.
         def _refresh(ds)
-          v = super
+          super
           compositions.clear
-          v
         end
 
         # For each composition, set the columns in the model class based

data/lib/sequel/plugins/eager_each.rb

@@ -0,0 +1,59 @@
+module Sequel
+  module Plugins
+    # The eager_each plugin makes calling each on an eager loaded dataset do eager loading.
+    # By default, each does not work on an eager loaded dataset, because each iterates
+    # over rows of the dataset as they come in, and to eagerly load you need to have all
+    # values up front.  With the default associations code, you must call #all on an eagerly
+    # loaded dataset, as calling #each on an #eager dataset skips the eager loading, and calling
+    # #each on an #eager_graph dataset makes it yield plain hashes with columns from all
+    # tables, instead of yielding the instances of the main model.
+    #
+    # This plugin makes #each call #all for eagerly loaded datasets.  As #all usually calls
+    # #each, this is a bit of issue, but this plugin resolves the issue by cloning the dataset
+    # and setting a new flag in the cloned dataset, so that each can check with the flag to
+    # determine whether it should call all.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_each
+    #
+    #   # Make the Album class eagerly load for each
+    #   Album.plugin :eager_each
+    module EagerEach 
+      # Methods added to eagerly loaded datasets when the eager_each plugin is in use.
+      module EagerDatasetMethods
+        # Call #all instead of #each unless #each is being called by #all.
+        def each(&block)
+          if opts[:all_called]
+            super
+          else
+            all(&block)
+          end
+        end
+
+        # Clone the dataset and set a flag to let #each know not to call #all,
+        # to avoid the infinite loop.
+        def all(&block)
+          if opts[:all_called]
+            super
+          else
+            clone(:all_called=>true).all(&block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager(*)
+          super.extend(EagerDatasetMethods)
+        end
+        
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager_graph(*)
+          super.extend(EagerDatasetMethods)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/json_serializer.rb

@@ -139,8 +139,13 @@ module Sequel
       module InstanceMethods
         # Parse the provided JSON, which should return a hash,
         # and call +set+ with that hash.
-        def from_json(json)
-          set(JSON.parse(json))
+        def from_json(json, opts={})
+          h = JSON.parse(json)
+          if fields = opts[:fields]
+            set_fields(h, fields, opts)
+          else
+            set(h)
+          end
         end
 
         # Return a string in JSON format.  Accepts the following
@@ -200,7 +205,21 @@ module Sequel
       module DatasetMethods
         # Return a JSON string representing an array of all objects in
         # this dataset.  Takes the same options as the the instance
-        # method, and passes them to every instance.
+        # method, and passes them to every instance.  Additionally,
+        # respects the following options:
+        #
+        # :array :: An array of instances.  If this is not provided,
+        #           calls #all on the receiver to get the array.
+        # :root :: If set to :collection, only wraps the collection
+        #          in a root object.  If set to :instance, only wraps
+        #          the instances in a root object.  If set to :both,
+        #          wraps both the collection and instances in a root
+        #          object.  Unfortunately, for backwards compatibility,
+        #          if this option is true and doesn't match one of those
+        #          symbols, it defaults to both.  That may change in a
+        #          future version, so for forwards compatibility, you
+        #          should pick a specific symbol for your desired
+        #          behavior.
         def to_json(*a)
           if opts = a.first.is_a?(Hash)
             opts = model.json_serializer_opts.merge(a.first)
@@ -208,6 +227,19 @@ module Sequel
           else
             opts = model.json_serializer_opts
           end
+
+          collection_root = case opts[:root]
+          when nil, false, :instance
+            false
+          when :collection
+            opts = opts.dup
+            opts.delete(:root)
+            opts[:naked] = true unless opts.has_key?(:naked)
+            true
+          else
+            true
+          end
+
           res = if row_proc 
             array = if opts[:array]
               opts = opts.dup
@@ -219,7 +251,12 @@ module Sequel
            else
             all
           end
-          opts[:root] ? {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a) : res.to_json(*a)
+
+          if collection_root
+            {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a)
+          else
+            res.to_json(*a)
+          end
         end
       end
     end