sequel 4.12.0 → 4.13.0

data/lib/sequel/extensions/pg_array.rb

@@ -1,10 +1,10 @@
 # The pg_array extension adds support for Sequel to handle
 # PostgreSQL's array types.
 #
-# This extension integrates with Sequel's native postgres adapter, so
-# that when array fields are retrieved, they are parsed and returned
-# as instances of Sequel::Postgres::PGArray.  PGArray is
-# a DelegateClass of Array, so it mostly acts like an array, but not
+# This extension integrates with Sequel's native postgres adapter and
+# the jdbc/postgresql adapter, so that when array fields are retrieved,
+# they are parsed and returned as instances of Sequel::Postgres::PGArray.
+# PGArray is a DelegateClass of Array, so it mostly acts like an array, but not
 # completely (is_a?(Array) is false).  If you want the actual array,
 # you can call PGArray#to_a.  This is done so that Sequel does not
 # treat a PGArray like an Array by default, which would cause issues.
@@ -39,18 +39,21 @@
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using postgres array columns in CREATE/ALTER TABLE statements.
 #
-# If you are not using the native postgres adapter and are using array
-# types as model column values you probably should use the
-# typecast_on_load plugin if the column values are returned as a
-# regular array, and the pg_typecast_on_load plugin if the column
-# values are returned as a string.
+# If you are not using the native postgres or jdbc/postgresql adapter and are using array
+# types as model column values you probably should use the the pg_typecast_on_load plugin
+# if the column values are returned as a string.
 #
 # This extension by default includes handlers for array types for
 # all scalar types that the native postgres adapter handles. It
 # also makes it easy to add support for other array types.  In
 # general, you just need to make sure that the scalar type is
 # handled and has the appropriate converter installed in
-# Sequel::Postgres::PG_TYPES under the appropriate type OID.
+# Sequel::Postgres::PG_TYPES or the Database instance's
+# conversion_procs usingthe appropriate type OID.  For user defined
+# types, you can do this via:
+#
+#   DB.conversion_procs[scalar_type_oid] = lambda{|string| ...}
+#
 # Then you can call
 # Sequel::Postgres::PGArray::DatabaseMethods#register_array_type
 # to automatically set up a handler for the array type.  So if you
@@ -63,6 +66,7 @@
 # Sequel::Postgres::PGArray.register.  In this case, you'll have
 # to specify the type oids:
 #
+#   Sequel::Postgres::PG_TYPES[1234] = lambda{|string| ...}
 #   Sequel::Postgres::PGArray.register('foo', :oid=>4321, :scalar_oid=>1234)
 #
 # Both Sequel::Postgres::PGArray::DatabaseMethods#register_array_type

data/lib/sequel/extensions/pg_enum.rb

@@ -0,0 +1,135 @@
+# The pg_enum extension adds support for Sequel to handle PostgreSQL's enum
+# types.  To use this extension, first load it into your Database instance:
+#
+#   DB.extension :pg_enum
+#
+# It allows creation of enum types using create_enum:
+#
+#   DB.create_enum(:type_name, %w'value1 value2 value3')
+#
+# You can also add values to existing enums via add_enum_value:
+#
+#   DB.add_enum_value(:enum_type_name, 'value4')
+#
+# If you want to drop an enum type, you can use drop_enum:
+#
+#   DB.drop_enum(:type_name)
+#
+# Just like any user-created type, after creating the type, you
+# can create tables that have a column of that type:
+#
+#   DB.create_table(:table_name)
+#     enum_type_name :column_name
+#   end
+#
+# When parsing the schema, enum types are recognized, and available
+# values returned in the schema hash:
+#
+#   DB.schema(:table_name)
+#   [[:column_name, {:type=>:enum, :enum_values=>['value1', 'value2']}]]
+#
+# If the pg_array extension is used, arrays of enums are returned as a
+# PGArray:
+#
+#   DB.create_table(:table_name)
+#     column :column_name, 'enum_type_name[]'
+#   end
+#   DB[:table_name].get(:column_name)
+#   # ['value1', 'value2']
+#
+# Finally, typecasting for enums is setup to cast to strings, which
+# allows you to use symbols in your model code.  Similar, you can provide
+# the enum values as symbols when creating enums using create_enum or
+# add_enum_value.
+
+module Sequel
+  module Postgres
+    # Methods enabling Database object integration with enum types.
+    module EnumDatabaseMethods
+      # Parse the available enum values when loading this extension into
+      # your database.
+      def self.extended(db)
+        db.send(:parse_enum_labels)
+      end
+
+      # Run the SQL to add the given value to the existing enum type.
+      # Options:
+      # :after :: Add the new value after this existing value.
+      # :before :: Add the new value before this existing value.
+      # :if_not_exists :: Do not raise an error if the value already exists in the enum.
+      def add_enum_value(enum, value, opts=OPTS)
+        sql = "ALTER TYPE #{quote_schema_table(enum)} ADD VALUE#{' IF NOT EXISTS' if opts[:if_not_exists]} #{literal(value.to_s)}"
+        if v = opts[:before]
+          sql << " BEFORE #{literal(v.to_s)}"
+        elsif v = opts[:after]
+          sql << " AFTER #{literal(v.to_s)}"
+        end
+        run sql
+        parse_enum_labels
+        nil
+      end
+
+      # Run the SQL to create an enum type with the given name and values.
+      def create_enum(enum, values)
+        sql = "CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})"
+        run sql
+        parse_enum_labels
+        nil
+      end
+
+      # Run the SQL to drop the enum type with the given name.
+      # Options:
+      # :if_exists :: Do not raise an error if the enum type does not exist
+      # :cascade :: Also drop other objects that depend on the enum type
+      def drop_enum(enum, opts=OPTS)
+        sql = "DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}"
+        run sql
+        parse_enum_labels
+        nil
+      end
+
+      private
+
+      # Parse the pg_enum table to get enum values, and
+      # the pg_type table to get names and array oids for
+      # enums.
+      def parse_enum_labels
+        @enum_labels = metadata_dataset.from(:pg_enum).
+          order(:enumtypid, :enumsortorder).
+          select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel)
+
+        if respond_to?(:register_array_type)
+          array_types = metadata_dataset.
+            from(:pg_type).
+            where(:oid=>@enum_labels.keys).
+            exclude(:typarray=>0).
+            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v)])
+
+          existing_oids = conversion_procs.keys
+          array_types.each do |name, oid|
+            next if existing_oids.include?(oid)
+            register_array_type(name, :oid=>oid)
+          end
+        end
+      end
+
+      # For schema entries that are enums, set the type to
+      # :enum and add a :enum_values entry with the enum values.
+      def schema_parse_table(*)
+        super.each do |_, s|
+          if values = @enum_labels[s[:oid]]
+            s[:type] = :enum
+            s[:enum_values] = values
+          end
+        end
+      end
+
+      # Typecast the given value to a string.
+      def typecast_value_enum(value)
+        value.to_s
+      end
+    end
+  end
+
+  Database.register_extension(:pg_enum, Postgres::EnumDatabaseMethods)
+end

data/lib/sequel/extensions/pg_hstore.rb

@@ -3,8 +3,8 @@
 # the hstore type stores an arbitrary key-value table, where the keys
 # are strings and the values are strings or NULL.
 #
-# This extension integrates with Sequel's native postgres adapter, so
-# that when hstore fields are retrieved, they are parsed and returned
+# This extension integrates with Sequel's native postgres and jdbc/postgresql
+# adapters, so that when hstore fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::HStore.  HStore is
 # a DelegateClass of Hash, so it mostly acts like a hash, but not
 # completely (is_a?(Hash) is false).  If you want the actual hash,
@@ -78,11 +78,9 @@
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #
-# If you are not using the native postgres adapter and are using hstore
+# If you are not using the native postgres or jdbc/postgresql adapters and are using hstore
 # types as model column values you probably should use the
-# typecast_on_load plugin if the column values are returned as a
-# hash, and the pg_typecast_on_load plugin if the column
-# values are returned as a string.
+# pg_typecast_on_load plugin if the column values are returned as a string.
 #
 # This extension requires the delegate and strscan libraries.
 

data/lib/sequel/extensions/pg_inet.rb

@@ -1,16 +1,15 @@
 # The pg_inet extension adds support for Sequel to handle
 # PostgreSQL's inet and cidr types using ruby's IPAddr class.
 #
-# This extension integrates with Sequel's native postgres adapter, so
-# that when inet/cidr fields are retrieved, they are returned as
+# This extension integrates with Sequel's native postgres and jdbc/postgresql
+# adapters, so that when inet/cidr fields are retrieved, they are returned as
 # IPAddr instances
 #
-# After loading the extension, you should extend your dataset
-# with a module so that it correctly handles the inet/cidr type:
+# To use this extension, load it into your database:
 #
 #   DB.extension :pg_inet
 #
-# If you are not using the native postgres adapter and are using inet/cidr
+# If you are not using the native postgres or jdbc/postgresql adapters and are using inet/cidr
 # types as model column values you probably should use the
 # pg_typecast_on_load plugin if the column values are returned as a string.
 #

data/lib/sequel/extensions/pg_interval.rb

@@ -1,7 +1,7 @@
 # The pg_interval extension adds support for PostgreSQL's interval type.
 #
-# This extension integrates with Sequel's native postgres adapter, so
-# that when interval type values are retrieved, they are parsed and returned
+# This extension integrates with Sequel's native postgres and jdbc/postgresql
+# adapters, so that when interval type values are retrieved, they are parsed and returned
 # as instances of ActiveSupport::Duration.
 #
 # In addition to the parser, this extension adds literalizers for
@@ -15,7 +15,7 @@
 #
 #   DB.extension :pg_interval
 #
-# If you are not using the native postgres adapter and are using interval
+# If you are not using the native postgres or jdbc/postgresql adapters and are using interval
 # types as model column values you probably should use the
 # pg_typecast_on_load plugin if the column values are returned as a string.
 #

data/lib/sequel/extensions/pg_json.rb

@@ -1,15 +1,16 @@
 # 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
+# PostgreSQL's json and jsonb types.  It is slightly more strict than the
+# PostgreSQL json types in that the object returned should 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.
+# strings, true, false, and null as valid).  Sequel will work with
+# PostgreSQL json values that are not arrays or objects, but support
+# is fairly limited and the values do not roundtrip.
 #
 # 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
+# Sequel::Postgres::JSONHash (or JSONBArray or JSONBHash for jsonb
+# columns).  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
@@ -20,15 +21,15 @@
 # To turn an existing Array or Hash into a JSONArray or JSONHash,
 # use Sequel.pg_json:
 #
-#   Sequel.pg_json(array)
-#   Sequel.pg_json(hash)
+#   Sequel.pg_json(array) # or Sequel.pg_jsonb(array) for jsonb type
+#   Sequel.pg_json(hash)  # or Sequel.pg_jsonb(hash) for jsonb type
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
 # and have activated refinements for the file, you can also use Array#pg_json and Hash#pg_json:
 #
-#   array.pg_json
-#   hash.pg_json
+#   array.pg_json # or array.pg_jsonb for jsonb type
+#   hash.pg_json  # or hash.pg_jsonb for jsonb type
 #
 # So if you want to insert an array or hash into an json database column:
 #
@@ -154,8 +155,9 @@ module Sequel
       end
 
       # 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.
+      # or JSONHash instance (or JSONBArray or JSONBHash instance if jsonb
+      # argument is true), or a String, Numeric, true, false, or nil
+      # if the json library used supports that.
       def self.parse_json(s, jsonb=false)
         begin
           value = Sequel.parse_json(s)
@@ -168,6 +170,8 @@ module Sequel
           (jsonb ? JSONBArray : JSONArray).new(value)
         when Hash 
           (jsonb ? JSONBHash : JSONHash).new(value)
+        when String, Numeric, true, false, nil
+          value
         else
           raise Sequel::InvalidValue, "unhandled json value: #{value.inspect} (from #{s.inspect})"
         end

data/lib/sequel/extensions/pg_range.rb

@@ -6,7 +6,7 @@
 # unbounded beginnings and endings (which ruby's range does not
 # support).
 #
-# This extension integrates with Sequel's native postgres adapter, so
+# This extension integrates with Sequel's native postgres and jdbc/postgresql adapters, so
 # that when range type values are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::PGRange.  PGRange mostly acts
 # like a Range, but it's not a Range as not all PostgreSQL range
@@ -45,7 +45,7 @@
 #
 #   DB.extension :pg_range
 #
-# If you are not using the native postgres adapter and are using range
+# If you are not using the native postgres or jdbc/postgresql adapters and are using range
 # types as model column values you probably should use the
 # pg_typecast_on_load plugin if the column values are returned as a string.
 #
@@ -395,7 +395,9 @@ module Sequel
         end
       end
 
-      # Whether this range is empty (has no points).
+      # Whether this range is empty (has no points).  Note that for manually created ranges
+      # (ones not retrieved from the database), this will only be true if the range
+      # was created using the :empty option.
       def empty?
         @empty
       end

data/lib/sequel/extensions/pg_row.rb

@@ -1,7 +1,7 @@
 # The pg_row extension adds support for Sequel to handle
 # PostgreSQL's row-valued/composite types.
 #
-# This extension integrates with Sequel's native postgres adapter, so
+# This extension integrates with Sequel's native postgres and jdbc/postgresql adapters, so
 # that when composite fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::PGRow::(HashRow|ArrayRow), or
 # optionally a custom type.  HashRow and ArrayRow are DelegateClasses of
@@ -74,7 +74,7 @@
 #   DB.conversion_procs.select{|k,v| v.is_a?(Sequel::Postgres::PGRow::Parser) && \
 #     v.converter && (v.converter.name.nil? || v.converter.name == '') }.map{|k,v| v}
 # 
-# If you are not using the native postgres adapter and are using composite types
+# If you are not using the native postgres or jdbc/postgresql adapters and are using composite types
 # types as model column values you probably should use the
 # pg_typecast_on_load plugin if the column values are returned as a string.
 #

data/lib/sequel/extensions/round_timestamps.rb

@@ -0,0 +1,52 @@
+# The round_timestamps extension will automatically round timestamp
+# values to the database's supported level of precision before literalizing
+# them.
+#
+# For example, if the database supports microsecond precision, and you give
+# it a Time value with greater than microsecond precision, it will round it
+# appropriately:
+#
+#   Time.at(1405341161.917999982833862)
+#   # default: 2014-07-14 14:32:41.917999
+#   # with extension: 2014-07-14 14:32:41.918000
+#
+# The round_timestamps extension correctly deals with databases that support
+# millisecond or second precision.  In addition to handling Time values, it
+# also handles DateTime values and Sequel::SQLTime values (for the TIME type).
+#
+# To round timestamps for a single dataset:
+#
+#   ds = ds.extension(:round_timestamps)
+#
+# To round timestamps for all datasets on a single database:
+#
+#   DB.extension(:round_timestamps)
+
+unless RUBY_VERSION >= '1.9'
+  # :nocov:
+  raise LoadError, 'the round_timestamps extension only works on ruby 1.9+'
+  # :nocov:
+end
+
+module Sequel
+  class Dataset
+    module RoundTimestamps
+      # Round DateTime values before literalizing
+      def literal_datetime(v)
+        super(v + Rational(5, 10**timestamp_precision)/864000)
+      end
+
+      # Round Sequel::SQLTime values before literalizing
+      def literal_sqltime(v)
+        super(v.round(timestamp_precision))
+      end
+
+      # Round Time values before literalizing
+      def literal_time(v)
+        super(v.round(timestamp_precision))
+      end
+    end
+
+    register_extension(:round_timestamps, RoundTimestamps)
+  end
+end

data/lib/sequel/model.rb

@@ -35,7 +35,7 @@ module Sequel
   #     dataset # => DB1[:comments]
   #   end
   def self.Model(source)
-    if cache_anonymous_models && (klass = Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
+    if cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
       return klass
     end
     klass = if source.is_a?(Database)
@@ -45,7 +45,7 @@ module Sequel
     else
       Class.new(Model).set_dataset(source)
     end
-    Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
+    Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
     klass
   end
 
@@ -78,6 +78,9 @@ module Sequel
     # of classes when dealing with code reloading.
     ANONYMOUS_MODEL_CLASSES = {}
 
+    # Mutex protecting access to ANONYMOUS_MODEL_CLASSES
+    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new
+
     # Class methods added to model that call the method of the same name on the dataset
     DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
       [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]

data/lib/sequel/model/associations.rb

@@ -1206,7 +1206,7 @@ module Sequel
         
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
-          cached_fetch(:select){Sequel::SQL::ColumnAll.new(associated_class.table_name)}
+          cached_fetch(:select){default_select}
         end
 
         private
@@ -1215,6 +1215,17 @@ module Sequel
           super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
         end
 
+        # The default selection for associations that require joins.  These do not use the default
+        # model selection unless all entries in the select are explicitly qualified identifiers, as
+        # other it can include unqualified columns which would be made ambiguous by joining.
+        def default_select
+          if (sel = associated_class.dataset.opts[:select]) && sel.all?{|c| selection_is_qualified?(c)}
+            sel
+          else
+            Sequel::SQL::ColumnAll.new(associated_class.table_name)
+          end
+        end
+
         def filter_by_associations_conditions_associated_keys
           qualify(join_table_alias, self[:left_keys])
         end
@@ -1252,6 +1263,21 @@ module Sequel
           :many_to_many
         end
 
+        # Whether the given expression represents a qualified identifier.  Used to determine if it is
+        # OK to use directly when joining.
+        def selection_is_qualified?(c)
+          case c
+          when Symbol
+            Sequel.split_symbol(c)[0]
+          when Sequel::SQL::QualifiedIdentifier
+            true
+          when Sequel::SQL::AliasedExpression
+            selection_is_qualified?(c.expression)
+          else
+            false
+          end
+        end
+
         # Split the join table into source and alias parts.
         def split_join_table_alias
           associated_class.dataset.split_alias(self[:join_table])
@@ -1478,8 +1504,8 @@ module Sequel
         #                the current association's key(s).  Set to nil to not use a reciprocal.
         # :remover :: Proc used to define the private _remove_* method for doing the database work
         #             to remove the association between the given object and the current object (*_to_many assocations).
-        # :select :: the columns to select.  Defaults to the associated class's
-        #            table_name.* in a many_to_many association, which means it doesn't include the attributes from the
+        # :select :: the columns to select.  Defaults to the associated class's table_name.* in an association
+        #            that uses joins, which means it doesn't include the attributes from the
         #            join table.  If you want to include the join table attributes, you can
         #            use this option, but beware that the join table attributes can clash with
         #            attributes from the model table, so you should alias any attributes that have