/[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 1026 by frank, Mon May 26 11:46:42 2003 UTC revision 1511 by bh, Tue Jul 29 14:48:57 2003 UTC
# Line 18  __version__ = "$Revision$" Line 18  __version__ = "$Revision$"
18  # $Source$  # $Source$
19  # $Id$  # $Id$
20    
 import os  
 import weakref  
21  from sqlite import connect  from sqlite import connect
22    
23  from base import TitledObject  from base import TitledObject
# Line 245  class TransientTableBase(table.OldTableI Line 243  class TransientTableBase(table.OldTableI
243      def Width(self, col):      def Width(self, col):
244          """Return the maximum width of values in the column          """Return the maximum width of values in the column
245    
246          The return value is the the maximum length of string representation          The return value is the the maximum length of string
247          of the values in the column (represented by index or name)."""          representation of the values in the column (represented by index
248            or name).
249            """
250          max = 0          max = 0
251            
252          type  = self.column_map[col].type          type  = self.column_map[col].type
253          iname = self.column_map[col].internal_name          iname = self.column_map[col].internal_name
254          cursor = self.db.cursor()          cursor = self.db.cursor()
# Line 257  class TransientTableBase(table.OldTableI Line 257  class TransientTableBase(table.OldTableI
257          if not values:          if not values:
258              return None              return None
259    
260          if type == sql_type_map[table.FIELDTYPE_DOUBLE]:          if type == table.FIELDTYPE_DOUBLE:
261              prec = self.Precision(col)              format = "%.12f"
262              format = "%%.%df" % prec          elif type == table.FIELDTYPE_INT:
         elif type == sql_type_map[table.FIELDTYPE_INT]:  
263              format = "%d"              format = "%d"
264          else:          else:
265              format = "%s"              format = "%s"
# Line 272  class TransientTableBase(table.OldTableI Line 271  class TransientTableBase(table.OldTableI
271    
272          return max          return max
273    
     def Precision(self, col):  
         """Return the precision of the column  
   
         The return value is the maximum number of numeric characters after the  
         decimal if column type is double. Else precision zero is returned.  
         The column can be represented by index or name.  
         """  
       
         type  = self.column_map[col].type  
         if type == sql_type_map[table.FIELDTYPE_DOUBLE]:  
             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 0  
               
             max = 0  
             for value in values:  
                 if value is None: continue  
                 l = len(str(value % 1))  
                 if l > max:  
                     max = l  
             if max > 2:  
                 return max - 2  
             else:  
                 return 0  
         else:  
             return 0  
   
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 410  class TransientJoinedTable(TitledObject, Line 379  class TransientJoinedTable(TitledObject,
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    
382          The joined table contains all columns of the input tables with          The joined table contains all columns of the input tables,
383          one exception: Any column in the right_table with the same name          however, the column names of the right table may be changed
384          as one of the columns in the left_table will be omitted. This is          slightly to make them unique in the joined table. This is
385          somewhat of an implementation detail, but is done so that the          currently done by appending a sufficient number of underscores
386          column names of the joined table can be the same as the column          ('_').
         names of the input tables without having to create prefixes.  
387          """          """
388          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
389          self.dependencies = (left_table, right_table)          self.dependencies = (left_table, right_table)
# Line 441  class TransientJoinedTable(TitledObject, Line 409  class TransientJoinedTable(TitledObject,
409    
410          self.right_table.ensure_index(self.right_field)          self.right_table.ensure_index(self.right_field)
411    
412            # determine the internal column names to join on before
413            # coalescing the column information because if the external
414            # column names are the same they will be mapped to the same
415            # internal name afterwards.
416            internal_left_col = self.left_table.orig_to_internal[self.left_field]
417            internal_right_col =self.right_table.orig_to_internal[self.right_field]
418    
419          # Coalesce the column information          # Coalesce the column information
420          visited = {}          visited = {}
421          columns = []          columns = []
422          for col in self.left_table.columns + self.right_table.columns:          newcolumns = []
423              if col.name in visited:          for table in (self.left_table, self.right_table):
424                  # We can't allow multiple columns with the same original              for col in table.Columns():
425                  # name, so omit this one. FIXME: There should be a                  colname = col.name
426                  # better solution.                  # We can't allow multiple columns with the same
427                  continue                  # original name, so append '_' to this one until
428              columns.append(col)                  # it is unique.
429          TransientTableBase.create(self, columns)                  # FIXME: There should be a better solution.
430                    while colname in visited:
431                        colname = colname + '_'
432                    columns.append((table.tablename, col))
433                    newcol = ColumnReference(colname, col.type,
434                                                "Col%03d" % (len(newcolumns)+1))
435                    newcolumns.append(newcol)
436                    visited[colname] = 1
437            TransientTableBase.create(self, newcolumns)
438    
439          # Copy the joined data to the table.          # Copy the joined data to the table.
440          internal_names = [col.internal_name for col in self.columns]          newinternal_names = [col.internal_name for col in self.columns]
441            internal_references = ["%s.%s" % (table, col.internal_name)
442                                                        for table, col in columns]
443          if self.outer_join:          if self.outer_join:
444              join_operator = 'LEFT OUTER JOIN'              join_operator = 'LEFT OUTER JOIN'
445          else:          else:
446              join_operator = 'JOIN'              join_operator = 'JOIN'
447          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
448                  " %s %s ON %s = %s;"                  " %s %s ON %s.%s = %s.%s;"
449                  % (self.tablename,                  % (self.tablename,
450                     ", ".join(internal_names),                     ", ".join(newinternal_names),
451                     self.left_table.tablename,                     self.left_table.tablename,
452                     ", ".join(internal_names),                     ", ".join(internal_references),
453                     self.left_table.tablename,                     self.left_table.tablename,
454                     join_operator,                     join_operator,
455                     self.right_table.tablename,                     self.right_table.tablename,
456                     self.orig_to_internal[self.left_field],                     self.left_table.tablename,
457                     self.orig_to_internal[self.right_field]))                     internal_left_col,
458                       self.right_table.tablename,
459                       internal_right_col))
460          self.db.execute(stmt)          self.db.execute(stmt)
461    
462      def Dependencies(self):      def Dependencies(self):
463          """Return a tuple with the two tables the join depends on."""          """Return a tuple with the two tables the join depends on."""
464          return self.dependencies          return self.dependencies
465    
466        def JoinType(self):
467            """Return the type of the join (either 'INNER' or 'LEFT OUTER')"""
468            if self.outer_join:
469                return "LEFT OUTER"
470            else:
471                return "INNER"
472    
473    
474  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):
475    
# Line 566  class AutoTransientTable(TitledObject, t Line 560  class AutoTransientTable(TitledObject, t
560          """Return a tuple containing the original table"""          """Return a tuple containing the original table"""
561          return (self.table,)          return (self.table,)
562    
563        def Width(self, col):
564            return self.table.Width(col)
Legend:
Removed from v.1026  
changed lines
  Added in v.1511
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26