1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
// file : odb/mysql/simple-object-result.txx
// copyright : Copyright (c) 2009-2018 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
#include <cassert>
#include <odb/callback.hxx>
#include <odb/exceptions.hxx> // result_not_cached
#include <odb/mysql/simple-object-statements.hxx>
namespace odb
{
namespace mysql
{
template <typename T>
object_result_impl<T>::
~object_result_impl ()
{
if (!this->end_)
statement_->free_result ();
}
template <typename T>
void object_result_impl<T>::
invalidate ()
{
if (!this->end_)
{
statement_->free_result ();
this->end_ = true;
}
statement_.reset ();
}
template <typename T>
object_result_impl<T>::
object_result_impl (const query_base&,
details::shared_ptr<select_statement> statement,
statements_type& statements,
const schema_version_migration* svm)
: base_type (statements.connection ()),
statement_ (statement),
statements_ (statements),
tc_ (svm),
count_ (0)
{
}
template <typename T>
void object_result_impl<T>::
load (object_type& obj, bool f)
{
if (count_ > statement_->fetched ())
fetch ();
else if (f && statement_->cached ())
{
// We have to re-load the image in case it has been overwritten
// between the last time we fetched and this call to load().
//
fetch (false);
}
// This is a top-level call so the statements cannot be locked.
//
assert (!statements_.locked ());
typename statements_type::auto_lock l (statements_);
object_traits::callback (this->db_, obj, callback_event::pre_load);
typename object_traits::image_type& i (statements_.image ());
tc_.init (obj, i, &this->db_);
// Initialize the id image and binding and load the rest of the object
// (containers, etc).
//
typename object_traits::id_image_type& idi (statements_.id_image ());
object_traits::init (idi, object_traits::id (i));
binding& idb (statements_.id_image_binding ());
if (idi.version != statements_.id_image_version () || idb.version == 0)
{
object_traits::bind (idb.bind, idi);
statements_.id_image_version (idi.version);
idb.version++;
}
tc_.load_ (statements_, obj, false);
statements_.load_delayed (tc_.version ());
l.unlock ();
object_traits::callback (this->db_, obj, callback_event::post_load);
}
template <typename T>
typename object_result_impl<T>::id_type
object_result_impl<T>::
load_id ()
{
if (count_ > statement_->fetched ())
fetch ();
else if (statement_->cached ())
{
// We have to re-load the image in case it has been overwritten
// between the last time we fetched and this call to load_id().
//
fetch (false);
}
return object_traits::id (statements_.image ());
}
template <typename T>
void object_result_impl<T>::
next ()
{
this->current (pointer_type ());
if (this->end_)
return;
// If we are cached, simply increment the position and
// postpone the actual row fetching until later. This way
// if the same object is loaded in between iteration, the
// image won't be messed up.
//
count_++;
if (statement_->cached ())
this->end_ = count_ > statement_->result_size ();
else
fetch ();
if (this->end_)
statement_->free_result ();
}
template <typename T>
void object_result_impl<T>::
fetch (bool next)
{
// If the result is cached, the image can grow between calls
// to fetch() as a result of other statements execution.
//
if (statement_->cached ())
{
typename object_traits::image_type& im (statements_.image ());
if (im.version != statements_.select_image_version ())
{
binding& b (statements_.select_image_binding ());
tc_.bind (b.bind, im, statement_select);
statements_.select_image_version (im.version);
b.version++;
}
}
while (!this->end_ && (!next || count_ > statement_->fetched ()))
{
select_statement::result r (statement_->fetch (next));
switch (r)
{
case select_statement::truncated:
{
// Don't re-fetch data we are skipping.
//
if (next && count_ != statement_->fetched ())
continue;
typename object_traits::image_type& im (statements_.image ());
if (tc_.grow (im, statements_.select_image_truncated ()))
im.version++;
if (im.version != statements_.select_image_version ())
{
binding& b (statements_.select_image_binding ());
tc_.bind (b.bind, im, statement_select);
statements_.select_image_version (im.version);
b.version++;
statement_->refetch ();
}
// Fall throught.
}
case select_statement::success:
{
break;
}
case select_statement::no_data:
{
this->end_ = true;
break;
}
}
// If we are refetching the current row, then we are done.
//
if (!next)
break;
}
}
template <typename T>
void object_result_impl<T>::
cache ()
{
if (!this->end_ && !statement_->cached ())
{
statement_->cache ();
if (count_ == statement_->result_size ())
{
statement_->free_result ();
count_++; // One past the result size.
this->end_ = true;
}
}
}
template <typename T>
std::size_t object_result_impl<T>::
size ()
{
if (!this->end_)
{
if (!statement_->cached ())
throw result_not_cached ();
return statement_->result_size ();
}
else
return count_ - 1; // One past the result size.
}
}
}
|
