/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.42 2000/07/29 18:46:12 tgl Exp $
+ * $PostgreSQL: pgsql/src/test/regress/regress.c,v 1.72 2009/01/07 13:44:37 tgl Exp $
*/
-#include <float.h> /* faked on sunos */
-
#include "postgres.h"
-#include "utils/geo_decls.h" /* includes <math.h> */
-#include "executor/executor.h" /* For GetAttributeByName */
-#include "commands/sequence.h" /* for nextval() */
+#include <float.h>
+#include <math.h>
+
+#include "access/transam.h"
+#include "access/xact.h"
+#include "catalog/pg_type.h"
+#include "commands/sequence.h"
+#include "commands/trigger.h"
+#include "executor/executor.h"
+#include "executor/spi.h"
+#include "utils/builtins.h"
+#include "utils/geo_decls.h"
+
#define P_MAXDIG 12
#define LDELIM '('
#define RDELIM ')'
#define DELIM ','
-typedef TupleTableSlot *TUPLE;
-
-extern double *regress_dist_ptpath(Point *pt, PATH *path);
-extern double *regress_path_dist(PATH *p1, PATH *p2);
+extern Datum regress_dist_ptpath(PG_FUNCTION_ARGS);
+extern Datum regress_path_dist(PG_FUNCTION_ARGS);
extern PATH *poly2path(POLYGON *poly);
-extern Point *interpt_pp(PATH *p1, PATH *p2);
+extern Datum interpt_pp(PG_FUNCTION_ARGS);
extern void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
extern Datum overpaid(PG_FUNCTION_ARGS);
extern Datum boxarea(PG_FUNCTION_ARGS);
extern char *reverse_name(char *string);
+extern int oldstyle_length(int n, text *t);
+extern Datum int44in(PG_FUNCTION_ARGS);
+extern Datum int44out(PG_FUNCTION_ARGS);
+
+#ifdef PG_MODULE_MAGIC
+PG_MODULE_MAGIC;
+#endif
+
/*
-** Distance from a point to a path
-*/
-double *
-regress_dist_ptpath(pt, path)
-Point *pt;
-PATH *path;
+ * Distance from a point to a path
+ */
+PG_FUNCTION_INFO_V1(regress_dist_ptpath);
+
+Datum
+regress_dist_ptpath(PG_FUNCTION_ARGS)
{
- double *result;
- double *tmp;
+ Point *pt = PG_GETARG_POINT_P(0);
+ PATH *path = PG_GETARG_PATH_P(1);
+ float8 result = 0.0; /* keep compiler quiet */
+ float8 tmp;
int i;
LSEG lseg;
switch (path->npts)
{
case 0:
- result = palloc(sizeof(double));
- *result = Abs((double) DBL_MAX); /* +infinity */
- break;
+ PG_RETURN_NULL();
case 1:
- result = point_distance(pt, &path->p[0]);
+ result = point_dt(pt, &path->p[0]);
break;
default:
/*
- * the distance from a point to a path is the smallest
- * distance from the point to any of its constituent segments.
+ * the distance from a point to a path is the smallest distance
+ * from the point to any of its constituent segments.
*/
Assert(path->npts > 1);
- result = palloc(sizeof(double));
for (i = 0; i < path->npts - 1; ++i)
{
regress_lseg_construct(&lseg, &path->p[i], &path->p[i + 1]);
- tmp = dist_ps(pt, &lseg);
- if (i == 0 || *tmp < *result)
- *result = *tmp;
- pfree(tmp);
-
+ tmp = DatumGetFloat8(DirectFunctionCall2(dist_ps,
+ PointPGetDatum(pt),
+ LsegPGetDatum(&lseg)));
+ if (i == 0 || tmp < result)
+ result = tmp;
}
break;
}
- return result;
+ PG_RETURN_FLOAT8(result);
}
-/* this essentially does a cartesian product of the lsegs in the
- two paths, and finds the min distance between any two lsegs */
-double *
-regress_path_dist(p1, p2)
-PATH *p1;
-PATH *p2;
+/*
+ * this essentially does a cartesian product of the lsegs in the
+ * two paths, and finds the min distance between any two lsegs
+ */
+PG_FUNCTION_INFO_V1(regress_path_dist);
+
+Datum
+regress_path_dist(PG_FUNCTION_ARGS)
{
- double *min,
- *tmp;
+ PATH *p1 = PG_GETARG_PATH_P(0);
+ PATH *p2 = PG_GETARG_PATH_P(1);
+ bool have_min = false;
+ float8 min = 0.0; /* initialize to keep compiler quiet */
+ float8 tmp;
int i,
j;
LSEG seg1,
seg2;
- regress_lseg_construct(&seg1, &p1->p[0], &p1->p[1]);
- regress_lseg_construct(&seg2, &p2->p[0], &p2->p[1]);
- min = lseg_distance(&seg1, &seg2);
-
for (i = 0; i < p1->npts - 1; i++)
+ {
for (j = 0; j < p2->npts - 1; j++)
{
regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
- if (*min < *(tmp = lseg_distance(&seg1, &seg2)))
- *min = *tmp;
- pfree(tmp);
+ tmp = DatumGetFloat8(DirectFunctionCall2(lseg_distance,
+ LsegPGetDatum(&seg1),
+ LsegPGetDatum(&seg2)));
+ if (!have_min || tmp < min)
+ {
+ min = tmp;
+ have_min = true;
+ }
}
+ }
- return min;
+ if (!have_min)
+ PG_RETURN_NULL();
+
+ PG_RETURN_FLOAT8(min);
}
PATH *
-poly2path(poly)
-POLYGON *poly;
+poly2path(POLYGON *poly)
{
int i;
char *output = (char *) palloc(2 * (P_MAXDIG + 1) * poly->npts + 64);
for (i = 0; i < poly->npts; i++)
{
- sprintf(buf, ",%*g,%*g", P_MAXDIG, poly->p[i].x, P_MAXDIG, poly->p[i].y);
+ snprintf(buf, sizeof(buf), ",%*g,%*g",
+ P_MAXDIG, poly->p[i].x, P_MAXDIG, poly->p[i].y);
strcat(output, buf);
}
- sprintf(buf, "%c", RDELIM);
+ snprintf(buf, sizeof(buf), "%c", RDELIM);
strcat(output, buf);
return DatumGetPathP(DirectFunctionCall1(path_in,
CStringGetDatum(output)));
}
-/* return the point where two paths intersect. Assumes that they do. */
-Point *
-interpt_pp(p1, p2)
-PATH *p1;
-PATH *p2;
-{
+/* return the point where two paths intersect, or NULL if no intersection. */
+PG_FUNCTION_INFO_V1(interpt_pp);
- Point *retval;
+Datum
+interpt_pp(PG_FUNCTION_ARGS)
+{
+ PATH *p1 = PG_GETARG_PATH_P(0);
+ PATH *p2 = PG_GETARG_PATH_P(1);
int i,
j;
LSEG seg1,
seg2;
-
-#ifdef NOT_USED
- LINE *ln;
-
-#endif
bool found; /* We've found the intersection */
found = false; /* Haven't found it yet */
for (i = 0; i < p1->npts - 1 && !found; i++)
+ {
+ regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
for (j = 0; j < p2->npts - 1 && !found; j++)
{
- regress_lseg_construct(&seg1, &p1->p[i], &p1->p[i + 1]);
regress_lseg_construct(&seg2, &p2->p[j], &p2->p[j + 1]);
- if (lseg_intersect(&seg1, &seg2))
+ if (DatumGetBool(DirectFunctionCall2(lseg_intersect,
+ LsegPGetDatum(&seg1),
+ LsegPGetDatum(&seg2))))
found = true;
}
+ }
-#ifdef NOT_USED
- ln = line_construct_pp(&seg2.p[0], &seg2.p[1]);
- retval = interpt_sl(&seg1, ln);
-#endif
- retval = lseg_interpt(&seg1, &seg2);
+ if (!found)
+ PG_RETURN_NULL();
- return retval;
+ /*
+ * Note: DirectFunctionCall2 will kick out an error if lseg_interpt()
+ * returns NULL, but that should be impossible since we know the two
+ * segments intersect.
+ */
+ PG_RETURN_DATUM(DirectFunctionCall2(lseg_interpt,
+ LsegPGetDatum(&seg1),
+ LsegPGetDatum(&seg2)));
}
/* like lseg_construct, but assume space already allocated */
void
-regress_lseg_construct(lseg, pt1, pt2)
-LSEG *lseg;
-Point *pt1;
-Point *pt2;
+regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2)
{
lseg->p[0].x = pt1->x;
lseg->p[0].y = pt1->y;
lseg->m = point_sl(pt1, pt2);
}
+PG_FUNCTION_INFO_V1(overpaid);
+
Datum
overpaid(PG_FUNCTION_ARGS)
{
- TUPLE tuple = (TUPLE) PG_GETARG_POINTER(0);
+ HeapTupleHeader tuple = PG_GETARG_HEAPTUPLEHEADER(0);
bool isnull;
- long salary;
+ int32 salary;
- salary = (long) GetAttributeByName(tuple, "salary", &isnull);
+ salary = DatumGetInt32(GetAttributeByName(tuple, "salary", &isnull));
if (isnull)
PG_RETURN_NULL();
PG_RETURN_BOOL(salary > 699);
{
Point center;
double radius;
-} WIDGET;
+} WIDGET;
WIDGET *widget_in(char *str);
char *widget_out(WIDGET * widget);
#define NARGS 3
WIDGET *
-widget_in(str)
-char *str;
+widget_in(char *str)
{
char *p,
*coord[NARGS],
result->center.y = atof(coord[1]);
result->radius = atof(coord[2]);
- sprintf(buf2, "widget_in: read (%f, %f, %f)\n", result->center.x,
- result->center.y, result->radius);
+ snprintf(buf2, sizeof(buf2), "widget_in: read (%f, %f, %f)\n",
+ result->center.x, result->center.y, result->radius);
return result;
}
char *
-widget_out(widget)
-WIDGET *widget;
+widget_out(WIDGET * widget)
{
char *result;
return result;
}
+PG_FUNCTION_INFO_V1(pt_in_widget);
+
Datum
pt_in_widget(PG_FUNCTION_ARGS)
{
PG_RETURN_BOOL(point_dt(point, &widget->center) < widget->radius);
}
-#define ABS(X) ((X) >= 0 ? (X) : -(X))
+PG_FUNCTION_INFO_V1(boxarea);
Datum
boxarea(PG_FUNCTION_ARGS)
double width,
height;
- width = ABS(box->high.x - box->low.x);
- height = ABS(box->high.y - box->low.y);
+ width = Abs(box->high.x - box->low.x);
+ height = Abs(box->high.y - box->low.y);
PG_RETURN_FLOAT8(width * height);
}
char *
-reverse_name(string)
-char *string;
+reverse_name(char *string)
{
int i;
int len;
char *new_string;
- if (!(new_string = palloc(NAMEDATALEN)))
- {
- fprintf(stderr, "reverse_name: palloc failed\n");
- return NULL;
- }
- MemSet(new_string, 0, NAMEDATALEN);
+ new_string = palloc0(NAMEDATALEN);
for (i = 0; i < NAMEDATALEN && string[i]; ++i)
;
if (i == NAMEDATALEN || !string[i])
return new_string;
}
-#include "executor/spi.h" /* this is what you need to work with SPI */
-#include "commands/trigger.h" /* -"- and triggers */
+/*
+ * This rather silly function is just to test that oldstyle functions
+ * work correctly on toast-able inputs.
+ */
+int
+oldstyle_length(int n, text *t)
+{
+ int len = 0;
+
+ if (t)
+ len = VARSIZE(t) - VARHDRSZ;
+
+ return n + len;
+}
+
static TransactionId fd17b_xid = InvalidTransactionId;
static TransactionId fd17a_xid = InvalidTransactionId;
static bool fd17a_recursion = true;
extern Datum funny_dup17(PG_FUNCTION_ARGS);
+PG_FUNCTION_INFO_V1(funny_dup17);
+
Datum
funny_dup17(PG_FUNCTION_ARGS)
{
if (SPI_processed > 0)
{
selected = DatumGetInt32(DirectFunctionCall1(int4in,
- CStringGetDatum(SPI_getvalue(
- SPI_tuptable->vals[0],
- SPI_tuptable->tupdesc,
- 1
- ))));
+ CStringGetDatum(SPI_getvalue(
+ SPI_tuptable->vals[0],
+ SPI_tuptable->tupdesc,
+ 1
+ ))));
}
- elog(NOTICE, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
+ elog(DEBUG4, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
when, *level, inserted, selected);
SPI_finish();
#define TTDUMMY_INFINITY 999999
-static void *splan = NULL;
+static SPIPlanPtr splan = NULL;
static bool ttoff = false;
+PG_FUNCTION_INFO_V1(ttdummy);
+
Datum
ttdummy(PG_FUNCTION_ARGS)
{
if (!CALLED_AS_TRIGGER(fcinfo))
elog(ERROR, "ttdummy: not fired by trigger manager");
if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
- elog(ERROR, "ttdummy: can't process STATEMENT events");
+ elog(ERROR, "ttdummy: cannot process STATEMENT events");
if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
elog(ERROR, "ttdummy: must be fired before event");
if (TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
- elog(ERROR, "ttdummy: can't process INSERT event");
+ elog(ERROR, "ttdummy: cannot process INSERT event");
if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
newtuple = trigdata->tg_newtuple;
elog(ERROR, "ttdummy (%s): %s must be NOT NULL", relname, args[1]);
if (oldon != newon || oldoff != newoff)
- elog(ERROR, "ttdummy (%s): you can't change %s and/or %s columns (use set_ttdummy)",
+ elog(ERROR, "ttdummy (%s): you cannot change %s and/or %s columns (use set_ttdummy)",
relname, args[0], args[1]);
if (newoff != TTDUMMY_INFINITY)
return PointerGetDatum(NULL);
}
- {
- text *seqname = DatumGetTextP(DirectFunctionCall1(textin,
- CStringGetDatum("ttdummy_seq")));
-
- newoff = DirectFunctionCall1(nextval,
- PointerGetDatum(seqname));
- pfree(seqname);
- }
+ newoff = DirectFunctionCall1(nextval, CStringGetTextDatum("ttdummy_seq"));
+ /* nextval now returns int64; coerce down to int32 */
+ newoff = Int32GetDatum((int32) DatumGetInt64(newoff));
/* Connect to SPI manager */
if ((ret = SPI_connect()) < 0)
cnulls[attnum[1] - 1] = ' ';
}
else
-/* DELETE */
+ /* DELETE */
{
cvals[attnum[1] - 1] = newoff; /* stop_date eq current date */
cnulls[attnum[1] - 1] = ' ';
/* if there is no plan ... */
if (splan == NULL)
{
- void *pplan;
+ SPIPlanPtr pplan;
Oid *ctypes;
char *query;
SPI_freetuple(tmptuple);
}
else
-/* DELETE */
+ /* DELETE */
rettuple = trigtuple;
SPI_finish(); /* don't forget say Bye to SPI mgr */
return PointerGetDatum(rettuple);
}
+PG_FUNCTION_INFO_V1(set_ttdummy);
+
Datum
set_ttdummy(PG_FUNCTION_ARGS)
{
PG_RETURN_INT32(1);
}
+
+
+/*
+ * Type int44 has no real-world use, but the regression tests use it.
+ * It's a four-element vector of int4's.
+ */
+
+/*
+ * int44in - converts "num num ..." to internal form
+ *
+ * Note: Fills any missing positions with zeroes.
+ */
+PG_FUNCTION_INFO_V1(int44in);
+
+Datum
+int44in(PG_FUNCTION_ARGS)
+{
+ char *input_string = PG_GETARG_CSTRING(0);
+ int32 *result = (int32 *) palloc(4 * sizeof(int32));
+ int i;
+
+ i = sscanf(input_string,
+ "%d, %d, %d, %d",
+ &result[0],
+ &result[1],
+ &result[2],
+ &result[3]);
+ while (i < 4)
+ result[i++] = 0;
+
+ PG_RETURN_POINTER(result);
+}
+
+/*
+ * int44out - converts internal form to "num num ..."
+ */
+PG_FUNCTION_INFO_V1(int44out);
+
+Datum
+int44out(PG_FUNCTION_ARGS)
+{
+ int32 *an_array = (int32 *) PG_GETARG_POINTER(0);
+ char *result = (char *) palloc(16 * 4); /* Allow 14 digits +
+ * sign */
+ int i;
+ char *walk;
+
+ walk = result;
+ for (i = 0; i < 4; i++)
+ {
+ pg_ltoa(an_array[i], walk);
+ while (*++walk != '\0')
+ ;
+ *walk++ = ' ';
+ }
+ *--walk = '\0';
+ PG_RETURN_CSTRING(result);
+}