1: /*
2: ** 2010 August 28
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** Code for testing all sorts of SQLite interfaces. This code
13: ** is not included in the SQLite library.
14: */
15:
16: #include <sqlite3.h>
17:
18: /* Solely for the UNUSED_PARAMETER() macro. */
19: #include "sqliteInt.h"
20:
21: #ifdef SQLITE_ENABLE_RTREE
22: /*
23: ** Type used to cache parameter information for the "circle" r-tree geometry
24: ** callback.
25: */
26: typedef struct Circle Circle;
27: struct Circle {
28: struct Box {
29: double xmin;
30: double xmax;
31: double ymin;
32: double ymax;
33: } aBox[2];
34: double centerx;
35: double centery;
36: double radius;
37: };
38:
39: /*
40: ** Destructor function for Circle objects allocated by circle_geom().
41: */
42: static void circle_del(void *p){
43: sqlite3_free(p);
44: }
45:
46: /*
47: ** Implementation of "circle" r-tree geometry callback.
48: */
49: static int circle_geom(
50: sqlite3_rtree_geometry *p,
51: int nCoord,
52: double *aCoord,
53: int *pRes
54: ){
55: int i; /* Iterator variable */
56: Circle *pCircle; /* Structure defining circular region */
57: double xmin, xmax; /* X dimensions of box being tested */
58: double ymin, ymax; /* X dimensions of box being tested */
59:
60: if( p->pUser==0 ){
61: /* If pUser is still 0, then the parameter values have not been tested
62: ** for correctness or stored into a Circle structure yet. Do this now. */
63:
64: /* This geometry callback is for use with a 2-dimensional r-tree table.
65: ** Return an error if the table does not have exactly 2 dimensions. */
66: if( nCoord!=4 ) return SQLITE_ERROR;
67:
68: /* Test that the correct number of parameters (3) have been supplied,
69: ** and that the parameters are in range (that the radius of the circle
70: ** radius is greater than zero). */
71: if( p->nParam!=3 || p->aParam[2]<0.0 ) return SQLITE_ERROR;
72:
73: /* Allocate a structure to cache parameter data in. Return SQLITE_NOMEM
74: ** if the allocation fails. */
75: pCircle = (Circle *)(p->pUser = sqlite3_malloc(sizeof(Circle)));
76: if( !pCircle ) return SQLITE_NOMEM;
77: p->xDelUser = circle_del;
78:
79: /* Record the center and radius of the circular region. One way that
80: ** tested bounding boxes that intersect the circular region are detected
81: ** is by testing if each corner of the bounding box lies within radius
82: ** units of the center of the circle. */
83: pCircle->centerx = p->aParam[0];
84: pCircle->centery = p->aParam[1];
85: pCircle->radius = p->aParam[2];
86:
87: /* Define two bounding box regions. The first, aBox[0], extends to
88: ** infinity in the X dimension. It covers the same range of the Y dimension
89: ** as the circular region. The second, aBox[1], extends to infinity in
90: ** the Y dimension and is constrained to the range of the circle in the
91: ** X dimension.
92: **
93: ** Then imagine each box is split in half along its short axis by a line
94: ** that intersects the center of the circular region. A bounding box
95: ** being tested can be said to intersect the circular region if it contains
96: ** points from each half of either of the two infinite bounding boxes.
97: */
98: pCircle->aBox[0].xmin = pCircle->centerx;
99: pCircle->aBox[0].xmax = pCircle->centerx;
100: pCircle->aBox[0].ymin = pCircle->centery + pCircle->radius;
101: pCircle->aBox[0].ymax = pCircle->centery - pCircle->radius;
102: pCircle->aBox[1].xmin = pCircle->centerx + pCircle->radius;
103: pCircle->aBox[1].xmax = pCircle->centerx - pCircle->radius;
104: pCircle->aBox[1].ymin = pCircle->centery;
105: pCircle->aBox[1].ymax = pCircle->centery;
106: }
107:
108: pCircle = (Circle *)p->pUser;
109: xmin = aCoord[0];
110: xmax = aCoord[1];
111: ymin = aCoord[2];
112: ymax = aCoord[3];
113:
114: /* Check if any of the 4 corners of the bounding-box being tested lie
115: ** inside the circular region. If they do, then the bounding-box does
116: ** intersect the region of interest. Set the output variable to true and
117: ** return SQLITE_OK in this case. */
118: for(i=0; i<4; i++){
119: double x = (i&0x01) ? xmax : xmin;
120: double y = (i&0x02) ? ymax : ymin;
121: double d2;
122:
123: d2 = (x-pCircle->centerx)*(x-pCircle->centerx);
124: d2 += (y-pCircle->centery)*(y-pCircle->centery);
125: if( d2<(pCircle->radius*pCircle->radius) ){
126: *pRes = 1;
127: return SQLITE_OK;
128: }
129: }
130:
131: /* Check if the bounding box covers any other part of the circular region.
132: ** See comments above for a description of how this test works. If it does
133: ** cover part of the circular region, set the output variable to true
134: ** and return SQLITE_OK. */
135: for(i=0; i<2; i++){
136: if( xmin<=pCircle->aBox[i].xmin
137: && xmax>=pCircle->aBox[i].xmax
138: && ymin<=pCircle->aBox[i].ymin
139: && ymax>=pCircle->aBox[i].ymax
140: ){
141: *pRes = 1;
142: return SQLITE_OK;
143: }
144: }
145:
146: /* The specified bounding box does not intersect the circular region. Set
147: ** the output variable to zero and return SQLITE_OK. */
148: *pRes = 0;
149: return SQLITE_OK;
150: }
151:
152: /* END of implementation of "circle" geometry callback.
153: **************************************************************************
154: *************************************************************************/
155:
156: #include <assert.h>
157: #include "tcl.h"
158:
159: typedef struct Cube Cube;
160: struct Cube {
161: double x;
162: double y;
163: double z;
164: double width;
165: double height;
166: double depth;
167: };
168:
169: static void cube_context_free(void *p){
170: sqlite3_free(p);
171: }
172:
173: /*
174: ** The context pointer registered along with the 'cube' callback is
175: ** always ((void *)&gHere). This is just to facilitate testing, it is not
176: ** actually used for anything.
177: */
178: static int gHere = 42;
179:
180: /*
181: ** Implementation of a simple r-tree geom callback to test for intersection
182: ** of r-tree rows with a "cube" shape. Cubes are defined by six scalar
183: ** coordinates as follows:
184: **
185: ** cube(x, y, z, width, height, depth)
186: **
187: ** The width, height and depth parameters must all be greater than zero.
188: */
189: static int cube_geom(
190: sqlite3_rtree_geometry *p,
191: int nCoord,
192: double *aCoord,
193: int *piRes
194: ){
195: Cube *pCube = (Cube *)p->pUser;
196:
197: assert( p->pContext==(void *)&gHere );
198:
199: if( pCube==0 ){
200: if( p->nParam!=6 || nCoord!=6
201: || p->aParam[3]<=0.0 || p->aParam[4]<=0.0 || p->aParam[5]<=0.0
202: ){
203: return SQLITE_ERROR;
204: }
205: pCube = (Cube *)sqlite3_malloc(sizeof(Cube));
206: if( !pCube ){
207: return SQLITE_NOMEM;
208: }
209: pCube->x = p->aParam[0];
210: pCube->y = p->aParam[1];
211: pCube->z = p->aParam[2];
212: pCube->width = p->aParam[3];
213: pCube->height = p->aParam[4];
214: pCube->depth = p->aParam[5];
215:
216: p->pUser = (void *)pCube;
217: p->xDelUser = cube_context_free;
218: }
219:
220: assert( nCoord==6 );
221: *piRes = 0;
222: if( aCoord[0]<=(pCube->x+pCube->width)
223: && aCoord[1]>=pCube->x
224: && aCoord[2]<=(pCube->y+pCube->height)
225: && aCoord[3]>=pCube->y
226: && aCoord[4]<=(pCube->z+pCube->depth)
227: && aCoord[5]>=pCube->z
228: ){
229: *piRes = 1;
230: }
231:
232: return SQLITE_OK;
233: }
234: #endif /* SQLITE_ENABLE_RTREE */
235:
236: static int register_cube_geom(
237: void * clientData,
238: Tcl_Interp *interp,
239: int objc,
240: Tcl_Obj *CONST objv[]
241: ){
242: #ifndef SQLITE_ENABLE_RTREE
243: UNUSED_PARAMETER(clientData);
244: UNUSED_PARAMETER(interp);
245: UNUSED_PARAMETER(objc);
246: UNUSED_PARAMETER(objv);
247: #else
248: extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
249: extern const char *sqlite3TestErrorName(int);
250: sqlite3 *db;
251: int rc;
252:
253: if( objc!=2 ){
254: Tcl_WrongNumArgs(interp, 1, objv, "DB");
255: return TCL_ERROR;
256: }
257: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
258: rc = sqlite3_rtree_geometry_callback(db, "cube", cube_geom, (void *)&gHere);
259: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
260: #endif
261: return TCL_OK;
262: }
263:
264: static int register_circle_geom(
265: void * clientData,
266: Tcl_Interp *interp,
267: int objc,
268: Tcl_Obj *CONST objv[]
269: ){
270: #ifndef SQLITE_ENABLE_RTREE
271: UNUSED_PARAMETER(clientData);
272: UNUSED_PARAMETER(interp);
273: UNUSED_PARAMETER(objc);
274: UNUSED_PARAMETER(objv);
275: #else
276: extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**);
277: extern const char *sqlite3TestErrorName(int);
278: sqlite3 *db;
279: int rc;
280:
281: if( objc!=2 ){
282: Tcl_WrongNumArgs(interp, 1, objv, "DB");
283: return TCL_ERROR;
284: }
285: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
286: rc = sqlite3_rtree_geometry_callback(db, "circle", circle_geom, 0);
287: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
288: #endif
289: return TCL_OK;
290: }
291:
292: int Sqlitetestrtree_Init(Tcl_Interp *interp){
293: Tcl_CreateObjCommand(interp, "register_cube_geom", register_cube_geom, 0, 0);
294: Tcl_CreateObjCommand(interp, "register_circle_geom",register_circle_geom,0,0);
295: return TCL_OK;
296: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_rtree.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src