serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/date_arithmetic.rb

@@ -0,0 +1,254 @@
+# frozen-string-literal: true
+#
+# The date_arithmetic extension adds the ability to perform database-independent
+# addition/substraction of intervals to/from dates and timestamps.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :date_arithmetic
+#
+# Then you can use the Sequel.date_add and Sequel.date_sub methods
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
+#
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
+#   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
+#
+# In addition to specifying the interval as a hash, there is also
+# support for specifying the interval as an ActiveSupport::Duration
+# object:
+#
+#   require 'active_support/all'
+#   add = Sequel.date_add(:date_column, 1.years + 2.months + 3.days)
+#   sub = Sequel.date_sub(:date_column, 1.hours + 2.minutes + 3.seconds)
+#
+# By default, values are casted to the generic timestamp type for the
+# database.  You can override the cast type using the :cast option:
+#
+#   add = Sequel.date_add(:date_column, {years: 1, months: 2, days: 3}, cast: :timestamptz)
+#
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
+#
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
+# Related module: Sequel::SQL::DateAdd
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a DateAdd expression, adding an interval to the date/timestamp expr.
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_add(expr, interval, opts=OPTS)
+        DateAdd.new(expr, interval, opts)
+      end
+
+      # Return a DateAdd expression, adding the negative of the interval to
+      # the date/timestamp expr.
+      # Options:
+      # :cast :: Cast to the specified type instead of the default if casting
+      def date_sub(expr, interval, opts=OPTS)
+        if defined?(ActiveSupport::Duration) && interval.is_a?(ActiveSupport::Duration)
+          interval = interval.parts
+        end
+        parts = {}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
+        end
+        DateAdd.new(expr, parts, opts)
+      end
+    end
+
+    # The DateAdd class represents the addition of an interval to a
+    # date/timestamp expression.
+    class DateAdd < GenericExpression
+      # These methods are added to datasets using the date_arithmetic
+      # extension, for the purposes of correctly literalizing DateAdd
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
+        DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
+        MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
+        MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
+        H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
+        DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
+        ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
+        DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
+
+        # Append the SQL fragment for the DateAdd expression to the SQL query.
+        def date_add_sql_append(sql, da)
+          if defined?(super)
+            return super
+          end
+
+          h = da.interval
+          expr = da.expr
+          cast_type = da.cast_type || Time
+
+          cast = case db_type = db.database_type
+          when :postgres
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
+            end
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
+            else
+              return literal_append(sql, casted)
+            end
+          when :sqlite
+            args = [expr]
+            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+              args << "#{value} #{sql_unit}"
+            end
+            return function_sql_append(sql, Sequel.function(:datetime, *args))
+          when :mysql, :hsqldb
+            if db_type == :hsqldb
+              # HSQLDB requires 2.2.9+ for the DATE_ADD function
+              expr = Sequel.cast(expr, cast_type)
+            end
+            each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.function(:DATE_ADD, expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
+            end
+          when :mssql, :h2, :access, :sqlanywhere
+            units = case db_type
+            when :h2
+              H2_DURATION_UNITS
+            when :access
+              ACCESS_DURATION_UNITS
+            else
+              MSSQL_DURATION_UNITS
+            end
+            each_valid_interval_unit(h, units) do |value, sql_unit|
+              expr = Sequel.function(:DATEADD, sql_unit, value, expr)
+            end
+          when :derby
+            if expr.is_a?(Date) && !expr.is_a?(DateTime)
+              # Work around for https://issues.apache.org/jira/browse/DERBY-896
+              expr = Sequel.cast_string(expr) + ' 00:00:00'
+            end
+            each_valid_interval_unit(h, DERBY_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.lit(["{fn timestampadd(#{sql_unit}, ", ", timestamp(", "))}"], value, expr)
+            end
+          when :oracle
+            each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.+(expr, Sequel.lit(["INTERVAL ", " "], value.to_s, sql_unit))
+            end
+          when :db2
+            expr = Sequel.cast(expr, cast_type)
+            each_valid_interval_unit(h, DB2_DURATION_UNITS) do |value, sql_unit|
+              expr = Sequel.+(expr, Sequel.lit(["", " "], value, sql_unit))
+            end
+            false
+          else
+            raise Error, "date arithmetic is not implemented on #{db.database_type}"
+          end
+
+          if cast
+            expr = Sequel.cast(expr, cast_type)
+          end
+
+          literal_append(sql, expr)
+        end
+
+        private
+
+        # Yield the value in the interval for each of the units
+        # present in the interval, along with the SQL fragment
+        # representing the unit name.  Returns false if any
+        # values were yielded, true otherwise
+        def each_valid_interval_unit(interval, units)
+          cast = true
+          units.each do |unit, sql_unit|
+            if (value = interval[unit]) && value != 0
+              cast = false
+              yield value, sql_unit
+            end
+          end
+          cast
+        end
+      end
+
+      # The expression that the interval is being added to.
+      attr_reader :expr
+
+      # The interval added to the expression, as a hash with
+      # symbol keys.
+      attr_reader :interval
+
+      # The type to cast the expression to.  nil if not overridden, in which cast
+      # the generic timestamp type for the database will be used.
+      attr_reader :cast_type
+
+      # Supports two types of intervals:
+      # Hash :: Used directly, but values cannot be plain strings.
+      # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
+      def initialize(expr, interval, opts=OPTS)
+        @expr = expr
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
+          end
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
+          end
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
+          end
+
+          h[unit] += value
+        end
+
+        @interval = Hash[h].freeze
+        @cast_type = opts[:cast] if opts[:cast]
+        freeze
+      end
+
+      to_s_method :date_add_sql
+    end
+  end
+
+  Dataset.register_extension(:date_arithmetic, SQL::DateAdd::DatasetMethods)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/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/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/datetime_parse_to_time.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+#
+# This switches the default parsing of strings into Time values
+# from using Time.parse to using DateTime.parse.to_time.  This
+# fixes issues when the times being parsed have no timezone
+# information, the implicit timezone for the Database instance
+# is set to +:utc+, and the timestamps being used include values
+# not valid in the local timezone, such as during a daylight
+# savings time switch.  
+#
+# To load the extension:
+#
+#   Sequel.extension :datetime_parse_to_time
+
+#
+module Sequel::DateTimeParseToTime
+  private
+
+  # 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)
+      # :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
+        t = t.localtime
+      end
+      t
+    else
+      super
+    end
+  rescue => e
+    raise convert_exception_class(e, Sequel::InvalidValue)
+  end
+end
+
+Sequel.extend(Sequel::DateTimeParseToTime)

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+#
+# The duplicate_columns_handler extension allows you to customize handling of
+# duplicate column names in your queries on a per-database or per-dataset level.
+#
+# For example, you may want to raise an exception if you join 2 tables together
+# which contains a column that will override another columns.
+#
+# To use the extension, you need to load the extension into the database:
+#
+#   DB.extension :duplicate_columns_handler
+#
+# or into individual datasets:
+#
+#   ds = DB[:items].extension(:duplicate_columns_handler)
+#
+# If the Database option :on_duplicate_columns is set, it configures how this
+# extension works. The value should be # or any object that responds to :call.
+#
+#   on_duplicate_columns: :raise # or 'raise'
+#   on_duplicate_columns: :warn # or 'warn'
+#   on_duplicate_columns: :ignore # or anything unrecognized
+#   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
+#
+# You may also configure duplicate columns handling for a specific dataset:
+#
+#   ds.on_duplicate_columns(:warn)
+#   ds.on_duplicate_columns(:raise)
+#   ds.on_duplicate_columns(:ignore)
+#   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
+#   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
+#
+# If :raise or 'raise' is specified, a Sequel::DuplicateColumnError is raised.
+# If :warn or 'warn' is specified, you will receive a warning via +warn+.
+# If a callable is specified, it will be called.
+# For other values, duplicate columns are ignored (Sequel's default behavior)
+# If no on_duplicate_columns is specified, the default is :warn.
+#
+# Related module: Sequel::DuplicateColumnsHandler
+
+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 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
+
+    private
+
+    # Call handle_duplicate_columns if there are duplicate columns.
+    def columns=(cols)
+      if cols && cols.uniq.size != cols.size
+        handle_duplicate_columns(cols)
+      end
+      super
+    end
+
+    # Invoke the appropriate behavior when duplicate columns are present.
+    def handle_duplicate_columns(cols)
+      message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
+
+      case duplicate_columns_handler_type(cols)
+      when :raise, 'raise'
+        raise DuplicateColumnError, message
+      when :warn, 'warn'
+        warn message
+      end
+    end
+
+    # Try to find dataset option for on_duplicate_columns. If not present on the dataset,
+    # use the on_duplicate_columns option on the database. If not present on the database,
+    # default to :warn.
+    def duplicate_columns_handler_type(cols)
+      handler = opts.fetch(:on_duplicate_columns){db.opts.fetch(:on_duplicate_columns, :warn)}
+
+      if handler.respond_to?(:call)
+        handler.call(cols)
+      else
+        handler
+      end
+    end
+  end
+
+  # Error which is raised when duplicate columns are present in a dataset which is configured
+  # to :raise on_duplicate_columns.
+  class DuplicateColumnError < Error
+  end
+
+  Dataset.register_extension(:duplicate_columns_handler, Sequel::DuplicateColumnsHandler)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+#
+# This changes Sequel's literalization of IN/NOT IN with an empty
+# array value to consider NULL values if one of the referenced
+# columns is NULL:
+#
+#   DB[:test].where(name: [])
+#   # SELECT * FROM test WHERE (name != name)
+#   DB[:test].exclude(name: [])
+#   # SELECT * FROM test WHERE (name = name)
+#
+# This works for sets in addition to arrays:
+#
+#   DB[:test].where(name: Set[])
+#   # SELECT * FROM test WHERE (name != name)
+#   DB[:test].exclude(name: Set[])
+#   # SELECT * FROM test WHERE (name = name)
+#
+# The default Sequel behavior is to ignore NULLs, as the above
+# query is not generally optimized well by databases.
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:empty_array_consider_nulls)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:empty_array_consider_nulls)
+#
+# Related module: Sequel::EmptyArrayConsiderNulls
+
+#
+module Sequel
+  module EmptyArrayConsiderNulls
+    # Use an expression that returns NULL if the column value is NULL.
+    def empty_array_value(op, cols)
+      c = Array(cols)
+      SQL::BooleanExpression.from_value_pairs(c.zip(c), :AND, op == :IN)
+    end
+    
+  end
+
+  Dataset.register_extension(:empty_array_consider_nulls, EmptyArrayConsiderNulls)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/error_sql.rb

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+#
+# The error_sql extension adds a DatabaseError#sql method
+# that you can use to get the sql that caused the error
+# to be raised.
+#
+#   begin
+#     DB.run "Invalid SQL"
+#   rescue => e
+#     puts e.sql # "Invalid SQL"
+#   end
+#
+# On some databases, the error message contains part or all
+# of the SQL used, but on other databases, none of the SQL
+# used is displayed in the error message, so it can be
+# difficult to track down what is causing the error without
+# using a logger.  This extension should hopefully make
+# debugging easier on databases that have bad error
+# messages.
+#
+# This extension may not work correctly in the following cases:
+#
+# * log_connection_yield is not used when executing the query.
+# * The underlying exception is frozen or reused.
+# * The underlying exception doesn't correctly record instance
+#   variables set on it (seems to happen on JRuby when underlying
+#   exception objects are Java exceptions).
+#
+# To load the extension into the database:
+#
+#   DB.extension :error_sql
+#
+# Related module: Sequel::ErrorSQL
+
+#
+module Sequel
+  class DatabaseError
+    # Get the SQL code that caused this error to be raised.
+    def sql
+      # We store the error SQL in the wrapped exception instead of the
+      # current exception, since when the error SQL is originally associated
+      # with the wrapped exception, the current exception doesn't exist.  It's
+      # possible to copy the error SQL into the current exception, but there
+      # doesn't seem to be a reason to do that.
+      wrapped_exception.instance_variable_get(:@sequel_error_sql) if wrapped_exception
+    end
+  end
+
+  module ErrorSQL
+    # Store the SQL related to the exception with the exception, so it
+    # is available for DatabaseError#sql later.
+    def log_exception(exception, message)
+      exception.instance_variable_set(:@sequel_error_sql, message)
+      super
+    end
+
+    # If there are no loggers for this database and an exception is raised
+    # store the SQL related to the exception with the exception, so it
+    # is available for DatabaseError#sql later.
+    def log_connection_yield(sql, conn, args=nil)
+      if @loggers.empty?
+        begin
+          yield
+        rescue => e
+          sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
+          e.instance_variable_set(:@sequel_error_sql, sql)
+          raise
+        end
+      else
+        super
+      end
+    end
+  end
+
+  Database.register_extension(:error_sql, ErrorSQL)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/escaped_like.rb

@@ -0,0 +1,100 @@
+# frozen-string-literal: true
+#
+# The escaped_like extension adds +escaped_like+ and +escaped_ilike+
+# methods to Sequel::SQL::StringMethods, which allow them to be easily
+# used with most of Sequel's expression objects.  Example:
+#
+#   DB[:table].where{string_column.escaped_like('?%', user_input)}
+#   # user_input is 'foo':
+#   #  SELECT * FROM table WHERE string_column LIKE 'foo%' ESCAPE '\'
+#   # user_input is '%foo':
+#   #  SELECT * FROM table WHERE string_column LIKE '\%foo%' ESCAPE '\'
+#
+# To load the extension:
+#
+#   Sequel.extension :escaped_like
+#
+# Related modules: Sequel::SQL::StringMethods, Sequel::SQL::EscapedLikeExpression
+
+#
+module Sequel
+  module SQL
+    # Represents an pattern match SQL expression, where the pattern can depend
+    # upon interpolated values in a database-dependent manner.
+    class EscapedLikeExpression < Expression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include OrderMethods
+
+      # Initialize the expression. Arguments:
+      # expr :: Right hand site of LIKE/ILIKE operator, what you are matching against the pattern
+      # case_insensitive :: Whether the match is case sensitive
+      # placeholder_pattern :: The pattern to match against, with +?+ for the placeholders
+      # placeholder_values :: The string values for each +?+ in the placeholder pattern.  Should be an
+      #                       array of strings, though it can be a single string if there is only
+      #                       a single placeholder.
+      def initialize(expr, case_sensitive, placeholder_pattern, placeholder_values)
+        @expr = expr
+        @method = case_sensitive ? :like : :ilike
+        @pattern = placeholder_pattern
+        unless placeholder_values.is_a?(Array)
+          placeholder_values = [placeholder_values].freeze
+        end
+        @values = placeholder_values
+        freeze
+      end
+
+      # Interpolate the pattern values into the placeholder pattern to get the final pattern,
+      # now that we have access to the dataset.  Use the expression and final pattern and
+      # add an appropriate LIKE/ILIKE expression to the SQL being built.
+      def to_s_append(ds, sql)
+        i = -1
+        match_len = @values.length - 1
+        like_pattern = String.new
+        pattern = @pattern
+        while true
+          previous, q, pattern = pattern.partition('?')
+          like_pattern << previous
+
+          unless q.empty?
+            if i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            like_pattern << ds.escape_like(@values.at(i+=1))
+          end
+
+          if pattern.empty?
+            unless i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            break
+          end
+        end
+        ds.literal_append(sql, Sequel.send(@method, @expr, like_pattern))
+      end
+    end
+
+    module StringMethods
+      # Create a +EscapedLikeExpression+ case insensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_ilike('?%', 'A') # "a" ILIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_ilike('?%', '%A') # "a" ILIKE '\%A%' ESCAPE '\'
+      def escaped_ilike(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, false, placeholder_pattern, placeholder_values)
+      end
+
+      # Create a +EscapedLikeExpression+ case sensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_like('?%', 'A') # "a" LIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_like('?%', '%A') # "a" LIKE '\%A%' ESCAPE '\'
+      def escaped_like(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, true, placeholder_pattern, placeholder_values)
+      end
+    end
+  end
+end