161 |
return self.column_map.has_key(col) |
return self.column_map.has_key(col) |
162 |
|
|
163 |
def ReadRowAsDict(self, index): |
def ReadRowAsDict(self, index): |
164 |
|
# Implementation Strategy: Executing a completely new select |
165 |
|
# statement every time this method is called is too slow. The |
166 |
|
# most important usage is to read the records more or less |
167 |
|
# sequentially. This happens e.g. when drawing a layer with a |
168 |
|
# classification where the shapes are drawn in order of the |
169 |
|
# shape ids. Another pattern is that the same row is requested |
170 |
|
# several times in a row. This happens in the table view, for |
171 |
|
# instance. |
172 |
|
|
173 |
|
# We can exploit this to make access faster by having one cursor |
174 |
|
# open all the time and keeping the last row read around in case |
175 |
|
# the same row is accessed again the next time and if the row |
176 |
|
# index is larger than the row we have read last we simply fetch |
177 |
|
# rows from the cursor until we've reached the requested row. If |
178 |
|
# the requested row index is smaller then we start a new cursor. |
179 |
|
|
180 |
|
# FIXME: So far this scheme seems to work well enough. Obvious |
181 |
|
# improvements would be to start the cursor at exactly the |
182 |
|
# requested row (should be efficient and easy to do now that the |
183 |
|
# id is the primary key) and to perhaps to also start a new |
184 |
|
# cursor if the requested index is much larger than the last row |
185 |
|
# so that we don't read and discard lots of the rows. |
186 |
|
|
187 |
|
# Check whether we have to start a new cursor |
188 |
if self.read_record_cursor is None or index <self.read_record_last_row: |
if self.read_record_cursor is None or index <self.read_record_last_row: |
189 |
stmt = ("SELECT %s FROM %s;" |
stmt = ("SELECT %s FROM %s;" |
190 |
% (", ".join([c.internal_name for c in self.columns]), |
% (", ".join([c.internal_name for c in self.columns]), |
208 |
self.read_record_last_row = index |
self.read_record_last_row = index |
209 |
return dict(zip(self.orig_names, result)) |
return dict(zip(self.orig_names, result)) |
210 |
|
|
211 |
|
def ReadValue(self, row, col): |
212 |
|
"""Return the value of the specified row and column |
213 |
|
|
214 |
|
The col parameter may be the index of the column or its name. |
215 |
|
""" |
216 |
|
# Depending on the actual access patterns of the table data, it |
217 |
|
# might be a bit faster in some circumstances to not implement |
218 |
|
# this via ReadRowAsDict, but this simple implementation should |
219 |
|
# be fast enough for most purposes. |
220 |
|
return self.ReadRowAsDict(row)[self.column_map[col].name] |
221 |
|
|
222 |
def ValueRange(self, col): |
def ValueRange(self, col): |
223 |
col = self.column_map[col] |
col = self.column_map[col] |
224 |
iname = col.internal_name |
iname = col.internal_name |
280 |
result.append(row[0]) |
result.append(row[0]) |
281 |
return result |
return result |
282 |
|
|
283 |
|
def Dependencies(self): |
284 |
|
"""Placeholder for a method in a derived class. |
285 |
|
|
286 |
|
Return a sequence with the tables and other data objects that |
287 |
|
self depends on. |
288 |
|
""" |
289 |
|
raise NotImplementedError |
290 |
|
|
291 |
|
|
292 |
class TransientTable(TransientTableBase): |
class TransientTable(TransientTableBase): |
293 |
|
|
355 |
names of the input tables without having to create prefixes. |
names of the input tables without having to create prefixes. |
356 |
""" |
""" |
357 |
TransientTableBase.__init__(self, transient_db) |
TransientTableBase.__init__(self, transient_db) |
358 |
|
self.dependencies = (left_table, right_table) |
359 |
self.left_table = left_table.transient_table() |
self.left_table = left_table.transient_table() |
360 |
self.left_field = left_field |
self.left_field = left_field |
361 |
self.right_table = right_table.transient_table() |
self.right_table = right_table.transient_table() |
397 |
self.orig_to_internal[self.right_field])) |
self.orig_to_internal[self.right_field])) |
398 |
self.db.execute(stmt) |
self.db.execute(stmt) |
399 |
|
|
400 |
|
def Dependencies(self): |
401 |
|
"""Return a tuple with the two tables the join depends on.""" |
402 |
|
return self.dependencies |
403 |
|
|
404 |
|
|
405 |
class AutoTransientTable(table.OldTableInterfaceMixin): |
class AutoTransientTable(table.OldTableInterfaceMixin): |
406 |
|
|
440 |
else: |
else: |
441 |
return self.table.ReadRowAsDict(record) |
return self.table.ReadRowAsDict(record) |
442 |
|
|
443 |
|
def ReadValue(self, row, col): |
444 |
|
"""Return the value of the specified row and column |
445 |
|
|
446 |
|
The col parameter may be the index of the column or its name. |
447 |
|
""" |
448 |
|
if self.t_table is not None: |
449 |
|
return self.t_table.ReadValue(row, col) |
450 |
|
else: |
451 |
|
return self.table.ReadValue(row, col) |
452 |
|
|
453 |
def copy_to_transient(self): |
def copy_to_transient(self): |
454 |
"""Internal: Create a transient table and copy the data into it""" |
"""Internal: Create a transient table and copy the data into it""" |
455 |
self.t_table = TransientTable(self.transient_db, self) |
self.t_table = TransientTable(self.transient_db, self) |
471 |
if self.t_table is None: |
if self.t_table is None: |
472 |
self.copy_to_transient() |
self.copy_to_transient() |
473 |
return self.t_table.UniqueValues(col) |
return self.t_table.UniqueValues(col) |
474 |
|
|
475 |
|
def SimpleQuery(self, left, comparison, right): |
476 |
|
if self.t_table is None: |
477 |
|
self.copy_to_transient() |
478 |
|
# Make sure to use the column object of the transient table. The |
479 |
|
# left argument is always a column object so we can just ask the |
480 |
|
# t_table for the right object. |
481 |
|
if hasattr(right, "name"): |
482 |
|
return self.t_table.SimpleQuery(self.t_table.Column(left.name), |
483 |
|
comparison, |
484 |
|
self.t_table.Column(right.name)) |
485 |
|
else: |
486 |
|
return self.t_table.SimpleQuery(self.t_table.Column(left.name), |
487 |
|
comparison, right) |
488 |
|
|
489 |
|
def Dependencies(self): |
490 |
|
"""Return a tuple containing the original table""" |
491 |
|
return (self.table,) |