class Sequel::Dataset::PlaceholderLiteralizer::Recorder

the SQL query.
Records the offsets at which the placeholder arguments are used in

def arg(v=(no_arg_given = true; @argn+=1))

argument for the same receiver.
general you shouldn't mix calls with an argument and calls without an
Return an Argument with the specified position, or the next position. In 
def arg(v=(no_arg_given = true; @argn+=1))
  unless no_arg_given
    @argn = v if @argn < v
  end
  Argument.new(self, v)
end

def loader(dataset, &block)

return the dataset that you want to load.
call #arg on the receiver for each placeholder argument, and
Yields the receiver and the dataset to the block, which should 
def loader(dataset, &block)
  PlaceholderLiteralizer.new(*process(dataset, &block))
end

def prepared_sql_and_frags(dataset, prepared_args, &block)

emulated prepared statements.
Sequel::SQL::PlaceholderLiteralString. Designed for use with
SQL fragments suitable for using for creating a
(suitable for inspect), the the second being an array of
SQL string with interpolated prepared argument placeholders
Return an array with two elements, the first being an 
def prepared_sql_and_frags(dataset, prepared_args, &block)
  _, frags, final_sql, _ = process(dataset, &block)
  frags = frags.map(&:first)
  prepared_sql = String.new
  frags.each_with_index do |sql, i|
    prepared_sql << sql
    prepared_sql << "$#{prepared_args[i]}"
  end
  frags << final_sql
  prepared_sql << final_sql
  [prepared_sql, frags]
end

def process(dataset)

Internals of #loader and #prepared_sql_and_frags. 
def process(dataset)
  @argn = -1
  @args = []
  ds = yield self, dataset
  sql = ds.clone(:placeholder_literalizer=>self).sql
  last_offset = 0
  fragments = @args.map do |used_sql, offset, arg, t|
    raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
    a = [sql[last_offset...offset], arg, t]
    last_offset = offset
    a
  end
  final_sql = sql[last_offset..-1]
  arity = @argn+1
  [ds, fragments, final_sql, arity]
end

def use(sql, arg, transformer)

transforming block.
Record the offset at which the argument is used in the SQL query, and any 
def use(sql, arg, transformer)
  @args << [sql, sql.length, arg, transformer]
end