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.



12
13
14
15
16
17
18
 
# File 'lib/db/model/relation.rb', line 12

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.



22
23
24
 
# File 'lib/db/model/relation.rb', line 22

def cache
  @cache
end

#context ⇒ Object (readonly)

Returns the value of attribute context.



20
21
22
 
# File 'lib/db/model/relation.rb', line 20

def context
  @context
end

#model ⇒ Object (readonly)

Returns the value of attribute model.



21
22
23
 
# File 'lib/db/model/relation.rb', line 21

def model
  @model
end

Instance Method Details

#cache_key ⇒ Object 



122
123
124
 
# File 'lib/db/model/relation.rb', line 122

def cache_key
	[@model, self.predicate]
end

#create(**attributes) ⇒ Object 



26
27
28
 
# File 'lib/db/model/relation.rb', line 26

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

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



94
95
96
97
98
99
100
101
102
 
# File 'lib/db/model/relation.rb', line 94

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 



38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/db/model/relation.rb', line 38

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 



104
105
106
107
108
109
110
 
# File 'lib/db/model/relation.rb', line 104

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 



34
35
36
 
# File 'lib/db/model/relation.rb', line 34

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

#inspect ⇒ Object 



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

def inspect
	to_s
end

#new(**attributes) ⇒ Object 



30
31
32
 
# File 'lib/db/model/relation.rb', line 30

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

#predicate ⇒ Object 



61
62
63
 
# File 'lib/db/model/relation.rb', line 61

def predicate
	nil
end

#preload(name) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/db/model/relation.rb', line 65

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 



130
131
132
 
# File 'lib/db/model/relation.rb', line 130

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

#to_a ⇒ Object 



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

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

#to_s ⇒ Object 



134
135
136
 
# File 'lib/db/model/relation.rb', line 134

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

#update_cache(result) ⇒ Object 



126
127
128
 
# File 'lib/db/model/relation.rb', line 126

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

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



51
52
53
54
55
56
57
58
59
 
# File 'lib/db/model/relation.rb', line 51

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