Class: Sequel::Model::Associations::AssociationReflection

Inherits:
Hash
  • Object
show all
Includes:
Inflections
Defined in:
lib/sequel/model/associations.rb

Overview

AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It provides methods to reduce internal code duplication. It should not be instantiated by the user.

Constant Summary collapse

ASSOCIATION_DATASET_PROC = 
proc{|r| r.association_dataset_for(self)}
FINALIZE_SETTINGS =

Map of methods to cache keys used for finalizing associations.

{
  :associated_class=>:class,
  :associated_dataset=>:_dataset,
  :eager_limit_strategy=>:_eager_limit_strategy,
  :placeholder_loader=>:placeholder_loader,
  :predicate_key=>:predicate_key,
  :predicate_keys=>:predicate_keys,
  :reciprocal=>:reciprocal,
}.freeze

Instance Method Summary collapse

Methods included from Inflections

clear, irregular, plural, singular, uncountable

Methods inherited from Hash

#&, #case, #hstore, #pg_json, #pg_jsonb, #sql_expr, #sql_negate, #sql_or, #|, #~

Instance Method Details

#_add_method ⇒ Object

Name symbol for the _add internal association method

[View source]

36
37
38
 
# File 'lib/sequel/model/associations.rb', line 36

def _add_method
  self[:_add_method]
end

#_remove_all_method ⇒ Object

Name symbol for the _remove_all internal association method

[View source]

41
42
43
 
# File 'lib/sequel/model/associations.rb', line 41

def _remove_all_method
  self[:_remove_all_method]
end

#_remove_method ⇒ Object

Name symbol for the _remove internal association method

[View source]

46
47
48
 
# File 'lib/sequel/model/associations.rb', line 46

def _remove_method
  self[:_remove_method]
end

#_setter_method ⇒ Object

Name symbol for the _setter association method

[View source]

51
52
53
 
# File 'lib/sequel/model/associations.rb', line 51

def _setter_method
  self[:_setter_method]
end

#add_method ⇒ Object

Name symbol for the add association method

[View source]

56
57
58
 
# File 'lib/sequel/model/associations.rb', line 56

def add_method
  self[:add_method]
end

#apply_dataset_changes(ds) ⇒ Object

Apply all non-instance specific changes to the given dataset and return it.

[View source]

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/sequel/model/associations.rb', line 84

def apply_dataset_changes(ds)
  ds = ds.with_extend(AssociationDatasetMethods).clone(:association_reflection => self)
  if exts = self[:reverse_extend]
    ds = ds.with_extend(*exts)
  end
  ds = ds.select(*select) if select
  if c = self[:conditions]
    ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
  end
  ds = ds.order(*self[:order]) if self[:order]
  ds = ds.limit(*self[:limit]) if self[:limit]
  ds = ds.limit(1).skip_limit_check if limit_to_single_row?
  ds = ds.eager(self[:eager]) if self[:eager]
  ds = ds.distinct if self[:distinct]
  ds
end

#apply_distinct_on_eager_limit_strategy(ds) ⇒ Object

Use DISTINCT ON and ORDER BY clauses to limit the results to the first record with matching keys.

[View source]

138
139
140
141
 
# File 'lib/sequel/model/associations.rb', line 138

def apply_distinct_on_eager_limit_strategy(ds)
  keys = predicate_key
  ds.distinct(*keys).order_prepend(*keys)
end

#apply_eager_dataset_changes(ds) ⇒ Object

Apply all non-instance specific changes and the eager_block option to the given dataset and return it.

[View source]

103
104
105
106
107
108
109
 
# File 'lib/sequel/model/associations.rb', line 103

def apply_eager_dataset_changes(ds)
  ds = apply_dataset_changes(ds)
  if block = self[:eager_block]
    ds = block.call(ds)
  end
  ds
end

#apply_eager_graph_limit_strategy(strategy, ds) ⇒ Object

Apply the eager graph limit strategy to the dataset to graph into the current dataset, or return the dataset unmodified if no SQL limit strategy is needed.

[View source]

113
114
115
116
117
118
119
120
121
122
 
# File 'lib/sequel/model/associations.rb', line 113

def apply_eager_graph_limit_strategy(strategy, ds)
  case strategy
  when :distinct_on
    apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order]))
  when :window_function
    apply_window_function_eager_limit_strategy(ds.order_prepend(*self[:order])).select(*ds.columns)
  else
    ds
  end
end

#apply_eager_limit_strategy(ds, strategy = eager_limit_strategy, limit_and_offset = limit_and_offset()) ⇒ Object

Apply an eager limit strategy to the dataset, or return the dataset unmodified if it doesn’t need an eager limit strategy.

[View source]

126
127
128
129
130
131
132
133
134
135
 
# File 'lib/sequel/model/associations.rb', line 126

def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy, limit_and_offset=limit_and_offset())
  case strategy
  when :distinct_on
    apply_distinct_on_eager_limit_strategy(ds)
  when :window_function
    apply_window_function_eager_limit_strategy(ds, limit_and_offset)
  else
    ds
  end
end

#apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset()) ⇒ Object

If the ruby eager limit strategy is being used, slice the array using the slice range to return the object(s) at the correct offset/limit.

[View source]

165
166
167
168
169
170
171
172
173
174
 
# File 'lib/sequel/model/associations.rb', line 165

def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
  name = self[:name]
  return unless range = slice_range(limit_and_offset)
  if returns_array?
    rows.each{|o| o.associations[name] = o.associations[name][range] || []}
  else
    offset = range.begin
    rows.each{|o| o.associations[name] = o.associations[name][offset]}
  end
end

#apply_window_function_eager_limit_strategy(ds, limit_and_offset = limit_and_offset()) ⇒ Object

Use a window function to limit the results of the eager loading dataset.

[View source]

144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/sequel/model/associations.rb', line 144

def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
  rn = ds.row_number_column 
  limit, offset = limit_and_offset
  ds = ds.unordered.select_append{|o| o.row_number.function.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
  ds = ds.order(rn) if ds.db.database_type == :mysql
  ds = if !returns_array?
    ds.where(rn => offset ? offset+1 : 1)
  elsif offset
    offset += 1
    if limit
      ds.where(rn => (offset...(offset+limit))) 
    else
      ds.where{SQL::Identifier.new(rn) >= offset} 
    end
  else
    ds.where{SQL::Identifier.new(rn) <= limit} 
  end
end

#assign_singular? ⇒ Boolean

Whether the associations cache should use an array when storing the associated records during eager loading.

Returns:

  • (Boolean)
[View source]

178
179
180
 
# File 'lib/sequel/model/associations.rb', line 178

def assign_singular?
  !returns_array?
end

#associated_class ⇒ Object

The class associated to the current model class via this association

[View source]

66
67
68
69
70
71
72
73
74
 
# File 'lib/sequel/model/associations.rb', line 66

def associated_class
  cached_fetch(:class) do
    begin
      constantize(self[:class_name])
    rescue NameError => e
      raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace
    end
  end
end

#associated_dataset ⇒ Object

The dataset associated via this association, with the non-instance specific changes already applied. This will be a joined dataset if the association requires joining tables.

[View source]

79
80
81
 
# File 'lib/sequel/model/associations.rb', line 79

def associated_dataset
  cached_fetch(:_dataset){apply_dataset_changes(_associated_dataset)}
end

#association_dataset_for(object) ⇒ Object

Return an dataset that will load the appropriate associated objects for the given object using this association.

[View source]

215
216
217
218
219
220
221
222
223
 
# File 'lib/sequel/model/associations.rb', line 215

def association_dataset_for(object)
  condition = if can_have_associated_objects?(object)
    predicate_keys.zip(predicate_key_values(object))
  else
    false
  end

  associated_dataset.where(condition)
end

#association_dataset_proc ⇒ Object

Proc used to create the association dataset method.

[View source]

227
228
229
 
# File 'lib/sequel/model/associations.rb', line 227

def association_dataset_proc
  ASSOCIATION_DATASET_PROC
end

#association_method ⇒ Object

Name symbol for association method, the same as the name of the association.

[View source]

61
62
63
 
# File 'lib/sequel/model/associations.rb', line 61

def association_method
  self[:name]
end

#can_have_associated_objects?(obj) ⇒ Boolean

Whether this association can have associated objects, given the current object. Should be false if obj cannot have associated objects because the necessary key columns are NULL.

Returns:

  • (Boolean)
[View source]

185
186
187
 
# File 'lib/sequel/model/associations.rb', line 185

def can_have_associated_objects?(obj)
  true
end

#cloneable?(ref) ⇒ Boolean

Whether you are able to clone from the given association type to the current association type, true by default only if the types match.

Returns:

  • (Boolean)
[View source]

191
192
193
 
# File 'lib/sequel/model/associations.rb', line 191

def cloneable?(ref)
  ref[:type] == self[:type]
end

#dataset_method ⇒ Object

Name symbol for the dataset association method

[View source]

196
197
198
 
# File 'lib/sequel/model/associations.rb', line 196

def dataset_method
  self[:dataset_method]
end

#dataset_need_primary_key? ⇒ Boolean

Whether the dataset needs a primary key to function, true by default.

Returns:

  • (Boolean)
[View source]

201
202
203
 
# File 'lib/sequel/model/associations.rb', line 201

def dataset_need_primary_key?
  true
end

#delete_row_number_column(ds = associated_dataset) ⇒ Object

Return the symbol used for the row number column if the window function eager limit strategy is being used, or nil otherwise.

[View source]

207
208
209
210
211
 
# File 'lib/sequel/model/associations.rb', line 207

def delete_row_number_column(ds=associated_dataset)
  if eager_limit_strategy == :window_function
    ds.row_number_column 
  end
end

#eager_graph_lazy_dataset? ⇒ Boolean

Whether to eagerly graph a lazy dataset, true by default. If this is false, the association won’t respect the :eager_graph option when loading the association for a single record.

Returns:

  • (Boolean)
[View source]

354
355
356
 
# File 'lib/sequel/model/associations.rb', line 354

def eager_graph_lazy_dataset?
  true
end

#eager_graph_limit_strategy(strategy) ⇒ Object

The eager_graph limit strategy to use for this dataset

[View source]

232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/sequel/model/associations.rb', line 232

def eager_graph_limit_strategy(strategy)
  if self[:limit] || !returns_array?
    strategy = strategy[self[:name]] if strategy.is_a?(Hash)
    case strategy
    when true
      true_eager_graph_limit_strategy
    when Symbol
      strategy
    else
      if returns_array? || offset
        :ruby
      end
    end
  end
end

#eager_limit_strategy ⇒ Object

The eager limit strategy to use for this dataset.

[View source]

249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/sequel/model/associations.rb', line 249

def eager_limit_strategy
  cached_fetch(:_eager_limit_strategy) do
    if self[:limit] || !returns_array?
      case s = cached_fetch(:eager_limit_strategy){default_eager_limit_strategy}
      when true
        true_eager_limit_strategy
      else
        s
      end
    end
  end
end

#eager_load_results(eo, &block) ⇒ Object

Eager load the associated objects using the hash of eager options, yielding each row to the block.

[View source]

264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/sequel/model/associations.rb', line 264

def eager_load_results(eo, &block)
  rows = eo[:rows]
  unless eo[:initialize_rows] == false
    Sequel.synchronize_with(eo[:mutex]){initialize_association_cache(rows)}
  end
  if eo[:id_map]
    ids = eo[:id_map].keys
    return ids if ids.empty?
  end
  strategy = eager_limit_strategy
  cascade = eo[:associations]
  eager_limit = nil

  if eo[:no_results]
    no_results = true
  elsif eo[:eager_block] || eo[:loader] == false || !use_placeholder_loader?
    ds = eager_loading_dataset(eo)

    strategy = ds.opts[:eager_limit_strategy] || strategy

    eager_limit =
      if el = ds.opts[:eager_limit]
        raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array?
        strategy ||= true_eager_graph_limit_strategy
        if el.is_a?(Array)
          el
        else
          [el, nil]
        end
      else
        limit_and_offset
      end

    strategy = true_eager_graph_limit_strategy if strategy == :union
    # Correlated subqueries are not supported for regular eager loading
    strategy = :ruby if strategy == :correlated_subquery
    strategy = nil if strategy == :ruby && assign_singular?
    objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all

    if strategy == :window_function
      delete_rn = ds.row_number_column 
      objects.each{|obj| obj.values.delete(delete_rn)}
    end
  elsif strategy == :union
    objects = []
    ds = associated_dataset
    loader = union_eager_loader
    joiner = " UNION ALL "
    ids.each_slice(subqueries_per_union).each do |slice|
      sql = loader.send(:sql_origin)
      join = false
      slice.each do |k|
        if join
          sql << joiner
        else
          join = true
        end
        loader.append_sql(sql, *k)
      end
      objects.concat(ds.with_sql(sql).to_a)
    end
    ds = ds.eager(cascade) if cascade
    ds.send(:post_load, objects)
  else
    loader = placeholder_eager_loader
    loader = loader.with_dataset{|dataset| dataset.eager(cascade)} if cascade
    objects = loader.all(ids)
  end

  Sequel.synchronize_with(eo[:mutex]){objects.each(&block)} unless no_results

  if strategy == :ruby
    apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
  end
end

#eager_loader_key ⇒ Object

The key to use for the key hash when eager loading

[View source]

341
342
343
 
# File 'lib/sequel/model/associations.rb', line 341

def eager_loader_key
  self[:eager_loader_key]
end

#eager_loading_use_associated_key? ⇒ Boolean

By default associations do not need to select a key in an associated table to eagerly load.

Returns:

  • (Boolean)
[View source]

347
348
349
 
# File 'lib/sequel/model/associations.rb', line 347

def eager_loading_use_associated_key?
  false
end

#filter_by_associations_add_conditions? ⇒ Boolean

Whether additional conditions should be added when using the filter by associations support.

Returns:

  • (Boolean)
[View source]

360
361
362
 
# File 'lib/sequel/model/associations.rb', line 360

def filter_by_associations_add_conditions?
  self[:conditions] || self[:eager_block] || self[:limit]
end

#filter_by_associations_conditions_expression(obj) ⇒ Object

The expression to use for the additional conditions to be added for the filter by association support, when the association itself is filtered. Works by using a subquery to test that the objects passed also meet the association filter criteria.

[View source]

368
369
370
371
 
# File 'lib/sequel/model/associations.rb', line 368

def filter_by_associations_conditions_expression(obj)
  ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
  {filter_by_associations_conditions_key=>ds}
end

#finalize ⇒ Object

Finalize the association by first attempting to populate the thread-safe cache, and then transfering the thread-safe cache value to the association itself, so that a mutex is not needed to get the value.

[View source]

376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
# File 'lib/sequel/model/associations.rb', line 376

def finalize
  return unless cache = self[:cache]

  finalizer = proc do |meth, key|
    next if has_key?(key)

    # Allow calling private methods to make sure caching is done appropriately
    send(meth)
    self[key] = cache.delete(key) if cache.has_key?(key)
  end

  finalize_settings.each(&finalizer)

  unless self[:instance_specific]
    finalizer.call(:associated_eager_dataset, :associated_eager_dataset)
    finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset)
  end

  nil
end

#finalize_settings ⇒ Object

[View source]

407
408
409
 
# File 'lib/sequel/model/associations.rb', line 407

def finalize_settings
  FINALIZE_SETTINGS
end

#handle_silent_modification_failure? ⇒ Boolean

Whether to handle silent modification failure when adding/removing associated records, false by default.

Returns:

  • (Boolean)
[View source]

413
414
415
 
# File 'lib/sequel/model/associations.rb', line 413

def handle_silent_modification_failure?
  false
end

#hash ⇒ Object

Hash value for the association reflection. This is precomputed to avoid concurrency issues at runtime.

[View source]

419
420
421
 
# File 'lib/sequel/model/associations.rb', line 419

def hash
  self[:_hash]
end

#initialize_association_cache(objects) ⇒ Object

Initialize the associations cache for the current association for the given objects.

[View source]

424
425
426
427
428
429
430
431
 
# File 'lib/sequel/model/associations.rb', line 424

def initialize_association_cache(objects)
  name = self[:name]
  if assign_singular?
    objects.each{|object| object.associations[name] = nil}
  else
    objects.each{|object| object.associations[name] = []}
  end
end

#inspect ⇒ Object

Show which type of reflection this is, and a guess at what code was used to create the association.

[View source]

435
436
437
438
439
440
441
442
443
 
# File 'lib/sequel/model/associations.rb', line 435

def inspect
  o = self[:orig_opts].dup
  o.delete(:class)
  o.delete(:class_name)
  o.delete(:block) unless o[:block]
  o[:class] = self[:orig_class] if self[:orig_class]

  "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>"
end

#limit_and_offset ⇒ Object

The limit and offset for this association (returned as a two element array).

[View source]

446
447
448
449
450
451
452
 
# File 'lib/sequel/model/associations.rb', line 446

def limit_and_offset
  if (v = self[:limit]).is_a?(Array)
    v
  else
    [v, nil]
  end
end

#need_associated_primary_key? ⇒ Boolean

Whether the associated object needs a primary key to be added/removed, false by default.

Returns:

  • (Boolean)
[View source]

456
457
458
 
# File 'lib/sequel/model/associations.rb', line 456

def need_associated_primary_key?
  false
end

#placeholder_loader ⇒ Object

A placeholder literalizer that can be used to lazily load the association. If one can’t be used, returns nil.

[View source]

462
463
464
465
466
467
468
469
470
471
472
473
474
 
# File 'lib/sequel/model/associations.rb', line 462

def placeholder_loader
  if use_placeholder_loader?
    cached_fetch(:placeholder_loader) do
      associated_dataset.placeholder_literalizer_loader do |pl, ds|
        ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
        if self[:block]
          ds = self[:block].call(ds)
        end
        ds
      end
    end
  end
end

#predicate_key_values(object) ⇒ Object

The values that predicate_keys should match for objects to be associated.

[View source]

482
483
484
 
# File 'lib/sequel/model/associations.rb', line 482

def predicate_key_values(object)
  predicate_key_methods.map{|k| object.get_column_value(k)}
end

#predicate_keys ⇒ Object

The keys to use for loading of the regular dataset, as an array.

[View source]

477
478
479
 
# File 'lib/sequel/model/associations.rb', line 477

def predicate_keys
  cached_fetch(:predicate_keys){Array(predicate_key)}
end

#qualify(table, col) ⇒ Object

Qualify col with the given table name.

[View source]

487
488
489
490
491
492
493
494
495
496
 
# File 'lib/sequel/model/associations.rb', line 487

def qualify(table, col)
  transform(col) do |k|
    case k
    when Symbol, SQL::Identifier
      SQL::QualifiedIdentifier.new(table, k)
    else
      Sequel::Qualifier.new(table).transform(k)
    end
  end
end

#qualify_assoc(col) ⇒ Object

Qualify col with the associated model’s table name.

[View source]

499
500
501
 
# File 'lib/sequel/model/associations.rb', line 499

def qualify_assoc(col)
  qualify(associated_class.table_name, col)
end

#qualify_cur(col) ⇒ Object

Qualify col with the current model’s table name.

[View source]

504
505
506
 
# File 'lib/sequel/model/associations.rb', line 504

def qualify_cur(col)
  qualify(self[:model].table_name, col)
end

#reciprocal ⇒ Object

Returns the reciprocal association variable, if one exists. The reciprocal association is the association in the associated class that is the opposite of the current association. For example, Album.many_to_one :artist and Artist.one_to_many :albums are reciprocal associations. This information is to populate reciprocal associations. For example, when you do this_artist.add_album(album) it sets album.artist to this_artist.

[View source]

514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'lib/sequel/model/associations.rb', line 514

def reciprocal
  cached_fetch(:reciprocal) do
    possible_recips = []

    associated_class.all_association_reflections.each do |assoc_reflect|
      if reciprocal_association?(assoc_reflect)
        possible_recips << assoc_reflect
      end
    end

    if possible_recips.length == 1
      cached_set(:reciprocal_type, possible_recips.first[:type]) if ambiguous_reciprocal_type?
      possible_recips.first[:name]
    end
  end
end

#reciprocal_array? ⇒ Boolean

Whether the reciprocal of this association returns an array of objects instead of a single object, true by default.

Returns:

  • (Boolean)
[View source]

533
534
535
 
# File 'lib/sequel/model/associations.rb', line 533

def reciprocal_array?
  true
end

#remove_all_method ⇒ Object

Name symbol for the remove_all_ association method

[View source]

538
539
540
 
# File 'lib/sequel/model/associations.rb', line 538

def remove_all_method
  self[:remove_all_method]
end

#remove_before_destroy? ⇒ Boolean

Whether associated objects need to be removed from the association before being destroyed in order to preserve referential integrity.

Returns:

  • (Boolean)
[View source]

544
545
546
 
# File 'lib/sequel/model/associations.rb', line 544

def remove_before_destroy?
  true
end

#remove_method ⇒ Object

Name symbol for the remove_ association method

[View source]

549
550
551
 
# File 'lib/sequel/model/associations.rb', line 549

def remove_method
  self[:remove_method]
end

#remove_should_check_existing? ⇒ Boolean

Whether to check that an object to be disassociated is already associated to this object, false by default.

Returns:

  • (Boolean)
[View source]

554
555
556
 
# File 'lib/sequel/model/associations.rb', line 554

def remove_should_check_existing?
  false
end

#returns_array? ⇒ Boolean

Whether this association returns an array of objects instead of a single object, true by default.

Returns:

  • (Boolean)
[View source]

560
561
562
 
# File 'lib/sequel/model/associations.rb', line 560

def returns_array?
  true
end

#select ⇒ Object

The columns to select when loading the association.

[View source]

565
566
567
 
# File 'lib/sequel/model/associations.rb', line 565

def select
  self[:select]
end

#set_reciprocal_to_self? ⇒ Boolean

Whether to set the reciprocal association to self when loading associated records, false by default.

Returns:

  • (Boolean)
[View source]

571
572
573
 
# File 'lib/sequel/model/associations.rb', line 571

def set_reciprocal_to_self?
  false
end

#setter_method ⇒ Object

Name symbol for the setter association method

[View source]

576
577
578
 
# File 'lib/sequel/model/associations.rb', line 576

def setter_method
  self[:setter_method]
end

#slice_range(limit_and_offset = limit_and_offset()) ⇒ Object

The range used for slicing when using the :ruby eager limit strategy.

[View source]

581
582
583
584
585
586
 
# File 'lib/sequel/model/associations.rb', line 581

def slice_range(limit_and_offset = limit_and_offset())
  limit, offset = limit_and_offset
  if limit || offset
    (offset||0)..(limit ? (offset||0)+limit-1 : -1)
  end
end