/[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 839 by bh, Tue May 6 15:54:18 2003 UTC revision 998 by bh, Thu May 22 19:29:39 2003 UTC
# Line 118  class TransientTableBase(table.OldTableI Line 118  class TransientTableBase(table.OldTableI
118    
119          # Build the CREATE TABLE statement and create the table in the          # Build the CREATE TABLE statement and create the table in the
120          # database          # database
121          table_types = []          table_types = ["id INTEGER PRIMARY KEY"]
122          for col in self.columns:          for col in self.columns:
123              table_types.append("%s %s" % (col.internal_name,              table_types.append("%s %s" % (col.internal_name,
124                                            sql_type_map[col.type]))                                            sql_type_map[col.type]))
# 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 205  class TransientTableBase(table.OldTableI Line 240  class TransientTableBase(table.OldTableI
240              result.append(row[0])              result.append(row[0])
241          return result          return result
242    
243        def SimpleQuery(self, left, comparison, right):
244            """Return the indices of all rows that matching a condition.
245    
246            Parameters:
247               left -- The column object for the left side of the comparison
248    
249               comparison -- The comparison operator as a string. It must be
250                             one of '==', '!=', '<', '<=', '>=', '>'
251    
252               right -- The right hand side of the comparison. It must be
253                        either a column object or a value, i.e. a string,
254                        int or float.
255    
256            The return value is a sorted list of the indices of the rows
257            where the condition is true.
258            """
259            if comparison not in ("==", "!=", "<", "<=", ">=", ">"):
260                raise ValueError("Comparison operator %r not allowed" % comparison)
261    
262            if hasattr(right, "internal_name"):
263                right_template = right.internal_name
264                params = ()
265            else:
266                right_template = "%s"
267                params = (right,)
268    
269            query = "SELECT id FROM %s WHERE %s %s %s ORDER BY id;" \
270                    % (self.tablename, left.internal_name, comparison,
271                       right_template)
272    
273            cursor = self.db.cursor()
274            cursor.execute(query, params)
275            result = []
276            while 1:
277                row = cursor.fetchone()
278                if row is None:
279                    break
280                result.append(row[0])
281            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 217  class TransientTable(TransientTableBase) Line 300  class TransientTable(TransientTableBase)
300          interface.          interface.
301          """          """
302          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
303            self.title = table.Title()
304          self.create(table)          self.create(table)
305    
306        def Title(self):
307            """Return the title of the table.
308    
309            The title is the same as that of the original table
310            """
311            return self.title
312    
313      def create(self, table):      def create(self, table):
314          columns = []          columns = []
315          for col in table.Columns():          for col in table.Columns():
# Line 227  class TransientTable(TransientTableBase) Line 318  class TransientTable(TransientTableBase)
318          TransientTableBase.create(self, columns)          TransientTableBase.create(self, columns)
319    
320          # copy the input table to the transient db          # copy the input table to the transient db
321          insert_template = "INSERT INTO %s (%s) VALUES (%s);" \  
322            # A key to insert to use for the formatting of the insert
323            # statement. The key must not be equal to any of the column
324            # names so we construct one by building a string of x's that is
325            # longer than any of the column names
326            id_key = max([len(col.name) for col in self.columns]) * "x"
327    
328            insert_template = "INSERT INTO %s (id, %s) VALUES (%%(%s)s, %s);" \
329                                 % (self.tablename,                                 % (self.tablename,
330                                    ", ".join([col.internal_name                                    ", ".join([col.internal_name
331                                               for col in self.columns]),                                               for col in self.columns]),
332                                      id_key,
333                                    ", ".join(["%%(%s)s" % col.name                                    ", ".join(["%%(%s)s" % col.name
334                                               for col in self.columns]))                                               for col in self.columns]))
335          cursor = self.db.cursor()          cursor = self.db.cursor()
336          for i in range(table.NumRows()):          for i in range(table.NumRows()):
337              cursor.execute(insert_template, table.ReadRowAsDict(i))              row = table.ReadRowAsDict(i)
338                row[id_key] = i
339                cursor.execute(insert_template, row)
340          self.db.conn.commit()          self.db.conn.commit()
341    
342    
# Line 262  class TransientJoinedTable(TransientTabl Line 363  class TransientJoinedTable(TransientTabl
363          names of the input tables without having to create prefixes.          names of the input tables without having to create prefixes.
364          """          """
365          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
366            self.dependencies = (left_table, right_table)
367          self.left_table = left_table.transient_table()          self.left_table = left_table.transient_table()
368          self.left_field = left_field          self.left_field = left_field
369          self.right_table = right_table.transient_table()          self.right_table = right_table.transient_table()
# Line 271  class TransientJoinedTable(TransientTabl Line 373  class TransientJoinedTable(TransientTabl
373              self.right_field = self.left_field              self.right_field = self.left_field
374          self.create()          self.create()
375    
376        def Title(self):
377            """Return the title of the joined table"""
378            return "Join of %(left)s and %(right)s" \
379                   % {"left": self.left_table.Title(),
380                      "right": self.right_table.Title()}
381    
382      def create(self):      def create(self):
383          """Internal: Create the table with the joined data"""          """Internal: Create the table with the joined data"""
384          self.tablename = self.db.new_table_name()          self.tablename = self.db.new_table_name()
# Line 282  class TransientJoinedTable(TransientTabl Line 390  class TransientJoinedTable(TransientTabl
390          columns = []          columns = []
391          for col in self.left_table.columns + self.right_table.columns:          for col in self.left_table.columns + self.right_table.columns:
392              if col.name in visited:              if col.name in visited:
393                    # We can't allow multiple columns with the same original
394                    # name, so omit this one. FIXME: There should be a
395                    # better solution.
396                  continue                  continue
397              columns.append(col)              columns.append(col)
398          TransientTableBase.create(self, columns)          TransientTableBase.create(self, columns)
399    
400          # Copy the joined data to the table.          # Copy the joined data to the table.
401          internal_names = [col.internal_name for col in self.columns]          internal_names = [col.internal_name for col in self.columns]
402          stmt = "INSERT INTO %s (%s) SELECT %s FROM %s JOIN %s ON %s = %s;" \          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
403                 % (self.tablename,                  " JOIN %s ON %s = %s;"
404                    ", ".join(internal_names),                  % (self.tablename,
405                    ", ".join(internal_names),                     ", ".join(internal_names),
406                    self.left_table.tablename,                     self.left_table.tablename,
407                    self.right_table.tablename,                     ", ".join(internal_names),
408                    self.orig_to_internal[self.left_field],                     self.left_table.tablename,
409                    self.orig_to_internal[self.right_field])                     self.right_table.tablename,
410                       self.orig_to_internal[self.left_field],
411                       self.orig_to_internal[self.right_field]))
412          self.db.execute(stmt)          self.db.execute(stmt)
413    
414        def Dependencies(self):
415            """Return a tuple with the two tables the join depends on."""
416            return self.dependencies
417    
418    
419  class AutoTransientTable(table.OldTableInterfaceMixin):  class AutoTransientTable(table.OldTableInterfaceMixin):
420    
# Line 312  class AutoTransientTable(table.OldTableI Line 429  class AutoTransientTable(table.OldTableI
429          self.table = table          self.table = table
430          self.t_table = None          self.t_table = None
431    
432        def Title(self):
433            """Return the title of the table.
434    
435            The title is the same as that of the original table.
436            """
437            return self.table.Title()
438    
439      def Columns(self):      def Columns(self):
440          return self.table.Columns()          return self.table.Columns()
441    
# Line 337  class AutoTransientTable(table.OldTableI Line 461  class AutoTransientTable(table.OldTableI
461          else:          else:
462              return self.table.ReadRowAsDict(record)              return self.table.ReadRowAsDict(record)
463    
464        def ReadValue(self, row, col):
465            """Return the value of the specified row and column
466    
467            The col parameter may be the index of the column or its name.
468            """
469            if self.t_table is not None:
470                return self.t_table.ReadValue(row, col)
471            else:
472                return self.table.ReadValue(row, col)
473    
474      def copy_to_transient(self):      def copy_to_transient(self):
475          """Internal: Create a transient table and copy the data into it"""          """Internal: Create a transient table and copy the data into it"""
476          self.t_table = TransientTable(self.transient_db, self)          self.t_table = TransientTable(self.transient_db, self)
# Line 358  class AutoTransientTable(table.OldTableI Line 492  class AutoTransientTable(table.OldTableI
492          if self.t_table is None:          if self.t_table is None:
493              self.copy_to_transient()              self.copy_to_transient()
494          return self.t_table.UniqueValues(col)          return self.t_table.UniqueValues(col)
495    
496        def SimpleQuery(self, left, comparison, right):
497            if self.t_table is None:
498                self.copy_to_transient()
499            # Make sure to use the column object of the transient table. The
500            # left argument is always a column object so we can just ask the
501            # t_table for the right object.
502            if hasattr(right, "name"):
503                return self.t_table.SimpleQuery(self.t_table.Column(left.name),
504                                                comparison,
505                                                self.t_table.Column(right.name))
506            else:
507                return self.t_table.SimpleQuery(self.t_table.Column(left.name),
508                                                comparison, right)
509    
510        def Dependencies(self):
511            """Return a tuple containing the original table"""
512            return (self.table,)
Legend:
Removed from v.839  
changed lines
  Added in v.998
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26