/[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 1662 by bh, Wed Aug 27 13:51:01 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 162  class TransientTableBase(table.OldTableI Line 160  class TransientTableBase(table.OldTableI
160          """          """
161          return self.column_map.has_key(col)          return self.column_map.has_key(col)
162    
163      def ReadRowAsDict(self, index):      def RowIdToOrdinal(self, gid):
164            """Return the row ordinal given its id
165    
166            At the moment the transient tables are only used for tables that
167            don't distinguish between row number and row id, so the value is
168            returned unchanged.
169            """
170            return gid
171    
172        def RowOrdinalToId(self, num):
173            """Return the rowid for given its ordinal
174    
175            At the moment the transient tables are only used for tables that
176            don't distinguish between row number and row id, so the value is
177            returned unchanged.
178            """
179            return num
180    
181        def ReadRowAsDict(self, index, row_is_ordinal = 0):
182            """Return the entire row as a dictionary with column names as keys
183    
184            The row_is_ordinal is ignored because at the moment the
185            transient tables are only used for DBF files where it doesn't
186            matter.
187            """
188          # Implementation Strategy: Executing a completely new select          # Implementation Strategy: Executing a completely new select
189          # statement every time this method is called is too slow. The          # statement every time this method is called is too slow. The
190          # most important usage is to read the records more or less          # most important usage is to read the records more or less
# Line 210  class TransientTableBase(table.OldTableI Line 232  class TransientTableBase(table.OldTableI
232          self.read_record_last_row = index          self.read_record_last_row = index
233          return dict(zip(self.orig_names, result))          return dict(zip(self.orig_names, result))
234    
235      def ReadValue(self, row, col):      def ReadValue(self, row, col, row_is_ordinal = 0):
236          """Return the value of the specified row and column          """Return the value of the specified row and column
237    
238          The col parameter may be the index of the column or its name.          The col parameter may be the index of the column or its name.
239    
240            The row_is_ordinal is ignored because at the moment the
241            transient tables are only used for DBF files where it doesn't
242            matter.
243          """          """
244          # Depending on the actual access patterns of the table data, it          # Depending on the actual access patterns of the table data, it
245          # might be a bit faster in some circumstances to not implement          # might be a bit faster in some circumstances to not implement
# Line 245  class TransientTableBase(table.OldTableI Line 271  class TransientTableBase(table.OldTableI
271      def Width(self, col):      def Width(self, col):
272          """Return the maximum width of values in the column          """Return the maximum width of values in the column
273    
274          The return value is the the maximum length of string representation          The return value is the the maximum length of string
275          of the values in the column (represented by index or name)."""          representation of the values in the column (represented by index
276            or name).
277            """
278          max = 0          max = 0
279            
280          type  = self.column_map[col].type          type  = self.column_map[col].type
281          iname = self.column_map[col].internal_name          iname = self.column_map[col].internal_name
282          cursor = self.db.cursor()          cursor = self.db.cursor()
# Line 257  class TransientTableBase(table.OldTableI Line 285  class TransientTableBase(table.OldTableI
285          if not values:          if not values:
286              return None              return None
287    
288          if type == sql_type_map[table.FIELDTYPE_DOUBLE]:          if type == table.FIELDTYPE_DOUBLE:
289              prec = self.Precision(col)              format = "%.12f"
290              format = "%%.%df" % prec          elif type == table.FIELDTYPE_INT:
         elif type == sql_type_map[table.FIELDTYPE_INT]:  
291              format = "%d"              format = "%d"
292          else:          else:
293              format = "%s"              format = "%s"
# Line 272  class TransientTableBase(table.OldTableI Line 299  class TransientTableBase(table.OldTableI
299    
300          return max          return max
301    
     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  
   
302      def SimpleQuery(self, left, comparison, right):      def SimpleQuery(self, left, comparison, right):
303          """Return the indices of all rows that matching a condition.          """Return the indices of all rows that matching a condition.
304    
# Line 410  class TransientJoinedTable(TitledObject, Line 407  class TransientJoinedTable(TitledObject,
407          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
408          equal to the value of the right_field in the right_table.          equal to the value of the right_field in the right_table.
409    
410          The joined table contains all columns of the input tables with          The joined table contains all columns of the input tables,
411          one exception: Any column in the right_table with the same name          however, the column names of the right table may be changed
412          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
413          somewhat of an implementation detail, but is done so that the          currently done by appending a sufficient number of underscores
414          column names of the joined table can be the same as the column          ('_').
         names of the input tables without having to create prefixes.  
415          """          """
416          TransientTableBase.__init__(self, transient_db)          TransientTableBase.__init__(self, transient_db)
417          self.dependencies = (left_table, right_table)          self.dependencies = (left_table, right_table)
# Line 441  class TransientJoinedTable(TitledObject, Line 437  class TransientJoinedTable(TitledObject,
437    
438          self.right_table.ensure_index(self.right_field)          self.right_table.ensure_index(self.right_field)
439    
440            # determine the internal column names to join on before
441            # coalescing the column information because if the external
442            # column names are the same they will be mapped to the same
443            # internal name afterwards.
444            internal_left_col = self.left_table.orig_to_internal[self.left_field]
445            internal_right_col =self.right_table.orig_to_internal[self.right_field]
446    
447          # Coalesce the column information          # Coalesce the column information
448          visited = {}          visited = {}
449          columns = []          columns = []
450          for col in self.left_table.columns + self.right_table.columns:          newcolumns = []
451              if col.name in visited:          for table in (self.left_table, self.right_table):
452                  # We can't allow multiple columns with the same original              for col in table.Columns():
453                  # name, so omit this one. FIXME: There should be a                  colname = col.name
454                  # better solution.                  # We can't allow multiple columns with the same
455                  continue                  # original name, so append '_' to this one until
456              columns.append(col)                  # it is unique.
457          TransientTableBase.create(self, columns)                  # FIXME: There should be a better solution.
458                    while colname in visited:
459                        colname = colname + '_'
460                    columns.append((table.tablename, col))
461                    newcol = ColumnReference(colname, col.type,
462                                                "Col%03d" % (len(newcolumns)+1))
463                    newcolumns.append(newcol)
464                    visited[colname] = 1
465            TransientTableBase.create(self, newcolumns)
466    
467          # Copy the joined data to the table.          # Copy the joined data to the table.
468          internal_names = [col.internal_name for col in self.columns]          newinternal_names = [col.internal_name for col in self.columns]
469            internal_references = ["%s.%s" % (table, col.internal_name)
470                                                        for table, col in columns]
471          if self.outer_join:          if self.outer_join:
472              join_operator = 'LEFT OUTER JOIN'              join_operator = 'LEFT OUTER JOIN'
473          else:          else:
474              join_operator = 'JOIN'              join_operator = 'JOIN'
475          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
476                  " %s %s ON %s = %s;"                  " %s %s ON %s.%s = %s.%s;"
477                  % (self.tablename,                  % (self.tablename,
478                     ", ".join(internal_names),                     ", ".join(newinternal_names),
479                     self.left_table.tablename,                     self.left_table.tablename,
480                     ", ".join(internal_names),                     ", ".join(internal_references),
481                     self.left_table.tablename,                     self.left_table.tablename,
482                     join_operator,                     join_operator,
483                     self.right_table.tablename,                     self.right_table.tablename,
484                     self.orig_to_internal[self.left_field],                     self.left_table.tablename,
485                     self.orig_to_internal[self.right_field]))                     internal_left_col,
486                       self.right_table.tablename,
487                       internal_right_col))
488          self.db.execute(stmt)          self.db.execute(stmt)
489    
490      def Dependencies(self):      def Dependencies(self):
491          """Return a tuple with the two tables the join depends on."""          """Return a tuple with the two tables the join depends on."""
492          return self.dependencies          return self.dependencies
493    
494        def JoinType(self):
495            """Return the type of the join (either 'INNER' or 'LEFT OUTER')"""
496            if self.outer_join:
497                return "LEFT OUTER"
498            else:
499                return "INNER"
500    
501    
502  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):  class AutoTransientTable(TitledObject, table.OldTableInterfaceMixin):
503    
# Line 508  class AutoTransientTable(TitledObject, t Line 530  class AutoTransientTable(TitledObject, t
530      def NumColumns(self):      def NumColumns(self):
531          return self.table.NumColumns()          return self.table.NumColumns()
532    
533      def ReadRowAsDict(self, record):      def RowIdToOrdinal(self, gid):
534            """Return the row ordinal given its id"""
535            if self.t_table is not None:
536                return self.t_table.RowIdToOrdinal(gid)
537            else:
538                return self.table.RowIdToOrdinal(gid)
539    
540        def RowOrdinalToId(self, num):
541            """Return the rowid for given its ordinal"""
542            if self.t_table is not None:
543                return self.t_table.RowOrdinalToId(num)
544            else:
545                return self.table.RowOrdinalToId(num)
546    
547        def ReadRowAsDict(self, record, row_is_ordinal = 0):
548          """Return the record no. record as a dict mapping field names to values          """Return the record no. record as a dict mapping field names to values
549          """          """
550          if self.t_table is not None:          if self.t_table is not None:
551              return self.t_table.ReadRowAsDict(record)              return self.t_table.ReadRowAsDict(record,
552                                                  row_is_ordinal = row_is_ordinal)
553          else:          else:
554              return self.table.ReadRowAsDict(record)              return self.table.ReadRowAsDict(record,
555                                                row_is_ordinal = row_is_ordinal)
556    
557      def ReadValue(self, row, col):      def ReadValue(self, row, col, row_is_ordinal = 0):
558          """Return the value of the specified row and column          """Return the value of the specified row and column
559    
560          The col parameter may be the index of the column or its name.          The col parameter may be the index of the column or its name.
561          """          """
562          if self.t_table is not None:          if self.t_table is not None:
563              return self.t_table.ReadValue(row, col)              return self.t_table.ReadValue(row, col,
564                                              row_is_ordinal = row_is_ordinal)
565          else:          else:
566              return self.table.ReadValue(row, col)              return self.table.ReadValue(row, col,
567                                            row_is_ordinal = row_is_ordinal)
568    
569      def copy_to_transient(self):      def copy_to_transient(self):
570          """Internal: Create a transient table and copy the data into it"""          """Internal: Create a transient table and copy the data into it"""
# Line 566  class AutoTransientTable(TitledObject, t Line 606  class AutoTransientTable(TitledObject, t
606          """Return a tuple containing the original table"""          """Return a tuple containing the original table"""
607          return (self.table,)          return (self.table,)
608    
609        def Width(self, col):
610            return self.table.Width(col)
Legend:
Removed from v.1026  
changed lines
  Added in v.1662
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26