Thuban/Model/table.py

# Copyright (c) 2001, 2002, 2003 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.
    """

    # Implementation strategy regarding writing to a DBF file:
    #
    # Most of the time Thuban only needs to read from a table and it is
    # 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 read/write DBF file will be used for
    # 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
    # returns the new values. With two separate objects this wouldn't
    # work because a DBF file object buffers some data

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

        # If true, self.dbf is open for writing.
        self._writable = 0

    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 field_info_by_name(self, fieldName):
        count = self.field_count()

        for i in range(count):
            info = self.field_info(i)
            if info[1] == fieldName:
                return info

        return None

    def field_range(self, fieldName):
        """Finds the first occurences of the minimum and maximum values 
        in the table for the given field.

        This assumes that the standard comparison operators (<, >, etc.)
        will work for the given data.

        Returns a tuple ((min, rec), (max, rec)) where:
            min is the minimum value
            max is the maximum value
            rec is the record number where the value was found. One
                should check that the record number of min is not
                the same as the record number of max.

        Returns None if there are no records

        """


        count = self.record_count()

        if count == 0:
            return None

        rec = self.read_record(0)

        min = rec[fieldName]
        min_rec = 0

        max = rec[fieldName]
        max_rec = 0

        for i in range(1, count):
            rec = self.read_record(i)
            data = rec[fieldName]

            if data < min: 
                min = data
                min_rec = rec
            elif data > max: 
                max = data
                max_rec = rec

        return ((min, min_rec), (max, max_rec))

    def GetUniqueValues(self, fieldName):
        """Return a list of all unique entries in the table for the given
        field name.
        """

        dict = {}

        for i in range(0, self.record_count()):
            rec = self.read_record(i)
            data = rec[fieldName]

            if not dict.has_key(data):
                dict[data] = 0

        return dict.keys()

    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.
        """
        if not self._writable:
            new_dbf = dbflib.DBFFile(self.filename, "r+b")
            self.dbf.close()
            self.dbf = new_dbf
            self._writable = 1
        self.dbf.write_record(record, values)
        self.dbf.commit()

1	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# 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	# Implementation strategy regarding writing to a DBF file:
36	#
37	# Most of the time Thuban only needs to read from a table and it is
38	# important that Thuban can work with read-only files. Therefore the
39	# DBF file is opened only for reading initially. Only when
40	# write_record is called we try to open the DBF file for writing as
41	# well. If that succeeds the read/write DBF file will be used for
42	# all IO afterwards.
43	#
44	# It's important to use the same DBF file object for both reading
45	# and writing to make sure that reading a records after writing
46	# returns the new values. With two separate objects this wouldn't
47	# work because a DBF file object buffers some data
48
49	def __init__(self, filename):
50	self.filename = filename
51	self.dbf = dbflib.DBFFile(filename)
52
53	# If true, self.dbf is open for writing.
54	self._writable = 0
55
56	def Destroy(self):
57	self.dbf.close()
58	self.dbf = None
59
60	def record_count(self):
61	"""Return the number of records"""
62	return self.dbf.record_count()
63
64	def field_count(self):
65	"""Return the number of fields in a record"""
66	return self.dbf.field_count()
67
68	def field_info(self, field):
69	"""Return a tuple (type, name, width, prec) for the field no. field
70
71	type is the data type of the field, name the name, width the
72	field width in characters and prec the decimal precision.
73	"""
74	type, name, width, prec = self.dbf.field_info(field)
75	type = dbflib_fieldtypes[type]
76	return type, name, width, prec
77
78	def field_info_by_name(self, fieldName):
79	count = self.field_count()
80
81	for i in range(count):
82	info = self.field_info(i)
83	if info[1] == fieldName:
84	return info
85
86	return None
87
88	def field_range(self, fieldName):
89	"""Finds the first occurences of the minimum and maximum values
90	in the table for the given field.
91
92	This assumes that the standard comparison operators (<, >, etc.)
93	will work for the given data.
94
95	Returns a tuple ((min, rec), (max, rec)) where:
96	min is the minimum value
97	max is the maximum value
98	rec is the record number where the value was found. One
99	should check that the record number of min is not
100	the same as the record number of max.
101
102	Returns None if there are no records
103
104	"""
105
106
107	count = self.record_count()
108
109	if count == 0:
110	return None
111
112	rec = self.read_record(0)
113
114	min = rec[fieldName]
115	min_rec = 0
116
117	max = rec[fieldName]
118	max_rec = 0
119
120	for i in range(1, count):
121	rec = self.read_record(i)
122	data = rec[fieldName]
123
124	if data < min:
125	min = data
126	min_rec = rec
127	elif data > max:
128	max = data
129	max_rec = rec
130
131	return ((min, min_rec), (max, max_rec))
132
133	def GetUniqueValues(self, fieldName):
134	"""Return a list of all unique entries in the table for the given
135	field name.
136	"""
137
138	dict = {}
139
140	for i in range(0, self.record_count()):
141	rec = self.read_record(i)
142	data = rec[fieldName]
143
144	if not dict.has_key(data):
145	dict[data] = 0
146
147	return dict.keys()
148
149	def read_record(self, record):
150	"""Return the record no. record as a dict mapping field names to values
151	"""
152	return self.dbf.read_record(record)
153
154	def write_record(self, record, values):
155	"""Write the values into the record
156
157	The values parameter may either be a dictionary or a sequence.
158
159	If it's a dictionary the keys must be the names of the fields
160	and their value must have a suitable type. Only the fields
161	actually contained in the dictionary are written. Fields for
162	which there's no item in the dict are not modified.
163
164	If it's a sequence, all fields must be present in the right
165	order.
166	"""
167	if not self._writable:
168	new_dbf = dbflib.DBFFile(self.filename, "r+b")
169	self.dbf.close()
170	self.dbf = new_dbf
171	self._writable = 1
172	self.dbf.write_record(record, values)
173	self.dbf.commit()
174
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision