/[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 933 by jonathan, Tue May 20 15:23:50 2003 UTC revision 1043 by bh, Mon May 26 19:27:15 2003 UTC
# Line 22  import os Line 22  import os
22  import weakref  import weakref
23  from sqlite import connect  from sqlite import connect
24    
25    from base import TitledObject
26    
27  import table  import table
28    
29  sql_type_map = {  sql_type_map = {
# Line 240  class TransientTableBase(table.OldTableI Line 242  class TransientTableBase(table.OldTableI
242              result.append(row[0])              result.append(row[0])
243          return result          return result
244    
245        def Width(self, col):
246            """Return the maximum width of values in the column
247    
248            The return value is the the maximum length of string representation
249            of the values in the column (represented by index or name)."""
250            max = 0
251            
252            type  = self.column_map[col].type
253            iname = self.column_map[col].internal_name
254            cursor = self.db.cursor()
255            cursor.execute("SELECT %s FROM %s;" % (iname, self.tablename))
256            values = [ i[0] for i in cursor.fetchall()]
257            if not values:
258                return None
259    
260            if type == sql_type_map[table.FIELDTYPE_DOUBLE]:
261                format = "%.12f"
262            elif type == sql_type_map[table.FIELDTYPE_INT]:
263                format = "%d"
264            else:
265                format = "%s"
266            for value in values:
267                if value is None: continue
268                l = len(format % value)
269                if l > max:
270                    max = l
271    
272            return max
273    
274      def SimpleQuery(self, left, comparison, right):      def SimpleQuery(self, left, comparison, right):
275          """Return the indices of all rows that matching a condition.          """Return the indices of all rows that matching a condition.
276    
# Line 280  class TransientTableBase(table.OldTableI Line 311  class TransientTableBase(table.OldTableI
311              result.append(row[0])              result.append(row[0])
312          return result          return result
313    
314        def Dependencies(self):
315            """Placeholder for a method in a derived class.
316    
317            Return a sequence with the tables and other data objects that
318            self depends on.
319            """
320            raise NotImplementedError
321    
322    
323  class TransientTable(TransientTableBase):  class TransientTable(TitledObject, TransientTableBase):
324    
325      """A Table in a transient DB that starts as the copy of a Thuban Table."""      """A Table in a transient DB that starts as the copy of a Thuban Table."""
326    
# Line 292  class TransientTable(TransientTableBase) Line 331  class TransientTable(TransientTableBase)
331          interface.          interface.
332          """          """
333          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
334            TitledObject.__init__(self, table.Title())
335          self.create(table)          self.create(table)
336    
337      def create(self, table):      def create(self, table):
# Line 325  class TransientTable(TransientTableBase) Line 365  class TransientTable(TransientTableBase)
365    
366    
367    
368  class TransientJoinedTable(TransientTableBase):  class TransientJoinedTable(TitledObject, TransientTableBase):
369    
370      """A Table in the transient DB that contains a join of two tables"""      """A Table in the transient DB that contains a join of two tables"""
371    
372      def __init__(self, transient_db, left_table, left_field,      def __init__(self, transient_db, left_table, left_field,
373                   right_table, right_field = None):                   right_table, right_field = None, outer_join = False):
374          """Create a new table in the transient DB as a join of two tables.          """Create a new table in the transient DB as a join of two tables.
375    
376          Both input tables, left_table and right_table must have a          Both input tables, left_table and right_table must have a
377          transient_table method that returns a table object for a table          transient_table method that returns a table object for a table
378          in the trnsient database. The join is performed on the condition          in the transient database. The join is performed on the condition
379          that the value of the left_field column the the left table is          that the value of the left_field column the the left table is
380          equal to the value of the right_field in the right_table.          equal to the value of the right_field in the right_table.
381    
# Line 347  class TransientJoinedTable(TransientTabl Line 387  class TransientJoinedTable(TransientTabl
387          names of the input tables without having to create prefixes.          names of the input tables without having to create prefixes.
388          """          """
389          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
390            self.dependencies = (left_table, right_table)
391          self.left_table = left_table.transient_table()          self.left_table = left_table.transient_table()
392          self.left_field = left_field          self.left_field = left_field
393          self.right_table = right_table.transient_table()          self.right_table = right_table.transient_table()
# Line 354  class TransientJoinedTable(TransientTabl Line 395  class TransientJoinedTable(TransientTabl
395              self.right_field = right_field              self.right_field = right_field
396          else:          else:
397              self.right_field = self.left_field              self.right_field = self.left_field
398            self.outer_join = outer_join
399    
400            title = "Join of %(left)s and %(right)s" \
401                    % {"left": self.left_table.Title(),
402                       "right": self.right_table.Title()}
403            TitledObject.__init__(self, title)
404    
405          self.create()          self.create()
406    
407      def create(self):      def create(self):
# Line 376  class TransientJoinedTable(TransientTabl Line 424  class TransientJoinedTable(TransientTabl
424    
425          # Copy the joined data to the table.          # Copy the joined data to the table.
426          internal_names = [col.internal_name for col in self.columns]          internal_names = [col.internal_name for col in self.columns]
427            if self.outer_join:
428                join_operator = 'LEFT OUTER JOIN'
429            else:
430                join_operator = 'JOIN'
431          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
432                  " JOIN %s ON %s = %s;"                  " %s %s ON %s = %s;"
433                  % (self.tablename,                  % (self.tablename,
434                     ", ".join(internal_names),                     ", ".join(internal_names),
435                     self.left_table.tablename,                     self.left_table.tablename,
436                     ", ".join(internal_names),                     ", ".join(internal_names),
437                     self.left_table.tablename,                     self.left_table.tablename,
438                       join_operator,
439                     self.right_table.tablename,                     self.right_table.tablename,
440                     self.orig_to_internal[self.left_field],                     self.orig_to_internal[self.left_field],
441                     self.orig_to_internal[self.right_field]))                     self.orig_to_internal[self.right_field]))
442          self.db.execute(stmt)          self.db.execute(stmt)
443    
444        def Dependencies(self):
445            """Return a tuple with the two tables the join depends on."""
446            return self.dependencies
447    
448    
449  class AutoTransientTable(table.OldTableInterfaceMixin):  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):
450    
451      """Table that copies data to a transient table on demand.      """Table that copies data to a transient table on demand.
452    
# Line 398  class AutoTransientTable(table.OldTableI Line 455  class AutoTransientTable(table.OldTableI
455      """      """
456    
457      def __init__(self, transient_db, table):      def __init__(self, transient_db, table):
458            TitledObject.__init__(self, table.Title())
459          self.transient_db = transient_db          self.transient_db = transient_db
460          self.table = table          self.table = table
461          self.t_table = None          self.t_table = None
# Line 472  class AutoTransientTable(table.OldTableI Line 530  class AutoTransientTable(table.OldTableI
530          else:          else:
531              return self.t_table.SimpleQuery(self.t_table.Column(left.name),              return self.t_table.SimpleQuery(self.t_table.Column(left.name),
532                                              comparison, right)                                              comparison, right)
533    
534        def Dependencies(self):
535            """Return a tuple containing the original table"""
536            return (self.table,)
537    
538        def Width(self, col):
539            return self.table.Width(col)
Legend:
Removed from v.933  
changed lines
  Added in v.1043
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26