← Back to branch summary

~ubuntu-branches/ubuntu/wily/spatialite/wily-proposed

« back to all changes in this revision

Viewing changes to test/shape_primitives.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-07-14 11:57:46 UTC
  • mfrom: (16.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20150714115746-e2iljfmb5sq7o5hh
Tags: 4.3.0-1
Move from experimental to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/shape_primitives.c
52
52
#include "sqlite3.h"
53
53
#include "spatialite.h"
54
54
 
55
 
void cleanup_shapefile(const char *filename)
 
55
void
 
56
cleanup_shapefile (const char *filename)
56
57
{
57
58
    char nam[1000];
58
 
    
59
 
    if (!filename) {
60
 
        return;
61
 
    }
62
 
    
63
 
    snprintf(nam, 1000, "%s.dbf", filename);
64
 
    unlink(nam);
65
 
    snprintf(nam, 1000, "%s.prj", filename);
66
 
    unlink(nam);
67
 
    snprintf(nam, 1000, "%s.shp", filename);
68
 
    unlink(nam);
69
 
    snprintf(nam, 1000, "%s.shx", filename);
70
 
    unlink(nam);
 
59
 
 
60
    if (!filename)
 
61
      {
 
62
          return;
 
63
      }
 
64
 
 
65
    snprintf (nam, 1000, "%s.dbf", filename);
 
66
    unlink (nam);
 
67
    snprintf (nam, 1000, "%s.prj", filename);
 
68
    unlink (nam);
 
69
    snprintf (nam, 1000, "%s.shp", filename);
 
70
    unlink (nam);
 
71
    snprintf (nam, 1000, "%s.shx", filename);
 
72
    unlink (nam);
71
73
}
72
74
 
73
 
int do_test(sqlite3 *handle)
 
75
int
 
76
do_test (sqlite3 * handle)
74
77
{
75
78
/* testing some DB */
76
 
#ifndef OMIT_ICONV      /* only if ICONV is supported */
77
 
    char *dumpname = __FILE__"dump";
 
79
#ifndef OMIT_ICONV              /* only if ICONV is supported */
 
80
    char *dumpname = __FILE__ "dump";
78
81
    char *err_msg = NULL;
79
82
    int row_count;
80
83
    int ret;
81
84
    gaiaVectorLayersListPtr list;
82
 
        
83
 
    ret = sqlite3_exec (handle, "CREATE TABLE Point_Test (Name TEXT, Description TEXT)", NULL, NULL, &err_msg);
84
 
    if (ret != SQLITE_OK) {
85
 
        fprintf (stderr, "CREATE TABLE error: %s\n", err_msg);
86
 
        sqlite3_free(err_msg);
87
 
        sqlite3_close(handle);
88
 
        return -3;
89
 
    }
90
 
 
91
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Point_Test', 'geomZ', 4326, 'POINT', 'XYZ', 0)", NULL, NULL, &err_msg);
92
 
    if (ret != SQLITE_OK) {
93
 
        fprintf (stderr, "AddGeometryColumn POINT XYZ error: %s\n", err_msg);
94
 
        sqlite3_free(err_msg);
95
 
        sqlite3_close(handle);
96
 
        return -4;
97
 
    }
98
 
    
99
 
    ret = sqlite3_exec (handle, "INSERT INTO Point_Test (Name, Description, geomZ) VALUES ('Point 1', 'Some point', GeomFromText('POINTZ(136 -33 365)', 4326))", NULL, NULL, &err_msg);
100
 
    if (ret != SQLITE_OK) {
101
 
        fprintf (stderr, "INSERT POINT XYZ error: %s\n", err_msg);
102
 
        sqlite3_free(err_msg);
103
 
        sqlite3_close(handle);
104
 
        return -5;
105
 
    }
106
 
    
107
 
    ret = dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8", "POINT", 1, &row_count, err_msg);
108
 
    if (!ret) {
109
 
        fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n", err_msg);
110
 
        sqlite3_close(handle);
111
 
        return -6;
112
 
    }
113
 
    cleanup_shapefile(dumpname);
114
 
    
115
 
    ret = dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8", "MULTIPOINT", 1, &row_count, err_msg);
116
 
    if (!ret) {
117
 
        fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n", err_msg);
118
 
        sqlite3_close(handle);
119
 
        return -7;
120
 
    }
121
 
    cleanup_shapefile(dumpname);
122
 
    
123
 
    ret = dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
124
 
    if (!ret) {
125
 
        fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n", err_msg);
126
 
        sqlite3_close(handle);
127
 
        return -7; /* dupe */
128
 
    }
129
 
    cleanup_shapefile(dumpname);
130
 
    
131
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Point_Test', 'geomM', 4326, 'POINT', 'XYM', 0)", NULL, NULL, &err_msg);
132
 
    if (ret != SQLITE_OK) {
133
 
        fprintf (stderr, "AddGeometryColumn POINT XYM error: %s\n", err_msg);
134
 
        sqlite3_free(err_msg);
135
 
        sqlite3_close(handle);
136
 
        return -8;
137
 
    }
138
 
    
139
 
    ret = sqlite3_exec (handle, "INSERT INTO Point_Test (Name, Description, geomM) VALUES ('Point 2', 'Some pointM', GeomFromText('POINTM(136 -33 26.7)', 4326))", NULL, NULL, &err_msg);
140
 
    if (ret != SQLITE_OK) {
141
 
        fprintf (stderr, "INSERT POINT XYM error: %s\n", err_msg);
142
 
        sqlite3_free(err_msg);
143
 
        sqlite3_close(handle);
144
 
        return -9;
145
 
    }
146
 
    
147
 
    ret = dump_shapefile (handle, "Point_Test", "geomM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
148
 
    if (!ret) {
149
 
        fprintf (stderr, "dump_shapefile() error for POINT XYM: %s\n", err_msg);
150
 
        sqlite3_close(handle);
151
 
        return -10;
152
 
    }
153
 
    cleanup_shapefile(dumpname);
154
 
    
155
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Point_Test', 'geomXY', 4326, 'POINT', 'XY', 0)", NULL, NULL, &err_msg);
156
 
    if (ret != SQLITE_OK) {
157
 
        fprintf (stderr, "AddGeometryColumn POINT XY error: %s\n", err_msg);
158
 
        sqlite3_free(err_msg);
159
 
        sqlite3_close(handle);
160
 
        return -11;
161
 
    }
162
 
    
163
 
    ret = sqlite3_exec (handle, "INSERT INTO Point_Test (Name, Description, geomXY) VALUES ('Point 3', 'Some point', GeomFromText('POINT(136 -33)', 4326))", NULL, NULL, &err_msg);
164
 
    if (ret != SQLITE_OK) {
165
 
        fprintf (stderr, "INSERT POINT XY error: %s\n", err_msg);
166
 
        sqlite3_free(err_msg);
167
 
        sqlite3_close(handle);
168
 
        return -12;
169
 
    }
170
 
    
171
 
    ret = dump_shapefile (handle, "Point_Test", "geomXY", dumpname, "UTF-8", "", 1, &row_count, err_msg);
172
 
    if (!ret) {
173
 
        fprintf (stderr, "dump_shapefile() error for POINT XY: %s\n", err_msg);
174
 
        sqlite3_close(handle);
175
 
        return -13;
176
 
    }
177
 
    cleanup_shapefile(dumpname);
178
 
    
179
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Point_Test', 'geomXYZM', 4326, 'POINT', 'XYZM', 0)", NULL, NULL, &err_msg);
180
 
    if (ret != SQLITE_OK) {
181
 
        fprintf (stderr, "AddGeometryColumn POINT XYZM error: %s\n", err_msg);
182
 
        sqlite3_free(err_msg);
183
 
        sqlite3_close(handle);
184
 
        return -14;
185
 
    }
186
 
    
187
 
    ret = sqlite3_exec (handle, "INSERT INTO Point_Test (Name, Description, geomXYZM) VALUES ('Point 4', 'Some pointXYZM', GeomFromText('POINT(136 -33 424 233.2)', 4326))", NULL, NULL, &err_msg);
188
 
    if (ret != SQLITE_OK) {
189
 
        fprintf (stderr, "INSERT POINT XYZM error: %s\n", err_msg);
190
 
        sqlite3_free(err_msg);
191
 
        sqlite3_close(handle);
192
 
        return -15;
193
 
    }
194
 
    
195
 
    ret = dump_shapefile (handle, "Point_Test", "geomXYZM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
196
 
    if (!ret) {
197
 
        fprintf (stderr, "dump_shapefile() error for POINT XYZM: %s\n", err_msg);
198
 
        sqlite3_close(handle);
199
 
        return -16;
200
 
    }
201
 
    cleanup_shapefile(dumpname);
202
 
    
 
85
 
 
86
    ret =
 
87
        sqlite3_exec (handle,
 
88
                      "CREATE TABLE Point_Test (Name TEXT, Description TEXT)",
 
89
                      NULL, NULL, &err_msg);
 
90
    if (ret != SQLITE_OK)
 
91
      {
 
92
          fprintf (stderr, "CREATE TABLE error: %s\n", err_msg);
 
93
          sqlite3_free (err_msg);
 
94
          sqlite3_close (handle);
 
95
          return -3;
 
96
      }
 
97
 
 
98
    ret =
 
99
        sqlite3_exec (handle,
 
100
                      "SELECT AddGeometryColumn('Point_Test', 'geomZ', 4326, 'POINT', 'XYZ', 0)",
 
101
                      NULL, NULL, &err_msg);
 
102
    if (ret != SQLITE_OK)
 
103
      {
 
104
          fprintf (stderr, "AddGeometryColumn POINT XYZ error: %s\n", err_msg);
 
105
          sqlite3_free (err_msg);
 
106
          sqlite3_close (handle);
 
107
          return -4;
 
108
      }
 
109
 
 
110
    ret =
 
111
        sqlite3_exec (handle,
 
112
                      "INSERT INTO Point_Test (Name, Description, geomZ) VALUES ('Point 1', 'Some point', GeomFromText('POINTZ(136 -33 365)', 4326))",
 
113
                      NULL, NULL, &err_msg);
 
114
    if (ret != SQLITE_OK)
 
115
      {
 
116
          fprintf (stderr, "INSERT POINT XYZ error: %s\n", err_msg);
 
117
          sqlite3_free (err_msg);
 
118
          sqlite3_close (handle);
 
119
          return -5;
 
120
      }
 
121
 
 
122
    ret =
 
123
        dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8",
 
124
                        "POINT", 1, &row_count, err_msg);
 
125
    if (!ret)
 
126
      {
 
127
          fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n",
 
128
                   err_msg);
 
129
          sqlite3_close (handle);
 
130
          return -6;
 
131
      }
 
132
    cleanup_shapefile (dumpname);
 
133
 
 
134
    ret =
 
135
        dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8",
 
136
                        "MULTIPOINT", 1, &row_count, err_msg);
 
137
    if (!ret)
 
138
      {
 
139
          fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n",
 
140
                   err_msg);
 
141
          sqlite3_close (handle);
 
142
          return -7;
 
143
      }
 
144
    cleanup_shapefile (dumpname);
 
145
 
 
146
    ret =
 
147
        dump_shapefile (handle, "Point_Test", "geomZ", dumpname, "UTF-8", "", 1,
 
148
                        &row_count, err_msg);
 
149
    if (!ret)
 
150
      {
 
151
          fprintf (stderr, "dump_shapefile() error for POINT XYZ: %s\n",
 
152
                   err_msg);
 
153
          sqlite3_close (handle);
 
154
          return -7;            /* dupe */
 
155
      }
 
156
    cleanup_shapefile (dumpname);
 
157
 
 
158
    ret =
 
159
        sqlite3_exec (handle,
 
160
                      "SELECT AddGeometryColumn('Point_Test', 'geomM', 4326, 'POINT', 'XYM', 0)",
 
161
                      NULL, NULL, &err_msg);
 
162
    if (ret != SQLITE_OK)
 
163
      {
 
164
          fprintf (stderr, "AddGeometryColumn POINT XYM error: %s\n", err_msg);
 
165
          sqlite3_free (err_msg);
 
166
          sqlite3_close (handle);
 
167
          return -8;
 
168
      }
 
169
 
 
170
    ret =
 
171
        sqlite3_exec (handle,
 
172
                      "INSERT INTO Point_Test (Name, Description, geomM) VALUES ('Point 2', 'Some pointM', GeomFromText('POINTM(136 -33 26.7)', 4326))",
 
173
                      NULL, NULL, &err_msg);
 
174
    if (ret != SQLITE_OK)
 
175
      {
 
176
          fprintf (stderr, "INSERT POINT XYM error: %s\n", err_msg);
 
177
          sqlite3_free (err_msg);
 
178
          sqlite3_close (handle);
 
179
          return -9;
 
180
      }
 
181
 
 
182
    ret =
 
183
        dump_shapefile (handle, "Point_Test", "geomM", dumpname, "UTF-8", "", 1,
 
184
                        &row_count, err_msg);
 
185
    if (!ret)
 
186
      {
 
187
          fprintf (stderr, "dump_shapefile() error for POINT XYM: %s\n",
 
188
                   err_msg);
 
189
          sqlite3_close (handle);
 
190
          return -10;
 
191
      }
 
192
    cleanup_shapefile (dumpname);
 
193
 
 
194
    ret =
 
195
        sqlite3_exec (handle,
 
196
                      "SELECT AddGeometryColumn('Point_Test', 'geomXY', 4326, 'POINT', 'XY', 0)",
 
197
                      NULL, NULL, &err_msg);
 
198
    if (ret != SQLITE_OK)
 
199
      {
 
200
          fprintf (stderr, "AddGeometryColumn POINT XY error: %s\n", err_msg);
 
201
          sqlite3_free (err_msg);
 
202
          sqlite3_close (handle);
 
203
          return -11;
 
204
      }
 
205
 
 
206
    ret =
 
207
        sqlite3_exec (handle,
 
208
                      "INSERT INTO Point_Test (Name, Description, geomXY) VALUES ('Point 3', 'Some point', GeomFromText('POINT(136 -33)', 4326))",
 
209
                      NULL, NULL, &err_msg);
 
210
    if (ret != SQLITE_OK)
 
211
      {
 
212
          fprintf (stderr, "INSERT POINT XY error: %s\n", err_msg);
 
213
          sqlite3_free (err_msg);
 
214
          sqlite3_close (handle);
 
215
          return -12;
 
216
      }
 
217
 
 
218
    ret =
 
219
        dump_shapefile (handle, "Point_Test", "geomXY", dumpname, "UTF-8", "",
 
220
                        1, &row_count, err_msg);
 
221
    if (!ret)
 
222
      {
 
223
          fprintf (stderr, "dump_shapefile() error for POINT XY: %s\n",
 
224
                   err_msg);
 
225
          sqlite3_close (handle);
 
226
          return -13;
 
227
      }
 
228
    cleanup_shapefile (dumpname);
 
229
 
 
230
    ret =
 
231
        sqlite3_exec (handle,
 
232
                      "SELECT AddGeometryColumn('Point_Test', 'geomXYZM', 4326, 'POINT', 'XYZM', 0)",
 
233
                      NULL, NULL, &err_msg);
 
234
    if (ret != SQLITE_OK)
 
235
      {
 
236
          fprintf (stderr, "AddGeometryColumn POINT XYZM error: %s\n", err_msg);
 
237
          sqlite3_free (err_msg);
 
238
          sqlite3_close (handle);
 
239
          return -14;
 
240
      }
 
241
 
 
242
    ret =
 
243
        sqlite3_exec (handle,
 
244
                      "INSERT INTO Point_Test (Name, Description, geomXYZM) VALUES ('Point 4', 'Some pointXYZM', GeomFromText('POINT(136 -33 424 233.2)', 4326))",
 
245
                      NULL, NULL, &err_msg);
 
246
    if (ret != SQLITE_OK)
 
247
      {
 
248
          fprintf (stderr, "INSERT POINT XYZM error: %s\n", err_msg);
 
249
          sqlite3_free (err_msg);
 
250
          sqlite3_close (handle);
 
251
          return -15;
 
252
      }
 
253
 
 
254
    ret =
 
255
        dump_shapefile (handle, "Point_Test", "geomXYZM", dumpname, "UTF-8", "",
 
256
                        1, &row_count, err_msg);
 
257
    if (!ret)
 
258
      {
 
259
          fprintf (stderr, "dump_shapefile() error for POINT XYZM: %s\n",
 
260
                   err_msg);
 
261
          sqlite3_close (handle);
 
262
          return -16;
 
263
      }
 
264
    cleanup_shapefile (dumpname);
 
265
 
203
266
    ret = sqlite3_exec (handle, "DROP TABLE Point_Test", NULL, NULL, &err_msg);
204
 
    if (ret != SQLITE_OK) {
205
 
        fprintf (stderr, "DROP TABLE Point_Test error: %s\n", err_msg);
206
 
        sqlite3_free(err_msg);
207
 
        sqlite3_close(handle);
208
 
        return -20;
209
 
    }
210
 
    
211
 
    ret = sqlite3_exec (handle, "CREATE TABLE MPoint_Test (Name TEXT, Description TEXT)", NULL, NULL, &err_msg);
212
 
    if (ret != SQLITE_OK) {
213
 
        fprintf (stderr, "CREATE TABLE MPoint_Test error: %s\n", err_msg);
214
 
        sqlite3_free(err_msg);
215
 
        sqlite3_close(handle);
216
 
        return -21;
217
 
    }
218
 
 
219
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('MPoint_Test', 'geom', 4326, 'MULTIPOINT', 'XY', 0)", NULL, NULL, &err_msg);
220
 
    if (ret != SQLITE_OK) {
221
 
        fprintf (stderr, "AddGeometryColumn MPOINT XY error: %s\n", err_msg);
222
 
        sqlite3_free(err_msg);
223
 
        sqlite3_close(handle);
224
 
        return -22;
225
 
    }
226
 
    
227
 
    ret = sqlite3_exec (handle, "INSERT INTO MPoint_Test (Name, Description, geom) VALUES ('Point 1', 'Some point', GeomFromText('MULTIPOINT(136 -33, 47 2, -20, 12)', 4326))", NULL, NULL, &err_msg);
228
 
    if (ret != SQLITE_OK) {
229
 
        fprintf (stderr, "INSERT MPOINT XY error: %s\n", err_msg);
230
 
        sqlite3_free(err_msg);
231
 
        sqlite3_close(handle);
232
 
        return -23;
233
 
    }
234
 
    
235
 
    ret = dump_shapefile (handle, "MPoint_Test", "geom", dumpname, "UTF-8", "MULTIPOINT", 1, &row_count, err_msg);
236
 
    if (!ret) {
237
 
        fprintf (stderr, "dump_shapefile() error for MPOINT XY: %s\n", err_msg);
238
 
        sqlite3_close(handle);
239
 
        return -24;
240
 
    }
241
 
    cleanup_shapefile(dumpname);
242
 
    
243
 
    ret = dump_shapefile (handle, "MPoint_Test", "geom", dumpname, "UTF-8", "", 1, &row_count, err_msg);
244
 
    if (!ret) {
245
 
        fprintf (stderr, "dump_shapefile() error for MPOINT XY: %s\n", err_msg);
246
 
        sqlite3_close(handle);
247
 
        return -25;
248
 
    }
249
 
    cleanup_shapefile(dumpname);
250
 
    
251
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('MPoint_Test', 'geomZ', 4326, 'MULTIPOINT', 'XYZ', 0)", NULL, NULL, &err_msg);
252
 
    if (ret != SQLITE_OK) {
253
 
        fprintf (stderr, "AddGeometryColumn MPOINT XYZ error: %s\n", err_msg);
254
 
        sqlite3_free(err_msg);
255
 
        sqlite3_close(handle);
256
 
        return -26;
257
 
    }
258
 
    
259
 
    ret = sqlite3_exec (handle, "INSERT INTO MPoint_Test (Name, Description, geomZ) VALUES ('Point 2', 'Some pointZ', GeomFromText('MULTIPOINTZ(136 -33 1, 47 2 2, -20, 12 3)', 4326))", NULL, NULL, &err_msg);
260
 
    if (ret != SQLITE_OK) {
261
 
        fprintf (stderr, "INSERT MPOINT XYZ error: %s\n", err_msg);
262
 
        sqlite3_free(err_msg);
263
 
        sqlite3_close(handle);
264
 
        return -27;
265
 
    }
266
 
    
267
 
    ret = dump_shapefile (handle, "MPoint_Test", "geomZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
268
 
    if (!ret) {
269
 
        fprintf (stderr, "dump_shapefile() error for MPOINT XYZ: %s\n", err_msg);
270
 
        sqlite3_close(handle);
271
 
        return -28;
272
 
    }
273
 
    cleanup_shapefile(dumpname);
274
 
    
275
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('MPoint_Test', 'geomM', 4326, 'MULTIPOINT', 'XYM', 0)", NULL, NULL, &err_msg);
276
 
    if (ret != SQLITE_OK) {
277
 
        fprintf (stderr, "AddGeometryColumn MPOINT XYM error: %s\n", err_msg);
278
 
        sqlite3_free(err_msg);
279
 
        sqlite3_close(handle);
280
 
        return -29;
281
 
    }
282
 
    
283
 
    ret = sqlite3_exec (handle, "INSERT INTO MPoint_Test (Name, Description, geomM) VALUES ('Point 3', 'Some pointM', GeomFromText('MULTIPOINTM(136 -33 1, 47 2 2, -20, 12 3)', 4326))", NULL, NULL, &err_msg);
284
 
    if (ret != SQLITE_OK) {
285
 
        fprintf (stderr, "INSERT MPOINT XYM error: %s\n", err_msg);
286
 
        sqlite3_free(err_msg);
287
 
        sqlite3_close(handle);
288
 
        return -30;
289
 
    }
290
 
    
291
 
    ret = dump_shapefile (handle, "MPoint_Test", "geomM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
292
 
    if (!ret) {
293
 
        fprintf (stderr, "dump_shapefile() error for MPOINT XYM: %s\n", err_msg);
294
 
        sqlite3_close(handle);
295
 
        return -31;
296
 
    }
297
 
    cleanup_shapefile(dumpname);
298
 
 
299
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('MPoint_Test', 'geomMZ', 4326, 'MULTIPOINT', 'XYZM', 0)", NULL, NULL, &err_msg);
300
 
    if (ret != SQLITE_OK) {
301
 
        fprintf (stderr, "AddGeometryColumn MPOINT XYZM error: %s\n", err_msg);
302
 
        sqlite3_free(err_msg);
303
 
        sqlite3_close(handle);
304
 
        return -32;
305
 
    }
306
 
    
307
 
    ret = sqlite3_exec (handle, "INSERT INTO MPoint_Test (Name, Description, geomMZ) VALUES ('Point 4', 'Some pointMZ', GeomFromText('MULTIPOINTMZ(136 -33 1 4.2, 47 2 2.3 1, -20, 12 3 -2)', 4326))", NULL, NULL, &err_msg);
308
 
    if (ret != SQLITE_OK) {
309
 
        fprintf (stderr, "INSERT MPOINT XYZM error: %s\n", err_msg);
310
 
        sqlite3_free(err_msg);
311
 
        sqlite3_close(handle);
312
 
        return -33;
313
 
    }
314
 
    
315
 
    ret = dump_shapefile (handle, "MPoint_Test", "geomMZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
316
 
    if (!ret) {
317
 
        fprintf (stderr, "dump_shapefile() error for MPOINT XYZM %s\n", err_msg);
318
 
        sqlite3_close(handle);
319
 
        return -34;
320
 
    }
321
 
    cleanup_shapefile(dumpname);
322
 
    
 
267
    if (ret != SQLITE_OK)
 
268
      {
 
269
          fprintf (stderr, "DROP TABLE Point_Test error: %s\n", err_msg);
 
270
          sqlite3_free (err_msg);
 
271
          sqlite3_close (handle);
 
272
          return -20;
 
273
      }
 
274
 
 
275
    ret =
 
276
        sqlite3_exec (handle,
 
277
                      "CREATE TABLE MPoint_Test (Name TEXT, Description TEXT)",
 
278
                      NULL, NULL, &err_msg);
 
279
    if (ret != SQLITE_OK)
 
280
      {
 
281
          fprintf (stderr, "CREATE TABLE MPoint_Test error: %s\n", err_msg);
 
282
          sqlite3_free (err_msg);
 
283
          sqlite3_close (handle);
 
284
          return -21;
 
285
      }
 
286
 
 
287
    ret =
 
288
        sqlite3_exec (handle,
 
289
                      "SELECT AddGeometryColumn('MPoint_Test', 'geom', 4326, 'MULTIPOINT', 'XY', 0)",
 
290
                      NULL, NULL, &err_msg);
 
291
    if (ret != SQLITE_OK)
 
292
      {
 
293
          fprintf (stderr, "AddGeometryColumn MPOINT XY error: %s\n", err_msg);
 
294
          sqlite3_free (err_msg);
 
295
          sqlite3_close (handle);
 
296
          return -22;
 
297
      }
 
298
 
 
299
    ret =
 
300
        sqlite3_exec (handle,
 
301
                      "INSERT INTO MPoint_Test (Name, Description, geom) VALUES ('Point 1', 'Some point', GeomFromText('MULTIPOINT(136 -33, 47 2, -20, 12)', 4326))",
 
302
                      NULL, NULL, &err_msg);
 
303
    if (ret != SQLITE_OK)
 
304
      {
 
305
          fprintf (stderr, "INSERT MPOINT XY error: %s\n", err_msg);
 
306
          sqlite3_free (err_msg);
 
307
          sqlite3_close (handle);
 
308
          return -23;
 
309
      }
 
310
 
 
311
    ret =
 
312
        dump_shapefile (handle, "MPoint_Test", "geom", dumpname, "UTF-8",
 
313
                        "MULTIPOINT", 1, &row_count, err_msg);
 
314
    if (!ret)
 
315
      {
 
316
          fprintf (stderr, "dump_shapefile() error for MPOINT XY: %s\n",
 
317
                   err_msg);
 
318
          sqlite3_close (handle);
 
319
          return -24;
 
320
      }
 
321
    cleanup_shapefile (dumpname);
 
322
 
 
323
    ret =
 
324
        dump_shapefile (handle, "MPoint_Test", "geom", dumpname, "UTF-8", "", 1,
 
325
                        &row_count, err_msg);
 
326
    if (!ret)
 
327
      {
 
328
          fprintf (stderr, "dump_shapefile() error for MPOINT XY: %s\n",
 
329
                   err_msg);
 
330
          sqlite3_close (handle);
 
331
          return -25;
 
332
      }
 
333
    cleanup_shapefile (dumpname);
 
334
 
 
335
    ret =
 
336
        sqlite3_exec (handle,
 
337
                      "SELECT AddGeometryColumn('MPoint_Test', 'geomZ', 4326, 'MULTIPOINT', 'XYZ', 0)",
 
338
                      NULL, NULL, &err_msg);
 
339
    if (ret != SQLITE_OK)
 
340
      {
 
341
          fprintf (stderr, "AddGeometryColumn MPOINT XYZ error: %s\n", err_msg);
 
342
          sqlite3_free (err_msg);
 
343
          sqlite3_close (handle);
 
344
          return -26;
 
345
      }
 
346
 
 
347
    ret =
 
348
        sqlite3_exec (handle,
 
349
                      "INSERT INTO MPoint_Test (Name, Description, geomZ) VALUES ('Point 2', 'Some pointZ', GeomFromText('MULTIPOINTZ(136 -33 1, 47 2 2, -20, 12 3)', 4326))",
 
350
                      NULL, NULL, &err_msg);
 
351
    if (ret != SQLITE_OK)
 
352
      {
 
353
          fprintf (stderr, "INSERT MPOINT XYZ error: %s\n", err_msg);
 
354
          sqlite3_free (err_msg);
 
355
          sqlite3_close (handle);
 
356
          return -27;
 
357
      }
 
358
 
 
359
    ret =
 
360
        dump_shapefile (handle, "MPoint_Test", "geomZ", dumpname, "UTF-8", "",
 
361
                        1, &row_count, err_msg);
 
362
    if (!ret)
 
363
      {
 
364
          fprintf (stderr, "dump_shapefile() error for MPOINT XYZ: %s\n",
 
365
                   err_msg);
 
366
          sqlite3_close (handle);
 
367
          return -28;
 
368
      }
 
369
    cleanup_shapefile (dumpname);
 
370
 
 
371
    ret =
 
372
        sqlite3_exec (handle,
 
373
                      "SELECT AddGeometryColumn('MPoint_Test', 'geomM', 4326, 'MULTIPOINT', 'XYM', 0)",
 
374
                      NULL, NULL, &err_msg);
 
375
    if (ret != SQLITE_OK)
 
376
      {
 
377
          fprintf (stderr, "AddGeometryColumn MPOINT XYM error: %s\n", err_msg);
 
378
          sqlite3_free (err_msg);
 
379
          sqlite3_close (handle);
 
380
          return -29;
 
381
      }
 
382
 
 
383
    ret =
 
384
        sqlite3_exec (handle,
 
385
                      "INSERT INTO MPoint_Test (Name, Description, geomM) VALUES ('Point 3', 'Some pointM', GeomFromText('MULTIPOINTM(136 -33 1, 47 2 2, -20, 12 3)', 4326))",
 
386
                      NULL, NULL, &err_msg);
 
387
    if (ret != SQLITE_OK)
 
388
      {
 
389
          fprintf (stderr, "INSERT MPOINT XYM error: %s\n", err_msg);
 
390
          sqlite3_free (err_msg);
 
391
          sqlite3_close (handle);
 
392
          return -30;
 
393
      }
 
394
 
 
395
    ret =
 
396
        dump_shapefile (handle, "MPoint_Test", "geomM", dumpname, "UTF-8", "",
 
397
                        1, &row_count, err_msg);
 
398
    if (!ret)
 
399
      {
 
400
          fprintf (stderr, "dump_shapefile() error for MPOINT XYM: %s\n",
 
401
                   err_msg);
 
402
          sqlite3_close (handle);
 
403
          return -31;
 
404
      }
 
405
    cleanup_shapefile (dumpname);
 
406
 
 
407
    ret =
 
408
        sqlite3_exec (handle,
 
409
                      "SELECT AddGeometryColumn('MPoint_Test', 'geomMZ', 4326, 'MULTIPOINT', 'XYZM', 0)",
 
410
                      NULL, NULL, &err_msg);
 
411
    if (ret != SQLITE_OK)
 
412
      {
 
413
          fprintf (stderr, "AddGeometryColumn MPOINT XYZM error: %s\n",
 
414
                   err_msg);
 
415
          sqlite3_free (err_msg);
 
416
          sqlite3_close (handle);
 
417
          return -32;
 
418
      }
 
419
 
 
420
    ret =
 
421
        sqlite3_exec (handle,
 
422
                      "INSERT INTO MPoint_Test (Name, Description, geomMZ) VALUES ('Point 4', 'Some pointMZ', GeomFromText('MULTIPOINTMZ(136 -33 1 4.2, 47 2 2.3 1, -20, 12 3 -2)', 4326))",
 
423
                      NULL, NULL, &err_msg);
 
424
    if (ret != SQLITE_OK)
 
425
      {
 
426
          fprintf (stderr, "INSERT MPOINT XYZM error: %s\n", err_msg);
 
427
          sqlite3_free (err_msg);
 
428
          sqlite3_close (handle);
 
429
          return -33;
 
430
      }
 
431
 
 
432
    ret =
 
433
        dump_shapefile (handle, "MPoint_Test", "geomMZ", dumpname, "UTF-8", "",
 
434
                        1, &row_count, err_msg);
 
435
    if (!ret)
 
436
      {
 
437
          fprintf (stderr, "dump_shapefile() error for MPOINT XYZM %s\n",
 
438
                   err_msg);
 
439
          sqlite3_close (handle);
 
440
          return -34;
 
441
      }
 
442
    cleanup_shapefile (dumpname);
 
443
 
323
444
    ret = sqlite3_exec (handle, "DROP TABLE MPoint_Test", NULL, NULL, &err_msg);
324
 
    if (ret != SQLITE_OK) {
325
 
        fprintf (stderr, "DROP TABLE MPoint_Test error: %s\n", err_msg);
326
 
        sqlite3_free(err_msg);
327
 
        sqlite3_close(handle);
328
 
        return -35;
329
 
    }
330
 
    
331
 
    ret = sqlite3_exec (handle, "CREATE TABLE Linestring_Test (Name TEXT, Description TEXT)", NULL, NULL, &err_msg);
332
 
    if (ret != SQLITE_OK) {
333
 
        fprintf (stderr, "CREATE TABLE Linestring_Test error: %s\n", err_msg);
334
 
        sqlite3_free(err_msg);
335
 
        sqlite3_close(handle);
336
 
        return -36;
337
 
    }
338
 
 
339
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Linestring_Test', 'geom', 4326, 'LINESTRING', 'XY', 0)", NULL, NULL, &err_msg);
340
 
    if (ret != SQLITE_OK) {
341
 
        fprintf (stderr, "AddGeometryColumn LINESTRING XY error: %s\n", err_msg);
342
 
        sqlite3_free(err_msg);
343
 
        sqlite3_close(handle);
344
 
        return -37;
345
 
    }
346
 
    
347
 
    ret = sqlite3_exec (handle, "INSERT INTO Linestring_Test (Name, Description, geom) VALUES ('Point 1', 'Some linestring', GeomFromText('LINESTRING(136 -33, 47 2, -20, 12)', 4326))", NULL, NULL, &err_msg);
348
 
    if (ret != SQLITE_OK) {
349
 
        fprintf (stderr, "INSERT LINESTRING XY error: %s\n", err_msg);
350
 
        sqlite3_free(err_msg);
351
 
        sqlite3_close(handle);
352
 
        return -38;
353
 
    }
354
 
    
355
 
    ret = dump_shapefile (handle, "Linestring_Test", "geom", dumpname, "UTF-8", "", 1, &row_count, err_msg);
356
 
    if (!ret) {
357
 
        fprintf (stderr, "dump_shapefile() error for LINESTRING XY: %s\n", err_msg);
358
 
        sqlite3_close(handle);
359
 
        return -39;
360
 
    }
361
 
    cleanup_shapefile(dumpname);
362
 
 
363
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Linestring_Test', 'geomZ', 4326, 'LINESTRING', 'XYZ', 0)", NULL, NULL, &err_msg);
364
 
    if (ret != SQLITE_OK) {
365
 
        fprintf (stderr, "AddGeometryColumn LINESTRING XYZ error: %s\n", err_msg);
366
 
        sqlite3_free(err_msg);
367
 
        sqlite3_close(handle);
368
 
        return -40;
369
 
    }
370
 
    
371
 
    ret = sqlite3_exec (handle, "INSERT INTO Linestring_Test (Name, Description, geomZ) VALUES ('Point 2', 'Some linestringZ', GeomFromText('LINESTRINGZ(136 -33 3, 47 2 3.8, -20 12 10.1)', 4326))", NULL, NULL, &err_msg);
372
 
    if (ret != SQLITE_OK) {
373
 
        fprintf (stderr, "INSERT LINESTRING XYZ error: %s\n", err_msg);
374
 
        sqlite3_free(err_msg);
375
 
        sqlite3_close(handle);
376
 
        return -41;
377
 
    }
378
 
    
379
 
    ret = dump_shapefile (handle, "Linestring_Test", "geomZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
380
 
    if (!ret) {
381
 
        fprintf (stderr, "dump_shapefile() error for LINESTRING XYZ: %s\n", err_msg);
382
 
        sqlite3_close(handle);
383
 
        return -42;
384
 
    }
385
 
    cleanup_shapefile(dumpname);
386
 
    
387
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Linestring_Test', 'geomM', 4326, 'LINESTRING', 'XYM', 0)", NULL, NULL, &err_msg);
388
 
    if (ret != SQLITE_OK) {
389
 
        fprintf (stderr, "AddGeometryColumn LINESTRING XYM error: %s\n", err_msg);
390
 
        sqlite3_free(err_msg);
391
 
        sqlite3_close(handle);
392
 
        return -43;
393
 
    }
394
 
    
395
 
    ret = sqlite3_exec (handle, "INSERT INTO Linestring_Test (Name, Description, geomM) VALUES ('Point 3', 'Some linestringM', GeomFromText('LINESTRINGM(136 -33 3, 47 2 3.8, -20 12 10.1)', 4326))", NULL, NULL, &err_msg);
396
 
    if (ret != SQLITE_OK) {
397
 
        fprintf (stderr, "INSERT LINESTRING XYM error: %s\n", err_msg);
398
 
        sqlite3_free(err_msg);
399
 
        sqlite3_close(handle);
400
 
        return -44;
401
 
    }
402
 
    
403
 
    ret = dump_shapefile (handle, "Linestring_Test", "geomM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
404
 
    if (!ret) {
405
 
        fprintf (stderr, "dump_shapefile() error for LINESTRING XYM: %s\n", err_msg);
406
 
        sqlite3_close(handle);
407
 
        return -45;
408
 
    }
409
 
    cleanup_shapefile(dumpname);
410
 
    
411
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Linestring_Test', 'geomMZ', 4326, 'LINESTRING', 'XYZM', 0)", NULL, NULL, &err_msg);
412
 
    if (ret != SQLITE_OK) {
413
 
        fprintf (stderr, "AddGeometryColumn LINESTRING XYZM error: %s\n", err_msg);
414
 
        sqlite3_free(err_msg);
415
 
        sqlite3_close(handle);
416
 
        return -46;
417
 
    }
418
 
    
419
 
    ret = sqlite3_exec (handle, "INSERT INTO Linestring_Test (Name, Description, geomMZ) VALUES ('Point 3', 'Some linestringZM', GeomFromText('LINESTRINGZM(136 -33 3 4.2, 47 2 3.8 1, -20 12 10.1 321)', 4326))", NULL, NULL, &err_msg);
420
 
    if (ret != SQLITE_OK) {
421
 
        fprintf (stderr, "INSERT LINESTRING XYZM error: %s\n", err_msg);
422
 
        sqlite3_free(err_msg);
423
 
        sqlite3_close(handle);
424
 
        return -47;
425
 
    }
426
 
    
427
 
    ret = dump_shapefile (handle, "Linestring_Test", "geomMZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
428
 
    if (!ret) {
429
 
        fprintf (stderr, "dump_shapefile() error for LINESTRING XYZM: %s\n", err_msg);
430
 
        sqlite3_close(handle);
431
 
        return -48;
432
 
    }
433
 
    cleanup_shapefile(dumpname);
434
 
    
435
 
    ret = sqlite3_exec (handle, "DROP TABLE Linestring_Test", NULL, NULL, &err_msg);
436
 
    if (ret != SQLITE_OK) {
437
 
        fprintf (stderr, "DROP TABLE Linestring_Test error: %s\n", err_msg);
438
 
        sqlite3_free(err_msg);
439
 
        sqlite3_close(handle);
440
 
        return -49;
441
 
    }
442
 
    
443
 
    ret = sqlite3_exec (handle, "CREATE TABLE Polygon_Test (Name TEXT, Description TEXT, thing1 INTEGER, thing2 REAL, thing3 DOUBLE, thing4 BLOB)", NULL, NULL, &err_msg);
444
 
    if (ret != SQLITE_OK) {
445
 
        fprintf (stderr, "CREATE TABLE Polygon_Test error: %s\n", err_msg);
446
 
        sqlite3_free(err_msg);
447
 
        sqlite3_close(handle);
448
 
        return -50;
449
 
    }
450
 
 
451
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Polygon_Test', 'geom', 4326, 'POLYGON', 'XY', 0)", NULL, NULL, &err_msg);
452
 
    if (ret != SQLITE_OK) {
453
 
        fprintf (stderr, "AddGeometryColumn POLYGON XY error: %s\n", err_msg);
454
 
        sqlite3_free(err_msg);
455
 
        sqlite3_close(handle);
456
 
        return -51;
457
 
    }
458
 
    /* TODO: try dumping an empty table */ 
459
 
    
460
 
    ret = sqlite3_exec (handle, "INSERT INTO Polygon_Test (Name, Description, thing1, thing2, thing3, thing4, geom) VALUES ('Polygon 1', 'Some polygon', 2, 4.25, 343.343, zeroblob(40), GeomFromText('POLYGON((136 -33, 47 2, -20 -1, 136 -33),(10 -2, -20 -0.4, 40 0.1, 10 -2))', 4326))", NULL, NULL, &err_msg);
461
 
    if (ret != SQLITE_OK) {
462
 
        fprintf (stderr, "INSERT POLYGON XY error: %s\n", err_msg);
463
 
        sqlite3_free(err_msg);
464
 
        sqlite3_close(handle);
465
 
        return -54;
466
 
    }
467
 
    
468
 
    ret = dump_shapefile (handle, "Polygon_Test", "geom", dumpname, "UTF-8", "", 1, &row_count, err_msg);
469
 
    if (!ret) {
470
 
        fprintf (stderr, "dump_shapefile() error for POLYGON XY: %s\n", err_msg);
471
 
        sqlite3_close(handle);
472
 
        return -55;
473
 
    }
474
 
    cleanup_shapefile(dumpname);
475
 
    
476
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Polygon_Test', 'geomZ', 4326, 'POLYGON', 'XYZ', 0)", NULL, NULL, &err_msg);
477
 
    if (ret != SQLITE_OK) {
478
 
        fprintf (stderr, "AddGeometryColumn POLYGON XYZ error: %s\n", err_msg);
479
 
        sqlite3_free(err_msg);
480
 
        sqlite3_close(handle);
481
 
        return -56;
482
 
    }
483
 
    
484
 
    ret = sqlite3_exec (handle, "INSERT INTO Polygon_Test (Name, Description, thing1, thing2, thing3, thing4, geomZ) VALUES ('Polygon 2', 'Some polygonZ', 12, 14.25, 1343.343, zeroblob(140), GeomFromText('POLYGONZ((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, 40 0.1 1.6, -20 -0.4 1, 10 -2 4)', 4326))", NULL, NULL, &err_msg);
485
 
    if (ret != SQLITE_OK) {
486
 
        fprintf (stderr, "INSERT POLYGON XYZ error: %s\n", err_msg);
487
 
        sqlite3_free(err_msg);
488
 
        sqlite3_close(handle);
489
 
        return -57;
490
 
    }
491
 
    ret = sqlite3_exec (handle, "INSERT INTO Polygon_Test (Name, Description, geomZ) VALUES ('Polygon 2', 'wrong direction', GeomFromText('POLYGONZ((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, -20 -0.4 1, 40 0.1 1.6, 10 -2 4))', 4326))", NULL, NULL, &err_msg);
492
 
    if (ret != SQLITE_OK) {
493
 
        fprintf (stderr, "INSERT POLYGON XYZ 2 error: %s\n", err_msg);
494
 
        sqlite3_free(err_msg);
495
 
        sqlite3_close(handle);
496
 
        return -57; /* dupe */
497
 
    }
498
 
    
499
 
    ret = dump_shapefile (handle, "Polygon_Test", "geomZ", dumpname, "UTF-8", "", 1, &row_count, err_msg);
500
 
    if (!ret) {
501
 
        fprintf (stderr, "dump_shapefile() error for POLYGON XYZ: %s\n", err_msg);
502
 
        sqlite3_close(handle);
503
 
        return -58;
504
 
    }
505
 
    cleanup_shapefile(dumpname);
506
 
 
507
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Polygon_Test', 'geomM', 4326, 'POLYGON', 'XYM', 0)", NULL, NULL, &err_msg);
508
 
    if (ret != SQLITE_OK) {
509
 
        fprintf (stderr, "AddGeometryColumn POLYGON XYM error: %s\n", err_msg);
510
 
        sqlite3_free(err_msg);
511
 
        sqlite3_close(handle);
512
 
        return -59;
513
 
    }
514
 
    
515
 
    ret = sqlite3_exec (handle, "INSERT INTO Polygon_Test (Name, Description, geomM) VALUES ('Polygon 3', 'Some polygonM', GeomFromText('POLYGONM((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, -20 -0.4 1, 40 0.1 1.6, 10 -2 4))', 4326))", NULL, NULL, &err_msg);
516
 
    if (ret != SQLITE_OK) {
517
 
        fprintf (stderr, "INSERT POLYGON XYM error: %s\n", err_msg);
518
 
        sqlite3_free(err_msg);
519
 
        sqlite3_close(handle);
520
 
        return -60;
521
 
    }
522
 
    
523
 
    ret = dump_shapefile (handle, "Polygon_Test", "geomM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
524
 
    if (!ret) {
525
 
        fprintf (stderr, "dump_shapefile() error for POLYGON XYM: %s\n", err_msg);
526
 
        sqlite3_close(handle);
527
 
        return -61;
528
 
    }
529
 
    cleanup_shapefile(dumpname);
530
 
    
531
 
    ret = sqlite3_exec (handle, "SELECT AddGeometryColumn('Polygon_Test', 'geomZM', 4326, 'POLYGON', 'XYZM', 0)", NULL, NULL, &err_msg);
532
 
    if (ret != SQLITE_OK) {
533
 
        fprintf (stderr, "AddGeometryColumn POLYGON XYZM error: %s\n", err_msg);
534
 
        sqlite3_free(err_msg);
535
 
        sqlite3_close(handle);
536
 
        return -62;
537
 
    }
538
 
    
539
 
    ret = sqlite3_exec (handle, "INSERT INTO Polygon_Test (Name, Description, geomZM) VALUES ('Polygon 4', 'Some polygonZM', GeomFromText('POLYGONZM((136 -33 4 4, 47 2 4.2 4.4, -20 -1 1 1, 136 -33 4 4),(10 -2 4 1, -20 -0.4 1 1, 40 0.1 1.6 1, 10 -2 4 1))', 4326))", NULL, NULL, &err_msg);
540
 
    if (ret != SQLITE_OK) {
541
 
        fprintf (stderr, "INSERT POLYGON XYZM error: %s\n", err_msg);
542
 
        sqlite3_free(err_msg);
543
 
        sqlite3_close(handle);
544
 
        return -63;
545
 
    }
546
 
    
547
 
    ret = dump_shapefile (handle, "Polygon_Test", "geomZM", dumpname, "UTF-8", "", 1, &row_count, err_msg);
548
 
    if (!ret) {
549
 
        fprintf (stderr, "dump_shapefile() error for POLYGON XYZM: %s\n", err_msg);
550
 
        sqlite3_close(handle);
551
 
        return -64;
552
 
    }
553
 
    cleanup_shapefile(dumpname);
 
445
    if (ret != SQLITE_OK)
 
446
      {
 
447
          fprintf (stderr, "DROP TABLE MPoint_Test error: %s\n", err_msg);
 
448
          sqlite3_free (err_msg);
 
449
          sqlite3_close (handle);
 
450
          return -35;
 
451
      }
 
452
 
 
453
    ret =
 
454
        sqlite3_exec (handle,
 
455
                      "CREATE TABLE Linestring_Test (Name TEXT, Description TEXT)",
 
456
                      NULL, NULL, &err_msg);
 
457
    if (ret != SQLITE_OK)
 
458
      {
 
459
          fprintf (stderr, "CREATE TABLE Linestring_Test error: %s\n", err_msg);
 
460
          sqlite3_free (err_msg);
 
461
          sqlite3_close (handle);
 
462
          return -36;
 
463
      }
 
464
 
 
465
    ret =
 
466
        sqlite3_exec (handle,
 
467
                      "SELECT AddGeometryColumn('Linestring_Test', 'geom', 4326, 'LINESTRING', 'XY', 0)",
 
468
                      NULL, NULL, &err_msg);
 
469
    if (ret != SQLITE_OK)
 
470
      {
 
471
          fprintf (stderr, "AddGeometryColumn LINESTRING XY error: %s\n",
 
472
                   err_msg);
 
473
          sqlite3_free (err_msg);
 
474
          sqlite3_close (handle);
 
475
          return -37;
 
476
      }
 
477
 
 
478
    ret =
 
479
        sqlite3_exec (handle,
 
480
                      "INSERT INTO Linestring_Test (Name, Description, geom) VALUES ('Point 1', 'Some linestring', GeomFromText('LINESTRING(136 -33, 47 2, -20, 12)', 4326))",
 
481
                      NULL, NULL, &err_msg);
 
482
    if (ret != SQLITE_OK)
 
483
      {
 
484
          fprintf (stderr, "INSERT LINESTRING XY error: %s\n", err_msg);
 
485
          sqlite3_free (err_msg);
 
486
          sqlite3_close (handle);
 
487
          return -38;
 
488
      }
 
489
 
 
490
    ret =
 
491
        dump_shapefile (handle, "Linestring_Test", "geom", dumpname, "UTF-8",
 
492
                        "", 1, &row_count, err_msg);
 
493
    if (!ret)
 
494
      {
 
495
          fprintf (stderr, "dump_shapefile() error for LINESTRING XY: %s\n",
 
496
                   err_msg);
 
497
          sqlite3_close (handle);
 
498
          return -39;
 
499
      }
 
500
    cleanup_shapefile (dumpname);
 
501
 
 
502
    ret =
 
503
        sqlite3_exec (handle,
 
504
                      "SELECT AddGeometryColumn('Linestring_Test', 'geomZ', 4326, 'LINESTRING', 'XYZ', 0)",
 
505
                      NULL, NULL, &err_msg);
 
506
    if (ret != SQLITE_OK)
 
507
      {
 
508
          fprintf (stderr, "AddGeometryColumn LINESTRING XYZ error: %s\n",
 
509
                   err_msg);
 
510
          sqlite3_free (err_msg);
 
511
          sqlite3_close (handle);
 
512
          return -40;
 
513
      }
 
514
 
 
515
    ret =
 
516
        sqlite3_exec (handle,
 
517
                      "INSERT INTO Linestring_Test (Name, Description, geomZ) VALUES ('Point 2', 'Some linestringZ', GeomFromText('LINESTRINGZ(136 -33 3, 47 2 3.8, -20 12 10.1)', 4326))",
 
518
                      NULL, NULL, &err_msg);
 
519
    if (ret != SQLITE_OK)
 
520
      {
 
521
          fprintf (stderr, "INSERT LINESTRING XYZ error: %s\n", err_msg);
 
522
          sqlite3_free (err_msg);
 
523
          sqlite3_close (handle);
 
524
          return -41;
 
525
      }
 
526
 
 
527
    ret =
 
528
        dump_shapefile (handle, "Linestring_Test", "geomZ", dumpname, "UTF-8",
 
529
                        "", 1, &row_count, err_msg);
 
530
    if (!ret)
 
531
      {
 
532
          fprintf (stderr, "dump_shapefile() error for LINESTRING XYZ: %s\n",
 
533
                   err_msg);
 
534
          sqlite3_close (handle);
 
535
          return -42;
 
536
      }
 
537
    cleanup_shapefile (dumpname);
 
538
 
 
539
    ret =
 
540
        sqlite3_exec (handle,
 
541
                      "SELECT AddGeometryColumn('Linestring_Test', 'geomM', 4326, 'LINESTRING', 'XYM', 0)",
 
542
                      NULL, NULL, &err_msg);
 
543
    if (ret != SQLITE_OK)
 
544
      {
 
545
          fprintf (stderr, "AddGeometryColumn LINESTRING XYM error: %s\n",
 
546
                   err_msg);
 
547
          sqlite3_free (err_msg);
 
548
          sqlite3_close (handle);
 
549
          return -43;
 
550
      }
 
551
 
 
552
    ret =
 
553
        sqlite3_exec (handle,
 
554
                      "INSERT INTO Linestring_Test (Name, Description, geomM) VALUES ('Point 3', 'Some linestringM', GeomFromText('LINESTRINGM(136 -33 3, 47 2 3.8, -20 12 10.1)', 4326))",
 
555
                      NULL, NULL, &err_msg);
 
556
    if (ret != SQLITE_OK)
 
557
      {
 
558
          fprintf (stderr, "INSERT LINESTRING XYM error: %s\n", err_msg);
 
559
          sqlite3_free (err_msg);
 
560
          sqlite3_close (handle);
 
561
          return -44;
 
562
      }
 
563
 
 
564
    ret =
 
565
        dump_shapefile (handle, "Linestring_Test", "geomM", dumpname, "UTF-8",
 
566
                        "", 1, &row_count, err_msg);
 
567
    if (!ret)
 
568
      {
 
569
          fprintf (stderr, "dump_shapefile() error for LINESTRING XYM: %s\n",
 
570
                   err_msg);
 
571
          sqlite3_close (handle);
 
572
          return -45;
 
573
      }
 
574
    cleanup_shapefile (dumpname);
 
575
 
 
576
    ret =
 
577
        sqlite3_exec (handle,
 
578
                      "SELECT AddGeometryColumn('Linestring_Test', 'geomMZ', 4326, 'LINESTRING', 'XYZM', 0)",
 
579
                      NULL, NULL, &err_msg);
 
580
    if (ret != SQLITE_OK)
 
581
      {
 
582
          fprintf (stderr, "AddGeometryColumn LINESTRING XYZM error: %s\n",
 
583
                   err_msg);
 
584
          sqlite3_free (err_msg);
 
585
          sqlite3_close (handle);
 
586
          return -46;
 
587
      }
 
588
 
 
589
    ret =
 
590
        sqlite3_exec (handle,
 
591
                      "INSERT INTO Linestring_Test (Name, Description, geomMZ) VALUES ('Point 3', 'Some linestringZM', GeomFromText('LINESTRINGZM(136 -33 3 4.2, 47 2 3.8 1, -20 12 10.1 321)', 4326))",
 
592
                      NULL, NULL, &err_msg);
 
593
    if (ret != SQLITE_OK)
 
594
      {
 
595
          fprintf (stderr, "INSERT LINESTRING XYZM error: %s\n", err_msg);
 
596
          sqlite3_free (err_msg);
 
597
          sqlite3_close (handle);
 
598
          return -47;
 
599
      }
 
600
 
 
601
    ret =
 
602
        dump_shapefile (handle, "Linestring_Test", "geomMZ", dumpname, "UTF-8",
 
603
                        "", 1, &row_count, err_msg);
 
604
    if (!ret)
 
605
      {
 
606
          fprintf (stderr, "dump_shapefile() error for LINESTRING XYZM: %s\n",
 
607
                   err_msg);
 
608
          sqlite3_close (handle);
 
609
          return -48;
 
610
      }
 
611
    cleanup_shapefile (dumpname);
 
612
 
 
613
    ret =
 
614
        sqlite3_exec (handle, "DROP TABLE Linestring_Test", NULL, NULL,
 
615
                      &err_msg);
 
616
    if (ret != SQLITE_OK)
 
617
      {
 
618
          fprintf (stderr, "DROP TABLE Linestring_Test error: %s\n", err_msg);
 
619
          sqlite3_free (err_msg);
 
620
          sqlite3_close (handle);
 
621
          return -49;
 
622
      }
 
623
 
 
624
    ret =
 
625
        sqlite3_exec (handle,
 
626
                      "CREATE TABLE Polygon_Test (Name TEXT, Description TEXT, thing1 INTEGER, thing2 REAL, thing3 DOUBLE, thing4 BLOB)",
 
627
                      NULL, NULL, &err_msg);
 
628
    if (ret != SQLITE_OK)
 
629
      {
 
630
          fprintf (stderr, "CREATE TABLE Polygon_Test error: %s\n", err_msg);
 
631
          sqlite3_free (err_msg);
 
632
          sqlite3_close (handle);
 
633
          return -50;
 
634
      }
 
635
 
 
636
    ret =
 
637
        sqlite3_exec (handle,
 
638
                      "SELECT AddGeometryColumn('Polygon_Test', 'geom', 4326, 'POLYGON', 'XY', 0)",
 
639
                      NULL, NULL, &err_msg);
 
640
    if (ret != SQLITE_OK)
 
641
      {
 
642
          fprintf (stderr, "AddGeometryColumn POLYGON XY error: %s\n", err_msg);
 
643
          sqlite3_free (err_msg);
 
644
          sqlite3_close (handle);
 
645
          return -51;
 
646
      }
 
647
    /* TODO: try dumping an empty table */
 
648
 
 
649
    ret =
 
650
        sqlite3_exec (handle,
 
651
                      "INSERT INTO Polygon_Test (Name, Description, thing1, thing2, thing3, thing4, geom) VALUES ('Polygon 1', 'Some polygon', 2, 4.25, 343.343, zeroblob(40), GeomFromText('POLYGON((136 -33, 47 2, -20 -1, 136 -33),(10 -2, -20 -0.4, 40 0.1, 10 -2))', 4326))",
 
652
                      NULL, NULL, &err_msg);
 
653
    if (ret != SQLITE_OK)
 
654
      {
 
655
          fprintf (stderr, "INSERT POLYGON XY error: %s\n", err_msg);
 
656
          sqlite3_free (err_msg);
 
657
          sqlite3_close (handle);
 
658
          return -54;
 
659
      }
 
660
 
 
661
    ret =
 
662
        dump_shapefile (handle, "Polygon_Test", "geom", dumpname, "UTF-8", "",
 
663
                        1, &row_count, err_msg);
 
664
    if (!ret)
 
665
      {
 
666
          fprintf (stderr, "dump_shapefile() error for POLYGON XY: %s\n",
 
667
                   err_msg);
 
668
          sqlite3_close (handle);
 
669
          return -55;
 
670
      }
 
671
    cleanup_shapefile (dumpname);
 
672
 
 
673
    ret =
 
674
        sqlite3_exec (handle,
 
675
                      "SELECT AddGeometryColumn('Polygon_Test', 'geomZ', 4326, 'POLYGON', 'XYZ', 0)",
 
676
                      NULL, NULL, &err_msg);
 
677
    if (ret != SQLITE_OK)
 
678
      {
 
679
          fprintf (stderr, "AddGeometryColumn POLYGON XYZ error: %s\n",
 
680
                   err_msg);
 
681
          sqlite3_free (err_msg);
 
682
          sqlite3_close (handle);
 
683
          return -56;
 
684
      }
 
685
 
 
686
    ret =
 
687
        sqlite3_exec (handle,
 
688
                      "INSERT INTO Polygon_Test (Name, Description, thing1, thing2, thing3, thing4, geomZ) VALUES ('Polygon 2', 'Some polygonZ', 12, 14.25, 1343.343, zeroblob(140), GeomFromText('POLYGONZ((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, 40 0.1 1.6, -20 -0.4 1, 10 -2 4)', 4326))",
 
689
                      NULL, NULL, &err_msg);
 
690
    if (ret != SQLITE_OK)
 
691
      {
 
692
          fprintf (stderr, "INSERT POLYGON XYZ error: %s\n", err_msg);
 
693
          sqlite3_free (err_msg);
 
694
          sqlite3_close (handle);
 
695
          return -57;
 
696
      }
 
697
    ret =
 
698
        sqlite3_exec (handle,
 
699
                      "INSERT INTO Polygon_Test (Name, Description, geomZ) VALUES ('Polygon 2', 'wrong direction', GeomFromText('POLYGONZ((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, -20 -0.4 1, 40 0.1 1.6, 10 -2 4))', 4326))",
 
700
                      NULL, NULL, &err_msg);
 
701
    if (ret != SQLITE_OK)
 
702
      {
 
703
          fprintf (stderr, "INSERT POLYGON XYZ 2 error: %s\n", err_msg);
 
704
          sqlite3_free (err_msg);
 
705
          sqlite3_close (handle);
 
706
          return -57;           /* dupe */
 
707
      }
 
708
 
 
709
    ret =
 
710
        dump_shapefile (handle, "Polygon_Test", "geomZ", dumpname, "UTF-8", "",
 
711
                        1, &row_count, err_msg);
 
712
    if (!ret)
 
713
      {
 
714
          fprintf (stderr, "dump_shapefile() error for POLYGON XYZ: %s\n",
 
715
                   err_msg);
 
716
          sqlite3_close (handle);
 
717
          return -58;
 
718
      }
 
719
    cleanup_shapefile (dumpname);
 
720
 
 
721
    ret =
 
722
        sqlite3_exec (handle,
 
723
                      "SELECT AddGeometryColumn('Polygon_Test', 'geomM', 4326, 'POLYGON', 'XYM', 0)",
 
724
                      NULL, NULL, &err_msg);
 
725
    if (ret != SQLITE_OK)
 
726
      {
 
727
          fprintf (stderr, "AddGeometryColumn POLYGON XYM error: %s\n",
 
728
                   err_msg);
 
729
          sqlite3_free (err_msg);
 
730
          sqlite3_close (handle);
 
731
          return -59;
 
732
      }
 
733
 
 
734
    ret =
 
735
        sqlite3_exec (handle,
 
736
                      "INSERT INTO Polygon_Test (Name, Description, geomM) VALUES ('Polygon 3', 'Some polygonM', GeomFromText('POLYGONM((136 -33 4, 47 2 4.2, -20 -1 1, 136 -33 4),(10 -2 4, -20 -0.4 1, 40 0.1 1.6, 10 -2 4))', 4326))",
 
737
                      NULL, NULL, &err_msg);
 
738
    if (ret != SQLITE_OK)
 
739
      {
 
740
          fprintf (stderr, "INSERT POLYGON XYM error: %s\n", err_msg);
 
741
          sqlite3_free (err_msg);
 
742
          sqlite3_close (handle);
 
743
          return -60;
 
744
      }
 
745
 
 
746
    ret =
 
747
        dump_shapefile (handle, "Polygon_Test", "geomM", dumpname, "UTF-8", "",
 
748
                        1, &row_count, err_msg);
 
749
    if (!ret)
 
750
      {
 
751
          fprintf (stderr, "dump_shapefile() error for POLYGON XYM: %s\n",
 
752
                   err_msg);
 
753
          sqlite3_close (handle);
 
754
          return -61;
 
755
      }
 
756
    cleanup_shapefile (dumpname);
 
757
 
 
758
    ret =
 
759
        sqlite3_exec (handle,
 
760
                      "SELECT AddGeometryColumn('Polygon_Test', 'geomZM', 4326, 'POLYGON', 'XYZM', 0)",
 
761
                      NULL, NULL, &err_msg);
 
762
    if (ret != SQLITE_OK)
 
763
      {
 
764
          fprintf (stderr, "AddGeometryColumn POLYGON XYZM error: %s\n",
 
765
                   err_msg);
 
766
          sqlite3_free (err_msg);
 
767
          sqlite3_close (handle);
 
768
          return -62;
 
769
      }
 
770
 
 
771
    ret =
 
772
        sqlite3_exec (handle,
 
773
                      "INSERT INTO Polygon_Test (Name, Description, geomZM) VALUES ('Polygon 4', 'Some polygonZM', GeomFromText('POLYGONZM((136 -33 4 4, 47 2 4.2 4.4, -20 -1 1 1, 136 -33 4 4),(10 -2 4 1, -20 -0.4 1 1, 40 0.1 1.6 1, 10 -2 4 1))', 4326))",
 
774
                      NULL, NULL, &err_msg);
 
775
    if (ret != SQLITE_OK)
 
776
      {
 
777
          fprintf (stderr, "INSERT POLYGON XYZM error: %s\n", err_msg);
 
778
          sqlite3_free (err_msg);
 
779
          sqlite3_close (handle);
 
780
          return -63;
 
781
      }
 
782
 
 
783
    ret =
 
784
        dump_shapefile (handle, "Polygon_Test", "geomZM", dumpname, "UTF-8", "",
 
785
                        1, &row_count, err_msg);
 
786
    if (!ret)
 
787
      {
 
788
          fprintf (stderr, "dump_shapefile() error for POLYGON XYZM: %s\n",
 
789
                   err_msg);
 
790
          sqlite3_close (handle);
 
791
          return -64;
 
792
      }
 
793
    cleanup_shapefile (dumpname);
554
794
 
555
795
/* testing VectorLayersList (several flavors) */
556
 
    list = gaiaGetVectorLayersList (handle, NULL, NULL, GAIA_VECTORS_LIST_FAST);
557
 
    gaiaFreeVectorLayersList (list);
558
 
    list = gaiaGetVectorLayersList (handle, NULL, NULL, GAIA_VECTORS_LIST_PESSIMISTIC);
559
 
    gaiaFreeVectorLayersList (list);
560
 
    list = gaiaGetVectorLayersList (handle, "Polygon_Test", "geomZM", GAIA_VECTORS_LIST_FAST);
561
 
    gaiaFreeVectorLayersList (list);
562
 
    list = gaiaGetVectorLayersList (handle, "Polygon_Test", "geomZM", GAIA_VECTORS_LIST_OPTIMISTIC);
563
 
    gaiaFreeVectorLayersList (list);
564
 
    
565
 
    ret = sqlite3_exec (handle, "DROP TABLE Polygon_Test", NULL, NULL, &err_msg);
566
 
    if (ret != SQLITE_OK) {
567
 
        fprintf (stderr, "DROP TABLE Polygon_Test error: %s\n", err_msg);
568
 
        sqlite3_free(err_msg);
569
 
        sqlite3_close(handle);
570
 
        return -65;
571
 
    }
572
 
        
 
796
    list =
 
797
        gaiaGetVectorLayersList (handle, NULL, NULL,
 
798
                                 GAIA_VECTORS_LIST_OPTIMISTIC);
 
799
    gaiaFreeVectorLayersList (list);
 
800
    list =
 
801
        gaiaGetVectorLayersList (handle, NULL, NULL,
 
802
                                 GAIA_VECTORS_LIST_PESSIMISTIC);
 
803
    gaiaFreeVectorLayersList (list);
 
804
    list =
 
805
        gaiaGetVectorLayersList (handle, "Polygon_Test", "geomZM",
 
806
                                 GAIA_VECTORS_LIST_OPTIMISTIC);
 
807
    gaiaFreeVectorLayersList (list);
 
808
    gaiaStatisticsInvalidate (handle, NULL, NULL);
 
809
    list =
 
810
        gaiaGetVectorLayersList (handle, NULL, NULL,
 
811
                                 GAIA_VECTORS_LIST_PESSIMISTIC);
 
812
    gaiaFreeVectorLayersList (list);
 
813
    gaiaStatisticsInvalidate (handle, "Polygon_Test", NULL);
 
814
    list =
 
815
        gaiaGetVectorLayersList (handle, NULL, NULL,
 
816
                                 GAIA_VECTORS_LIST_PESSIMISTIC);
 
817
    gaiaFreeVectorLayersList (list);
 
818
    gaiaStatisticsInvalidate (handle, "Polygon_Test", "geomZM");
 
819
    list =
 
820
        gaiaGetVectorLayersList (handle, NULL, NULL,
 
821
                                 GAIA_VECTORS_LIST_PESSIMISTIC);
 
822
    gaiaFreeVectorLayersList (list);
 
823
    gaiaStatisticsInvalidate (handle, "Palygon_Tost", "ZMgeom");
 
824
 
 
825
    ret =
 
826
        sqlite3_exec (handle, "DROP TABLE Polygon_Test", NULL, NULL, &err_msg);
 
827
    if (ret != SQLITE_OK)
 
828
      {
 
829
          fprintf (stderr, "DROP TABLE Polygon_Test error: %s\n", err_msg);
 
830
          sqlite3_free (err_msg);
 
831
          sqlite3_close (handle);
 
832
          return -65;
 
833
      }
 
834
 
573
835
/* final DB cleanup */
574
 
    ret = sqlite3_exec (handle, "DELETE FROM geometry_columns", NULL, NULL, &err_msg);
575
 
    if (ret != SQLITE_OK) {
576
 
        fprintf (stderr, "DELETE FROM geometry_columns error: %s\n", err_msg);
577
 
        sqlite3_free(err_msg);
578
 
        sqlite3_close(handle);
579
 
        return -66;
580
 
    }
581
 
    ret = sqlite3_exec (handle, "DELETE FROM spatialite_history WHERE geometry_column IS NOT NULL", NULL, NULL, &err_msg);
582
 
    if (ret != SQLITE_OK) {
583
 
        fprintf (stderr, "DELETE FROM spatialite_history error: %s\n", err_msg);
584
 
        sqlite3_free(err_msg);
585
 
        sqlite3_close(handle);
586
 
        return -66;
587
 
    }
 
836
    ret =
 
837
        sqlite3_exec (handle, "DELETE FROM geometry_columns", NULL, NULL,
 
838
                      &err_msg);
 
839
    if (ret != SQLITE_OK)
 
840
      {
 
841
          fprintf (stderr, "DELETE FROM geometry_columns error: %s\n", err_msg);
 
842
          sqlite3_free (err_msg);
 
843
          sqlite3_close (handle);
 
844
          return -66;
 
845
      }
 
846
    ret =
 
847
        sqlite3_exec (handle,
 
848
                      "DELETE FROM spatialite_history WHERE geometry_column IS NOT NULL",
 
849
                      NULL, NULL, &err_msg);
 
850
    if (ret != SQLITE_OK)
 
851
      {
 
852
          fprintf (stderr, "DELETE FROM spatialite_history error: %s\n",
 
853
                   err_msg);
 
854
          sqlite3_free (err_msg);
 
855
          sqlite3_close (handle);
 
856
          return -66;
 
857
      }
588
858
    ret = sqlite3_exec (handle, "VACUUM", NULL, NULL, &err_msg);
589
 
    if (ret != SQLITE_OK) {
590
 
        fprintf (stderr, "VACUUM error: %s\n", err_msg);
591
 
        sqlite3_free(err_msg);
592
 
        sqlite3_close(handle);
593
 
        return -66;
594
 
    }
595
 
#endif  /* end ICONV conditional */
596
 
        
 
859
    if (ret != SQLITE_OK)
 
860
      {
 
861
          fprintf (stderr, "VACUUM error: %s\n", err_msg);
 
862
          sqlite3_free (err_msg);
 
863
          sqlite3_close (handle);
 
864
          return -66;
 
865
      }
 
866
#endif /* end ICONV conditional */
 
867
 
597
868
/* ok, succesfull termination */
598
 
        return 0;
 
869
    return 0;
599
870
}
600
871
 
601
 
int main (int argc, char *argv[])
 
872
int
 
873
main (int argc, char *argv[])
602
874
{
603
 
#ifndef OMIT_ICONV      /* only if ICONV is supported */
 
875
#ifndef OMIT_ICONV              /* only if ICONV is supported */
604
876
#ifdef ENABLE_LWGEOM            /* only if LWGEOM is supported */
605
877
    int ret;
606
878
    sqlite3 *handle;
607
879
    char *err_msg = NULL;
608
 
    void *cache = spatialite_alloc_connection();
 
880
    void *cache = spatialite_alloc_connection ();
609
881
 
610
882
    if (argc > 1 || argv[0] == NULL)
611
883
        argc = 1;               /* silencing stupid compiler warnings */
612
884
 
613
885
/* testing current style metadata layout >= v.4.0.0 */
614
 
    ret = sqlite3_open_v2 (":memory:", &handle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
615
 
    if (ret != SQLITE_OK) {
616
 
        fprintf(stderr, "cannot open in-memory database: %s\n", sqlite3_errmsg (handle));
617
 
        sqlite3_close(handle);
618
 
        return -1;
619
 
    }
 
886
    ret =
 
887
        sqlite3_open_v2 (":memory:", &handle,
 
888
                         SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
 
889
    if (ret != SQLITE_OK)
 
890
      {
 
891
          fprintf (stderr, "cannot open in-memory database: %s\n",
 
892
                   sqlite3_errmsg (handle));
 
893
          sqlite3_close (handle);
 
894
          return -1;
 
895
      }
620
896
 
621
897
    spatialite_init_ex (handle, cache, 0);
622
 
    
623
 
    ret = sqlite3_exec (handle, "SELECT InitSpatialMetadata(1)", NULL, NULL, &err_msg);
624
 
    if (ret != SQLITE_OK) {
625
 
        fprintf (stderr, "InitSpatialMetadata() error: %s\n", err_msg);
626
 
        sqlite3_free(err_msg);
627
 
        sqlite3_close(handle);
628
 
        return -2;
629
 
    }
630
 
        
631
 
    ret = do_test(handle);
632
 
    if (ret != 0) {
633
 
        fprintf(stderr, "error while testing current style metadata layout\n");
634
 
        return ret;
635
 
    }
 
898
 
 
899
    ret =
 
900
        sqlite3_exec (handle, "SELECT InitSpatialMetadata(1)", NULL, NULL,
 
901
                      &err_msg);
 
902
    if (ret != SQLITE_OK)
 
903
      {
 
904
          fprintf (stderr, "InitSpatialMetadata() error: %s\n", err_msg);
 
905
          sqlite3_free (err_msg);
 
906
          sqlite3_close (handle);
 
907
          return -2;
 
908
      }
 
909
 
 
910
    ret = do_test (handle);
 
911
    if (ret != 0)
 
912
      {
 
913
          fprintf (stderr,
 
914
                   "error while testing current style metadata layout\n");
 
915
          return ret;
 
916
      }
636
917
 
637
918
    spatialite_cleanup_ex (cache);
638
 
    sqlite3_close(handle);
639
 
        
 
919
    sqlite3_close (handle);
 
920
 
640
921
/* testing legacy style metadata layout <= v.3.1.0 */
641
 
    cache = spatialite_alloc_connection();
642
 
    ret = system("cp test-legacy-3.0.1.sqlite copy-legacy-3.0.1.sqlite");
 
922
    cache = spatialite_alloc_connection ();
 
923
    ret =
 
924
        system
 
925
        ("cp test-legacy-3.0.1.sqlite copy-primitives-legacy-3.0.1.sqlite");
643
926
    if (ret != 0)
644
 
    {
645
 
        fprintf(stderr, "cannot copy legacy v.3.0.1 database\n");
646
 
        return -1;
647
 
    }
648
 
    ret = sqlite3_open_v2 ("copy-legacy-3.0.1.sqlite", &handle, SQLITE_OPEN_READWRITE, NULL);
649
 
    if (ret != SQLITE_OK) {
650
 
        fprintf(stderr, "cannot open legacy v.3.0.1 database: %s\n", sqlite3_errmsg (handle));
651
 
        sqlite3_close(handle);
652
 
        return -1;
653
 
    }
 
927
      {
 
928
          fprintf (stderr, "cannot copy legacy v.3.0.1 database\n");
 
929
          return -1;
 
930
      }
 
931
    ret =
 
932
        sqlite3_open_v2 ("copy-primitives-legacy-3.0.1.sqlite", &handle,
 
933
                         SQLITE_OPEN_READWRITE, NULL);
 
934
    if (ret != SQLITE_OK)
 
935
      {
 
936
          fprintf (stderr, "cannot open legacy v.3.0.1 database: %s\n",
 
937
                   sqlite3_errmsg (handle));
 
938
          sqlite3_close (handle);
 
939
          return -1;
 
940
      }
654
941
 
655
942
    spatialite_init_ex (handle, cache, 0);
656
 
        
657
 
    ret = do_test(handle);
658
 
    if (ret != 0) {
659
 
        fprintf(stderr, "error while testing legacy style metadata layout\n");
660
 
        return ret;
661
 
    }
 
943
 
 
944
    ret = do_test (handle);
 
945
    if (ret != 0)
 
946
      {
 
947
          fprintf (stderr,
 
948
                   "error while testing legacy style metadata layout\n");
 
949
          return ret;
 
950
      }
662
951
 
663
952
    spatialite_cleanup_ex (cache);
664
 
    sqlite3_close(handle);
665
 
    ret = unlink("copy-legacy-3.0.1.sqlite");
 
953
    sqlite3_close (handle);
 
954
    ret = unlink ("copy-primitives-legacy-3.0.1.sqlite");
666
955
    if (ret != 0)
667
 
    {
668
 
        fprintf(stderr, "cannot remove legacy v.3.0.1 database\n");
669
 
        return -1;
670
 
    }
671
 
        
 
956
      {
 
957
          fprintf (stderr, "cannot remove legacy v.3.0.1 database\n");
 
958
          return -1;
 
959
      }
 
960
 
672
961
/* testing invalid geometries [check/repair] */
673
 
    cache = spatialite_alloc_connection();
674
 
    ret = system("cp test-invalid.sqlite copy-invalid.sqlite");
 
962
    cache = spatialite_alloc_connection ();
 
963
    ret = system ("cp test-invalid.sqlite copy-invalid.sqlite");
675
964
    if (ret != 0)
676
 
    {
677
 
        fprintf(stderr, "cannot copy invalid-geoms database\n");
678
 
        return -1;
679
 
    }
680
 
    ret = sqlite3_open_v2 ("copy-invalid.sqlite", &handle, SQLITE_OPEN_READWRITE, NULL);
681
 
    if (ret != SQLITE_OK) {
682
 
        fprintf(stderr, "cannot open invalid-geoms database: %s\n", sqlite3_errmsg (handle));
683
 
        sqlite3_close(handle);
684
 
        return -1;
685
 
    }
 
965
      {
 
966
          fprintf (stderr, "cannot copy invalid-geoms database\n");
 
967
          return -1;
 
968
      }
 
969
    ret =
 
970
        sqlite3_open_v2 ("copy-invalid.sqlite", &handle, SQLITE_OPEN_READWRITE,
 
971
                         NULL);
 
972
    if (ret != SQLITE_OK)
 
973
      {
 
974
          fprintf (stderr, "cannot open invalid-geoms database: %s\n",
 
975
                   sqlite3_errmsg (handle));
 
976
          sqlite3_close (handle);
 
977
          return -1;
 
978
      }
686
979
 
687
980
    spatialite_init_ex (handle, cache, 0);
688
 
    
 
981
 
 
982
    ret = check_all_geometry_columns_r (cache, handle, "./report", NULL, NULL);
 
983
    if (!ret)
 
984
      {
 
985
          fprintf (stderr, "check_all_geometry_columns() error\n");
 
986
          sqlite3_close (handle);
 
987
          return -61;
 
988
      }
 
989
 
 
990
    ret =
 
991
        sanitize_all_geometry_columns_r (cache, handle, "tmp_", "./report",
 
992
                                         NULL, NULL);
 
993
    if (!ret)
 
994
      {
 
995
          fprintf (stderr, "sanitize_all_geometry_columns() error\n");
 
996
          sqlite3_close (handle);
 
997
          return -62;
 
998
      }
 
999
 
 
1000
    spatialite_cleanup_ex (cache);
 
1001
    sqlite3_close (handle);
 
1002
    ret = unlink ("copy-invalid.sqlite");
 
1003
    if (ret != 0)
 
1004
      {
 
1005
          fprintf (stderr, "cannot remove invalid-geoms database\n");
 
1006
          return -1;
 
1007
      }
 
1008
 
 
1009
/* testing invalid geometries [check/repair] - legacy mode */
 
1010
    spatialite_init (0);
 
1011
    ret = system ("cp test-invalid.sqlite copy-invalid.sqlite");
 
1012
    if (ret != 0)
 
1013
      {
 
1014
          fprintf (stderr, "cannot copy invalid-geoms database\n");
 
1015
          return -1;
 
1016
      }
 
1017
    ret =
 
1018
        sqlite3_open_v2 ("copy-invalid.sqlite", &handle, SQLITE_OPEN_READWRITE,
 
1019
                         NULL);
 
1020
    if (ret != SQLITE_OK)
 
1021
      {
 
1022
          fprintf (stderr, "cannot open invalid-geoms database: %s\n",
 
1023
                   sqlite3_errmsg (handle));
 
1024
          sqlite3_close (handle);
 
1025
          return -1;
 
1026
      }
 
1027
 
689
1028
    ret = check_all_geometry_columns (handle, "./report", NULL, NULL);
690
 
    if (!ret) {
691
 
        fprintf (stderr, "check_all_geometry_columns() error\n");
692
 
        sqlite3_close(handle);
693
 
        return -61;
694
 
    }
695
 
 
696
 
    ret = sanitize_all_geometry_columns (handle, "tmp_", "./report", NULL, NULL); 
697
 
    if (!ret) {
698
 
        fprintf (stderr, "sanitize_all_geometry_columns() error\n");
699
 
        sqlite3_close(handle);
700
 
        return -62;
701
 
    }
702
 
 
703
 
    spatialite_cleanup_ex (cache);
704
 
    sqlite3_close(handle);
705
 
    ret = unlink("copy-invalid.sqlite");
 
1029
    if (!ret)
 
1030
      {
 
1031
          fprintf (stderr, "check_all_geometry_columns() error\n");
 
1032
          sqlite3_close (handle);
 
1033
          return -91;
 
1034
      }
 
1035
 
 
1036
    ret =
 
1037
        sanitize_all_geometry_columns (handle, "tmp_", "./report", NULL, NULL);
 
1038
    if (!ret)
 
1039
      {
 
1040
          fprintf (stderr, "sanitize_all_geometry_columns() error\n");
 
1041
          sqlite3_close (handle);
 
1042
          return -92;
 
1043
      }
 
1044
 
 
1045
    spatialite_cleanup ();
 
1046
    sqlite3_close (handle);
 
1047
    ret = unlink ("copy-invalid.sqlite");
706
1048
    if (ret != 0)
707
 
    {
708
 
        fprintf(stderr, "cannot remove invalid-geoms database\n");
709
 
        return -1;
710
 
    }
711
 
        
 
1049
      {
 
1050
          fprintf (stderr, "cannot remove invalid-geoms database\n");
 
1051
          return -1;
 
1052
      }
 
1053
 
712
1054
/* testing legacy style metadata layout (v.2.3.1) */
713
 
    cache = spatialite_alloc_connection();
714
 
    ret = system("cp test-legacy-2.3.1.sqlite copy-legacy-2.3.1.sqlite");
 
1055
    cache = spatialite_alloc_connection ();
 
1056
    ret = system ("cp test-legacy-2.3.1.sqlite copy-legacy-2.3.1.sqlite");
715
1057
    if (ret != 0)
716
 
    {
717
 
        fprintf(stderr, "cannot copy legacy v.2.3.1 database\n");
718
 
        return -1;
719
 
    }
720
 
    ret = sqlite3_open_v2 ("copy-legacy-2.3.1.sqlite", &handle, SQLITE_OPEN_READWRITE, NULL);
721
 
    if (ret != SQLITE_OK) {
722
 
        fprintf(stderr, "cannot open legacy v.2.3.1 database: %s\n", sqlite3_errmsg (handle));
723
 
        sqlite3_close(handle);
724
 
        return -1;
725
 
    }
 
1058
      {
 
1059
          fprintf (stderr, "cannot copy legacy v.2.3.1 database\n");
 
1060
          return -1;
 
1061
      }
 
1062
    ret =
 
1063
        sqlite3_open_v2 ("copy-legacy-2.3.1.sqlite", &handle,
 
1064
                         SQLITE_OPEN_READWRITE, NULL);
 
1065
    if (ret != SQLITE_OK)
 
1066
      {
 
1067
          fprintf (stderr, "cannot open legacy v.2.3.1 database: %s\n",
 
1068
                   sqlite3_errmsg (handle));
 
1069
          sqlite3_close (handle);
 
1070
          return -1;
 
1071
      }
726
1072
 
727
1073
    spatialite_init_ex (handle, cache, 0);
728
 
        
729
 
    ret = do_test(handle);
730
 
    if (ret != 0) {
731
 
        fprintf(stderr, "error while testing legacy (2.3.1) style metadata layout\n");
732
 
        return ret;
733
 
    }
 
1074
 
 
1075
    ret = do_test (handle);
 
1076
    if (ret != 0)
 
1077
      {
 
1078
          fprintf (stderr,
 
1079
                   "error while testing legacy (2.3.1) style metadata layout\n");
 
1080
          return ret;
 
1081
      }
734
1082
 
735
1083
    spatialite_cleanup_ex (cache);
736
 
    sqlite3_close(handle);
737
 
    ret = unlink("copy-legacy-2.3.1.sqlite");
 
1084
    sqlite3_close (handle);
 
1085
    ret = unlink ("copy-legacy-2.3.1.sqlite");
738
1086
    if (ret != 0)
739
 
    {
740
 
        fprintf(stderr, "cannot remove legacy v.2.3.1 database\n");
741
 
        return -1;
742
 
    }
743
 
    
 
1087
      {
 
1088
          fprintf (stderr, "cannot remove legacy v.2.3.1 database\n");
 
1089
          return -1;
 
1090
      }
 
1091
 
744
1092
#endif /* end LWGEOM conditionals */
745
 
#endif  /* end ICONV conditional */
 
1093
#endif /* end ICONV conditional */
746
1094
 
 
1095
    spatialite_shutdown ();
747
1096
    return 0;
748
1097
}