class Sequel::Dataset::PlaceholderLiteralizer
PlaceholderLiteralizer
allows you to record the application of arbitrary changes to a dataset with placeholder arguments, recording where those placeholder arguments are used in the query. When running the query, the literalization process is much faster as Sequel
can skip most of the work it normally has to do when literalizing a dataset.
Basically, this enables optimizations that allow Sequel
to cache the SQL
produced for a given dataset, so that it doesn't need to recompute that information every time.
Example:
loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds| ds.where(id: pl.arg).exclude(name: pl.arg).limit(1) end loader.first(1, "foo") # SELECT * FROM items WHERE ((id = 1) AND (name != 'foo')) LIMIT 1 loader.first(2, "bar") # SELECT * FROM items WHERE ((id = 2) AND (name != 'bar')) LIMIT 1
Caveats:
Note that this method does not handle all possible cases. For example:
loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds| ds.join(pl.arg, item_id: :id) end loader.all(:cart_items)
Will not qualify the item_id column with cart_items. In this type of situation it's best to add a table alias when joining:
loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds| ds.join(Sequel.as(pl.arg, :t), item_id: :id) end loader.all(:cart_items)
There are other similar cases that are not handled, mainly when Sequel
changes the SQL
produced depending on the types of the arguments.
Public Class Methods
Create a PlaceholderLiteralizer
by yielding a Recorder
and dataset to the given block, recording the offsets at which the recorders arguments are used in the query.
# File lib/sequel/dataset/placeholder_literalizer.rb 149 def self.loader(dataset, &block) 150 Recorder.new.loader(dataset, &block) 151 end
Public Instance Methods
Return an array of all objects by running the SQL
query for the given arguments. If a block is given, yields all objects to the block after loading them.
# File lib/sequel/dataset/placeholder_literalizer.rb 181 def all(*args, &block) 182 @dataset.with_sql_all(sql(*args), &block) 183 end
Run the SQL
query for the given arguments, yielding each returned row to the block.
# File lib/sequel/dataset/placeholder_literalizer.rb 186 def each(*args, &block) 187 @dataset.with_sql_each(sql(*args), &block) 188 end
Run the SQL
query for the given arguments, returning the first row.
# File lib/sequel/dataset/placeholder_literalizer.rb 191 def first(*args) 192 @dataset.with_sql_first(sql(*args)) 193 end
Freeze the fragments and final SQL
when freezing the literalizer.
# File lib/sequel/dataset/placeholder_literalizer.rb 163 def freeze 164 @fragments.freeze 165 @final_sql.freeze 166 super 167 end
Run the SQL
query for the given arguments, returning the first value. For this to make sense, the dataset should return a single row with a single value (or no rows).
# File lib/sequel/dataset/placeholder_literalizer.rb 197 def get(*args) 198 @dataset.with_sql_single_value(sql(*args)) 199 end
Return the SQL
query to use for the given arguments.
# File lib/sequel/dataset/placeholder_literalizer.rb 202 def sql(*args) 203 raise Error, "wrong number of arguments (#{args.length} for #{@arity})" unless args.length == @arity 204 s = String.new 205 ds = @dataset 206 @fragments.each do |sql, i, transformer| 207 s << sql 208 if i.is_a?(Integer) 209 v = args.fetch(i) 210 v = transformer.call(v) if transformer 211 else 212 v = i.call 213 end 214 ds.literal_append(s, v) 215 end 216 if sql = @final_sql 217 s << sql 218 end 219 s 220 end
Return a new PlaceholderLiteralizer
with a modified dataset. This yields the receiver's dataset to the block, and the block should return the new dataset to use.
# File lib/sequel/dataset/placeholder_literalizer.rb 172 def with_dataset 173 dataset = yield @dataset 174 other = dup 175 other.instance_variable_set(:@dataset, dataset) 176 other.freeze 177 end