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

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

Parent Directory | Revision Log | View Patch Patch

-revision 844 by bh,
Tue May  6 18:05:04 2003 UTC
+revision 1328 by bh,
Tue Jul  1 12:01:58 2003 UTC
 Line 22 
 import os
  import weakref
  from sqlite import connect
+ from base import TitledObject
  import table
  sql_type_map = {
-Line 161 
 class TransientTableBase(table.OldTableI
+Line 163 
 class TransientTableBase(table.OldTableI
          return self.column_map.has_key(col)
      def ReadRowAsDict(self, index):
+         # Implementation Strategy: Executing a completely new select
+         # statement every time this method is called is too slow. The
+         # most important usage is to read the records more or less
+         # sequentially. This happens e.g. when drawing a layer with a
+         # classification where the shapes are drawn in order of the
+         # shape ids. Another pattern is that the same row is requested
+         # several times in a row. This happens in the table view, for
+         # instance.
+         # We can exploit this to make access faster by having one cursor
+         # open all the time and keeping the last row read around in case
+         # the same row is accessed again the next time and if the row
+         # index is larger than the row we have read last we simply fetch
+         # rows from the cursor until we've reached the requested row. If
+         # the requested row index is smaller then we start a new cursor.
+         # FIXME: So far this scheme seems to work well enough. Obvious
+         # improvements would be to start the cursor at exactly the
+         # requested row (should be efficient and easy to do now that the
+         # id is the primary key) and to perhaps to also start a new
+         # cursor if the requested index is much larger than the last row
+         # so that we don't read and discard lots of the rows.
+         # Check whether we have to start a new cursor
          if self.read_record_cursor is None or index <self.read_record_last_row:
              stmt = ("SELECT %s FROM %s;"
                      % (", ".join([c.internal_name for c in self.columns]),
-Line 184 
 class TransientTableBase(table.OldTableI
+Line 210 
 class TransientTableBase(table.OldTableI
          self.read_record_last_row = index
          return dict(zip(self.orig_names, result))
+     def ReadValue(self, row, col):
+         """Return the value of the specified row and column
+         The col parameter may be the index of the column or its name.
+         """
+         # Depending on the actual access patterns of the table data, it
+         # might be a bit faster in some circumstances to not implement
+         # this via ReadRowAsDict, but this simple implementation should
+         # be fast enough for most purposes.
+         return self.ReadRowAsDict(row)[self.column_map[col].name]
      def ValueRange(self, col):
          col = self.column_map[col]
          iname = col.internal_name
-Line 205 
 class TransientTableBase(table.OldTableI
+Line 242 
 class TransientTableBase(table.OldTableI
              result.append(row[0])
          return result
+     def Width(self, col):
+         """Return the maximum width of values in the column
+         The return value is the the maximum length of string representation
+         of the values in the column (represented by index or name)."""
+         max = 0
+         type  = self.column_map[col].type
+         iname = self.column_map[col].internal_name
+         cursor = self.db.cursor()
+         cursor.execute("SELECT %s FROM %s;" % (iname, self.tablename))
+         values = [ i[0] for i in cursor.fetchall()]
+         if not values:
+             return None
+         if type == sql_type_map[table.FIELDTYPE_DOUBLE]:
+             format = "%.12f"
+         elif type == sql_type_map[table.FIELDTYPE_INT]:
+             format = "%d"
+         else:
+             format = "%s"
+         for value in values:
+             if value is None: continue
+             l = len(format % value)
+             if l > max:
+                 max = l
+         return max
      def SimpleQuery(self, left, comparison, right):
          """Return the indices of all rows that matching a condition.
-Line 245 
 class TransientTableBase(table.OldTableI
+Line 311 
 class TransientTableBase(table.OldTableI
              result.append(row[0])
          return result
+     def Dependencies(self):
+         """Placeholder for a method in a derived class.
+         Return a sequence with the tables and other data objects that
+         self depends on.
+         """
+         raise NotImplementedError
- class TransientTable(TransientTableBase):
+ class TransientTable(TitledObject, TransientTableBase):
      """A Table in a transient DB that starts as the copy of a Thuban Table."""
-Line 257 
 class TransientTable(TransientTableBase)
+Line 331 
 class TransientTable(TransientTableBase)
          interface.
          """
          TransientTableBase.__init__(self, transient_db)
+         TitledObject.__init__(self, table.Title())
          self.create(table)
      def create(self, table):
-Line 290 
 class TransientTable(TransientTableBase)
+Line 365 
 class TransientTable(TransientTableBase)
- class TransientJoinedTable(TransientTableBase):
+ class TransientJoinedTable(TitledObject, TransientTableBase):
      """A Table in the transient DB that contains a join of two tables"""
      def __init__(self, transient_db, left_table, left_field,
-                  right_table, right_field = None):
+                  right_table, right_field = None, outer_join = False):
          """Create a new table in the transient DB as a join of two tables.
          Both input tables, left_table and right_table must have a
          transient_table method that returns a table object for a table
-         in the trnsient database. The join is performed on the condition
+         in the transient database. The join is performed on the condition
          that the value of the left_field column the the left table is
          equal to the value of the right_field in the right_table.
-Line 312 
 class TransientJoinedTable(TransientTabl
+Line 387 
 class TransientJoinedTable(TransientTabl
          names of the input tables without having to create prefixes.
          """
          TransientTableBase.__init__(self, transient_db)
+         self.dependencies = (left_table, right_table)
          self.left_table = left_table.transient_table()
          self.left_field = left_field
          self.right_table = right_table.transient_table()
-Line 319 
 class TransientJoinedTable(TransientTabl
+Line 395 
 class TransientJoinedTable(TransientTabl
              self.right_field = right_field
          else:
              self.right_field = self.left_field
+         self.outer_join = outer_join
+         title = "Join of %(left)s and %(right)s" \
+                 % {"left": self.left_table.Title(),
+                    "right": self.right_table.Title()}
+         TitledObject.__init__(self, title)
          self.create()
      def create(self):
-Line 327 
 class TransientJoinedTable(TransientTabl
+Line 410 
 class TransientJoinedTable(TransientTabl
          self.right_table.ensure_index(self.right_field)
+         # determine the internal column names to join on before
+         # coalescing the column information because if the external
+         # column names are the same they will be mapped to the same
+         # internal name afterwards.
+         internal_left_col = self.left_table.orig_to_internal[self.left_field]
+         internal_right_col =self.right_table.orig_to_internal[self.right_field]
          # Coalesce the column information
          visited = {}
          columns = []
-Line 337 
 class TransientJoinedTable(TransientTabl
+Line 427 
 class TransientJoinedTable(TransientTabl
                  # better solution.
                  continue
              columns.append(col)
+             visited[col.name] = 1
          TransientTableBase.create(self, columns)
          # Copy the joined data to the table.
          internal_names = [col.internal_name for col in self.columns]
+         if self.outer_join:
+             join_operator = 'LEFT OUTER JOIN'
+         else:
+             join_operator = 'JOIN'
          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
-                 " JOIN %s ON %s = %s;"
+                 " %s %s ON %s = %s;"
                  % (self.tablename,
                     ", ".join(internal_names),
                     self.left_table.tablename,
                     ", ".join(internal_names),
                     self.left_table.tablename,
+                    join_operator,
                     self.right_table.tablename,
-                    self.orig_to_internal[self.left_field],
+                    internal_left_col,
-                    self.orig_to_internal[self.right_field]))
+                    internal_right_col))
          self.db.execute(stmt)
+     def Dependencies(self):
+         """Return a tuple with the two tables the join depends on."""
+         return self.dependencies
- class AutoTransientTable(table.OldTableInterfaceMixin):
+ class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):
      """Table that copies data to a transient table on demand.
-Line 363 
 class AutoTransientTable(table.OldTableI
+Line 463 
 class AutoTransientTable(table.OldTableI
      """
      def __init__(self, transient_db, table):
+         TitledObject.__init__(self, table.Title())
          self.transient_db = transient_db
          self.table = table
          self.t_table = None
-Line 392 
 class AutoTransientTable(table.OldTableI
+Line 493 
 class AutoTransientTable(table.OldTableI
          else:
              return self.table.ReadRowAsDict(record)
+     def ReadValue(self, row, col):
+         """Return the value of the specified row and column
+         The col parameter may be the index of the column or its name.
+         """
+         if self.t_table is not None:
+             return self.t_table.ReadValue(row, col)
+         else:
+             return self.table.ReadValue(row, col)
      def copy_to_transient(self):
          """Internal: Create a transient table and copy the data into it"""
          self.t_table = TransientTable(self.transient_db, self)
-Line 420 
 class AutoTransientTable(table.OldTableI
+Line 531 
 class AutoTransientTable(table.OldTableI
          # Make sure to use the column object of the transient table. The
          # left argument is always a column object so we can just ask the
          # t_table for the right object.
-         return self.t_table.SimpleQuery(self.t_table.Column(left.name),
+         if hasattr(right, "name"):
-                                         comparison, right)
+             return self.t_table.SimpleQuery(self.t_table.Column(left.name),
+                                             comparison,
+                                             self.t_table.Column(right.name))
+         else:
+             return self.t_table.SimpleQuery(self.t_table.Column(left.name),
+                                             comparison, right)
+     def Dependencies(self):
+         """Return a tuple containing the original table"""
+         return (self.table,)
+     def Width(self, col):
+         return self.table.Width(col)

 Legend:



Removed from v.844
 


changed lines


 
Added in v.1328
 Legend:



Removed from v.844
 


changed lines


 
Added in v.1328
-Removed from v.844
+Added in v.1328

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26