module Sequel::Dataset::PreparedStatementMethods

  1. lib/sequel/dataset/prepared_statements.rb
Parent: Dataset

Backbone of the prepared statement support. Grafts bind variable support into datasets by hijacking literal and using placeholders. By default, emulates prepared statements and bind variables by taking the hash of bind variables and directly substituting them into the query, which works on all databases, as it is no different from using the dataset without bind variables.

Constants

PLACEHOLDER_RE = /\A\$(.*)\z/  

Attributes

log_sql [RW]

Whether to log the full SQL query. By default, just the prepared statement name is generally logged on adapters that support native prepared statements.
orig_dataset [RW]

The dataset that created this prepared statement.
prepared_args [RW]

The array/hash of bound variable placeholder names.
prepared_modify_values [RW]

The argument to supply to insert and update, which may use placeholders specified by #prepared_args
prepared_type [RW]

The type of prepared statement, should be one of :select, :first, :insert, :update, or :delete

Public Instance methods

call (bind_vars={}, &block)

Sets the #prepared_args to the given hash and runs the prepared statement.

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 69
def call(bind_vars={}, &block)
  bind(bind_vars).run(&block)
end
columns ()

Send the columns to the original dataset, as calling it on the prepared statement can cause problems.

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 75
def columns
  orig_dataset.columns
end
inspect ()

Programmer friendly string showing this is a prepared statement, with the prepared SQL it represents (which in general won’t have substituted variables).

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 120
def inspect
  "<#{visible_class_name}/PreparedStatement #{prepared_sql.inspect}>"
end
literal_symbol_append (sql, v)

Changes the values of symbols if they start with $ and #prepared_args is present. If so, they are considered placeholders, and they are substituted using prepared_arg.

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 104
def literal_symbol_append(sql, v)
  if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
    s = match[1].to_sym
    if prepared_arg?(s)
      literal_append(sql, prepared_arg(s))
    else
      sql << v.to_s
    end
  else
    super
  end
end
prepared_sql ()

Returns the SQL for the prepared statement, depending on the type of the statement and the prepared_modify_values.

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 81
def prepared_sql
  case @prepared_type
  when :select, :all, :each
    # Most common scenario, so listed first.
    select_sql
  when :first
    clone(:limit=>1).select_sql
  when :insert_select
    returning.insert_sql(*@prepared_modify_values)
  when :insert
    insert_sql(*@prepared_modify_values)
  when :update
    update_sql(*@prepared_modify_values)
  when :delete
    delete_sql
  else
    select_sql
  end
end

Protected Instance methods

run (&block)

Run the method based on the type of prepared statement, with :select running all to get all of the rows, and the other types running the method with the same name as the type.

[show source] 
# File lib/sequel/dataset/prepared_statements.rb, line 129
def run(&block)
  case @prepared_type
  when :select, :all
    # Most common scenario, so listed first
    all(&block)
  when :each
    each(&block)
  when :insert_select
    with_sql(prepared_sql).first
  when :first
    first
  when :insert
    insert(*@prepared_modify_values)
  when :update
    update(*@prepared_modify_values)
  when :delete
    delete
  when Array
    case @prepared_type.at(0)
    when :map, :to_hash, :to_hash_groups
      send(*@prepared_type, &block) 
    end
  else
    all(&block)
  end
end