sequel 5.33.0 → 5.58.0

data/lib/sequel/extensions/date_parse_input_handler.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+#
+# The date_parse_input_handler extension allows for configuring how input
+# to date parsing methods should be handled.  By default, the
+# extension does not change behavior.  However, you can use the
+# +Sequel.date_parse_input_handler+ method to support custom handling
+# of input strings to the date parsing methods.  For example, if you want
+# to implement a length check to prevent denial of service vulnerabilities
+# in older versions of Ruby, you can do:
+#
+#   Sequel.extension :date_parse_input_handler
+#   Sequel.date_parse_input_handler do |string|
+#     raise Sequel::InvalidValue, "string length (200) exceeds the limit 128" if string.bytesize > 128
+#     string
+#   end
+#
+# You can also use +Sequel.date_parse_input_handler+ to modify the string
+# that will be passed to the parsing methods.  For example, you could
+# truncate it:
+#
+#   Sequel.date_parse_input_handler do |string|
+#     string.b[0, 128]
+#   end
+#
+# Be aware that modern versions of Ruby will raise an exception if
+# date parsing input exceeds 128 bytes.
+
+module Sequel
+  module DateParseInputHandler
+    def date_parse_input_handler(&block)
+      singleton_class.class_eval do
+        define_method(:handle_date_parse_input, &block)
+        private :handle_date_parse_input
+        alias handle_date_parse_input handle_date_parse_input
+      end
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_date(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_datetime(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Call date parse input handler with input string.
+    def string_to_time(string)
+      super(handle_date_parse_input(string))
+    end
+
+    private
+
+    # Call date parse input handler with input string.
+    def _date_parse(string)
+      super(handle_date_parse_input(string))
+    end
+
+    # Return string as-is by default, so by default behavior does not change.
+    def handle_date_parse_input(string)
+      string
+    end
+  end
+
+  extend DateParseInputHandler
+end

data/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -19,7 +19,11 @@ module Sequel::DateTimeParseToTime
   # Use DateTime.parse.to_time to do the conversion if the input a string and is assumed to
   # be in UTC and there is no offset information in the string.
   def convert_input_timestamp(v, input_timezone)
-    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !Date._parse(v).has_key?(:offset)
+    if v.is_a?(String) && datetime_class == Time && input_timezone == :utc && !_date_parse(v).has_key?(:offset)
+      # :nocov:
+      # Whether this is fully branch covered depends on the order in which the specs are run.
+      v = handle_date_parse_input(v) if respond_to?(:handle_date_parse_input, true)
+      # :nocov:
       t = DateTime.parse(v).to_time
       case application_timezone
       when nil, :local

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -39,10 +39,12 @@
 
 module Sequel
   module DuplicateColumnsHandler
+    # :nocov:
     CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
+    # :nocov:
 
     # Customize handling of duplicate columns for this dataset.
-    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)
+    def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless defined?(yield); nil), &block)
       raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
       clone(:on_duplicate_columns=>handler||block)
     end

data/lib/sequel/extensions/eval_inspect.rb

@@ -55,6 +55,8 @@ module Sequel
 
   module SQL
     class Expression
+      alias inspect inspect
+
       # Attempt to produce a string suitable for eval, such that:
       #
       #   eval(obj.inspect) == obj

data/lib/sequel/extensions/inflector.rb

@@ -102,9 +102,17 @@ class String
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
 
   # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
   # is set to :lower then camelize produces lowerCamelCase.

data/lib/sequel/extensions/is_distinct_from.rb

@@ -0,0 +1,139 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  Only PostgreSQL and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/migration.rb

@@ -68,6 +68,9 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    # :nocov:
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -329,7 +332,8 @@ module Sequel
   # schema_migrations for timestamped migrations). in the database to keep track
   # of the current migration version. If no migration version is stored in the
   # database, the version is considered to be 0. If no target version is 
-  # specified, the database is migrated to the latest version available in the
+  # specified, or the target version specified is greater than the latest
+  # version available, the database is migrated to the latest version available in the
   # migration directory.
   #
   # For example, to migrate the database to the latest version:
@@ -384,6 +388,9 @@ module Sequel
 
     # Migrates the supplied database using the migration files in the specified directory. Options:
     # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
+    #                                   It is very risky to use this option, since it can result in
+    #                                   the database schema version number not matching the expected
+    #                                   database schema.
     # :column :: The column in the :table argument storing the migration version (default: :version).
     # :current :: The current version of the database.  If not given, it is retrieved from the database
     #             using the :table and :column options.
@@ -518,7 +525,6 @@ module Sequel
     def initialize(db, directory, opts=OPTS)
       super
       @current = opts[:current] || current_migration_version
-      raise(Error, "No current version available") unless current
 
       latest_version = latest_migration_version
       @target = if opts[:target]
@@ -538,6 +544,11 @@ module Sequel
       end
 
       @direction = current < target ? :up : :down
+
+      if @direction == :down && @current >= @files.length && !@allow_missing_migration_files
+        raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
+      end
+
       @migrations = get_migrations
     end
 

data/lib/sequel/extensions/named_timezones.rb

@@ -84,9 +84,9 @@ module Sequel
       def convert_output_time_other(v, output_timezone)
         Time.at(v.to_i, :in => output_timezone)
       end
-    else
       # :nodoc:
       # :nocov:
+    else
       def convert_input_time_other(v, input_timezone)
         local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
         Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
@@ -105,6 +105,8 @@ module Sequel
           Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
         end
       end
+      # :nodoc:
+      # :nocov:
     end
 
     # Handle both TZInfo 1 and TZInfo 2
@@ -142,6 +144,8 @@ module Sequel
         # Convert timezone offset from UTC to the offset for the output_timezone
         (v - local_offset).new_offset(local_offset)
       end
+      # :nodoc:
+      # :nocov:
     end
     
     # Returns TZInfo::Timezone instance if given a String.

data/lib/sequel/extensions/pagination.rb

@@ -54,7 +54,7 @@ module Sequel
     # an enumerator if no block is given.
     def each_page(page_size)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      return to_enum(:each_page, page_size) unless block_given?
+      return to_enum(:each_page, page_size) unless defined?(yield)
       record_count = count
       total_pages = (record_count / page_size.to_f).ceil
       (1..total_pages).each{|page_no| yield paginate(page_no, page_size, record_count)}

data/lib/sequel/extensions/pg_array.rb

@@ -213,6 +213,7 @@ module Sequel
             scalar_typecast_method = :"typecast_value_#{opts.fetch(:scalar_typecast, type)}"
             define_method(meth){|v| typecast_value_pg_array(v, creator, scalar_typecast_method)}
             private meth
+            alias_method(meth, meth)
           end
 
           @schema_type_classes[:"#{type}_array"] = PGArray

data/lib/sequel/extensions/pg_array_ops.rb

@@ -108,7 +108,7 @@ module Sequel
 
       # Call the ANY function:
       #
-      #   array_op.all # ANY(array)
+      #   array_op.any # ANY(array)
       #
       # Usually used like:
       #
@@ -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
@@ -283,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.
@@ -325,7 +329,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::ArrayOpMethods
+      send INCLUDE_METH, Sequel::Postgres::ArrayOpMethods
     end
   end
 end

data/lib/sequel/extensions/pg_enum.rb

@@ -42,7 +42,7 @@
 #
 # 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:
+# pg_enum extension:
 #
 #   DB.extension :pg_array, :pg_enum
 #
@@ -181,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,7 +83,7 @@ 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[2] || m[3])
+        if value.is_a?(String) && (m = /((?:[-+]\d\d:\d\d)(:\d\d)?)?( BC)?\z/.match(value)) && (m[2] || m[3])
           if m[3]
             value = value.sub(' BC', '').sub(' ', ' BC ')
             conv = defined?(JRUBY_VERSION) && JRUBY_VERSION == '9.2.0.0'
@@ -189,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

data/lib/sequel/extensions/pg_hstore.rb

@@ -76,7 +76,7 @@
 #
 # 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:
+# pg_hstore extension:
 #
 #   DB.extension :pg_array, :pg_hstore
 #

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -62,6 +62,19 @@
 #   # Delete a key
 #   DB[:tab].update(h: Sequel.hstore_op(:h).delete('k1'))
 #  
+# On PostgreSQL 14+, The hstore <tt>[]</tt> method will use subscripts instead of being
+# the same as +get+, if the value being wrapped is an identifer:
+#
+#   Sequel.hstore_op(:hstore_column)['a']    # hstore_column['a']
+#   Sequel.hstore_op(Sequel[:h][:s])['a']      # h.s['a']
+#
+# This support allows you to use hstore subscripts in UPDATE statements to update only
+# part of a column:
+#
+#   h = Sequel.hstore_op(:h)
+#   DB[:t].update(h['key1'] => 'val1', h['key2'] => 'val2')
+#   #  UPDATE "t" SET "h"['key1'] = 'val1', "h"['key2'] = 'val2'
+#
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.
 #
@@ -114,10 +127,15 @@ module Sequel
       #
       #   hstore_op['a'] # (hstore -> 'a')
       def [](key)
-        v = Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)])
         if key.is_a?(Array) || (defined?(Sequel::Postgres::PGArray) && key.is_a?(Sequel::Postgres::PGArray)) || (defined?(Sequel::Postgres::ArrayOp) && key.is_a?(Sequel::Postgres::ArrayOp))
-          wrap_output_array(v)
+          wrap_output_array(Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, wrap_input_array(key)]))
         else
+          v = case @value
+          when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
+            HStoreSubscriptOp.new(self, key)
+          else
+            Sequel::SQL::PlaceholderLiteralString.new(LOOKUP, [value, key])
+          end
           Sequel::SQL::StringExpression.new(:NOOP, v)
         end
       end
@@ -304,6 +322,38 @@ module Sequel
       end
     end
 
+    # Represents hstore subscripts. This is abstracted because the
+    # subscript support depends on the database version.
+    class HStoreSubscriptOp < SQL::Expression
+      SUBSCRIPT = ["".freeze, "[".freeze, "]".freeze].freeze
+
+      # The expression being subscripted
+      attr_reader :expression
+
+      # The subscript to use
+      attr_reader :sub
+
+      # Set the expression and subscript to the given arguments
+      def initialize(expression, sub)
+        @expression = expression
+        @sub = sub
+        freeze
+      end
+
+      # Use subscripts instead of -> operator on PostgreSQL 14+
+      def to_s_append(ds, sql)
+        server_version = ds.db.server_version
+        frag = server_version && server_version >= 140000 ? SUBSCRIPT : HStoreOp::LOOKUP
+        ds.literal_append(sql, Sequel::SQL::PlaceholderLiteralString.new(frag, [@expression, @sub]))
+      end
+
+      # Support transforming of hstore subscripts
+      def sequel_ast_transform(transformer)
+        self.class.new(transformer.call(@expression), transformer.call(@sub))
+      end
+    end
+
+
     module HStoreOpMethods
       # Wrap the receiver in an HStoreOp so you can easily use the PostgreSQL
       # hstore functions and operators with it.
@@ -312,7 +362,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.
@@ -354,7 +406,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::HStoreOpMethods
+      send INCLUDE_METH, Sequel::Postgres::HStoreOpMethods
     end
   end
 end

data/lib/sequel/extensions/pg_inet.rb

@@ -41,7 +41,9 @@ module Sequel
         db.instance_exec do
           extend_datasets(InetDatasetMethods)
 
+          # :nocov:
           if !defined?(SEQUEL_PG_VERSION_INTEGER) || SEQUEL_PG_VERSION_INTEGER >= 11300
+          # :nocov:
             # sequel_pg 1.13.0+ will use inet/cidr conversion procs, but doing so is
             # slower, so don't add the conversion procs if using sequel_pg 1.13.0+.
             meth = IPAddr.method(:new)

data/lib/sequel/extensions/pg_inet_ops.rb

@@ -197,7 +197,7 @@ end
 if defined?(Sequel::CoreRefinements)
   module Sequel::CoreRefinements
     refine Symbol do
-      include Sequel::Postgres::InetOpMethods
+      send INCLUDE_METH, Sequel::Postgres::InetOpMethods
     end
   end
 end

data/lib/sequel/extensions/pg_interval.rb

@@ -32,8 +32,16 @@
 #
 # Related module: Sequel::Postgres::IntervalDatabaseMethods
 
+require 'active_support'
 require 'active_support/duration'
 
+# :nocov:
+begin
+  require 'active_support/version'
+rescue LoadError
+end
+# :nocov:
+
 module Sequel
   module Postgres
     module IntervalDatabaseMethods
@@ -61,34 +69,47 @@ module Sequel
 
       # Creates callable objects that convert strings into ActiveSupport::Duration instances.
       class Parser
+        # Whether ActiveSupport::Duration.new takes parts as array instead of hash
+        USE_PARTS_ARRAY = !defined?(ActiveSupport::VERSION::STRING) || ActiveSupport::VERSION::STRING < '5.1'
+
+        if defined?(ActiveSupport::Duration::SECONDS_PER_MONTH)
+          SECONDS_PER_MONTH = ActiveSupport::Duration::SECONDS_PER_MONTH
+          SECONDS_PER_YEAR = ActiveSupport::Duration::SECONDS_PER_YEAR
+        # :nocov:
+        else
+          SECONDS_PER_MONTH = 2592000
+          SECONDS_PER_YEAR = 31557600
+        # :nocov:
+        end
+
         # Parse the interval input string into an ActiveSupport::Duration instance.
         def call(string)
           raise(InvalidValue, "invalid or unhandled interval format: #{string.inspect}") unless matches = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/.match(string)
 
           value = 0
-          parts = []
+          parts = {}
 
           if v = matches[1]
             v = v.to_i
-            value += 31557600 * v
-            parts << [:years, v]
+            value += SECONDS_PER_YEAR * v
+            parts[:years] = v
           end
           if v = matches[2]
             v = v.to_i
-            value += 2592000 * v
-            parts << [:months, v]
+            value += SECONDS_PER_MONTH * v
+            parts[:months] = v
           end
           if v = matches[3]
             v = v.to_i
             value += 86400 * v
-            parts << [:days, v]
+            parts[:days] = v
           end
           if matches[5]
             seconds = matches[5].to_i * 3600 + matches[6].to_i * 60
             seconds += matches[8] ? matches[7].to_f : matches[7].to_i
             seconds *= -1 if matches[4] == '-'
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
           elsif matches[9] || matches[10] || matches[11]
             seconds = 0
             if v = matches[9]
@@ -101,8 +122,14 @@ module Sequel
               seconds += matches[12] ? v.to_f : v.to_i
             end
             value += seconds
-            parts << [:seconds, seconds]
+            parts[:seconds] = seconds
+          end
+
+          # :nocov:
+          if USE_PARTS_ARRAY
+            parts = parts.to_a
           end
+          # :nocov:
 
           ActiveSupport::Duration.new(value, parts)
         end

data/lib/sequel/extensions/pg_json.rb

@@ -387,11 +387,9 @@ module Sequel
       # argument is true), or a String, Numeric, true, false, or nil
       # if the json library used supports that.
       def _parse_json(s)
-        begin
-          Sequel.parse_json(s)
-        rescue Sequel.json_parser_error_class => e
-          raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
-        end
+        Sequel.parse_json(s)
+      rescue Sequel.json_parser_error_class => e
+        raise Sequel.convert_exception_class(e, Sequel::InvalidValue)
       end
 
       # Wrap the parsed JSON value in the appropriate JSON wrapper class.