/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/transientdb.py

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/transientdb.py

Parent Directory | Revision Log | View Patch Patch

-revision 1026 by frank,
Mon May 26 11:46:42 2003 UTC
+revision 1333 by frank,
Tue Jul  1 15:41:08 2003 UTC
 Line 258 
 class TransientTableBase(table.OldTableI
              return None
          if type == sql_type_map[table.FIELDTYPE_DOUBLE]:
-             prec = self.Precision(col)
+             format = "%.12f"
-             format = "%%.%df" % prec
          elif type == sql_type_map[table.FIELDTYPE_INT]:
              format = "%d"
          else:
-Line 272 
 class TransientTableBase(table.OldTableI
+Line 271 
 class TransientTableBase(table.OldTableI
          return max
-     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
      def SimpleQuery(self, left, comparison, right):
          """Return the indices of all rows that matching a condition.
-Line 441 
 class TransientJoinedTable(TitledObject,
+Line 410 
 class TransientJoinedTable(TitledObject,
          self.right_table.ensure_index(self.right_field)
+         # determine the internal column names to join on before
+         # coalescing the column information because if the external
+         # column names are the same they will be mapped to the same
+         # internal name afterwards.
+         internal_left_col = self.left_table.orig_to_internal[self.left_field]
+         internal_right_col = self.right_table.orig_to_internal[self.right_field]
          # Coalesce the column information
          visited = {}
          columns = []
-         for col in self.left_table.columns + self.right_table.columns:
+         newcolumns = []
+         for table, col in (
+             [ (self.left_table.tablename, c) for c in self.left_table.columns ]
+             + [ (self.right_table.tablename, c) for c in self.right_table.columns]):
              if col.name in visited:
-                 # We can't allow multiple columns with the same original
+                 if col.name == self.left_field:
-                 # name, so omit this one. FIXME: There should be a
+                     continue
-                 # better solution.
+                 else:
-                 continue
+                     # We can't allow multiple columns with the same original
-             columns.append(col)
+                     # name, so append '_' to this one until it is unique.
-         TransientTableBase.create(self, columns)
+                     # FIXME: There should be a better solution.
+                     while col.name in visited:
+                         col.name = col.name + '_'
+             columns.append((table, col))
+             newcol = ColumnReference(col.name, col.type,
+                                         "Col%03d" % (len(newcolumns)+1))
+             newcolumns.append(newcol)
+             visited[col.name] = 1
+         TransientTableBase.create(self, newcolumns)
          # Copy the joined data to the table.
-         internal_names = [col.internal_name for col in self.columns]
+         newinternal_names = [col.internal_name for col in self.columns]
+         internal_references = ["%s.%s" % (table, col.internal_name)
+                                                     for table, col in columns]
          if self.outer_join:
              join_operator = 'LEFT OUTER JOIN'
          else:
              join_operator = 'JOIN'
          stmt = ("INSERT INTO %s (id, %s) SELECT %s.id, %s FROM %s"
-                 " %s %s ON %s = %s;"
+                 " %s %s ON %s.%s = %s.%s;"
                  % (self.tablename,
-                    ", ".join(internal_names),
+                    ", ".join(newinternal_names),
                     self.left_table.tablename,
-                    ", ".join(internal_names),
+                    ", ".join(internal_references),
                     self.left_table.tablename,
                     join_operator,
                     self.right_table.tablename,
-                    self.orig_to_internal[self.left_field],
+                    self.left_table.tablename,
-                    self.orig_to_internal[self.right_field]))
+                    internal_left_col,
+                    self.right_table.tablename,
+                    internal_right_col))
          self.db.execute(stmt)
      def Dependencies(self):
-Line 566 
 class AutoTransientTable(TitledObject, t
+Line 557 
 class AutoTransientTable(TitledObject, t
          """Return a tuple containing the original table"""
          return (self.table,)
+     def Width(self, col):
+         return self.table.Width(col)

 Legend:



Removed from v.1026
 


changed lines


 
Added in v.1333
 Legend:



Removed from v.1026
 


changed lines


 
Added in v.1333
-Removed from v.1026
+Added in v.1333

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26