/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/transientdb.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/transientdb.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 841 by bh, Tue May 6 17:12:53 2003 UTC revision 984 by bh, Thu May 22 16:37:48 2003 UTC
# Line 161  class TransientTableBase(table.OldTableI Line 161  class TransientTableBase(table.OldTableI
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]),
# Line 184  class TransientTableBase(table.OldTableI Line 208  class TransientTableBase(table.OldTableI
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
# Line 245  class TransientTableBase(table.OldTableI Line 280  class TransientTableBase(table.OldTableI
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    
# Line 312  class TransientJoinedTable(TransientTabl Line 355  class TransientJoinedTable(TransientTabl
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()
# Line 353  class TransientJoinedTable(TransientTabl Line 397  class TransientJoinedTable(TransientTabl
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    
# Line 392  class AutoTransientTable(table.OldTableI Line 440  class AutoTransientTable(table.OldTableI
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)
# Line 413  class AutoTransientTable(table.OldTableI Line 471  class AutoTransientTable(table.OldTableI
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,)

Legend:
Removed from v.841  
changed lines
  Added in v.984

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26