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

loader(dataset, &block) click to toggle source

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
new(dataset, fragments, final_sql, arity) click to toggle source

Save the dataset, array of SQL fragments, and ending SQL string.

    # File lib/sequel/dataset/placeholder_literalizer.rb
154 def initialize(dataset, fragments, final_sql, arity)
155   @dataset = dataset
156   @fragments = fragments
157   @final_sql = final_sql
158   @arity = arity
159   freeze
160 end

Public Instance Methods

all(*args, &block) click to toggle source

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
each(*args, &block) click to toggle source

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
first(*args) click to toggle source

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() click to toggle source

Freeze the fragments and final SQL when freezing the literalizer.

Calls superclass method
    # File lib/sequel/dataset/placeholder_literalizer.rb
163 def freeze
164   @fragments.freeze
165   @final_sql.freeze
166   super
167 end
get(*args) click to toggle source

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
sql(*args) click to toggle source

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
with_dataset() { |dataset| ... } click to toggle source

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