Thuban/Model/table.py

# Copyright (c) 2001, 2002 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Classes for handling tables of data.
"""

__version__ = "$Revision$"

import dbflib

# the field types supported by a Table instance.
FIELDTYPE_INT = "int"
FIELDTYPE_STRING = "string"
FIELDTYPE_DOUBLE = "double"


# map the dbflib constants for the field types to our constants
dbflib_fieldtypes = {dbflib.FTString: FIELDTYPE_STRING,
                     dbflib.FTInteger: FIELDTYPE_INT,
                     dbflib.FTDouble: FIELDTYPE_DOUBLE}

class Table:

    """
    Represent a table of data.

    Currently this is basically just a wrapper around dbflib.
    """

    def __init__(self, filename):
        self.filename = filename
        self.dbf = dbflib.DBFFile(filename)

    def Destroy(self):
        self.dbf.close()
        self.dbf = None

    def record_count(self):
        """Return the number of records"""
        return self.dbf.record_count()

    def field_count(self):
        """Return the number of fields in a record"""
        return self.dbf.field_count()

    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.
        """
        type, name, width, prec = self.dbf.field_info(field)
        type = dbflib_fieldtypes[type]
        return type, name, width, prec

    def read_record(self, record):
        """Return the record no. record as a dict mapping field names to values
        """
        return self.dbf.read_record(record)

    def write_record(self, record, values):
        """Write the values into the record

        The values parameter may either be a dictionary or a sequence.

        If it's a dictionary the keys must be the names of the fields
        and their value must have a suitable type. Only the fields
        actually contained in the dictionary are written. Fields for
        which there's no item in the dict are not modified.

        If it's a sequence, all fields must be present in the right
        order.
        """
        writable_dbf = dbflib.DBFFile(self.filename, "r+b")
        writable_dbf.write_record(record, values)
        writable_dbf.close()
1	bh	257	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Classes for handling tables of data.
10			"""
11
12			__version__ = "$Revision$"
13
14			import dbflib
15
16			# the field types supported by a Table instance.
17			FIELDTYPE_INT = "int"
18			FIELDTYPE_STRING = "string"
19			FIELDTYPE_DOUBLE = "double"
20
21
22			# map the dbflib constants for the field types to our constants
23			dbflib_fieldtypes = {dbflib.FTString: FIELDTYPE_STRING,
24			dbflib.FTInteger: FIELDTYPE_INT,
25			dbflib.FTDouble: FIELDTYPE_DOUBLE}
26
27			class Table:
28
29			"""
30			Represent a table of data.
31
32			Currently this is basically just a wrapper around dbflib.
33			"""
34
35			def __init__(self, filename):
36			self.filename = filename
37	bh	284	self.dbf = dbflib.DBFFile(filename)
38	bh	6
39	bh	257	def Destroy(self):
40			self.dbf.close()
41			self.dbf = None
42
43	bh	6	def record_count(self):
44			"""Return the number of records"""
45			return self.dbf.record_count()
46
47			def field_count(self):
48			"""Return the number of fields in a record"""
49			return self.dbf.field_count()
50
51			def field_info(self, field):
52			"""Return a tuple (type, name, width, prec) for the field no. field
53
54			type is the data type of the field, name the name, width the
55			field width in characters and prec the decimal precision.
56			"""
57			type, name, width, prec = self.dbf.field_info(field)
58			type = dbflib_fieldtypes[type]
59			return type, name, width, prec
60
61			def read_record(self, record):
62			"""Return the record no. record as a dict mapping field names to values
63			"""
64			return self.dbf.read_record(record)
65
66	bh	274	def write_record(self, record, values):
67			"""Write the values into the record
68
69			The values parameter may either be a dictionary or a sequence.
70
71			If it's a dictionary the keys must be the names of the fields
72			and their value must have a suitable type. Only the fields
73			actually contained in the dictionary are written. Fields for
74			which there's no item in the dict are not modified.
75
76			If it's a sequence, all fields must be present in the right
77			order.
78			"""
79	bh	284	writable_dbf = dbflib.DBFFile(self.filename, "r+b")
80			writable_dbf.write_record(record, values)
81			writable_dbf.close()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision