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

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

Parent Directory | Revision Log | View Patch Patch

-revision 467 by jonathan,
Wed Mar  5 18:18:38 2003 UTC
+revision 818 by bh,
Mon May  5 17:18:31 2003 UTC
 Line 1
- # Copyright (c) 2001, 2002 by Intevation GmbH
+ # Copyright (c) 2001, 2002, 2003 by Intevation GmbH
  # Authors:
  # Bernhard Herzog <[email protected]>
+ # Jan-Oliver Wagner <[email protected]>
  #
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
-Line 12 
 Classes for handling tables of data.
+Line 13 
 Classes for handling tables of data.
  __version__ = "$Revision$"
  import dbflib
- from Thuban.common import *
  # the field types supported by a Table instance.
- #FIELDTYPE_INT = "int"
+ FIELDTYPE_INT = "int"
- #FIELDTYPE_STRING = "string"
+ FIELDTYPE_STRING = "string"
- #FIELDTYPE_DOUBLE = "double"
+ FIELDTYPE_DOUBLE = "double"
  # map the dbflib constants for the field types to our constants
 Line 25 
 dbflib_fieldtypes = {dbflib.FTString: FI
                       dbflib.FTInteger: FIELDTYPE_INT,
                       dbflib.FTDouble: FIELDTYPE_DOUBLE}
- class Table:
+ class OldTableInterfaceMixin:
+     """Mixin to implement the old table interface using the new one"""
+     def record_count(self):
+         return self.NumRows()
+     def field_count(self):
+         return self.NumColumns()
+     def field_info(self, field):
+         """Return a tuple (type, name, width, prec) for the field no. field
+         type is the data type of the field, name the name, width the
+         field width in characters and prec the decimal precision. width
+         and prec will be zero if the information returned by the Column
+         method doesn't provide values for them.
+         """
+         col = self.Column(field)
+         return (col.type, col.name,
+                getattr(col, "width", 0), getattr(col, "prec", 0))
+     def field_info_by_name(self, col):
+         try:
+             return self.field_info(col)
+         except KeyError:
+             # FIXME: It may be that field_info raises other exceptions
+             # when the name is not a valid column name.
+             return None
+     def field_range(self, fieldName):
+         min, max = self.ValueRange(fieldName)
+         return ((min, None), (max, None))
+     def GetUniqueValues(self, field):
+         return self.UniqueValues(field)
+     def read_record(self, r):
+         return self.ReadRowAsDict(r)
+ class DBFColumn:
+     """Description of a column in a DBFTable
+     Instances have the following public attributes:
+     name -- Name of the column
+     type -- Type of the column (one of FIELDTYPE_STRING, FIELDTYPE_INT or\
+             FIELDTYPE_DOUBLE)
+     index -- The index of the column
+     width -- the width of the data in the column
+     prec -- The precision of the data (only valid for type == FIELDTYPE_DOUBLE)
      """
-     Represent a table of data.
-     Currently this is basically just a wrapper around dbflib.
+     def __init__(self, name, type, width, prec, index):
+         self.name = name
+         self.type = type
+         self.width = width
+         self.prec = prec
+         self.index = index
+ class DBFTable(OldTableInterfaceMixin):
+     """
+     Table interface for the data in a DBF file
      """
      # Implementation strategy regarding writing to a DBF file:
-Line 39 
 class Table:
+Line 102 
 class Table:
      # important that Thuban can work with read-only files. Therefore the
      # DBF file is opened only for reading initially. Only when
      # write_record is called we try to open the DBF file for writing as
-     # well. If that succeeds the dbf read/write DBF file will be used
+     # well. If that succeeds the read/write DBF file will be used for
-     # for all IO afterwards.
+     # all IO afterwards.
      #
      # It's important to use the same DBF file object for both reading
      # and writing to make sure that reading a records after writing
-Line 54 
 class Table:
+Line 117 
 class Table:
          # If true, self.dbf is open for writing.
          self._writable = 0
-     def Destroy(self):
+         # Create the column information objects
-         self.dbf.close()
+         self.columns = []
-         self.dbf = None
+         self.column_map = {}
+         for i in range(self.NumColumns()):
+             ftype, name, width, prec = self.dbf.field_info(i)
+             ftype = dbflib_fieldtypes[ftype]
+             index = len(self.columns)
+             col = DBFColumn(name, ftype, width, prec, index)
+             self.columns.append(col)
+             self.column_map[name] = col
+             self.column_map[index] = col
-     def record_count(self):
+     def NumRows(self):
-         """Return the number of records"""
+         """Return the number of rows in the table"""
          return self.dbf.record_count()
-     def field_count(self):
+     def NumColumns(self):
-         """Return the number of fields in a record"""
+         """Return the number of columns in the table"""
          return self.dbf.field_count()
-     def field_info(self, field):
+     def Columns(self):
-         """Return a tuple (type, name, width, prec) for the field no. field
+         """Return the table's colum definitions
-         type is the data type of the field, name the name, width the
+         The return value is a sequence of DBFColumn instances, one for
-         field width in characters and prec the decimal precision.
+         each column.
+         """
+         return self.columns
+     def Column(self, col):
+         """Return information about the column given by its name or index
+         The returned object is an instance of DBFColumn
          """
-         type, name, width, prec = self.dbf.field_info(field)
+         return self.column_map[col]
-         type = dbflib_fieldtypes[type]
-         return type, name, width, prec
+     def ReadRowAsDict(self, row):
+         """Return the entire row as a dictionary with column names as keys"""
+         return self.dbf.read_record(row)
-     def field_info_by_name(self, fieldName):
+     def ReadValue(self, row, col):
-         count = self.field_count()
+         """Return the value of the specified row and column
-         for i in range(count):
+         The col parameter may be the index of the column or its name.
-             info = self.field_info(i)
+         """
-             if info[1] == fieldName:
+         return self.dbf.read_record(row)[self.column_map[col].name]
-                 return info
-         return None
+     def ValueRange(self, col):
+         """Return the minimum and maximum values of the values in the column
-     def read_record(self, record):
+         The return value is a tuple (min, max) unless the table is empty
-         """Return the record no. record as a dict mapping field names to values
+         in which case the return value is None.
          """
-         return self.dbf.read_record(record)
+         count = self.NumRows()
+         if count == 0:
+             return None
+         min = max = self.ReadValue(0, col)
+         for i in range(1, count):
+             value = self.ReadValue(i, col)
+             if value < min:
+                 min = value
+             elif value > max:
+                 max = value
+         return (min, max)
+     def UniqueValues(self, col):
+         """Return a sorted list of all unique values in the column col"""
+         dict = {}
+         for i in range(self.NumRows()):
+             value = self.ReadValue(i, col)
+             dict[value] = 0
+         values = dict.keys()
+         values.sort()
+         return values
+     # DBF specific interface parts.
+     def Destroy(self):
+         self.dbf.close()
+         self.dbf = None
      def write_record(self, record, values):
          """Write the values into the record
-Line 112 
 class Table:
+Line 224 
 class Table:
          self.dbf.write_record(record, values)
          self.dbf.commit()
+ # Temporary backwards compatibility
+ Table = DBFTable
+ class MemoryColumn:
+     def __init__(self, name, type, index):
+         self.name = name
+         self.type = type
+         self.index = index
+ class MemoryTable(OldTableInterfaceMixin):
+     """Very simple table implementation that operates on a list of tuples"""
+     def __init__(self, fields, data):
+         """Initialize the MemoryTable
+         Parameters:
+         fields -- List of (name, field_type) pairs
+         data -- List of tuples, one for each row of data
+         """
+         self.data = data
+         # Create the column information objects
+         self.columns = []
+         self.column_map = {}
+         for name, ftype in fields:
+             index = len(self.columns)
+             col = MemoryColumn(name, ftype, index)
+             self.columns.append(col)
+             self.column_map[name] = col
+             self.column_map[index] = col
+     def NumColumns(self):
+         """Return the number of columns in the table"""
+         return len(self.columns)
+     def Column(self, col):
+         """Return information about the column given by its name or index
+         The returned object is an instance of MemoryColumn.
+         """
+         return self.column_map[col]
+     def Columns(self):
+         """Return the table's colum definitions
+         The return value is a sequence of MemoryColumn instances, one
+         for each column.
+         """
+         return self.columns
+     def NumRows(self):
+         """Return the number of rows in the table"""
+         return len(self.data)
+     def ReadValue(self, row, col):
+         """Return the value of the specified row and column
+         The col parameter may be the index of the column or its name.
+         """
+         return self.data[row][self.column_map[col].index]
+     def ReadRowAsDict(self, index):
+         """Return the entire row as a dictionary with column names as keys"""
+         return dict([(col.name, self.data[index][col.index])
+                       for col in self.columns])
+     def ValueRange(self, col):
+         """Return the minimum and maximum values of the values in the column
+         The return value is a tuple (min, max) unless the table is empty
+         in which case the return value is None.
+         """
+         index = self.column_map[col].index
+         values = [row[index] for row in self.data]
+         if not values:
+             return None
+         return min(values), max(values)
+     def UniqueValues(self, col):
+         """Return a sorted list of all unique values in the column col"""
+         dict = {}
+         for i in range(self.NumRows()):
+             value = self.ReadValue(i, col)
+             dict[value] = 0
+         values = dict.keys()
+         values.sort()
+         return values
+     def write_record(self, record, values):
+         # TODO: Check for correct lenght and perhaps also
+         # for correct types in case values is a tuple. How to report problems?
+         # TODO: Allow values to be a dictionary and write the single
+         # fields that are specified.
+         self.data[record] = values

 Legend:



Removed from v.467
 


changed lines


 
Added in v.818
 Legend:



Removed from v.467
 


changed lines


 
Added in v.818
-Removed from v.467
+Added in v.818

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26