Class: Sequel::Model::Associations::EagerGraphLoader

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

Overview

This class is the internal implementation of eager_graph. It is responsible for taking an array of plain hashes and returning an array of model objects with all eager_graphed associations already set in the association cache.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dataset) ⇒ EagerGraphLoader

Initialize all of the data structures used during loading.


3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
 
# File 'lib/sequel/model/associations.rb', line 3517

def initialize(dataset)
  opts = dataset.opts
  eager_graph = opts[:eager_graph]
  @master =  eager_graph[:master]
  requirements = eager_graph[:requirements]
  reflection_map = @reflection_map = eager_graph[:reflections]
  reciprocal_map = @reciprocal_map = eager_graph[:reciprocals]
  limit_map = @limit_map = eager_graph[:limits]
  @unique = eager_graph[:cartesian_product_number] > 1
      
  alias_map = @alias_map = {}
  type_map = @type_map = {}
  after_load_map = @after_load_map = {}
  reflection_map.each do |k, v|
    alias_map[k] = v[:name]
    after_load_map[k] = v[:after_load] if v[:after_load]
    type_map[k] = if v.returns_array?
      true
    elsif (limit_and_offset = limit_map[k]) && !limit_and_offset.last.nil?
      :offset
    end
  end
  after_load_map.freeze
  alias_map.freeze
  type_map.freeze

  # Make dependency map hash out of requirements array for each association.
  # This builds a tree of dependencies that will be used for recursion
  # to ensure that all parts of the object graph are loaded into the
  # appropriate subordinate association.
  dependency_map = @dependency_map = {}
  # Sort the associations by requirements length, so that
  # requirements are added to the dependency hash before their
  # dependencies.
  requirements.sort_by{|a| a[1].length}.each do |ta, deps|
    if deps.empty?
      dependency_map[ta] = {}
    else
      deps = deps.dup
      hash = dependency_map[deps.shift]
      deps.each do |dep|
        hash = hash[dep]
      end
      hash[ta] = {}
    end
  end
  freezer = lambda do |h|
    h.freeze
    h.each_value(&freezer)
  end
  freezer.call(dependency_map)
      
  datasets = opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
  column_aliases = opts[:graph][:column_aliases]
  primary_keys = {}
  column_maps = {}
  models = {}
  row_procs = {}
  datasets.each do |ta, ds|
    models[ta] = ds.model
    primary_keys[ta] = []
    column_maps[ta] = {}
    row_procs[ta] = ds.row_proc
  end
  column_aliases.each do |col_alias, tc|
    ta, column = tc
    column_maps[ta][col_alias] = column
  end
  column_maps.each do |ta, h|
    pk = models[ta].primary_key
    if pk.is_a?(Array)
      primary_keys[ta] = []
      h.select{|ca, c| primary_keys[ta] << ca if pk.include?(c)}
    else
      h.select{|ca, c| primary_keys[ta] = ca if pk == c}
    end
  end
  @column_maps = column_maps.freeze
  @primary_keys = primary_keys.freeze
  @row_procs = row_procs.freeze

  # For performance, create two special maps for the master table,
  # so you can skip a hash lookup.
  @master_column_map = column_maps[master]
  @master_primary_keys = primary_keys[master]

  # Add a special hash mapping table alias symbols to 5 element arrays that just
  # contain the data in other data structures for that table alias.  This is
  # used for performance, to get all values in one hash lookup instead of
  # separate hash lookups for each data structure.
  ta_map = {}
  alias_map.each_key do |ta|
    ta_map[ta] = [row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]].freeze
  end
  @ta_map = ta_map.freeze
  freeze
end

Instance Attribute Details

#after_load_map ⇒ Object (readonly)

Hash with table alias symbol keys and after_load hook values


3475
3476
3477
 
# File 'lib/sequel/model/associations.rb', line 3475

def after_load_map
  @after_load_map
end

#alias_map ⇒ Object (readonly)

Hash with table alias symbol keys and association name values


3478
3479
3480
 
# File 'lib/sequel/model/associations.rb', line 3478

def alias_map
  @alias_map
end

#column_maps ⇒ Object (readonly)

Hash with table alias symbol keys and subhash values mapping column_alias symbols to the symbol of the real name of the column


3482
3483
3484
 
# File 'lib/sequel/model/associations.rb', line 3482

def column_maps
  @column_maps
end

#dependency_map ⇒ Object (readonly)

Recursive hash with table alias symbol keys mapping to hashes with dependent table alias symbol keys.


3485
3486
3487
 
# File 'lib/sequel/model/associations.rb', line 3485

def dependency_map
  @dependency_map
end

#limit_map ⇒ Object (readonly)

Hash with table alias symbol keys and [limit, offset] values


3488
3489
3490
 
# File 'lib/sequel/model/associations.rb', line 3488

def limit_map
  @limit_map
end

#master ⇒ Object (readonly)

The table alias symbol for the primary model


3491
3492
3493
 
# File 'lib/sequel/model/associations.rb', line 3491

def master
  @master
end

#primary_keys ⇒ Object (readonly)

Hash with table alias symbol keys and primary key symbol values (or arrays of primary key symbols for composite key tables)


3495
3496
3497
 
# File 'lib/sequel/model/associations.rb', line 3495

def primary_keys
  @primary_keys
end

#reciprocal_map ⇒ Object (readonly)

Hash with table alias symbol keys and reciprocal association symbol values, used for setting reciprocals for one_to_many associations.


3499
3500
3501
 
# File 'lib/sequel/model/associations.rb', line 3499

def reciprocal_map
  @reciprocal_map
end

#records_map ⇒ Object (readonly)

Hash with table alias symbol keys and subhash values mapping primary key symbols (or array of symbols) to model instances. Used so that only a single model instance is created for each object.


3503
3504
3505
 
# File 'lib/sequel/model/associations.rb', line 3503

def records_map
  @records_map
end

#reflection_map ⇒ Object (readonly)

Hash with table alias symbol keys and AssociationReflection values


3506
3507
3508
 
# File 'lib/sequel/model/associations.rb', line 3506

def reflection_map
  @reflection_map
end

#row_procs ⇒ Object (readonly)

Hash with table alias symbol keys and callable values used to create model instances


3509
3510
3511
 
# File 'lib/sequel/model/associations.rb', line 3509

def row_procs
  @row_procs
end

#type_map ⇒ Object (readonly)

Hash with table alias symbol keys and true/false values, where true means the association represented by the table alias uses an array of values instead of a single value (i.e. true => *_many, false => *_to_one).


3514
3515
3516
 
# File 'lib/sequel/model/associations.rb', line 3514

def type_map
  @type_map
end

Instance Method Details

#load(hashes) ⇒ Object

Return an array of primary model instances with the associations cache prepopulated for all model objects (both primary and associated).


3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
 
# File 'lib/sequel/model/associations.rb', line 3617

def load(hashes)
  # This mapping is used to make sure that duplicate entries in the
  # result set are mapped to a single record.  For example, using a
  # single one_to_many association with 10 associated records,
  # the main object column values appear in the object graph 10 times.
  # We map by primary key, if available, or by the object's entire values,
  # if not. The mapping must be per table, so create sub maps for each table
  # alias.
  @records_map = records_map = {}
  alias_map.keys.each{|ta| records_map[ta] = {}}

  master = master()
      
  # Assign to local variables for speed increase
  rp = row_procs[master]
  rm = records_map[master] = {}
  dm = dependency_map

  records_map.freeze

  # This will hold the final record set that we will be replacing the object graph with.
  records = []

  hashes.each do |h|
    unless key = master_pk(h)
      key = hkey(master_hfor(h))
    end
    unless primary_record = rm[key]
      primary_record = rm[key] = rp.call(master_hfor(h))
      # Only add it to the list of records to return if it is a new record
      records.push(primary_record)
    end
    # Build all associations for the current object and it's dependencies
    _load(dm, primary_record, h)
  end
      
  # Remove duplicate records from all associations if this graph could possibly be a cartesian product
  # Run after_load procs if there are any
  post_process(records, dm) if @unique || !after_load_map.empty? || !limit_map.empty?

  records_map.each_value(&:freeze)
  freeze

  records
end