sequel 4.23.0 → 4.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b30c79c77e61381e85de13c0490b3e5cba437b25
-  data.tar.gz: daf911babab2bc31fb6e255d0a0219a4536f373f
+  metadata.gz: 1ce66a463879671227d5446f7e224b1610bccd9f
+  data.tar.gz: e16b849b789b960f5c6d86dd7049a61ebe42c169
 SHA512:
-  metadata.gz: b360c247c80f905380b13ac37ff319339127a09860ddcf13288378be326f8dea51c0e56b9880ae0f488253f32e46bf0752d5b4bf4abe4bd7f9200ddcbe563702
-  data.tar.gz: 15a84132c8caa90c4dad81998a6a060f931cd2bc77145345e5de5cadbf378c545b3e7f8bbab1a0900341be5a6dd1cf0e9121d35bfea5cfeb85f9ac45a6f42bf0
+  metadata.gz: 3ac3191f57bffb08c000deef706301c4b6628cb707ef9f870df162d7d55d3ed21982f931c3b9bbc3658cf4a693e7aa2b45d8a3dd1c62a0345d9d2d88dd7dc391
+  data.tar.gz: d05096b10746ea930ecd79f8cde66e295b9b5e99002c64df479369473a1bb603b36c9a69ce2462fecd33c1dc3217705bac651d590dca4c58a85edd44b1c515b3

data/CHANGELOG

@@ -1,3 +1,29 @@
+=== 4.24.0 (2015-07-01)
+
+* Allow class_table_inheritance plugin to support subclasses that don't add additional columns (QuinnHarris, jeremyevans) (#1030)
+
+* Add :columns option to update_refresh plugin, specifying the columns to include in the RETURNING clause (celsworth) (#1029)
+
+* Use column symbol key for auto validation unique errors if the unique index is on a single column (jeremyevans)
+
+* Allow :timeout option to Database#listen in the postgres adapter to be a callable object (celsworth) (#1028)
+
+* Add pg_inet_ops extension, for DSL support for PostgreSQL inet/cidr operators and functions (celsworth, jeremyevans) (#1024)
+
+* Support :*_opts options in auto_validations plugin, for setting options for the underlying validation methods (celsworth, jeremyevans) (#1026)
+
+* Support :delay_pks association option in association_pks to delay setting of associated_pks until after saving (jeremyevans)
+
+* Make jdbc subadapters work if they issue queries while the subadapter is being loaded (jeremyevans) (#1022)
+
+* Handle 64-bit auto incrementing primary keys in jdbc subadapters (DougEverly) (#1018, #1019)
+
+* Remove the deprecated db2 and dbi adapters (jeremyevans)
+
+* Make auto_validation plugin use :from=>:values option to setup validations on the underlying columns (jeremyevans)
+
+* Add :from=>:values option to validation_helpers methods, for getting values from the values hash instead of a method call (jeremyevans)
+
 === 4.23.0 (2015-06-01)
 
 * Make dataset.call_sproc(:insert) work in the jdbc adapter (flash-gordon) (#1013)

data/Rakefile

@@ -86,7 +86,7 @@ run_spec = proc do |patterns|
   lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
   rubylib = ENV['RUBYLIB']
   ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
-  if RUBY_PLATFORM =~ /mingw32/
+  if RUBY_PLATFORM =~ /mingw32/ || RUBY_DESCRIPTION =~ /windows/i
     patterns = patterns.split.map{|pat| Dir[pat].to_a}.flatten.join(' ')
   end
   sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| require f}\" #{patterns}"

data/doc/release_notes/4.24.0.txt

@@ -0,0 +1,99 @@
+= New Features
+
+* A pg_inet_ops extension has been added, for DSL support for
+  calling PostgreSQL inet functions and operators.  Example:
+
+    r = Sequel.pg_inet_op(:inet)
+
+    ~r                                 # ~inet
+    r & :other                         # inet & other
+    r | :other                         # inet | other
+    r << :other                        # inet << other
+    r >> :other                        # inet >> other
+ 
+    r.contained_by(:other)             # inet << other
+    r.contained_by_or_equals(:other)   # inet <<= other
+    r.contains(:other)                 # inet >> other
+    r.contains_or_equals(:other)       # inet >>= other
+    r.contains_or_contained_by(:other) # inet && other
+ 
+    r.abbrev           # abbrev(inet)
+    r.broadcast        # broadcast(inet)
+    r.family           # family(inet)
+    r.host             # host(inet)
+    r.hostmask         # hostmask(inet)
+    r.masklen          # masklen(inet)
+    r.netmask          # netmask(inet)
+    r.network          # network(inet)
+    r.set_masklen(16)  # set_masklen(inet, 16)
+    r.text             # text(inet)
+
+* The association_pks plugin now supports a :delay_pks association
+  option.  When set to true, this makes the methods created by the
+  plugin usable on new objects, by delaying the saving of the
+  associated pks until after the new object has been saved.  When
+  set to :always, this also changes the behavior of the methods
+  for existing objects, so that nothing is persisted until the
+  object has been saved.  Example:
+
+    Album.plugin :association_pks
+    Album.many_to_many :tags, :delay_pks=>true
+
+    album = Album.new(:tag_pks=>[1,2,3]) # No database query
+    album.save # Queries to insert album, and then update albums_tags
+
+* The class_table_inheritance plugin now supports subclasses that
+  don't require additional columns, and therefore do not need to
+  join to additional tables.  It now loads the
+  single_table_inheritance plugin and supports options that were
+  previously only supported by single_table_inheritance, such as the
+  :key_map and :key_chooser options.
+
+* The validation_helpers plugin now supports a :from=>:values option
+  in the validation methods, which will take the value directly from
+  the values hash instead of calling the related method.  This
+  allows validation_helpers to differentiate between validations on
+  underlying database column and validations on the model.
+
+  The auto_validations plugin has been modified to use this feature,
+  since all validations it generates are for validations on the
+  underlying database columns.
+
+* The auto_validations plugin now supports options to pass to each
+  of the underlying validation methods:
+
+    Sequel::Model.plugin :auto_validations,
+      :unique_opts=>{:only_if_modified=>true}
+
+  In addition to :unique_opts, there is support for :not_null_opts
+  (for NOT NULL columns without a default), :explicit_not_null_opts
+  (for NOT NULL columns with a default), :max_length_opts, and
+  :schema_types_opts. 
+
+* The update_refresh plugin now accepts a :columns option, which
+  specifies the columns to refresh.  This option is currently only
+  respected if the related dataset supports RETURNING.
+
+* The :timeout option to Database#listen in the postgres adapter can
+  now be a callable object, previously it had to be Numeric.  This
+  allows you to dynamically change the timeout based on current
+  application state.
+
+= Other Improvements
+
+* The uniqueness validations added by the auto_validations plugin now
+  use a symbol key in the related Errors instance if the underlying
+  index was on a single column.  Previously, the uniqueness
+  validations for a single column would use an array key in the
+  related Errors instance.
+
+* The jdbc subadapters now correctly handle 64-bit autoincrementing
+  primary keys.
+
+* The jdbc subadapters now work correctly if they issue queries while
+  the subadapter is being loaded.  This can happen in the
+  jdbc/postgresql adapter if the pg_hstore extension is used.
+
+= Backwards Compatibility
+
+* The deprecated db2 and dbi adapters have been removed.

data/doc/sql.rdoc

@@ -237,6 +237,15 @@ If the database supports schema qualified functions, Sequel can handle them by c
   DB[:albums].select{schema__function.function(col, 2, "a")}
   # SELECT schema.function(col, 2, 'a') FROM albums
 
+=== Portable/Emulated Functions
+
+Sequel offers some support for portable SQL functions, allowing you to call standard SQL functions, where Sequel will emulate support on databases that lack native support.
+Some examples are:
+
+  Sequel.char_length(:column)    # char_length(column)
+  Sequel.extract(:year, :column) # extract(year FROM column)
+  Sequel.trim(:column)           # trim(column)
+
 === Equality Operator (=)
 
 Sequel uses hashes to specify equality:
@@ -506,7 +515,7 @@ Note that using +ilike+ with a regular expression will always make the regexp ca
 
 === Order Specifications (ASC, DESC)
 
-Sequel supports specifying ascending or descending order using the asc+ and +desc+ method on most Sequel-specific expression objects:
+Sequel supports specifying ascending or descending order using the +asc+ and +desc+ method on most Sequel-specific expression objects:
 
   Sequel.expr(:column).asc # "column" ASC
   Sequel.expr(:column).qualify(:table).desc # "table"."column" DESC

data/lib/sequel/adapters/jdbc.rb

@@ -354,6 +354,7 @@ module Sequel
         raise(Error, "No connection string specified") unless uri
         
         resolved_uri = jndi? ? get_uri_from_jndi : uri
+        setup_type_convertor_map_early
 
         @driver = if (match = /\Ajdbc:([^:]+)/.match(resolved_uri)) && (prok = Sequel::Database.load_adapter(match[1].to_sym, :map=>DATABASE_SETUP, :subdir=>'jdbc'))
           prok.call(self)
@@ -640,7 +641,13 @@ module Sequel
         h[:table_schem] == 'INFORMATION_SCHEMA'
       end
 
+      # Called after loading subadapter-specific code, overridable by subadapters.
       def setup_type_convertor_map
+      end
+
+      # Called before loading subadapter-specific code, necessary so that subadapter initialization code
+      # that runs queries works correctly.  This cannot be overriding in subadapters,
+      def setup_type_convertor_map_early
         @type_convertor_map = TypeConvertor::MAP.merge(Java::JavaSQL::Types::TIMESTAMP=>timestamp_convertor)
         @basic_type_convertor_map = TypeConvertor::BASIC_MAP
       end

data/lib/sequel/adapters/jdbc/cubrid.rb

@@ -30,7 +30,7 @@ module Sequel
             rs = stmt.getGeneratedKeys
             begin
               if rs.next
-                rs.getInt(1)
+                rs.getLong(1)
               end
             rescue NativeException
               nil

data/lib/sequel/adapters/jdbc/db2.rb

@@ -66,7 +66,7 @@ module Sequel
             sql = IDENTITY_VAL_LOCAL
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
         

data/lib/sequel/adapters/jdbc/derby.rb

@@ -131,7 +131,7 @@ module Sequel
             sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
 

data/lib/sequel/adapters/jdbc/h2.rb

@@ -130,7 +130,7 @@ module Sequel
             sql = 'SELECT IDENTITY();'
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
         

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -101,7 +101,7 @@ module Sequel
             sql = 'CALL IDENTITY()'
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
         

data/lib/sequel/adapters/jdbc/mssql.rb

@@ -22,7 +22,7 @@ module Sequel
             sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
         

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -46,7 +46,7 @@ module Sequel
             rs = stmt.getGeneratedKeys
             begin
               if rs.next
-                rs.getInt(1)
+                rs.getLong(1)
               else
                 0
               end
@@ -57,7 +57,7 @@ module Sequel
             statement(conn) do |st|
               rs = st.executeQuery(LAST_INSERT_ID)
               rs.next
-              rs.getInt(1)
+              rs.getLong(1)
             end
           end
         end

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -72,7 +72,7 @@ module Sequel
               begin
                 rs = log_yield(sql){stmt.executeQuery(sql)}
                 rs.next
-                rs.getInt(1)
+                rs.getLong(1)
               rescue java.sql.SQLException
                 nil
               end

data/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -51,7 +51,7 @@ module Sequel
             sql = LAST_INSERT_ID
             rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
 

data/lib/sequel/adapters/jdbc/sqlite.rb

@@ -51,7 +51,7 @@ module Sequel
           statement(conn) do |stmt|
             rs = stmt.executeQuery(LAST_INSERT_ROWID)
             rs.next
-            rs.getInt(1)
+            rs.getLong(1)
           end
         end
         

data/lib/sequel/adapters/postgres.rb

@@ -439,14 +439,16 @@ module Sequel
         # :after_listen :: An object that responds to +call+ that is called with the underlying connection after the LISTEN
         #                  statement is sent, but before the connection starts waiting for notifications.
         # :loop :: Whether to continually wait for notifications, instead of just waiting for a single
-        #          notification. If this option is given, a block must be provided.  If this object responds to call, it is
+        #          notification. If this option is given, a block must be provided.  If this object responds to +call+, it is
         #          called with the underlying connection after each notification is received (after the block is called).
         #          If a :timeout option is used, and a callable object is given, the object will also be called if the
         #          timeout expires.  If :loop is used and you want to stop listening, you can either break from inside the
         #          block given to #listen, or you can throw :stop from inside the :loop object's call method or the block.
         # :server :: The server on which to listen, if the sharding support is being used.
-        # :timeout :: How long to wait for a notification, in seconds (can provide a float value for
-        #             fractional seconds).  If not given or nil, waits indefinitely.
+        # :timeout :: How long to wait for a notification, in seconds (can provide a float value for fractional seconds).
+        #             If this object responds to +call+, it will be called and should return the number of seconds to wait.
+        #             If the loop option is also specified, the object will be called on each iteration to obtain a new
+        #             timeout value.  If not given or nil, waits indefinitely.
         #
         # This method is only supported if pg is used as the underlying ruby driver.  It returns the
         # channel the notification was sent to (as a string), unless :loop was used, in which case it returns nil.
@@ -465,19 +467,25 @@ module Sequel
                   conn.execute(sql)
                 end
                 opts[:after_listen].call(conn) if opts[:after_listen]
-                timeout = opts[:timeout] ? [opts[:timeout]] : []
+                timeout = opts[:timeout]
+                if timeout
+                  timeout_block = timeout.respond_to?(:call) ? timeout : proc{timeout}
+                end
+
                 if l = opts[:loop]
                   raise Error, 'calling #listen with :loop requires a block' unless block
                   loop_call = l.respond_to?(:call)
                   catch(:stop) do
                     loop do
-                      conn.wait_for_notify(*timeout, &block)
+                      t = timeout_block ? [timeout_block.call] : []
+                      conn.wait_for_notify(*t, &block)
                       l.call(conn) if loop_call
                     end
                   end
                   nil
                 else
-                  conn.wait_for_notify(*timeout, &block)
+                  t = timeout_block ? [timeout_block.call] : []
+                  conn.wait_for_notify(*t, &block)
                 end
               ensure
                 conn.execute("UNLISTEN *")

data/lib/sequel/adapters/shared/mssql.rb

@@ -37,7 +37,7 @@ module Sequel
       # Execute the given stored procedure with the given name.
       #
       # Options:
-      # :args :: Arguments to stored procedure.  For named argumetns, this should be a
+      # :args :: Arguments to stored procedure.  For named arguments, this should be a
       #          hash keyed by argument named.  For unnamed arguments, this should be an
       #          array.  Output parameters to the function are specified using :output.
       #          You can also name output parameters and provide a type by using an

data/lib/sequel/core.rb

@@ -84,11 +84,22 @@ module Sequel
   #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
   #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
   #
+  # You can also pass a single options hash:
+  #
+  #   DB = Sequel.connect(:adapter=>'sqlite', :database=>'./blog.db')
+  #
   # If a block is given, it is passed the opened +Database+ object, which is
   # closed when the block exits.  For example:
   #
   #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
-  # 
+  #
+  # If a block is not given, a reference to this database will be held in
+  # <tt>Sequel::DATABASES</tt> until it is removed manually.  This is by
+  # design, and used by <tt>Sequel::Model</tt> to pick the default
+  # database.  It is recommended to pass a block if you do not want the
+  # resulting Database object to remain in memory until the process
+  # terminates.
+  #
   # For details, see the {"Connecting to a Database" guide}[rdoc-ref:doc/opening_databases.rdoc].
   # To set up a master/slave or sharded database connection, see the {"Master/Slave Databases and Sharding" guide}[rdoc-ref:doc/sharding.rdoc].
   def self.connect(*args, &block)

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
+    ADAPTERS = %w'ado amalgalite cubrid do firebird ibmdb informix jdbc mock mysql mysql2 odbc oracle postgres sqlanywhere sqlite swift tinytds'.collect(&:to_sym)
 
     @single_threaded = false
 
@@ -42,7 +42,6 @@ module Sequel
         else
           uri = URI.parse(conn_string)
           scheme = uri.scheme
-          scheme = :dbi if scheme =~ /\Adbi-/
           c = adapter_class(scheme)
           uri_options = c.send(:uri_to_options, uri)
           uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?

data/lib/sequel/extensions/pg_inet_ops.rb

@@ -0,0 +1,200 @@
+# The pg_inet_ops extension adds support to Sequel's DSL to make
+# it easier to call PostgreSQL inet functions and operators.
+#
+# To load the extension:
+#
+#   Sequel.extension :pg_inet_ops
+#
+# The most common usage is passing an expression to Sequel.pg_inet_op:
+#
+#   r = Sequel.pg_inet_op(:inet)
+#
+# Also, on most Sequel expression objects, you can call the pg_inet
+# method:
+#
+#   r = Sequel.expr(:ip).pg_inet
+#
+# 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 Symbol#pg_inet:
+#
+#   r = :inet.pg_inet
+#
+# This creates a Sequel::Postgres::InetOp object that can be used
+# for easier querying:
+#
+#   ~r                                 # ~inet
+#   r & other                          # inet & other
+#   r | other                          # inet | other
+#   r << :other                        # inet << other
+#   r >> :other                        # inet >> other
+#
+#   r.contained_by(:other)             # inet << other
+#   r.contained_by_or_equals(:other)   # inet <<= other
+#   r.contains(:other)                 # inet >> other
+#   r.contains_or_equals(:other)       # inet >>= other
+#   r.contains_or_contained_by(:other) # inet && other
+#
+#   r.abbrev           # abbrev(inet)
+#   r.broadcast        # broadcast(inet)
+#   r.family           # family(inet)
+#   r.host             # host(inet)
+#   r.hostmask         # hostmask(inet)
+#   r.masklen          # masklen(inet)
+#   r.netmask          # netmask(inet)
+#   r.network          # network(inet)
+#   r.set_masklen(16)  # set_masklen(inet, 16)
+#   r.text             # text(inet)
+#
+# If a String or IPAddr instance is passed to Sequel.pg_inet_op, it will automatically
+# be cast to +inet+.  To treat the object as a +cidr+, you must cast it before passing
+# it to Sequel.pg_inet_op:
+#
+#   r = Sequel.pg_inet_op(Sequel.cast('1.2.3.4', :cidr))
+#
+# See the PostgreSQL network function and operator documentation for more
+# details on what these functions and operators do.
+
+require 'ipaddr'
+
+module Sequel
+  module Postgres
+    # The InetOp class is a simple container for a single object that
+    # defines methods that yield Sequel expression objects representing
+    # PostgreSQL inet operators and functions.
+    #
+    # Most methods in this class are defined via metaprogramming, see
+    # the pg_inet_ops extension documentation for details on the API.
+    class InetOp < Sequel::SQL::Wrapper
+      include Sequel::SQL::BitwiseMethods
+
+      # For String and IPAddr instances, wrap them in a cast to inet,
+      # to avoid ambiguity issues when calling operator methods.
+      def initialize(v)
+        case v
+        when ::Sequel::LiteralString
+          # nothing
+        when String, IPAddr
+          v = Sequel.cast(v, :inet)
+        end
+        super
+      end
+
+      OPERATORS = {
+        :contained_by_or_equals => ["(".freeze, " <<= ".freeze, ")".freeze].freeze,
+        :contains_or_equals => ["(".freeze, " >>= ".freeze, ")".freeze].freeze,
+        :contains_or_contained_by => ["(".freeze, " && ".freeze, ")".freeze].freeze,
+      }.freeze
+
+      OPERATORS.keys.each do |f|
+        class_eval("def #{f}(v) Sequel::SQL::BooleanExpression.new(:NOOP, operator(:#{f}, v)) end", __FILE__, __LINE__)
+      end
+
+      %w'<< >>'.each do |f|
+        class_eval("def #{f}(v) Sequel::SQL::BooleanExpression.new(:NOOP, super) end", __FILE__, __LINE__)
+      end
+
+      %w'& | +'.each do |f|
+        class_eval("def #{f}(v) self.class.new(super) end", __FILE__, __LINE__)
+      end
+
+      %w'abbrev host text'.each do |f|
+        class_eval("def #{f}() Sequel::SQL::StringExpression.new(:NOOP, function(:#{f})) end", __FILE__, __LINE__)
+      end
+
+      %w'family masklen'.each do |f|
+        class_eval("def #{f}() Sequel::SQL::NumericExpression.new(:NOOP, function(:#{f})) end", __FILE__, __LINE__)
+      end
+
+      %w'broadcast hostmask netmask network'.each do |f|
+        class_eval("def #{f}() self.class.new(function(:#{f})) end", __FILE__, __LINE__)
+      end
+
+      # Return the receiver.
+      def pg_inet
+        self
+      end
+
+      # Return an expression for the bitwise NOT of the receiver 
+      def ~
+        self.class.new(super)
+      end
+
+      # Return an expression for the subtraction of the argument from the receiver
+      def -(v)
+        case v
+        when Integer
+          self.class.new(super)
+        else
+          Sequel::SQL::NumericExpression.new(:NOOP, super)
+        end
+      end
+
+      # Return an expression for the calling of the set_masklen function with the receiver and the given argument
+      def set_masklen(v)
+        self.class.new(Sequel::SQL::Function.new(:set_masklen, self, v))
+      end
+
+      alias contained_by <<
+      alias contains >> 
+
+      undef_method :*, :/
+
+      private
+
+      # Handle PostgreSQL specific operator types
+      def operator(type, other)
+        Sequel::SQL::PlaceholderLiteralString.new(OPERATORS[type], [value, other])
+      end
+
+      # Return a function called with the receiver.
+      def function(name)
+        Sequel::SQL::Function.new(name, self)
+      end
+    end
+
+    module InetOpMethods
+      # Wrap the receiver in an InetOp so you can easily use the PostgreSQL
+      # inet functions and operators with it.
+      def pg_inet
+        InetOp.new(self)
+      end
+    end
+  end
+
+  module SQL::Builders
+    # Return the expression wrapped in the Postgres::InetOp.
+    def pg_inet_op(v)
+      case v
+      when Postgres::InetOp
+        v
+      else
+        Postgres::InetOp.new(v)
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::Postgres::InetOpMethods
+  end
+
+  class LiteralString
+    include Sequel::Postgres::InetOpMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::Postgres::InetOpMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      include Sequel::Postgres::InetOpMethods
+    end
+  end
+end
+# :nocov: