开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
regress.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：14k
源码类别：

数据库系统

开发平台：

Unix_Linux

regress.c：源码内容
  1. /*
  2.  * $Header: /usr/local/cvsroot/pgsql/src/test/regress/regress.c,v 1.32 1999/05/25 16:15:26 momjian Exp $
  3.  */
  5. #include <float.h> /* faked on sunos */
  6. #include <stdio.h>
  7. #include <string.h> /* for MemSet() */
  9. #include <postgres.h>
  11. #include "utils/geo_decls.h" /* includes <math.h> */
  12. #include "executor/executor.h" /* For GetAttributeByName */
  14. #define P_MAXDIG 12
  15. #define LDELIM '('
  16. #define RDELIM ')'
  17. #define DELIM ','
  19. typedef void *TUPLE;
  21. extern double *regress_dist_ptpath(Point *pt, PATH *path);
  22. extern double *regress_path_dist(PATH *p1, PATH *p2);
  23. extern PATH *poly2path(POLYGON *poly);
  24. extern Point *interpt_pp(PATH *p1, PATH *p2);
  25. extern void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
  26. extern char overpaid(TUPLE tuple);
  27. extern int boxarea(BOX *box);
  28. extern char *reverse_name(char *string);
  30. /*
  31. ** Distance from a point to a path
  32. */
  33. double *
  34. regress_dist_ptpath(pt, path)
  35. Point    *pt;
  36. PATH    *path;
  37. {
  38. double    *result;
  39. double    *tmp;
  40. int i;
  41. LSEG lseg;
  43. switch (path->npts)
  44. {
  45. case 0:
  46. result = palloc(sizeof(double));
  47. *result = Abs((double) DBL_MAX); /* +infinity */
  48. break;
  49. case 1:
  50. result = point_distance(pt, &path->p[0]);
  51. break;
  52. default:
  54. /*
  55.  * the distance from a point to a path is the smallest
  56.  * distance from the point to any of its constituent segments.
  57.  */
  58. Assert(path->npts > 1);
  59. result = palloc(sizeof(double));
  60. for (i = 0; i < path->npts - 1; ++i)
  61. {
  62. regress_lseg_construct(&lseg, &path->p[i], &path->p[i + 1]);
  63. tmp = dist_ps(pt, &lseg);
  64. if (i == 0 || *tmp < *result)
  65. *result = *tmp;
  66. pfree(tmp);
  68. }
  69. break;
  70. }
  71. return result;
  72. }
  74. /* this essentially does a cartesian product of the lsegs in the
  75.    two paths, and finds the min distance between any two lsegs */
  76. double *
  77. regress_path_dist(p1, p2)
  78. PATH    *p1;
  79. PATH    *p2;
  80. {
  81. double    *min,
  82.    *tmp;
  83. int i,
  84. j;
  85. LSEG seg1,
  86. seg2;
  88. regress_lseg_construct(&seg1, &p1->p[0], &p1->p[1]);
  89. regress_lseg_construct(&seg2, &p2->p[0], &p2->p[1]);
  90. min = lseg_distance(&seg1, &seg2);
  92. for (i = 0; i < p1->npts - 1; i++)
  93. for (j = 0; j < p2->npts - 1; j++)
  94. {
  95. regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
  96. regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
  98. if (*min < *(tmp = lseg_distance(&seg1, &seg2)))
  99. *min = *tmp;
  100. pfree(tmp);
  101. }
  103. return min;
  104. }
  106. PATH *
  107. poly2path(poly)
  108. POLYGON    *poly;
  109. {
  110. int i;
  111. char    *output = (char *) palloc(2 * (P_MAXDIG + 1) * poly->npts + 64);
  112. char buf[2 * (P_MAXDIG) + 20];
  114. sprintf(output, "(1, %*d", P_MAXDIG, poly->npts);
  116. for (i = 0; i < poly->npts; i++)
  117. {
  118. sprintf(buf, ",%*g,%*g", P_MAXDIG, poly->p[i].x, P_MAXDIG, poly->p[i].y);
  119. strcat(output, buf);
  120. }
  122. sprintf(buf, "%c", RDELIM);
  123. strcat(output, buf);
  124. return path_in(output);
  125. }
  127. /* return the point where two paths intersect. Assumes that they do. */
  128. Point *
  129. interpt_pp(p1, p2)
  130. PATH    *p1;
  131. PATH    *p2;
  132. {
  134. Point    *retval;
  135. int i,
  136. j;
  137. LSEG seg1,
  138. seg2;
  140. #ifdef NOT_USED
  141. LINE    *ln;
  143. #endif
  144. bool found; /* We've found the intersection */
  146. found = false; /* Haven't found it yet */
  148. for (i = 0; i < p1->npts - 1 && !found; i++)
  149. for (j = 0; j < p2->npts - 1 && !found; j++)
  150. {
  151. regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
  152. regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
  153. if (lseg_intersect(&seg1, &seg2))
  154. found = true;
  155. }
  157. #ifdef NOT_USED
  158. ln = line_construct_pp(&seg2.p[0], &seg2.p[1]);
  159. retval = interpt_sl(&seg1, ln);
  160. #endif
  161. retval = lseg_interpt(&seg1, &seg2);
  163. return retval;
  164. }
  167. /* like lseg_construct, but assume space already allocated */
  168. void
  169. regress_lseg_construct(lseg, pt1, pt2)
  170. LSEG    *lseg;
  171. Point    *pt1;
  172. Point    *pt2;
  173. {
  174. lseg->p[0].x = pt1->x;
  175. lseg->p[0].y = pt1->y;
  176. lseg->p[1].x = pt2->x;
  177. lseg->p[1].y = pt2->y;
  178. lseg->m = point_sl(pt1, pt2);
  179. }
  182. char
  183. overpaid(tuple)
  184. TUPLE tuple;
  185. {
  186. bool isnull;
  187. long salary;
  189. salary = (long) GetAttributeByName(tuple, "salary", &isnull);
  190. return salary > 699;
  191. }
  193. /* New type "widget"
  194.  * This used to be "circle", but I added circle to builtins,
  195.  * so needed to make sure the names do not collide. - tgl 97/04/21
  196.  */
  198. typedef struct
  199. {
  200. Point center;
  201. double radius;
  202. } WIDGET;
  204. WIDGET    *widget_in(char *str);
  205. char    *widget_out(WIDGET * widget);
  206. int pt_in_widget(Point *point, WIDGET * widget);
  208. #define NARGS 3
  210. WIDGET *
  211. widget_in(str)
  212. char    *str;
  213. {
  214. char    *p,
  215.    *coord[NARGS],
  216. buf2[1000];
  217. int i;
  218. WIDGET    *result;
  220. if (str == NULL)
  221. return NULL;
  222. for (i = 0, p = str; *p && i < NARGS && *p != RDELIM; p++)
  223. if (*p == ',' || (*p == LDELIM && !i))
  224. coord[i++] = p + 1;
  225. if (i < NARGS - 1)
  226. return NULL;
  227. result = (WIDGET *) palloc(sizeof(WIDGET));
  228. result->center.x = atof(coord[0]);
  229. result->center.y = atof(coord[1]);
  230. result->radius = atof(coord[2]);
  232. sprintf(buf2, "widget_in: read (%f, %f, %f)n", result->center.x,
  233. result->center.y, result->radius);
  234. return result;
  235. }
  237. char *
  238. widget_out(widget)
  239. WIDGET    *widget;
  240. {
  241. char    *result;
  243. if (widget == NULL)
  244. return NULL;
  246. result = (char *) palloc(60);
  247. sprintf(result, "(%g,%g,%g)",
  248. widget->center.x, widget->center.y, widget->radius);
  249. return result;
  250. }
  252. int
  253. pt_in_widget(point, widget)
  254. Point    *point;
  255. WIDGET    *widget;
  256. {
  257. extern double point_dt();
  259. return point_dt(point, &widget->center) < widget->radius;
  260. }
  262. #define ABS(X) ((X) > 0 ? (X) : -(X))
  264. int
  265. boxarea(box)
  267. BOX    *box;
  269. {
  270. int width,
  271. height;
  273. width = ABS(box->high.x - box->low.x);
  274. height = ABS(box->high.y - box->low.y);
  275. return width * height;
  276. }
  278. char *
  279. reverse_name(string)
  280. char    *string;
  281. {
  282. int i;
  283. int len;
  284. char    *new_string;
  286. if (!(new_string = palloc(NAMEDATALEN)))
  287. {
  288. fprintf(stderr, "reverse_name: palloc failedn");
  289. return NULL;
  290. }
  291. MemSet(new_string, 0, NAMEDATALEN);
  292. for (i = 0; i < NAMEDATALEN && string[i]; ++i)
  293. ;
  294. if (i == NAMEDATALEN || !string[i])
  295. --i;
  296. len = i;
  297. for (; i >= 0; --i)
  298. new_string[len - i] = string[i];
  299. return new_string;
  300. }
  302. #include "executor/spi.h" /* this is what you need to work with SPI */
  303. #include "commands/trigger.h" /* -"- and triggers */
  305. static TransactionId fd17b_xid = InvalidTransactionId;
  306. static TransactionId fd17a_xid = InvalidTransactionId;
  307. static int fd17b_level = 0;
  308. static int fd17a_level = 0;
  309. static bool fd17b_recursion = true;
  310. static bool fd17a_recursion = true;
  311. HeapTuple funny_dup17(void);
  313. HeapTuple /* have to return HeapTuple to Executor */
  314. funny_dup17()
  315. {
  316. TransactionId *xid;
  317. int    *level;
  318. bool    *recursion;
  319. Relation rel;
  320. TupleDesc tupdesc;
  321. HeapTuple tuple;
  322. char sql[MAX_QUERY_SIZE];
  323. char    *when;
  324. int inserted;
  325. int selected = 0;
  326. int ret;
  328. tuple = CurrentTriggerData->tg_trigtuple;
  329. rel = CurrentTriggerData->tg_relation;
  330. tupdesc = rel->rd_att;
  331. if (TRIGGER_FIRED_BEFORE(CurrentTriggerData->tg_event))
  332. {
  333. xid = &fd17b_xid;
  334. level = &fd17b_level;
  335. recursion = &fd17b_recursion;
  336. when = "BEFORE";
  337. }
  338. else
  339. {
  340. xid = &fd17a_xid;
  341. level = &fd17a_level;
  342. recursion = &fd17a_recursion;
  343. when = "AFTER ";
  344. }
  346. CurrentTriggerData = NULL;
  348. if (!TransactionIdIsCurrentTransactionId(*xid))
  349. {
  350. *xid = GetCurrentTransactionId();
  351. *level = 0;
  352. *recursion = true;
  353. }
  355. if (*level == 17)
  356. {
  357. *recursion = false;
  358. return tuple;
  359. }
  361. if (!(*recursion))
  362. return tuple;
  364. (*level)++;
  366. SPI_connect();
  368. sprintf(sql, "insert into %s select * from %s where %s = '%s'::%s",
  369. SPI_getrelname(rel), SPI_getrelname(rel),
  370. SPI_fname(tupdesc, 1),
  371. SPI_getvalue(tuple, tupdesc, 1),
  372. SPI_gettype(tupdesc, 1));
  374. if ((ret = SPI_exec(sql, 0)) < 0)
  375. elog(ERROR, "funny_dup17 (fired %s) on level %3d: SPI_exec (insert ...) returned %d",
  376.  when, *level, ret);
  378. inserted = SPI_processed;
  380. sprintf(sql, "select count (*) from %s where %s = '%s'::%s",
  381. SPI_getrelname(rel),
  382. SPI_fname(tupdesc, 1),
  383. SPI_getvalue(tuple, tupdesc, 1),
  384. SPI_gettype(tupdesc, 1));
  386. if ((ret = SPI_exec(sql, 0)) < 0)
  387. elog(ERROR, "funny_dup17 (fired %s) on level %3d: SPI_exec (select ...) returned %d",
  388.  when, *level, ret);
  390. if (SPI_processed > 0)
  391. {
  392. selected = int4in(
  393.   SPI_getvalue(
  394.    SPI_tuptable->vals[0],
  395.    SPI_tuptable->tupdesc,
  396.    1
  397.    )
  398. );
  399. }
  401. elog(NOTICE, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
  402.  when, *level, inserted, selected);
  404. SPI_finish();
  406. (*level)--;
  408. if (*level == 0)
  409. *xid = InvalidTransactionId;
  411. return tuple;
  412. }
  414. HeapTuple ttdummy(void);
  415. int32 set_ttdummy(int32 on);
  417. extern int4 nextval(struct varlena * seqin);
  419. #define TTDUMMY_INFINITY 999999
  421. static void *splan = NULL;
  422. static bool ttoff = false;
  424. HeapTuple
  425. ttdummy()
  426. {
  427. Trigger    *trigger; /* to get trigger name */
  428. char   **args; /* arguments */
  429. int attnum[2]; /* fnumbers of start/stop columns */
  430. Datum oldon,
  431. oldoff;
  432. Datum newon,
  433. newoff;
  434. Datum    *cvals; /* column values */
  435. char    *cnulls; /* column nulls */
  436. char    *relname; /* triggered relation name */
  437. Relation rel; /* triggered relation */
  438. HeapTuple trigtuple;
  439. HeapTuple newtuple = NULL;
  440. HeapTuple rettuple;
  441. TupleDesc tupdesc; /* tuple description */
  442. int natts; /* # of attributes */
  443. bool isnull; /* to know is some column NULL or not */
  444. int ret;
  445. int i;
  447. if (!CurrentTriggerData)
  448. elog(ERROR, "ttdummy: triggers are not initialized");
  449. if (TRIGGER_FIRED_FOR_STATEMENT(CurrentTriggerData->tg_event))
  450. elog(ERROR, "ttdummy: can't process STATEMENT events");
  451. if (TRIGGER_FIRED_AFTER(CurrentTriggerData->tg_event))
  452. elog(ERROR, "ttdummy: must be fired before event");
  453. if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
  454. elog(ERROR, "ttdummy: can't process INSERT event");
  455. if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
  456. newtuple = CurrentTriggerData->tg_newtuple;
  458. trigtuple = CurrentTriggerData->tg_trigtuple;
  460. rel = CurrentTriggerData->tg_relation;
  461. relname = SPI_getrelname(rel);
  463. /* check if TT is OFF for this relation */
  464. if (ttoff) /* OFF - nothing to do */
  465. {
  466. pfree(relname);
  467. return (newtuple != NULL) ? newtuple : trigtuple;
  468. }
  470. trigger = CurrentTriggerData->tg_trigger;
  472. if (trigger->tgnargs != 2)
  473. elog(ERROR, "ttdummy (%s): invalid (!= 2) number of arguments %d",
  474.  relname, trigger->tgnargs);
  476. args = trigger->tgargs;
  477. tupdesc = rel->rd_att;
  478. natts = tupdesc->natts;
  480. CurrentTriggerData = NULL;
  482. for (i = 0; i < 2; i++)
  483. {
  484. attnum[i] = SPI_fnumber(tupdesc, args[i]);
  485. if (attnum[i] < 0)
  486. elog(ERROR, "ttdummy (%s): there is no attribute %s", relname, args[i]);
  487. if (SPI_gettypeid(tupdesc, attnum[i]) != INT4OID)
  488. elog(ERROR, "ttdummy (%s): attributes %s and %s must be of abstime type",
  489.  relname, args[0], args[1]);
  490. }
  492. oldon = SPI_getbinval(trigtuple, tupdesc, attnum[0], &isnull);
  493. if (isnull)
  494. elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
  496. oldoff = SPI_getbinval(trigtuple, tupdesc, attnum[1], &isnull);
  497. if (isnull)
  498. elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
  500. if (newtuple != NULL) /* UPDATE */
  501. {
  502. newon = SPI_getbinval(newtuple, tupdesc, attnum[0], &isnull);
  503. if (isnull)
  504. elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[0]);
  505. newoff = SPI_getbinval(newtuple, tupdesc, attnum[1], &isnull);
  506. if (isnull)
  507. elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
  509. if (oldon != newon || oldoff != newoff)
  510. elog(ERROR, "ttdummy (%s): you can't change %s and/or %s columns (use set_ttdummy)",
  511.  relname, args[0], args[1]);
  513. if (newoff != TTDUMMY_INFINITY)
  514. {
  515. pfree(relname); /* allocated in upper executor context */
  516. return NULL;
  517. }
  518. }
  519. else if (oldoff != TTDUMMY_INFINITY) /* DELETE */
  520. {
  521. pfree(relname);
  522. return NULL;
  523. }
  525. {
  526. struct varlena *seqname = textin("ttdummy_seq");
  528. newoff = nextval(seqname);
  529. pfree(seqname);
  530. }
  532. /* Connect to SPI manager */
  533. if ((ret = SPI_connect()) < 0)
  534. elog(ERROR, "ttdummy (%s): SPI_connect returned %d", relname, ret);
  536. /* Fetch tuple values and nulls */
  537. cvals = (Datum *) palloc(natts * sizeof(Datum));
  538. cnulls = (char *) palloc(natts * sizeof(char));
  539. for (i = 0; i < natts; i++)
  540. {
  541. cvals[i] = SPI_getbinval((newtuple != NULL) ? newtuple : trigtuple,
  542.  tupdesc, i + 1, &isnull);
  543. cnulls[i] = (isnull) ? 'n' : ' ';
  544. }
  546. /* change date column(s) */
  547. if (newtuple) /* UPDATE */
  548. {
  549. cvals[attnum[0] - 1] = newoff; /* start_date eq current date */
  550. cnulls[attnum[0] - 1] = ' ';
  551. cvals[attnum[1] - 1] = TTDUMMY_INFINITY; /* stop_date eq INFINITY */
  552. cnulls[attnum[1] - 1] = ' ';
  553. }
  554. else
  555. /* DELETE */
  556. {
  557. cvals[attnum[1] - 1] = newoff; /* stop_date eq current date */
  558. cnulls[attnum[1] - 1] = ' ';
  559. }
  561. /* if there is no plan ... */
  562. if (splan == NULL)
  563. {
  564. void    *pplan;
  565. Oid    *ctypes;
  566. char sql[MAX_QUERY_SIZE];
  568. /* allocate ctypes for preparation */
  569. ctypes = (Oid *) palloc(natts * sizeof(Oid));
  571. /*
  572.  * Construct query: INSERT INTO _relation_ VALUES ($1, ...)
  573.  */
  574. sprintf(sql, "INSERT INTO %s VALUES (", relname);
  575. for (i = 1; i <= natts; i++)
  576. {
  577. sprintf(sql + strlen(sql), "$%d%s",
  578. i, (i < natts) ? ", " : ")");
  579. ctypes[i - 1] = SPI_gettypeid(tupdesc, i);
  580. }
  582. /* Prepare plan for query */
  583. pplan = SPI_prepare(sql, natts, ctypes);
  584. if (pplan == NULL)
  585. elog(ERROR, "ttdummy (%s): SPI_prepare returned %d", relname, SPI_result);
  587. pplan = SPI_saveplan(pplan);
  588. if (pplan == NULL)
  589. elog(ERROR, "ttdummy (%s): SPI_saveplan returned %d", relname, SPI_result);
  591. splan = pplan;
  592. }
  594. ret = SPI_execp(splan, cvals, cnulls, 0);
  596. if (ret < 0)
  597. elog(ERROR, "ttdummy (%s): SPI_execp returned %d", relname, ret);
  599. /* Tuple to return to upper Executor ... */
  600. if (newtuple) /* UPDATE */
  601. {
  602. HeapTuple tmptuple;
  604. tmptuple = SPI_copytuple(trigtuple);
  605. rettuple = SPI_modifytuple(rel, tmptuple, 1, &(attnum[1]), &newoff, NULL);
  606. SPI_pfree(tmptuple);
  607. }
  608. else
  609. /* DELETE */
  610. rettuple = trigtuple;
  612. SPI_finish(); /* don't forget say Bye to SPI mgr */
  614. pfree(relname);
  616. return rettuple;
  617. }
  619. int32
  620. set_ttdummy(int32 on)
  621. {
  623. if (ttoff) /* OFF currently */
  624. {
  625. if (on == 0)
  626. return 0;
  628. /* turn ON */
  629. ttoff = false;
  630. return 0;
  631. }
  633. /* ON currently */
  634. if (on != 0)
  635. return 1;
  637. /* turn OFF */
  638. ttoff = true;
  640. return 1;
  642. }