sequel 5.8.0 → 5.38.0

data/lib/sequel/extensions/pg_array.rb

@@ -65,12 +65,12 @@
 # If you want an easy way to call PostgreSQL array functions and
 # operators, look into the pg_array_ops extension.
 #
-# This extension requires the strscan and delegate libraries.
+# This extension requires the delegate library, and the strscan library
+# sequel_pg has not been loaded.
 #
 # Related module: Sequel::Postgres::PGArray
 
 require 'delegate'
-require 'strscan'
 
 module Sequel
   module Postgres
@@ -99,7 +99,7 @@ module Sequel
             register_array_type('bytea', :oid=>1001, :scalar_oid=>17, :type_symbol=>:blob)
             register_array_type('date', :oid=>1182, :scalar_oid=>1082)
             register_array_type('time without time zone', :oid=>1183, :scalar_oid=>1083, :type_symbol=>:time)
-            register_array_type('time with time zone', :oid=>1270, :scalar_oid=>1083, :type_symbol=>:time_timezone, :scalar_typecast=>:time)
+            register_array_type('time with time zone', :oid=>1270, :scalar_oid=>1266, :type_symbol=>:time_timezone, :scalar_typecast=>:time)
 
             register_array_type('smallint', :oid=>1005, :scalar_oid=>21, :scalar_typecast=>:integer)
             register_array_type('oid', :oid=>1028, :scalar_oid=>26, :scalar_typecast=>:integer)
@@ -300,93 +300,101 @@ module Sequel
         end
       end
 
-      # PostgreSQL array parser that handles PostgreSQL array output format.
-      # Note that does not handle all forms out input that PostgreSQL will
-      # accept, and it will not raise an error for all forms of invalid input.
-      class Parser < StringScanner
-        # Set the source for the input, and any converter callable
-        # to call with objects to be created.  For nested parsers
-        # the source may contain text after the end current parse,
-        # which will be ignored.
-        def initialize(source, converter=nil)
-          super(source)
-          @converter = converter 
-          @stack = [[]]
-          @encoding = string.encoding
-          @recorded = String.new.force_encoding(@encoding)
-        end
+      unless Sequel::Postgres.respond_to?(:parse_pg_array)
+        require 'strscan'
+
+        # PostgreSQL array parser that handles PostgreSQL array output format.
+        # Note that does not handle all forms out input that PostgreSQL will
+        # accept, and it will not raise an error for all forms of invalid input.
+        class Parser < StringScanner
+          # Set the source for the input, and any converter callable
+          # to call with objects to be created.  For nested parsers
+          # the source may contain text after the end current parse,
+          # which will be ignored.
+          def initialize(source, converter=nil)
+            super(source)
+            @converter = converter 
+            @stack = [[]]
+            @encoding = string.encoding
+            @recorded = String.new.force_encoding(@encoding)
+          end
 
-        # Take the buffer of recorded characters and add it to the array
-        # of entries, and use a new buffer for recorded characters.
-        def new_entry(include_empty=false)
-          if !@recorded.empty? || include_empty
-            entry = @recorded
-            if entry == 'NULL' && !include_empty
-              entry = nil
-            elsif @converter
-              entry = @converter.call(entry)
+          # Take the buffer of recorded characters and add it to the array
+          # of entries, and use a new buffer for recorded characters.
+          def new_entry(include_empty=false)
+            if !@recorded.empty? || include_empty
+              entry = @recorded
+              if entry == 'NULL' && !include_empty
+                entry = nil
+              elsif @converter
+                entry = @converter.call(entry)
+              end
+              @stack.last.push(entry)
+              @recorded = String.new.force_encoding(@encoding)
             end
-            @stack.last.push(entry)
-            @recorded = String.new.force_encoding(@encoding)
           end
-        end
 
-        # Parse the input character by character, returning an array
-        # of parsed (and potentially converted) objects.
-        def parse
-          raise Sequel::Error, "invalid array, empty string" if eos?
-          raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
-
-          while !eos?
-            char = scan(/[{}",]|[^{}",]+/)
-            if char == ','
-              # Comma outside quoted string indicates end of current entry
-              new_entry
-            elsif char == '"'
-              raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
-              while true
-                char = scan(/["\\]|[^"\\]+/)
-                if char == '\\'
-                  @recorded << getch
-                elsif char == '"'
-                  n = peek(1)
-                  raise Sequel::Error, "invalid array, closing quote not followed by comma or closing brace" unless n == ',' || n == '}'
-                  break
+          # Parse the input character by character, returning an array
+          # of parsed (and potentially converted) objects.
+          def parse
+            raise Sequel::Error, "invalid array, empty string" if eos?
+            raise Sequel::Error, "invalid array, doesn't start with {" unless scan(/((\[\d+:\d+\])+=)?\{/)
+
+            # :nocov:
+            while !eos?
+            # :nocov:
+              char = scan(/[{}",]|[^{}",]+/)
+              if char == ','
+                # Comma outside quoted string indicates end of current entry
+                new_entry
+              elsif char == '"'
+                raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+                # :nocov:
+                while true
+                # :nocov:
+                  char = scan(/["\\]|[^"\\]+/)
+                  if char == '\\'
+                    @recorded << getch
+                  elsif char == '"'
+                    n = peek(1)
+                    raise Sequel::Error, "invalid array, closing quote not followed by comma or closing brace" unless n == ',' || n == '}'
+                    break
+                  else
+                    @recorded << char
+                  end
+                end
+                new_entry(true)
+              elsif char == '{'
+                raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
+
+                # Start of new array, add it to the stack
+                new = []
+                @stack.last << new
+                @stack << new
+              elsif char == '}'
+                # End of current array, add current entry to the current array
+                new_entry
+
+                if @stack.length == 1
+                  raise Sequel::Error, "array parsing finished without parsing entire string" unless eos?
+
+                  # Top level of array, parsing should be over.
+                  # Pop current array off stack and return it as result
+                  return @stack.pop
                 else
-                  @recorded << char
+                  # Nested array, pop current array off stack
+                  @stack.pop
                 end
-              end
-              new_entry(true)
-            elsif char == '{'
-              raise Sequel::Error, "invalid array, opening brace with existing recorded data" unless @recorded.empty?
-
-              # Start of new array, add it to the stack
-              new = []
-              @stack.last << new
-              @stack << new
-            elsif char == '}'
-              # End of current array, add current entry to the current array
-              new_entry
-
-              if @stack.length == 1
-                raise Sequel::Error, "array parsing finished without parsing entire string" unless eos?
-
-                # Top level of array, parsing should be over.
-                # Pop current array off stack and return it as result
-                return @stack.pop
               else
-                # Nested array, pop current array off stack
-                @stack.pop
+                # Add the character to the recorded character buffer.
+                @recorded << char
               end
-            else
-              # Add the character to the recorded character buffer.
-              @recorded << char
             end
-          end
 
-          raise Sequel::Error, "array parsing finished with array unclosed"
+            raise Sequel::Error, "array parsing finished with array unclosed"
+          end
         end
-      end unless Sequel::Postgres.respond_to?(:parse_pg_array)
+      end
 
       # Callable object that takes the input string and parses it using Parser.
       class Creator

data/lib/sequel/extensions/pg_array_ops.rb

@@ -51,8 +51,8 @@
 #   ia.length(2)       # array_length(int_array_column, 2)
 #   ia.lower           # array_lower(int_array_column, 1)
 #   ia.lower(2)        # array_lower(int_array_column, 2)
-#   ia.join            # array_to_string(int_array_column, '', NULL)
-#   ia.join(':')       # array_to_string(int_array_column, ':', NULL)
+#   ia.join            # array_to_string(int_array_column, '')
+#   ia.join(':')       # array_to_string(int_array_column, ':')
 #   ia.join(':', ' ')  # array_to_string(int_array_column, ':', ' ')
 #   ia.unnest          # unnest(int_array_column)
 #   ia.unnest(:b)      # unnest(int_array_column, b)
@@ -157,7 +157,9 @@ module Sequel
         else
           Sequel.function(:hstore, self, wrap_array(arg))
         end
+        # :nocov:
         if Sequel.respond_to?(:hstore_op)
+        # :nocov:
           v = Sequel.hstore_op(v)
         end
         v
@@ -217,12 +219,16 @@ module Sequel
 
       # Call the array_to_string method:
       #
-      #   array_op.join           # array_to_string(array, '', NULL)
-      #   array_op.to_string      # array_to_string(array, '', NULL)
-      #   array_op.join(":")      # array_to_string(array, ':', NULL)
+      #   array_op.join           # array_to_string(array, '')
+      #   array_op.to_string      # array_to_string(array, '')
+      #   array_op.join(":")      # array_to_string(array, ':')
       #   array_op.join(":", "*") # array_to_string(array, ':', '*')
       def to_string(joiner="", null=nil)
-        function(:array_to_string, joiner, null)
+        if null.nil?
+          function(:array_to_string, joiner)
+        else
+          function(:array_to_string, joiner, null)
+        end
       end
       alias join to_string
       
@@ -279,7 +285,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(PGArray)
+    # :nocov:
       class PGArray
         # Wrap the PGArray instance in an ArrayOp, allowing you to easily use
         # the PostgreSQL array functions and operators with literal arrays.

data/lib/sequel/extensions/pg_enum.rb

@@ -17,6 +17,12 @@
 #
 #   DB.rename_enum(:enum_type_name, :enum_type_another_name)
 #
+# If you want to rename an enum value, you can use rename_enum_value:
+#
+#   DB.rename_enum_value(
+#     :enum_type_name, :enum_value_name, :enum_value_another_name
+#   )
+#
 # If you want to drop an enum type, you can use drop_enum:
 #
 #   DB.drop_enum(:enum_type_name)
@@ -34,8 +40,11 @@
 #   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:
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of enum types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_enum
 #
 #   DB.create_table(:table_name) do
 #     column :column_name, 'enum_type_name[]'
@@ -86,26 +95,24 @@ module Sequel
         elsif v = opts[:after]
           sql << " AFTER #{literal(v.to_s)}"
         end
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql(sql)
       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
+        _process_enum_change_sql("CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})")
       end
 
       # Run the SQL to rename the enum type with the given name
       # to the another given name.
       def rename_enum(enum, new_name)
-        sql = "ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}")
+      end
+
+      # Run the SQL to rename the enum value with the given name
+      # to the another given name.
+      def rename_enum_value(enum, old_name, new_name)
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME VALUE #{literal(old_name.to_s)} TO #{literal(new_name.to_s)}")
       end
 
       # Run the SQL to drop the enum type with the given name.
@@ -113,20 +120,27 @@ module Sequel
       # :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
+        _process_enum_change_sql("DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}")
       end
 
       private
 
+      # Run the SQL on the database, reparsing the enum labels after it is run.
+      def _process_enum_change_sql(sql)
+        run(sql)
+        parse_enum_labels
+        nil
+      end
+
       # 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
+        order = [:enumtypid]
+        order << :enumsortorder if server_version >= 90100
+
         enum_labels = metadata_dataset.from(:pg_enum).
-          order(:enumtypid, :enumsortorder).
+          order(*order).
           select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
         enum_labels.each_value(&:freeze)
 
@@ -167,7 +181,9 @@ module Sequel
   end
 
   # support reversible create_enum statements if the migration extension is loaded
+  # :nocov:
   if defined?(MigrationReverser)
+  # :nocov:
     class MigrationReverser
       private
       def create_enum(name, _)

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -83,13 +83,30 @@ module Sequel
       # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
       # value based on the convert_infinite_timestamps setting.
       def to_application_timestamp(value)
-        if value.is_a?(String) && (m = value.match(/(?:(?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[1] || m[2])
-          if m[2]
+        if value.is_a?(String) && (m = value.match(/((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/)) && (m[2] || m[3])
+          if m[3]
             value = value.sub(' BC', '').sub(' ', ' BC ')
+            conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'
           end
-          if m[1]
+          if m[2] || conv
             dt = DateTime.parse(value)
-            dt = dt.to_time unless Sequel.datetime_class == DateTime
+            if conv
+              # :nocov:
+              if Sequel.datetime_class == DateTime
+                dt >>= 12
+              else
+                dt >>= 24
+              end
+              # :nocov:
+            end
+            unless Sequel.datetime_class == DateTime
+              dt = dt.to_time
+              if conv && (timezone == nil || timezone == :local) && !m[1]
+                # :nocov:
+                dt = Sequel.send(:convert_input_timestamp, dt.strftime("%F %T.%6N"), :local)
+                # :nocov:
+              end
+            end
             Sequel.convert_output_timestamp(dt, Sequel.application_timezone)
           else
             super(value)
@@ -172,7 +189,7 @@ module Sequel
           if date < DATETIME_YEAR_1
             date <<= ((date.year) * 24 - 12)
             date = db.from_application_timestamp(date)
-            minutes = (date.is_a?(DateTime) ? date.offset * 1440 : date.utc_offset/60).to_i
+            minutes = (date.offset * 1440).to_i
             date.strftime("'%Y-%m-%d %H:%M:%S.%N#{format_timestamp_offset(*minutes.divmod(60))} BC'")
           else
             super
@@ -191,15 +208,6 @@ module Sequel
         if RUBY_ENGINE == 'jruby'
           # :nocov:
 
-          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
-          def literal_time(time)
-            if time < TIME_YEAR_1
-              literal_datetime(DateTime.parse(super))
-            else
-              super
-            end
-          end
-
           ExtendedDateSupport::CONVERT_TYPES = [Java::JavaSQL::Types::DATE, Java::JavaSQL::Types::TIMESTAMP]
 
           # Use non-JDBC parsing as JDBC parsing doesn't work for BC dates/timestamps.
@@ -211,6 +219,18 @@ module Sequel
               super
             end
           end
+
+          # Work around JRuby bug #4822 in Time#to_datetime for times before date of calendar reform
+          def literal_time(time)
+            if time < TIME_YEAR_1
+              dt = DateTime.parse(super)
+              # Work around JRuby bug #5191
+              dt >>= 12 if JRUBY_VERSION == '9.2.0.0'
+              literal_datetime(dt)
+            else
+              super
+            end
+          end
           # :nocov:
         else
           # Handle BC Time objects.

data/lib/sequel/extensions/pg_hstore.rb

@@ -74,6 +74,12 @@
 #
 #   DB.extension :pg_hstore
 #
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of hstore types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_hstore
+#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -312,7 +312,9 @@ module Sequel
       end
     end
 
+    # :nocov:
     if defined?(HStore)
+    # :nocov:
       class HStore
         # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
         # hstore functions and operators with it.