Module Sequel::Dataset::PreparedStatementMethods
In: lib/sequel/dataset/prepared_statements.rb
lib/sequel/adapters/sqlite.rb
lib/sequel/adapters/jdbc.rb

Use JDBC PreparedStatements instead of emulated ones. Statements created using prepare are cached at the connection level to allow reuse. This also supports bind variables by using unnamed prepared statements created using call.

Methods

call   columns   inspect   literal_symbol_append   prepared_sql   run  

Included Modules

BindArgumentMethods Sequel::Dataset::UnnumberedArgumentMapper

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.

[Source]

    # File lib/sequel/dataset/prepared_statements.rb, line 69
69:       def call(bind_vars={}, &block)
70:         bind(bind_vars).run(&block)
71:       end
columns()

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

[Source]

    # File lib/sequel/dataset/prepared_statements.rb, line 75
75:       def columns
76:         orig_dataset.columns
77:       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).

[Source]

     # File lib/sequel/dataset/prepared_statements.rb, line 120
120:       def inspect
121:         "<#{self.class.name}/PreparedStatement #{prepared_sql.inspect}>"
122:       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.

[Source]

     # File lib/sequel/dataset/prepared_statements.rb, line 104
104:       def literal_symbol_append(sql, v)
105:         if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
106:           s = match[1].to_sym
107:           if prepared_arg?(s)
108:             literal_append(sql, prepared_arg(s))
109:           else
110:             sql << v.to_s
111:           end
112:         else
113:           super
114:         end
115:       end
prepared_sql()

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

[Source]

    # File lib/sequel/dataset/prepared_statements.rb, line 81
81:       def prepared_sql
82:         case @prepared_type
83:         when :select, :all, :each
84:           # Most common scenario, so listed first.
85:           select_sql
86:         when :first
87:           clone(:limit=>1).select_sql
88:         when :insert_select
89:           returning.insert_sql(*@prepared_modify_values)
90:         when :insert
91:           insert_sql(*@prepared_modify_values)
92:         when :update
93:           update_sql(*@prepared_modify_values)
94:         when :delete
95:           delete_sql
96:         else
97:           select_sql
98:         end
99:       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.

[Source]

     # File lib/sequel/dataset/prepared_statements.rb, line 129
129:       def run(&block)
130:         case @prepared_type
131:         when :select, :all
132:           # Most common scenario, so listed first
133:           all(&block)
134:         when :each
135:           each(&block)
136:         when :insert_select
137:           with_sql(prepared_sql).first
138:         when :first
139:           first
140:         when :insert
141:           insert(*@prepared_modify_values)
142:         when :update
143:           update(*@prepared_modify_values)
144:         when :delete
145:           delete
146:         when Array
147:           case @prepared_type.at(0)
148:           when :map, :to_hash, :to_hash_groups
149:             send(*@prepared_type, &block) 
150:           end
151:         else
152:           all(&block)
153:         end
154:       end

[Validate]