Class: DB::Model::Relation

Inherits:
Object
  • Object
show all
Includes:
Countable, Deletable
Defined in:
lib/db/model/relation.rb

Direct Known Subclasses

Scope, Table

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Countable

#count, #empty?

Methods included from Deletable

#delete

Constructor Details

#initialize(context, model, cache = nil) ⇒ Relation

Returns a new instance of Relation.



29
30
31
32
33
34
35
 
# File 'lib/db/model/relation.rb', line 29

def initialize(context, model, cache = nil)
  @context = context
  @model = model
  @cache = cache
  
  @select = nil
end

Instance Attribute Details

#cache ⇒ Object (readonly)

Returns the value of attribute cache.



39
40
41
 
# File 'lib/db/model/relation.rb', line 39

def cache
  @cache
end

#context ⇒ Object (readonly)

Returns the value of attribute context.



37
38
39
 
# File 'lib/db/model/relation.rb', line 37

def context
  @context
end

#model ⇒ Object (readonly)

Returns the value of attribute model.



38
39
40
 
# File 'lib/db/model/relation.rb', line 38

def model
  @model
end

Instance Method Details

#cache_key ⇒ Object 



139
140
141
 
# File 'lib/db/model/relation.rb', line 139

def cache_key
  [@model, self.predicate]
end

#create(**attributes) ⇒ Object 



43
44
45
 
# File 'lib/db/model/relation.rb', line 43

def create(**attributes)
  self.new(**attributes).save
end

#each(cache: @cache, &block) ⇒ Object 



111
112
113
114
115
116
117
118
119
 
# File 'lib/db/model/relation.rb', line 111

def each(cache: @cache, &block)
  if @cache
    @cache.fetch(self.cache_key) do
      self.select.to_a(@context, @cache)
    end.each(&block)
  else
    self.select.each(@context, &block)
  end
end

#find(*key) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/db/model/relation.rb', line 55

def find(*key)
  if predicate = self.predicate
    predicate = predicate & @model.find_predicate(*key)
  else
    predicate = @model.find_predicate(*key)
  end
  
  return Statement::Select.new(@model,
    where: predicate,
    limit: Statement::Limit::ONE
  ).to_a(@context).first
end

#first(count = nil) ⇒ Object 



121
122
123
124
125
126
127
 
# File 'lib/db/model/relation.rb', line 121

def first(count = nil)
  if count
    self.select.first(@context, count, @cache)
  else
    self.select.first(@context, 1, @cache).first
  end
end

#insert(keys, rows, **attributes) ⇒ Object 



51
52
53
 
# File 'lib/db/model/relation.rb', line 51

def insert(keys, rows, **attributes)
  @model.insert(@context, keys, rows, **attributes)
end

#inspect ⇒ Object 



155
156
157
 
# File 'lib/db/model/relation.rb', line 155

def inspect
  to_s
end

#new(**attributes) ⇒ Object 



47
48
49
 
# File 'lib/db/model/relation.rb', line 47

def new(**attributes)
  @model.new(@context, {}, @cache).assign(attributes)
end

#predicate ⇒ Object 



78
79
80
 
# File 'lib/db/model/relation.rb', line 78

def predicate
  nil
end

#preload(name) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/db/model/relation.rb', line 82

def preload(name)
  @cache ||= Cache.new
  
  scopes = []
  self.each do |record|
    scopes << record.send(name)
  end
  
  # Build a buffer of queries:
  query = @context.query
  first = true
  
  scopes.each do |scope|
    query.clause(";") unless first
    first = false
    
    scope.select.append_to(query)
  end
  
  query.call do |connection|
    scopes.each do |scope|
      result = connection.next_result
      scope.update_cache(result)
    end
  end
  
  return self
end

#select ⇒ Object 



147
148
149
 
# File 'lib/db/model/relation.rb', line 147

def select
  @select ||= Statement::Select.new(@model, where: self.predicate)
end

#to_a ⇒ Object 



129
130
131
132
133
134
135
136
137
 
# File 'lib/db/model/relation.rb', line 129

def to_a
  records = []
  
  self.each do |record|
    records << record
  end
  
  return records
end

#to_s ⇒ Object 



151
152
153
 
# File 'lib/db/model/relation.rb', line 151

def to_s
  "\#<#{self.class} #{@model}>"
end

#update_cache(result) ⇒ Object 



143
144
145
 
# File 'lib/db/model/relation.rb', line 143

def update_cache(result)
  @cache.update(self.cache_key, self.select.apply(@context, result))
end

#where(*arguments, **options, &block) ⇒ Object 



68
69
70
71
72
73
74
75
76
 
# File 'lib/db/model/relation.rb', line 68

def where(*arguments, **options, &block)
  where = @model.where(@context, *arguments, **options, &block)
  
  if predicate = self.predicate
    where.predicate &= predicate
  end
  
  return where
end