/[thuban]/branches/WIP-pyshapelib-bramz/test/test_dbf_table.py
ViewVC logotype

Annotation of /branches/WIP-pyshapelib-bramz/test/test_dbf_table.py

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1662 - (hide annotations)
Wed Aug 27 13:51:01 2003 UTC (21 years, 6 months ago) by bh
Original Path: trunk/thuban/test/test_dbf_table.py
File MIME type: text/x-python
File size: 9851 byte(s) 
Make the table interface distinguish between row ids (an integer
that uniquely identifies a row) and row ordinals (a simple row
count from 0 to NumRows() - 1)

* Thuban/Model/postgisdb.py (PostGISTable.RowIdToOrdinal)
(PostGISTable.RowOrdinalToId): New methods to conver between row
ids and row ordinals
(PostGISTable.ReadRowAsDict, PostGISTable.ReadValue): New keyword
parameter row_is_ordinal to indicate whether the row parameter is
the row id or the ordinal

* Thuban/Model/transientdb.py (TransientTableBase.RowIdToOrdinal)
(TransientTableBase.RowOrdinalToId)
(AutoTransientTable.RowIdToOrdinal)
(AutoTransientTable.RowOrdinalToId): Same new methods as in
PostGISTable.
(TransientTableBase.ReadRowAsDict, TransientTableBase.ReadValue)
(AutoTransientTable.ReadRowAsDict, AutoTransientTable.ReadValue):
Same new parameter as in PostGISTable.

* Thuban/Model/table.py (DBFTable.RowIdToOrdinal)
(DBFTable.RowOrdinalToId, MemoryTable.RowIdToOrdinal)
(MemoryTable.RowOrdinalToId): Same new methods as in PostGISTable.
(DBFTable.ReadValue, DBFTable.ReadRowAsDict)
(MemoryTable.ReadValue, MemoryTable.ReadRowAsDict): Same new
parameter as in PostGISTable.

* Thuban/UI/tableview.py (DataTable.RowIdToOrdinal)
(DataTable.RowOrdinalToId): New methods to convert between row ids
and row ordinals.
(TableGrid.SelectRowById): New method to select a row based on its
ID as opposed to its ordinal
(DataTable.GetValue, TableGrid.OnRangeSelect)
(TableGrid.OnSelectCell, LayerTableGrid.select_shapes)
(QueryTableFrame.OnQuery, QueryTableFrame.get_selected)
(LayerTableFrame.__init__): Convert between row ids and row
ordinals as appropriate

* test/postgissupport.py (PostGISDatabase.__init__): Add
doc-string.
(PostGISDatabase.initdb): The optional third item in a tuple in
tables is now a (key, value) list with additional arguments to
pass to upload_shapefile
(upload_shapefile): New parameter gid_offset to allow gids that
are not the same as the shapeids in the shapefile
(PostgreSQLServer.get_default_static_data_db): Use the new
gid_offset to make the gids in landmarks 1000 higher than the
shapeids in the shapefile

* test/test_viewport.py
(TestViewportWithPostGIS.test_find_shape_at_point): Adapt to the
new shapeids in the landmarks table

* test/test_transientdb.py
(TestTransientTable.run_iceland_political_tests)
(TestTransientTable.test_transient_joined_table): Add tests for
the new table methods and new keywords arguments.

* test/test_postgis_db.py
(TestPostGISTable.test_read_row_as_dict_row_count_mode)
(TestPostGISTable.test_read_value_row_count_mode)
(TestPostGISTable.test_row_id_to_ordinal)
(TestPostGISTable.test_row_oridnal_to_id): New test for the new
table methods and the new arguments
(TestPostGISShapestorePoint.test_shapes_in_region)
(TestPostGISShapestorePoint.test_shape_raw_data)
(TestPostGISShapestorePoint.test_shape_points)
(TestPostGISShapestorePoint.test_shape_shapeid)
(TestPostGISShapestorePoint.test_all_shapes)
(TestPostGISTable.test_simple_query)
(TestPostGISTable.test_simple_query)
(TestPostGISTable.test_simple_query)
(TestPostGISTable.test_read_value)
(TestPostGISTable.test_read_row_as_dict): Adapt to the new
shapeids in the landmarks table

* test/test_memory_table.py
(TestMemoryTable.test_read_row_as_dict_row_count_mode)
(TestMemoryTable.test_read_value_row_count_mode)
(TestMemoryTable.test_row_id_to_ordinal)
(TestMemoryTable.test_row_oridnal_to_id): New test for the new
table methods and the new arguments

* test/test_dbf_table.py
(TestDBFTable.test_read_row_as_dict_row_count_mode)
(TestDBFTable.test_read_value_row_count_mode)
(TestDBFTable.test_row_id_to_ordinal)
(TestDBFTable.test_row_oridnal_to_id): New test for the new table
methods and the new arguments
1 bh 818 # Copyright (c) 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     Test the DBFTable class
10     """
11    
12     __version__ = "$Revision$"
13     # $Source$
14     # $Id$
15    
16    
17     import os
18     import unittest
19    
20     import support
21     support.initthuban()
22    
23     from Thuban.Model.table import DBFTable, MemoryTable, \
24 frank 1028 FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING, \
25     table_to_dbf
26 bh 818 import dbflib
27    
28 bh 1042 class TestTableToDBF(unittest.TestCase, support.FileTestMixin):
29 bh 818
30 bh 1042 def test_table_to_dbf(self):
31 bh 1371 """Test table_to_dbf"""
32 bh 1042 memtable = MemoryTable([("type", FIELDTYPE_STRING),
33     ("value", FIELDTYPE_DOUBLE),
34     ("code", FIELDTYPE_INT)],
35     [("UNKNOWN", 0.0, 0),
36     ("Foo", 0.5, -1),
37     ("Foo", 1.0/256, 100),
38     ("bar", 1e10, 17)])
39    
40     filename = self.temp_file_name("test_table_to_dbf.dbf")
41     table_to_dbf(memtable, filename)
42    
43     dbf = dbflib.DBFFile(filename)
44     self.assertEquals(dbf.read_record(2),
45     {'code': 100, 'type': 'Foo', 'value': 0.00390625})
46     self.assertEquals(dbf.field_count(), 3)
47     self.assertEquals(dbf.record_count(), 4)
48     self.assertEquals(dbf.field_info(0),
49     (dbflib.FTString, "type", 7, 0))
50     self.assertEquals(dbf.field_info(1),
51     (dbflib.FTDouble, "value", 24, 12))
52     self.assertEquals(dbf.field_info(2),
53     (dbflib.FTInteger, "code", 3, 0))
54    
55 jonathan 1399 # save selected rows
56     table_to_dbf(memtable, filename, [1, 3])
57    
58     dbf = dbflib.DBFFile(filename)
59     self.assertEquals(dbf.read_record(0),
60     {'code': -1, 'type': 'Foo', 'value': 0.5})
61     self.assertEquals(dbf.field_count(), 3)
62     self.assertEquals(dbf.record_count(), 2)
63     self.assertEquals(dbf.field_info(0),
64     (dbflib.FTString, "type", 7, 0))
65     self.assertEquals(dbf.field_info(1),
66     (dbflib.FTDouble, "value", 24, 12))
67     self.assertEquals(dbf.field_info(2),
68     (dbflib.FTInteger, "code", 3, 0))
69    
70 bh 1371 def test_table_to_dbf_long_col_names(self):
71     """Test table_to_dbf with long column names."""
72     memtable = MemoryTable([("SOME_STRING", FIELDTYPE_STRING),
73     ("SOME_LONG_COLNAME", FIELDTYPE_DOUBLE),
74     ("SOME_LONG_COLNAME_2", FIELDTYPE_DOUBLE)],
75     [("UNKNOWN", 0.0, 0.0),
76     ("Foo", 1.0, 0.0),
77     ("Foo", 478.23482182999999, 0.0),
78     ("bar", -2.25, 1.0)])
79 bh 1042
80 bh 1371 filename = self.temp_file_name("test_table_to_dbf_long_col_names.dbf")
81     table_to_dbf(memtable, filename)
82    
83     dbf = dbflib.DBFFile(filename)
84     self.assertEquals(dbf.read_record(3),
85     {'SOME_STRIN': "bar", 'SOME_LONG_': -2.25,
86     'SOME_LONG1': 1.0})
87    
88 bh 818 class TestDBFTable(unittest.TestCase, support.FileTestMixin):
89    
90     def setUp(self):
91     """Create a new dbf file. The name is in self.filename"""
92     simple = MemoryTable([("type", FIELDTYPE_STRING),
93     ("value", FIELDTYPE_DOUBLE),
94     ("code", FIELDTYPE_INT)],
95     [("UNKNOWN", 0.0, 0),
96     ("Foo", 0.5, -1),
97     ("Foo", 0.25, 100),
98     ("bar", 1e10, 17)])
99    
100     self.filename = self.temp_file_name("test_dbf_read.dbf")
101     table_to_dbf(simple, self.filename)
102    
103     def test_num_rows(self):
104     """Test DBFTable.NumRows()"""
105     table = DBFTable(self.filename)
106     self.assertEquals(table.NumRows(), 4)
107    
108     def test_num_columns(self):
109     """Test DBFTable.NumColumns()"""
110     table = DBFTable(self.filename)
111     self.assertEquals(table.NumColumns(), 3)
112    
113     def test_columns(self):
114     """Test DBFTable.Columns()"""
115     table = DBFTable(self.filename)
116     columns = table.Columns()
117     self.assertEquals(columns[0].name, "type")
118     self.assertEquals(columns[0].type, FIELDTYPE_STRING)
119     self.assertEquals(columns[1].name, "value")
120     self.assertEquals(columns[1].type, FIELDTYPE_DOUBLE)
121     self.assertEquals(columns[2].name, "code")
122     self.assertEquals(columns[2].type, FIELDTYPE_INT)
123    
124     def test_column(self):
125     """Test DBFTable.Column()"""
126     table = DBFTable(self.filename)
127     # The Column method can be called with either an index or a name
128     col = table.Column(2)
129     self.assertEquals(col.name, "code")
130     self.assertEquals(col.type, FIELDTYPE_INT)
131     col = table.Column("value")
132     self.assertEquals(col.name, "value")
133     self.assertEquals(col.type, FIELDTYPE_DOUBLE)
134    
135 bh 839 def test_has_column(self):
136     """Test DBFTable.HasColumn()"""
137     table = DBFTable(self.filename)
138     # HasColumn
139     self.failUnless(table.HasColumn("value"))
140     self.failUnless(table.HasColumn(2))
141     # HasColumn for non-exisiting columns
142     self.failIf(table.HasColumn("non_existing_name"))
143     self.failIf(table.HasColumn(100))
144    
145 bh 818 def test_read_row_as_dict(self):
146     """Test DBFTable.ReadRowAsDict()"""
147     table = DBFTable(self.filename)
148     self.assertEquals(table.ReadRowAsDict(1),
149     {"type": "Foo", "value": 0.5, "code": -1})
150    
151 bh 1662 def test_read_row_as_dict_row_count_mode(self):
152     """Test DBFTable.ReadRowAsDict() row count address mode"""
153     table = DBFTable(self.filename)
154     self.assertEquals(table.ReadRowAsDict(1, row_is_ordinal = 1),
155     {"type": "Foo", "value": 0.5, "code": -1})
156    
157 bh 818 def test_read_value(self):
158     """Test DBFTable.ReadValue()"""
159     table = DBFTable(self.filename)
160     # The column in ReadValue may be given as either name or index
161     self.assertEquals(table.ReadValue(2, 0), "Foo")
162     self.assertEquals(table.ReadValue(3, "code"), 17)
163    
164 bh 1662 def test_read_value_row_count_mode(self):
165     """Test DBFTable.ReadValue() row count address mode"""
166     table = DBFTable(self.filename)
167     # The column in ReadValue may be given as either name or index
168     self.assertEquals(table.ReadValue(2, 0, row_is_ordinal = 1), "Foo")
169     self.assertEquals(table.ReadValue(3, "code", row_is_ordinal = 1), 17)
170    
171     def test_row_id_to_ordinal(self):
172     """Test DBFTable.RowIdToOrdinal()"""
173     table = DBFTable(self.filename)
174     self.assertEquals(table.RowIdToOrdinal(5), 5)
175    
176     def test_row_oridnal_to_id(self):
177     """Test DBFTable.RowOrdinalToId()"""
178     table = DBFTable(self.filename)
179     self.assertEquals(table.RowOrdinalToId(5), 5)
180    
181 bh 818 def test_value_range(self):
182     """Test DBFTable.ValueRange()"""
183     table = DBFTable(self.filename)
184     self.assertEquals(table.ValueRange("code"), (-1, 100))
185     self.assertEquals(table.ValueRange(1), (0, 1e10))
186    
187     def test_unique_values(self):
188     """Test DBFTable.UniqueValues()"""
189     table = DBFTable(self.filename)
190    
191     # The column can be specified by name or index
192     self.assertEquals(table.UniqueValues("type"),
193     ["Foo", "UNKNOWN", "bar"])
194     self.assertEquals(table.UniqueValues(2), [-1, 0, 17, 100])
195    
196 bh 984 def test_dependencies(self):
197     """Test DBFTable.Dependencies()"""
198     # A DBFTable doesn't have dependencies
199     table = DBFTable(self.filename)
200     self.assertEquals(len(table.Dependencies()), 0)
201    
202 bh 994 def test_filename(self):
203     """Test DBFTable.FileName()"""
204     # A DBFTable doesn't have dependencies
205     table = DBFTable(self.filename)
206     self.assertEquals(table.FileName(), self.filename)
207    
208 bh 998 def test_title(self):
209     """Test DBFTable.Title()"""
210     # A DBFTable doesn't have dependencies
211     table = DBFTable(self.filename)
212 bh 1078 self.assertEquals(table.Title(), "test_dbf_read")
213 bh 994
214 bh 998
215 bh 818 class TestDBFTableWriting(unittest.TestCase, support.FileTestMixin):
216    
217     def test_write(self):
218     """Test DBFTable.write_record()"""
219     eq = self.assertEquals
220    
221     # First create a DBF file
222 bh 994 dbffilename = self.temp_file_name("dbftable_write.dbf")
223 bh 818 dbf = dbflib.create(dbffilename)
224     dbf.add_field("NAME", dbflib.FTString, 20, 0)
225     dbf.add_field("INT", dbflib.FTInteger, 10, 0)
226     dbf.add_field("FLOAT", dbflib.FTDouble, 10, 4)
227     dbf.write_record(0, {'NAME': "Weatherwax", "INT":1,
228     "FLOAT":3.1415926535})
229     dbf.close()
230    
231     # Create the table
232     table = DBFTable(dbffilename)
233     record = table.ReadRowAsDict(0)
234     # The FLOAT value is different from above because of rounding
235     eq(record, {'NAME': "Weatherwax", "INT":1, "FLOAT":3.1415999999999999})
236    
237     # change only one field
238     table.write_record(0, {"NAME": "Ogg"})
239     # check whether it has been written immediately
240     dbf = dbflib.DBFFile(dbffilename)
241     control = dbf.read_record(0)
242     eq(control, {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
243     dbf.close()
244    
245     # check whether the table itself returns the new value
246     eq(table.ReadRowAsDict(0),
247     {'NAME': "Ogg", "INT":1, "FLOAT":3.1415999999999999})
248    
249     # Check whether we can specify the record as a tuple
250     table.write_record(0, ("Garlick", 2, 1.5))
251     eq(table.ReadRowAsDict(0), {"NAME": "Garlick", "INT": 2, "FLOAT": 1.5})
252    
253     table.Destroy()
254    
255    
256     if __name__ == "__main__":
257     support.run_tests()

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26