sequel 4.8.0 → 4.9.0

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -0,0 +1,57 @@
+# The current_datetime_timestamp extension makes Dataset#current_datetime
+# return an object that operates like Sequel.datetime_class.now, but will
+# be literalized as CURRENT_TIMESTAMP.
+#
+# This allows you to use the defaults_setter, timestamps, and touch
+# model plugins and make sure that CURRENT_TIMESTAMP is used instead of
+# a literalized timestamp value.
+#
+# The reason that CURRENT_TIMESTAMP is better than a literalized version
+# of the timestamp is that it obeys correct transactional semantics
+# (all calls to CURRENT_TIMESTAMP in the same transaction return the
+# same timestamp, at least on some databases).
+#
+# To have current_datetime be literalized as CURRENT_TIMESTAMP for
+# a single dataset:
+#
+#   ds = ds.extension(:current_datetime_timestamp)
+#
+# To have current_datetime be literalized as CURRENT_TIMESTAMP for all
+# datasets of a given database.
+#
+#   DB.extension(:current_datetime_timestamp)
+
+module Sequel
+  module CurrentDateTimeTimestamp
+    module DatasetMethods
+      # Return an instance of Sequel.datetime_class that will be literalized
+      # as CURRENT_TIMESTAMP.
+      def current_datetime
+        MAP.fetch(Sequel.datetime_class).now
+      end
+
+      private
+
+      # Literalize custom DateTime subclass objects as CURRENT_TIMESTAMP.
+      def literal_datetime_append(sql, v)
+        v.is_a?(DateTime) ? literal_append(sql, Sequel::CURRENT_TIMESTAMP) : super
+      end
+
+      # Literalize custom Time subclass objects as CURRENT_TIMESTAMP.
+      def literal_time_append(sql, v)
+        v.is_a?(Time) ? literal_append(sql, Sequel::CURRENT_TIMESTAMP) : super
+      end
+    end
+
+    # Time subclass literalized as CURRENT_TIMESTAMP
+    class Time < ::Time; end
+
+    # DateTime subclass literalized as CURRENT_TIMESTAMP
+    class DateTime < ::DateTime; end
+
+    # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
+    MAP = {::Time=>Time, ::DateTime=>DateTime}
+  end
+
+  Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)
+end

data/lib/sequel/extensions/pg_array.rb

@@ -23,7 +23,7 @@
 #
 #   array.pg_array
 #
-# You can also provide a type, though it many cases it isn't necessary:
+# You can also provide a type, though in many cases it isn't necessary:
 #
 #   Sequel.pg_array(array, :varchar) # or :integer, :"double precision", etc.
 #   array.pg_array(:varchar) # or :integer, :"double precision", etc.
@@ -73,35 +73,10 @@
 # If you want an easy way to call PostgreSQL array functions and
 # operators, look into the pg_array_ops extension.
 #
-# This extension requires both the json and delegate libraries.
-#
-# == Additional License
-#
-# PGArray::Parser code was translated from Javascript code in the
-# node-postgres project and has the following additional license:
-# 
-# Copyright (c) 2010 Brian Carlson (brian.m.carlson@gmail.com)
-# 
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject
-# to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# This extension requires the json, strscan, and delegate libraries.
 
 require 'delegate'
+require 'strscan'
 require 'json'
 Sequel.require 'adapters/utils/pg_types'
 
@@ -159,10 +134,6 @@ module Sequel
       # :type_symbol :: The base of the schema type symbol for this type.  For example, if you provide
       #                 :integer, Sequel will recognize this type as :integer_array during schema parsing.
       #                 Defaults to the db_type argument.
-      # :typecast_method :: If given, specifies the :type_symbol option, but additionally causes no
-      #                     typecasting method to be created in the database.  This should only be used
-      #                     to alias existing array types.  For example, if there is an array type that can be
-      #                     treated just like an integer array, you can do :typecast_method=>:integer.
       # :typecast_method_map :: The map in which to place the database type string to type symbol mapping.
       #                         Defaults to ARRAY_TYPES.
       # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
@@ -171,8 +142,7 @@ module Sequel
       # If a block is given, it is treated as the :converter option.
       def self.register(db_type, opts=OPTS, &block)
         db_type = db_type.to_s
-        typecast_method = opts[:typecast_method]
-        type = (typecast_method || opts[:type_symbol] || db_type).to_sym
+        type = (opts[:type_symbol] || db_type).to_sym
         type_procs = opts[:type_procs] || PG_TYPES
         mod = opts[:typecast_methods_module] || DatabaseMethods
         typecast_method_map = opts[:typecast_method_map] || ARRAY_TYPES
@@ -193,7 +163,7 @@ module Sequel
 
         typecast_method_map[db_type] = :"#{type}_array"
 
-        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type)) unless typecast_method
+        define_array_typecast_method(mod, type, creator, opts.fetch(:scalar_typecast, type))
 
         if oid = opts[:oid]
           type_procs[oid] = creator
@@ -261,7 +231,7 @@ module Sequel
             opts[:oid] = array_oid unless opts.has_key?(:oid)
           end
           PGArray.register(db_type, opts, &block)
-          @schema_type_classes[:"#{opts[:typecast_method] || opts[:type_symbol] || db_type}_array"] = PGArray
+          @schema_type_classes[:"#{opts[:type_symbol] || db_type}_array"] = PGArray
         end
 
         # Return PGArray if this type matches any supported array type.
@@ -334,7 +304,6 @@ module Sequel
         #   typecast all members of the array in ruby for performance reasons, but
         #   it will cast the array the appropriate database type when the array is
         #   literalized.
-        # * If given a String, call the parser for the subclass with it.
         def typecast_value_pg_array(value, creator, scalar_typecast_method=nil)
           case value
           when PGArray
@@ -354,45 +323,26 @@ module Sequel
         end
       end
 
-      # PostgreSQL array parser that handles all types of input.
-      #
-      # This parser is very simple and unoptimized, but should still
-      # be O(n) where n is the length of the input string.
-      class Parser
-        # Current position in the input string.
-        attr_reader :pos
+      # 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
+        UNQUOTED_RE = /[{}",]|[^{}",]+/
+        QUOTED_RE = /["\\]|[^"\\]+/
+        NULL_RE = /NULL",/
+        OPEN_RE = /\{/
 
         # 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)
-          @source = source
-          @source_length = source.length
+          super(source)
           @converter = converter 
-          @pos = -1
-          @entries = []
+          @stack = [[]]
           @recorded = ""
-          @dimension = 0
-        end
-
-        # Return 2 objects, whether the next character in the input
-        # was escaped with a backslash, and what the next character is.
-        def next_char
-          @pos += 1
-          if (c = @source[@pos..@pos]) == BACKSLASH
-            @pos += 1
-            [true, @source[@pos..@pos]]
-          else
-            [false, c]
-          end
         end
 
-        # Add a new character to the buffer of recorded characters.
-        def record(c)
-          @recorded << c
-        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)
@@ -403,53 +353,65 @@ module Sequel
             elsif @converter
               entry = @converter.call(entry)
             end
-            @entries.push(entry)
+            @stack.last.push(entry)
             @recorded = ""
           end
         end
 
         # Parse the input character by character, returning an array
         # of parsed (and potentially converted) objects.
-        def parse(nested=false)
-          # quote sets whether we are inside of a quoted string.
-          quote = false
-          until @pos >= @source_length
-            escaped, char = next_char
-            if char == OPEN_BRACE && !quote
-              @dimension += 1
-              if (@dimension > 1)
-                # Multi-dimensional array encounter, use a subparser
-                # to parse the next level down.
-                subparser = self.class.new(@source[@pos..-1], @converter)
-                @entries.push(subparser.parse(true))
-                @pos += subparser.pos - 1
-              end
-            elsif char == CLOSE_BRACE && !quote
-              @dimension -= 1
-              if (@dimension == 0)
-                new_entry
-                # Exit early if inside a subparser, since the
-                # text after parsing the current level should be
-                # ignored as it is handled by the parent parser.
-                return @entries if nested
+        def parse
+          raise Sequel::Error, "invalid array, empty string" if eos?
+          raise Sequel::Error, "invalid array, doesn't start with {" unless scan(OPEN_RE)
+
+          while !eos?
+            char = scan(UNQUOTED_RE)
+            if char == COMMA
+              # Comma outside quoted string indicates end of current entry
+              new_entry
+            elsif char == QUOTE
+              raise Sequel::Error, "invalid array, opening quote with existing recorded data" unless @recorded.empty?
+              while true
+                char = scan(QUOTED_RE)
+                if char == BACKSLASH
+                  @recorded << getch
+                elsif char == QUOTE
+                  n = peek(1)
+                  raise Sequel::Error, "invalid array, closing quote not followed by comma or closing brace" unless n == COMMA || n == CLOSE_BRACE
+                  break
+                else
+                  @recorded << char
+                end
               end
-            elsif char == QUOTE && !escaped
-              # If already inside the quoted string, this is the
-              # ending quote, so add the entry.  Otherwise, this
-              # is the opening quote, so set the quote flag.
-              new_entry(true) if quote
-              quote = !quote
-            elsif char == COMMA && !quote
-              # If not inside a string and a comma occurs, it indicates
-              # the end of the entry, so add the entry.
+              new_entry(true)
+            elsif char == OPEN_BRACE
+              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 == CLOSE_BRACE
+              # 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
+              end
             else
               # Add the character to the recorded character buffer.
-              record(char)
+              @recorded << char
             end
           end
-          raise Sequel::Error, "array dimensions not balanced" unless @dimension == 0
-          @entries
+
+          raise Sequel::Error, "array parsing finished with array unclosed"
         end
       end unless Sequel::Postgres.respond_to?(:parse_pg_array)
 
@@ -571,11 +533,11 @@ module Sequel
       register('time with time zone', :oid=>1270, :scalar_oid=>1083, :type_symbol=>:time_timezone, :scalar_typecast=>:time)
       register('timestamp with time zone', :oid=>1185, :scalar_oid=>1184, :type_symbol=>:datetime_timezone, :scalar_typecast=>:datetime)
 
-      register('smallint', :oid=>1005, :parser=>:json, :typecast_method=>:integer)
-      register('oid', :oid=>1028, :parser=>:json, :typecast_method=>:integer)
-      register('real', :oid=>1021, :scalar_oid=>701, :typecast_method=>:float)
-      register('character', :oid=>1014, :array_type=>:text, :typecast_method=>:string)
-      register('character varying', :oid=>1015, :typecast_method=>:string)
+      register('smallint', :oid=>1005, :parser=>:json, :scalar_typecast=>:integer)
+      register('oid', :oid=>1028, :parser=>:json, :scalar_typecast=>:integer)
+      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)
     end
   end
 

data/lib/sequel/extensions/pg_hstore.rb

@@ -28,16 +28,16 @@
 # Since the hstore type only supports strings, non string keys and
 # values are converted to strings
 #
-#   {:foo=>1}.hstore.to_hash # {'foo'=>'1'}
-#   v = {}.hstore
+#   Sequel.hstore(:foo=>1).to_hash # {'foo'=>'1'}
+#   v = Sequel.hstore({})
 #   v[:foo] = 1
 #   v # {'foo'=>'1'}
 #
 # However, to make life easier, lookups by key are converted to
 # strings (even when accessing the underlying hash directly):
 #
-#   {'foo'=>'bar'}.hstore[:foo] # 'bar'
-#   {'foo'=>'bar'}.hstore.to_hash[:foo] # 'bar'
+#   Sequel.hstore('foo'=>'bar')[:foo] # 'bar'
+#   Sequel.hstore('foo'=>'bar').to_hash[:foo] # 'bar'
 # 
 # HStore instances mostly just delegate to the underlying hash
 # instance, so Hash methods that modify the receiver or returned
@@ -66,7 +66,7 @@
 #
 # If you want to insert a hash into an hstore database column:
 #
-#   DB[:table].insert(:column=>{'foo'=>'bar'}.hstore)
+#   DB[:table].insert(:column=>Sequel.hstore('foo'=>'bar'))
 #
 # If you would like to use hstore columns in your model objects, you
 # probably want to modify the schema parsing/typecasting so that it

data/lib/sequel/extensions/schema_dumper.rb

@@ -12,6 +12,55 @@ Sequel.extension :eval_inspect
 
 module Sequel
   module SchemaDumper
+    # Convert the column schema information to a hash of column options, one of which must
+    # be :type.  The other options added should modify that type (e.g. :size).  If a
+    # database type is not recognized, return it as a String type.
+    def column_schema_to_ruby_type(schema)
+      case schema[:db_type].downcase
+      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
+        {:type=>Bignum}
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
+        {:type=>Float}
+      when 'boolean'
+        {:type=>TrueClass}
+      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
+        {:type=>String, :text=>true}
+      when 'date'
+        {:type=>Date}
+      when /\A(?:small)?datetime\z/o
+        {:type=>DateTime}
+      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
+        {:type=>DateTime, :size=>($1.to_i if $1)}
+      when /\Atime(?: with(?:out)? time zone)?\z/o
+        {:type=>Time, :only_time=>true}
+      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
+      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1)}
+      when /\A(?:small)?money\z/o
+        {:type=>BigDecimal, :size=>[19,2]}
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+        s = [($1.to_i if $1), ($2.to_i if $2)].compact
+        {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+        {:type=>File, :size=>($1.to_i if $1)}
+      when /\A(?:year|(?:int )?identity)\z/o
+        {:type=>Integer}
+      else
+        {:type=>String}
+      end
+    end
+
     # Dump foreign key constraints for all tables as a migration. This complements
     # the :foreign_keys=>false option to dump_schema_migration. This only dumps
     # the constraints (not the columns) using alter_table/add_foreign_key with an
@@ -145,55 +194,6 @@ END_MIG
       end
     end
 
-    # Convert the column schema information to a hash of column options, one of which must
-    # be :type.  The other options added should modify that type (e.g. :size).  If a
-    # database type is not recognized, return it as a String type.
-    def column_schema_to_ruby_type(schema)
-      case schema[:db_type].downcase
-      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
-        {:type=>Bignum}
-      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
-        {:type=>Float}
-      when 'boolean'
-        {:type=>TrueClass}
-      when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
-        {:type=>String, :text=>true}
-      when 'date'
-        {:type=>Date}
-      when /\A(?:small)?datetime\z/o
-        {:type=>DateTime}
-      when /\Atimestamp(?:\((\d+)\))?(?: with(?:out)? time zone)?\z/o
-        {:type=>DateTime, :size=>($1.to_i if $1)}
-      when /\Atime(?: with(?:out)? time zone)?\z/o
-        {:type=>Time, :only_time=>true}
-      when /\An?char(?:acter)?(?:\((\d+)\))?\z/o
-        {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
-      when /\A(?:n?varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
-        {:type=>String, :size=>($1.to_i if $1)}
-      when /\A(?:small)?money\z/o
-        {:type=>BigDecimal, :size=>[19,2]}
-      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
-        s = [($1.to_i if $1), ($2.to_i if $2)].compact
-        {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
-      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
-        {:type=>File, :size=>($1.to_i if $1)}
-      when /\A(?:year|(?:int )?identity)\z/o
-        {:type=>Integer}
-      else
-        {:type=>String}
-      end
-    end
-
     # For the table and foreign key metadata array, return an alter_table
     # string that would add the foreign keys if run in a migration.
     def dump_add_fk_constraints(table, fks)