/[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 1009 by frank, Fri May 23 08:26:58 2003 UTC revision 1328 by bh, Tue Jul 1 12:01:58 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 289  class TransientTableBase(table.OldTableI Line 320  class TransientTableBase(table.OldTableI
320          raise NotImplementedError          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 300  class TransientTable(TransientTableBase) Line 331  class TransientTable(TransientTableBase)
331          interface.          interface.
332          """          """
333          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
334          self.title = table.Title()          TitledObject.__init__(self, table.Title())
335          self.create(table)          self.create(table)
336    
     def Title(self):  
         """Return the title of the table.  
   
         The title is the same as that of the original table  
         """  
         return self.title  
   
337      def create(self, table):      def create(self, table):
338          columns = []          columns = []
339          for col in table.Columns():          for col in table.Columns():
# Line 341  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    
# Line 372  class TransientJoinedTable(TransientTabl Line 396  class TransientJoinedTable(TransientTabl
396          else:          else:
397              self.right_field = self.left_field              self.right_field = self.left_field
398          self.outer_join = outer_join          self.outer_join = outer_join
         self.create()  
399    
400      def Title(self):          title = "Join of %(left)s and %(right)s" \
401          """Return the title of the joined table"""                  % {"left": self.left_table.Title(),
402          return "Join of %(left)s and %(right)s" \                     "right": self.right_table.Title()}
403                 % {"left": self.left_table.Title(),          TitledObject.__init__(self, title)
404                    "right": self.right_table.Title()}  
405            self.create()
406    
407      def create(self):      def create(self):
408          """Internal: Create the table with the joined data"""          """Internal: Create the table with the joined data"""
# Line 386  class TransientJoinedTable(TransientTabl Line 410  class TransientJoinedTable(TransientTabl
410    
411          self.right_table.ensure_index(self.right_field)          self.right_table.ensure_index(self.right_field)
412    
413            # determine the internal column names to join on before
414            # coalescing the column information because if the external
415            # column names are the same they will be mapped to the same
416            # internal name afterwards.
417            internal_left_col = self.left_table.orig_to_internal[self.left_field]
418            internal_right_col =self.right_table.orig_to_internal[self.right_field]
419    
420          # Coalesce the column information          # Coalesce the column information
421          visited = {}          visited = {}
422          columns = []          columns = []
# Line 396  class TransientJoinedTable(TransientTabl Line 427  class TransientJoinedTable(TransientTabl
427                  # better solution.                  # better solution.
428                  continue                  continue
429              columns.append(col)              columns.append(col)
430                visited[col.name] = 1
431          TransientTableBase.create(self, columns)          TransientTableBase.create(self, columns)
432    
433          # Copy the joined data to the table.          # Copy the joined data to the table.
# Line 413  class TransientJoinedTable(TransientTabl Line 445  class TransientJoinedTable(TransientTabl
445                     self.left_table.tablename,                     self.left_table.tablename,
446                     join_operator,                     join_operator,
447                     self.right_table.tablename,                     self.right_table.tablename,
448                     self.orig_to_internal[self.left_field],                     internal_left_col,
449                     self.orig_to_internal[self.right_field]))                     internal_right_col))
450          self.db.execute(stmt)          self.db.execute(stmt)
451    
452      def Dependencies(self):      def Dependencies(self):
# Line 422  class TransientJoinedTable(TransientTabl Line 454  class TransientJoinedTable(TransientTabl
454          return self.dependencies          return self.dependencies
455    
456    
457  class AutoTransientTable(table.OldTableInterfaceMixin):  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):
458    
459      """Table that copies data to a transient table on demand.      """Table that copies data to a transient table on demand.
460    
# Line 431  class AutoTransientTable(table.OldTableI Line 463  class AutoTransientTable(table.OldTableI
463      """      """
464    
465      def __init__(self, transient_db, table):      def __init__(self, transient_db, table):
466            TitledObject.__init__(self, table.Title())
467          self.transient_db = transient_db          self.transient_db = transient_db
468          self.table = table          self.table = table
469          self.t_table = None          self.t_table = None
470    
     def Title(self):  
         """Return the title of the table.  
   
         The title is the same as that of the original table.  
         """  
         return self.table.Title()  
   
471      def Columns(self):      def Columns(self):
472          return self.table.Columns()          return self.table.Columns()
473    
# Line 516  class AutoTransientTable(table.OldTableI Line 542  class AutoTransientTable(table.OldTableI
542      def Dependencies(self):      def Dependencies(self):
543          """Return a tuple containing the original table"""          """Return a tuple containing the original table"""
544          return (self.table,)          return (self.table,)
545    
546        def Width(self, col):
547            return self.table.Width(col)
Legend:
Removed from v.1009  
changed lines
  Added in v.1328
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26