index 090c8494701ecf770b63ecf4138f1207659cfc8b..02cc0a45b1d1a10a7065fe6e20900974510f399a 100644 (file)
gbt_bpchar_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- void *query = (void *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
+ void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */
index 586de63a4d3ac908bf5b41f8ba45e65d221151fc..a43d81a165170a35917785fbab1de80dd5bd19f0 100644 (file)
gbt_var_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+ GBT_VARKEY *key = (GBT_VARKEY *) PG_DETOAST_DATUM(entry->key);
if (key != (GBT_VARKEY *) DatumGetPointer(entry->key))
{
@@ -159,7 +159,7 @@ gbt_var_node_cp_len(const GBT_VARKEY *node, const gbtree_vinfo *tinfo)
l--;
i++;
}
- return ml; /* lower == upper */
+ return ml; /* lower == upper */
}
gbt_var_fetch(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+ GBT_VARKEY *key = (GBT_VARKEY *) PG_DETOAST_DATUM(entry->key);
GBT_VARKEY_R r = gbt_var_key_readable(key);
GISTENTRY *retval;
index 1032b997f97171008e6c2edf4bf900535fc0fa62..b7702716fed213e74dc9344914d8a0da036480ef 100644 (file)
cube_scanner_finish();
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
else
SET_POINT_BIT(result);
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/*
for (i = 0; i < dim; i++)
result->x[i] = dur[i];
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
Datum
cube_subset(PG_FUNCTION_ARGS)
{
- NDBOX *c = PG_GETARG_NDBOX(0);
+ NDBOX *c = PG_GETARG_NDBOX_P(0);
ArrayType *idx = PG_GETARG_ARRAYTYPE_P(1);
NDBOX *result;
int size,
}
PG_FREE_IF_COPY(c, 0);
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
Datum
cube_out(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
StringInfoData buf;
int dim = DIM(cube);
int i;
g_cube_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- NDBOX *query = PG_GETARG_NDBOX(1);
+ NDBOX *query = PG_GETARG_NDBOX_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */
* g_cube_leaf_consistent
*/
if (GIST_LEAF(entry))
- res = g_cube_leaf_consistent(DatumGetNDBOX(entry->key),
+ res = g_cube_leaf_consistent(DatumGetNDBOXP(entry->key),
query, strategy);
else
- res = g_cube_internal_consistent(DatumGetNDBOX(entry->key),
+ res = g_cube_internal_consistent(DatumGetNDBOXP(entry->key),
query, strategy);
PG_FREE_IF_COPY(query, 1);
NDBOX *tmp;
int i;
- tmp = DatumGetNDBOX(entryvec->vector[0].key);
+ tmp = DatumGetNDBOXP(entryvec->vector[0].key);
/*
* sizep = sizeof(NDBOX); -- NDBOX has variable size
for (i = 1; i < entryvec->n; i++)
{
out = g_cube_binary_union(tmp,
- DatumGetNDBOX(entryvec->vector[i].key),
+ DatumGetNDBOXP(entryvec->vector[i].key),
sizep);
tmp = out;
}
g_cube_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- NDBOX *key = DatumGetNDBOX(PG_DETOAST_DATUM(entry->key));
+ NDBOX *key = DatumGetNDBOXP(entry->key);
- if (key != DatumGetNDBOX(entry->key))
+ if (key != DatumGetNDBOXP(entry->key))
{
GISTENTRY *retval = (GISTENTRY *) palloc(sizeof(GISTENTRY));
double tmp1,
tmp2;
- ud = cube_union_v0(DatumGetNDBOX(origentry->key),
- DatumGetNDBOX(newentry->key));
+ ud = cube_union_v0(DatumGetNDBOXP(origentry->key),
+ DatumGetNDBOXP(newentry->key));
rt_cube_size(ud, &tmp1);
- rt_cube_size(DatumGetNDBOX(origentry->key), &tmp2);
+ rt_cube_size(DatumGetNDBOXP(origentry->key), &tmp2);
*result = (float) (tmp1 - tmp2);
PG_RETURN_FLOAT8(*result);
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
{
- datum_alpha = DatumGetNDBOX(entryvec->vector[i].key);
+ datum_alpha = DatumGetNDBOXP(entryvec->vector[i].key);
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
{
- datum_beta = DatumGetNDBOX(entryvec->vector[j].key);
+ datum_beta = DatumGetNDBOXP(entryvec->vector[j].key);
/* compute the wasted space by unioning these guys */
/* size_waste = size_union - size_inter; */
union_d = cube_union_v0(datum_alpha, datum_beta);
rt_cube_size(union_d, &size_union);
- inter_d = DatumGetNDBOX(DirectFunctionCall2(cube_inter,
- entryvec->vector[i].key, entryvec->vector[j].key));
+ inter_d = DatumGetNDBOXP(DirectFunctionCall2(cube_inter,
+ entryvec->vector[i].key,
+ entryvec->vector[j].key));
rt_cube_size(inter_d, &size_inter);
size_waste = size_union - size_inter;
right = v->spl_right;
v->spl_nright = 0;
- datum_alpha = DatumGetNDBOX(entryvec->vector[seed_1].key);
+ datum_alpha = DatumGetNDBOXP(entryvec->vector[seed_1].key);
datum_l = cube_union_v0(datum_alpha, datum_alpha);
rt_cube_size(datum_l, &size_l);
- datum_beta = DatumGetNDBOX(entryvec->vector[seed_2].key);
+ datum_beta = DatumGetNDBOXP(entryvec->vector[seed_2].key);
datum_r = cube_union_v0(datum_beta, datum_beta);
rt_cube_size(datum_r, &size_r);
}
/* okay, which page needs least enlargement? */
- datum_alpha = DatumGetNDBOX(entryvec->vector[i].key);
+ datum_alpha = DatumGetNDBOXP(entryvec->vector[i].key);
union_dl = cube_union_v0(datum_l, datum_alpha);
union_dr = cube_union_v0(datum_r, datum_alpha);
rt_cube_size(union_dl, &size_alpha);
Datum
g_cube_same(PG_FUNCTION_ARGS)
{
- NDBOX *b1 = PG_GETARG_NDBOX(0);
- NDBOX *b2 = PG_GETARG_NDBOX(1);
+ NDBOX *b1 = PG_GETARG_NDBOX_P(0);
+ NDBOX *b2 = PG_GETARG_NDBOX_P(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
if (cube_cmp_v0(b1, b2) == 0)
else
*result = FALSE;
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/*
Datum
cube_union(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0);
- NDBOX *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0);
+ NDBOX *b = PG_GETARG_NDBOX_P(1);
NDBOX *res;
res = cube_union_v0(a, b);
PG_FREE_IF_COPY(a, 0);
PG_FREE_IF_COPY(b, 1);
- PG_RETURN_NDBOX(res);
+ PG_RETURN_NDBOX_P(res);
}
/* cube_inter */
Datum
cube_inter(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0);
- NDBOX *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0);
+ NDBOX *b = PG_GETARG_NDBOX_P(1);
NDBOX *result;
bool swapped = false;
int i;
/*
* Is it OK to return a non-null intersection for non-overlapping boxes?
*/
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/* cube_size */
Datum
cube_size(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0);
+ NDBOX *a = PG_GETARG_NDBOX_P(0);
double result;
rt_cube_size(a, &result);
Datum
cube_cmp(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_eq(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_ne(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_lt(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_gt(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_le(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_ge(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
int32 res;
res = cube_cmp_v0(a, b);
Datum
cube_contains(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool res;
res = cube_contains_v0(a, b);
Datum
cube_contained(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool res;
res = cube_contains_v0(b, a);
Datum
cube_overlap(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool res;
res = cube_overlap_v0(a, b);
Datum
cube_distance(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool swapped = false;
double d,
distance;
Datum
distance_taxicab(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool swapped = false;
double distance;
int i;
Datum
distance_chebyshev(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0),
- *b = PG_GETARG_NDBOX(1);
+ NDBOX *a = PG_GETARG_NDBOX_P(0),
+ *b = PG_GETARG_NDBOX_P(1);
bool swapped = false;
double d,
distance;
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
- NDBOX *cube = DatumGetNDBOX(entry->key);
+ NDBOX *cube = DatumGetNDBOXP(entry->key);
double retval;
if (strategy == CubeKNNDistanceCoord)
}
else
{
- NDBOX *query = PG_GETARG_NDBOX(1);
+ NDBOX *query = PG_GETARG_NDBOX_P(1);
switch (strategy)
{
@@ -1392,7 +1393,7 @@ distance_1D(double a1, double a2, double b1, double b2)
Datum
cube_is_point(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
bool result;
result = cube_is_point_internal(cube);
Datum
cube_dim(PG_FUNCTION_ARGS)
{
- NDBOX *c = PG_GETARG_NDBOX(0);
+ NDBOX *c = PG_GETARG_NDBOX_P(0);
int dim = DIM(c);
PG_FREE_IF_COPY(c, 0);
Datum
cube_ll_coord(PG_FUNCTION_ARGS)
{
- NDBOX *c = PG_GETARG_NDBOX(0);
+ NDBOX *c = PG_GETARG_NDBOX_P(0);
int n = PG_GETARG_INT32(1);
double result;
Datum
cube_ur_coord(PG_FUNCTION_ARGS)
{
- NDBOX *c = PG_GETARG_NDBOX(0);
+ NDBOX *c = PG_GETARG_NDBOX_P(0);
int n = PG_GETARG_INT32(1);
double result;
Datum
cube_coord(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
int coord = PG_GETARG_INT32(1);
if (coord <= 0 || coord > 2 * DIM(cube))
Datum
cube_coord_llur(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
int coord = PG_GETARG_INT32(1);
if (coord <= 0 || coord > 2 * DIM(cube))
Datum
cube_enlarge(PG_FUNCTION_ARGS)
{
- NDBOX *a = PG_GETARG_NDBOX(0);
+ NDBOX *a = PG_GETARG_NDBOX_P(0);
double r = PG_GETARG_FLOAT8(1);
int32 n = PG_GETARG_INT32(2);
NDBOX *result;
}
PG_FREE_IF_COPY(a, 0);
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/* Create a one dimensional box with identical upper and lower coordinates */
SET_POINT_BIT(result);
result->x[0] = x;
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/* Create a one dimensional box */
result->x[1] = x1;
}
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/* Add a dimension to an existing cube with the same values for the new
Datum
cube_c_f8(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
double x = PG_GETARG_FLOAT8(1);
NDBOX *result;
int size;
}
PG_FREE_IF_COPY(cube, 0);
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
/* Add a dimension to an existing cube */
Datum
cube_c_f8_f8(PG_FUNCTION_ARGS)
{
- NDBOX *cube = PG_GETARG_NDBOX(0);
+ NDBOX *cube = PG_GETARG_NDBOX_P(0);
double x1 = PG_GETARG_FLOAT8(1);
double x2 = PG_GETARG_FLOAT8(2);
NDBOX *result;
}
PG_FREE_IF_COPY(cube, 0);
- PG_RETURN_NDBOX(result);
+ PG_RETURN_NDBOX_P(result);
}
index 6e6ddfd3d75c55c89abbbb9b7f5d93672298c15e..dbe7d4f7429a6baaf6e3b7e3f6f739b9225fdf3f 100644 (file)
#define CUBE_SIZE(_dim) (offsetof(NDBOX, x) + sizeof(double)*(_dim)*2)
/* fmgr interface macros */
-#define DatumGetNDBOX(x) ((NDBOX *) PG_DETOAST_DATUM(x))
-#define PG_GETARG_NDBOX(x) DatumGetNDBOX(PG_GETARG_DATUM(x))
-#define PG_RETURN_NDBOX(x) PG_RETURN_POINTER(x)
+#define DatumGetNDBOXP(x) ((NDBOX *) PG_DETOAST_DATUM(x))
+#define PG_GETARG_NDBOX_P(x) DatumGetNDBOXP(PG_GETARG_DATUM(x))
+#define PG_RETURN_NDBOX_P(x) PG_RETURN_POINTER(x)
/* GiST operator strategy numbers */
#define CubeKNNDistanceCoord 15 /* ~> */
index c4862a82e17f785d517647f4e95b6f0cce8e7705..bf4a565ed9b33aafc5bc0212e17f2d5ac3c7ebf0 100644 (file)
@@ -151,7 +151,7 @@ extern HStore *hstoreUpgrade(Datum orig);
#define DatumGetHStoreP(d) hstoreUpgrade(d)
-#define PG_GETARG_HS(x) DatumGetHStoreP(PG_GETARG_DATUM(x))
+#define PG_GETARG_HSTORE_P(x) DatumGetHStoreP(PG_GETARG_DATUM(x))
/*
index d98fb3845833d280f56069b4dcbf11e78e79a002..4c3a422643dcee040cc96513ac7fdd9150e9a14d 100644 (file)
@@ -43,7 +43,7 @@ makeitem(char *str, int len, char flag)
Datum
gin_extract_hstore(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
Datum *entries = NULL;
HEntry *hsent = ARRPTR(hs);
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
- /* HStore *query = PG_GETARG_HS(2); */
+ /* HStore *query = PG_GETARG_HSTORE_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
index f8f5934e404e803eab2ac0aa1e82c984610b892e..3a61342019b4798e826d16fc1c13836aed6b2a6a 100644 (file)
if (strategy == HStoreContainsStrategyNumber ||
strategy == HStoreOldContainsStrategyNumber)
{
- HStore *query = PG_GETARG_HS(1);
+ HStore *query = PG_GETARG_HSTORE_P(1);
HEntry *qe = ARRPTR(query);
char *qv = STRPTR(query);
int count = HS_COUNT(query);
index a44c1b223530694e8a6b0bc21c83665ce2840657..6363c321c5d0f825287fb162c68c37c1bf68901c 100644 (file)
@@ -962,7 +962,7 @@ hstore_populate_record(PG_FUNCTION_ARGS)
tupTypmod = HeapTupleHeaderGetTypMod(rec);
}
- hs = PG_GETARG_HS(1);
+ hs = PG_GETARG_HSTORE_P(1);
entries = ARRPTR(hs);
ptr = STRPTR(hs);
Datum
hstore_out(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int buflen,
i;
int count = HS_COUNT(in);
Datum
hstore_send(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
Datum
hstore_to_json_loose(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
Datum
hstore_to_json(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
Datum
hstore_to_jsonb(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
Datum
hstore_to_jsonb_loose(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
index 612be23a74fa163e82da31ac6220fe1b2a5722f7..8f9277f8da2dd59ca4f84ffddfa3fbff97a234b3 100644 (file)
Datum
hstore_fetchval(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
text *key = PG_GETARG_TEXT_PP(1);
HEntry *entries = ARRPTR(hs);
text *out;
Datum
hstore_exists(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
text *key = PG_GETARG_TEXT_PP(1);
int idx = hstoreFindKey(hs, NULL,
VARDATA_ANY(key), VARSIZE_ANY_EXHDR(key));
Datum
hstore_exists_any(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
int nkeys;
Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);
Datum
hstore_exists_all(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
int nkeys;
Pairs *key_pairs = hstoreArrayToPairs(keys, &nkeys);
Datum
hstore_defined(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
text *key = PG_GETARG_TEXT_PP(1);
HEntry *entries = ARRPTR(hs);
int idx = hstoreFindKey(hs, NULL,
Datum
hstore_delete(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
text *key = PG_GETARG_TEXT_PP(1);
char *keyptr = VARDATA_ANY(key);
int keylen = VARSIZE_ANY_EXHDR(key);
@@ -294,7 +294,7 @@ PG_FUNCTION_INFO_V1(hstore_delete_array);
Datum
hstore_delete_array(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
HStore *out = palloc(VARSIZE(hs));
int hs_count = HS_COUNT(hs);
char *ps,
@@ -373,8 +373,8 @@ PG_FUNCTION_INFO_V1(hstore_delete_hstore);
Datum
hstore_delete_hstore(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
- HStore *hs2 = PG_GETARG_HS(1);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
+ HStore *hs2 = PG_GETARG_HSTORE_P(1);
HStore *out = palloc(VARSIZE(hs));
int hs_count = HS_COUNT(hs);
int hs2_count = HS_COUNT(hs2);
Datum
hstore_concat(PG_FUNCTION_ARGS)
{
- HStore *s1 = PG_GETARG_HS(0);
- HStore *s2 = PG_GETARG_HS(1);
+ HStore *s1 = PG_GETARG_HSTORE_P(0);
+ HStore *s2 = PG_GETARG_HSTORE_P(1);
HStore *out = palloc(VARSIZE(s1) + VARSIZE(s2));
char *ps1,
*ps2,
@@ -571,7 +571,7 @@ PG_FUNCTION_INFO_V1(hstore_slice_to_array);
Datum
hstore_slice_to_array(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
HEntry *entries = ARRPTR(hs);
char *ptr = STRPTR(hs);
ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);
@@ -634,7 +634,7 @@ PG_FUNCTION_INFO_V1(hstore_slice_to_hstore);
Datum
hstore_slice_to_hstore(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
HEntry *entries = ARRPTR(hs);
char *ptr = STRPTR(hs);
ArrayType *key_array = PG_GETARG_ARRAYTYPE_P(1);
Datum
hstore_akeys(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
Datum *d;
ArrayType *a;
HEntry *entries = ARRPTR(hs);
Datum
hstore_avals(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
Datum *d;
bool *nulls;
ArrayType *a;
Datum
hstore_to_array(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
ArrayType *out = hstore_to_array_internal(hs, 1);
PG_RETURN_POINTER(out);
Datum
hstore_to_matrix(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
ArrayType *out = hstore_to_array_internal(hs, 2);
PG_RETURN_POINTER(out);
if (SRF_IS_FIRSTCALL())
{
- hs = PG_GETARG_HS(0);
+ hs = PG_GETARG_HSTORE_P(0);
funcctx = SRF_FIRSTCALL_INIT();
setup_firstcall(funcctx, hs, NULL);
}
if (SRF_IS_FIRSTCALL())
{
- hs = PG_GETARG_HS(0);
+ hs = PG_GETARG_HSTORE_P(0);
funcctx = SRF_FIRSTCALL_INIT();
setup_firstcall(funcctx, hs, NULL);
}
Datum
hstore_contains(PG_FUNCTION_ARGS)
{
- HStore *val = PG_GETARG_HS(0);
- HStore *tmpl = PG_GETARG_HS(1);
+ HStore *val = PG_GETARG_HSTORE_P(0);
+ HStore *tmpl = PG_GETARG_HSTORE_P(1);
bool res = true;
HEntry *te = ARRPTR(tmpl);
char *tstr = STRPTR(tmpl);
if (SRF_IS_FIRSTCALL())
{
- hs = PG_GETARG_HS(0);
+ hs = PG_GETARG_HSTORE_P(0);
funcctx = SRF_FIRSTCALL_INIT();
setup_firstcall(funcctx, hs, fcinfo);
}
Datum
hstore_cmp(PG_FUNCTION_ARGS)
{
- HStore *hs1 = PG_GETARG_HS(0);
- HStore *hs2 = PG_GETARG_HS(1);
+ HStore *hs1 = PG_GETARG_HSTORE_P(0);
+ HStore *hs2 = PG_GETARG_HSTORE_P(1);
int hcount1 = HS_COUNT(hs1);
int hcount2 = HS_COUNT(hs2);
int res = 0;
Datum
hstore_hash(PG_FUNCTION_ARGS)
{
- HStore *hs = PG_GETARG_HS(0);
+ HStore *hs = PG_GETARG_HSTORE_P(0);
Datum hval = hash_any((unsigned char *) VARDATA(hs),
VARSIZE(hs) - VARHDRSZ);
index cc46a525f6f7fc066d8fa0f54240087d6f4268d8..6bc3bb37fc3ba356fb4b012512c690f971454f90 100644 (file)
hstore_to_plperl(PG_FUNCTION_ARGS)
{
dTHX;
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
index b184324ebf0d90c058ff0376bcfd1e066b8e2f4b..22366bd40f76c99f3c88a53c2bda6625d0e37105 100644 (file)
@@ -85,7 +85,7 @@ PG_FUNCTION_INFO_V1(hstore_to_plpython);
Datum
hstore_to_plpython(PG_FUNCTION_ARGS)
{
- HStore *in = PG_GETARG_HS(0);
+ HStore *in = PG_GETARG_HSTORE_P(0);
int i;
int count = HS_COUNT(in);
char *base = STRPTR(in);
index a387f5b899eb0e82fcaa4d978c18cb97c64216b0..23952df4afeacefafbc832080b2cee55e34fd319 100644 (file)
_ltree_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- char *query = (char *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
+ void *query = (void *) PG_DETOAST_DATUM(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */
index fdf6ebb43b10e2903750a0c4ac00119dfdcb4885..9bb6bcaeffaed80ab5359e094a0ceb828c9604f3 100644 (file)
_ltree_isparent(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltree *query = PG_GETARG_LTREE(1);
+ ltree *query = PG_GETARG_LTREE_P(1);
bool res = array_iterator(la, ltree_isparent, (void *) query, NULL);
PG_FREE_IF_COPY(la, 0);
_ltree_risparent(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltree *query = PG_GETARG_LTREE(1);
+ ltree *query = PG_GETARG_LTREE_P(1);
bool res = array_iterator(la, ltree_risparent, (void *) query, NULL);
PG_FREE_IF_COPY(la, 0);
_ltq_regex(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- lquery *query = PG_GETARG_LQUERY(1);
+ lquery *query = PG_GETARG_LQUERY_P(1);
bool res = array_iterator(la, ltq_regex, (void *) query, NULL);
PG_FREE_IF_COPY(la, 0);
_ltxtq_exec(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltxtquery *query = PG_GETARG_LTXTQUERY(1);
+ ltxtquery *query = PG_GETARG_LTXTQUERY_P(1);
bool res = array_iterator(la, ltxtq_exec, (void *) query, NULL);
PG_FREE_IF_COPY(la, 0);
_ltree_extract_isparent(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltree *query = PG_GETARG_LTREE(1);
+ ltree *query = PG_GETARG_LTREE_P(1);
ltree *found,
*item;
_ltree_extract_risparent(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltree *query = PG_GETARG_LTREE(1);
+ ltree *query = PG_GETARG_LTREE_P(1);
ltree *found,
*item;
_ltq_extract_regex(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- lquery *query = PG_GETARG_LQUERY(1);
+ lquery *query = PG_GETARG_LQUERY_P(1);
ltree *found,
*item;
_ltxtq_extract_exec(PG_FUNCTION_ARGS)
{
ArrayType *la = PG_GETARG_ARRAYTYPE_P(0);
- ltxtquery *query = PG_GETARG_LTXTQUERY(1);
+ ltxtquery *query = PG_GETARG_LTXTQUERY_P(1);
ltree *found,
*item;
index 229ddd0ae3d49af511a05ba3205e71c1abb12ca5..b6d2deb1af4b9d67cb8f97042502ac31e1b11570 100644 (file)
@@ -302,8 +302,8 @@ checkCond(lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_nu
Datum
ltq_regex(PG_FUNCTION_ARGS)
{
- ltree *tree = PG_GETARG_LTREE(0);
- lquery *query = PG_GETARG_LQUERY(1);
+ ltree *tree = PG_GETARG_LTREE_P(0);
+ lquery *query = PG_GETARG_LQUERY_P(1);
bool res = false;
if (query->flag & LQUERY_HASNOT)
Datum
lt_q_regex(PG_FUNCTION_ARGS)
{
- ltree *tree = PG_GETARG_LTREE(0);
+ ltree *tree = PG_GETARG_LTREE_P(0);
ArrayType *_query = PG_GETARG_ARRAYTYPE_P(1);
lquery *query = (lquery *) ARR_DATA_PTR(_query);
bool res = false;
index fd86323ffe0b6625216149685e66b9edbeab665e..e4b8c84fa621e78615b11cde10c9e833c30efeca 100644 (file)
@@ -165,12 +165,21 @@ bool compare_subnode(ltree_level *t, char *q, int len,
ltree *lca_inner(ltree **a, int len);
int ltree_strncasecmp(const char *a, const char *b, size_t s);
-#define PG_GETARG_LTREE(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
-#define PG_GETARG_LTREE_COPY(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x))))
-#define PG_GETARG_LQUERY(x) ((lquery*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
-#define PG_GETARG_LQUERY_COPY(x) ((lquery*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x))))
-#define PG_GETARG_LTXTQUERY(x) ((ltxtquery*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
-#define PG_GETARG_LTXTQUERY_COPY(x) ((ltxtquery*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x))))
+/* fmgr macros for ltree objects */
+#define DatumGetLtreeP(X) ((ltree *) PG_DETOAST_DATUM(X))
+#define DatumGetLtreePCopy(X) ((ltree *) PG_DETOAST_DATUM_COPY(X))
+#define PG_GETARG_LTREE_P(n) DatumGetLtreeP(PG_GETARG_DATUM(n))
+#define PG_GETARG_LTREE_P_COPY(n) DatumGetLtreePCopy(PG_GETARG_DATUM(n))
+
+#define DatumGetLqueryP(X) ((lquery *) PG_DETOAST_DATUM(X))
+#define DatumGetLqueryPCopy(X) ((lquery *) PG_DETOAST_DATUM_COPY(X))
+#define PG_GETARG_LQUERY_P(n) DatumGetLqueryP(PG_GETARG_DATUM(n))
+#define PG_GETARG_LQUERY_P_COPY(n) DatumGetLqueryPCopy(PG_GETARG_DATUM(n))
+
+#define DatumGetLtxtqueryP(X) ((ltxtquery *) PG_DETOAST_DATUM(X))
+#define DatumGetLtxtqueryPCopy(X) ((ltxtquery *) PG_DETOAST_DATUM_COPY(X))
+#define PG_GETARG_LTXTQUERY_P(n) DatumGetLtxtqueryP(PG_GETARG_DATUM(n))
+#define PG_GETARG_LTXTQUERY_P_COPY(n) DatumGetLtxtqueryPCopy(PG_GETARG_DATUM(n))
/* GiST support for ltree */
index 70e78a672aca3aff549285ca5c04bb29375a29b8..ecfd9d84d7689e44c0043393e592ab81a1363a4b 100644 (file)
@@ -53,7 +53,7 @@ ltree_compress(PG_FUNCTION_ARGS)
if (entry->leafkey)
{ /* ltree */
ltree_gist *key;
- ltree *val = (ltree *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+ ltree *val = DatumGetLtreeP(entry->key);
int32 len = LTG_HDRSIZE + VARSIZE(val);
key = (ltree_gist *) palloc0(len);
ltree_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- ltree_gist *key = (ltree_gist *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+ ltree_gist *key = (ltree_gist *) PG_DETOAST_DATUM(entry->key);
if (PointerGetDatum(key) != entry->key)
{
switch (strategy)
{
case BTLessStrategyNumber:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
res = (GIST_LEAF(entry)) ?
(ltree_compare((ltree *) query, LTG_NODE(key)) > 0)
:
(ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0);
break;
case BTLessEqualStrategyNumber:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
res = (ltree_compare((ltree *) query, LTG_GETLNODE(key)) >= 0);
break;
case BTEqualStrategyNumber:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
if (GIST_LEAF(entry))
res = (ltree_compare((ltree *) query, LTG_NODE(key)) == 0);
else
);
break;
case BTGreaterEqualStrategyNumber:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
res = (ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0);
break;
case BTGreaterStrategyNumber:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
res = (GIST_LEAF(entry)) ?
(ltree_compare((ltree *) query, LTG_GETRNODE(key)) < 0)
:
(ltree_compare((ltree *) query, LTG_GETRNODE(key)) <= 0);
break;
case 10:
- query = PG_GETARG_LTREE_COPY(1);
+ query = PG_GETARG_LTREE_P_COPY(1);
res = (GIST_LEAF(entry)) ?
inner_isparent((ltree *) query, LTG_NODE(key))
:
gist_isparent(key, (ltree *) query);
break;
case 11:
- query = PG_GETARG_LTREE(1);
+ query = PG_GETARG_LTREE_P(1);
res = (GIST_LEAF(entry)) ?
inner_isparent(LTG_NODE(key), (ltree *) query)
:
break;
case 12:
case 13:
- query = PG_GETARG_LQUERY(1);
+ query = PG_GETARG_LQUERY_P(1);
if (GIST_LEAF(entry))
res = DatumGetBool(DirectFunctionCall2(ltq_regex,
PointerGetDatum(LTG_NODE(key)),
break;
case 14:
case 15:
- query = PG_GETARG_LQUERY(1);
+ query = PG_GETARG_LTXTQUERY_P(1);
if (GIST_LEAF(entry))
res = DatumGetBool(DirectFunctionCall2(ltxtq_exec,
PointerGetDatum(LTG_NODE(key)),
- PointerGetDatum((lquery *) query)
+ PointerGetDatum((ltxtquery *) query)
));
else
res = gist_qtxt(key, (ltxtquery *) query);
break;
case 16:
case 17:
- query = DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
+ query = PG_GETARG_ARRAYTYPE_P(1);
if (GIST_LEAF(entry))
res = DatumGetBool(DirectFunctionCall2(lt_q_regex,
PointerGetDatum(LTG_NODE(key)),
index 34ca597a484cbc495e78679ffdeaea1cabcf817e..f54f03744365b0202f2ea325e8fb9589bb97b6ae 100644 (file)
Datum
ltree_out(PG_FUNCTION_ARGS)
{
- ltree *in = PG_GETARG_LTREE(0);
+ ltree *in = PG_GETARG_LTREE_P(0);
char *buf,
*ptr;
int i;
Datum
lquery_out(PG_FUNCTION_ARGS)
{
- lquery *in = PG_GETARG_LQUERY(0);
+ lquery *in = PG_GETARG_LQUERY_P(0);
char *buf,
*ptr;
int i,
index aa1e9918befb5c29dc12af9b3e2634512dd1aca6..d62ca02521be87fb6f4ff7a3e21d4eaf8e971ee5 100644 (file)
@@ -67,65 +67,65 @@ ltree_compare(const ltree *a, const ltree *b)
}
#define RUNCMP \
-ltree *a = PG_GETARG_LTREE(0); \
-ltree *b = PG_GETARG_LTREE(1); \
-int res = ltree_compare(a,b); \
-PG_FREE_IF_COPY(a,0); \
-PG_FREE_IF_COPY(b,1); \
+ltree *a = PG_GETARG_LTREE_P(0); \
+ltree *b = PG_GETARG_LTREE_P(1); \
+int res = ltree_compare(a,b); \
+PG_FREE_IF_COPY(a,0); \
+PG_FREE_IF_COPY(b,1)
Datum
ltree_cmp(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_INT32(res);
+ RUNCMP;
+ PG_RETURN_INT32(res);
}
Datum
ltree_lt(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res < 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res < 0) ? true : false);
}
Datum
ltree_le(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res <= 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res <= 0) ? true : false);
}
Datum
ltree_eq(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res == 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res == 0) ? true : false);
}
Datum
ltree_ge(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res >= 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res >= 0) ? true : false);
}
Datum
ltree_gt(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res > 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res > 0) ? true : false);
}
Datum
ltree_ne(PG_FUNCTION_ARGS)
{
- RUNCMP
- PG_RETURN_BOOL((res != 0) ? true : false);
+ RUNCMP;
+ PG_RETURN_BOOL((res != 0) ? true : false);
}
Datum
nlevel(PG_FUNCTION_ARGS)
{
- ltree *a = PG_GETARG_LTREE(0);
+ ltree *a = PG_GETARG_LTREE_P(0);
int res = a->numlevel;
PG_FREE_IF_COPY(a, 0);
@@ -159,8 +159,8 @@ inner_isparent(const ltree *c, const ltree *p)
Datum
ltree_isparent(PG_FUNCTION_ARGS)
{
- ltree *c = PG_GETARG_LTREE(1);
- ltree *p = PG_GETARG_LTREE(0);
+ ltree *c = PG_GETARG_LTREE_P(1);
+ ltree *p = PG_GETARG_LTREE_P(0);
bool res = inner_isparent(c, p);
PG_FREE_IF_COPY(c, 1);
Datum
ltree_risparent(PG_FUNCTION_ARGS)
{
- ltree *c = PG_GETARG_LTREE(0);
- ltree *p = PG_GETARG_LTREE(1);
+ ltree *c = PG_GETARG_LTREE_P(0);
+ ltree *p = PG_GETARG_LTREE_P(1);
bool res = inner_isparent(c, p);
PG_FREE_IF_COPY(c, 0);
@@ -223,7 +223,7 @@ inner_subltree(ltree *t, int32 startpos, int32 endpos)
Datum
subltree(PG_FUNCTION_ARGS)
{
- ltree *t = PG_GETARG_LTREE(0);
+ ltree *t = PG_GETARG_LTREE_P(0);
ltree *res = inner_subltree(t, PG_GETARG_INT32(1), PG_GETARG_INT32(2));
PG_FREE_IF_COPY(t, 0);
Datum
subpath(PG_FUNCTION_ARGS)
{
- ltree *t = PG_GETARG_LTREE(0);
+ ltree *t = PG_GETARG_LTREE_P(0);
int32 start = PG_GETARG_INT32(1);
int32 len = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
int32 end;
Datum
ltree_addltree(PG_FUNCTION_ARGS)
{
- ltree *a = PG_GETARG_LTREE(0);
- ltree *b = PG_GETARG_LTREE(1);
+ ltree *a = PG_GETARG_LTREE_P(0);
+ ltree *b = PG_GETARG_LTREE_P(1);
ltree *r;
r = ltree_concat(a, b);
Datum
ltree_addtext(PG_FUNCTION_ARGS)
{
- ltree *a = PG_GETARG_LTREE(0);
+ ltree *a = PG_GETARG_LTREE_P(0);
text *b = PG_GETARG_TEXT_PP(1);
char *s;
ltree *r,
Datum
ltree_index(PG_FUNCTION_ARGS)
{
- ltree *a = PG_GETARG_LTREE(0);
- ltree *b = PG_GETARG_LTREE(1);
+ ltree *a = PG_GETARG_LTREE_P(0);
+ ltree *b = PG_GETARG_LTREE_P(1);
int start = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
int i,
j;
Datum
ltree_textadd(PG_FUNCTION_ARGS)
{
- ltree *a = PG_GETARG_LTREE(1);
+ ltree *a = PG_GETARG_LTREE_P(1);
text *b = PG_GETARG_TEXT_PP(0);
char *s;
ltree *r,
a = (ltree **) palloc(sizeof(ltree *) * fcinfo->nargs);
for (i = 0; i < fcinfo->nargs; i++)
- a[i] = PG_GETARG_LTREE(i);
+ a[i] = PG_GETARG_LTREE_P(i);
res = lca_inner(a, (int) fcinfo->nargs);
for (i = 0; i < fcinfo->nargs; i++)
PG_FREE_IF_COPY(a[i], i);
Datum
ltree2text(PG_FUNCTION_ARGS)
{
- ltree *in = PG_GETARG_LTREE(0);
+ ltree *in = PG_GETARG_LTREE_P(0);
char *ptr;
int i;
ltree_level *curlevel;
index 9ca19942491fe92a824dce44106e67e94119cd35..56bf39d145b0b6c9bf1bcaeb4b27bc33e3340dcd 100644 (file)
Datum
ltxtq_out(PG_FUNCTION_ARGS)
{
- ltxtquery *query = PG_GETARG_LTXTQUERY(0);
+ ltxtquery *query = PG_GETARG_LTXTQUERY_P(0);
INFIX nrm;
if (query->size == 0)
index 6e9dbc46906351fe9ce0befeb4057a5059520000..dc0ee82bb6e0779b9b5b5ab7c18046d65bd7115f 100644 (file)
@@ -86,8 +86,8 @@ checkcondition_str(void *checkval, ITEM *val)
Datum
ltxtq_exec(PG_FUNCTION_ARGS)
{
- ltree *val = PG_GETARG_LTREE(0);
- ltxtquery *query = PG_GETARG_LTXTQUERY(1);
+ ltree *val = PG_GETARG_LTREE_P(0);
+ ltxtquery *query = PG_GETARG_LTXTQUERY_P(1);
CHKVAL chkval;
bool result;
index bdd462a91b9c15d160de92f001542846cdb1e860..ae9b90dd10b03dccba7e8dda5a011fce66d67a65 100644 (file)
@@ -40,7 +40,7 @@ PG_FUNCTION_INFO_V1(ltree_to_plpython);
Datum
ltree_to_plpython(PG_FUNCTION_ARGS)
{
- ltree *in = PG_GETARG_LTREE(0);
+ ltree *in = PG_GETARG_LTREE_P(0);
int i;
PyObject *list;
ltree_level *curlevel;
index 35d9ab276cfd7a76a638ff6f50fbb9d4c2cf3e55..cf55e3910d04ee197f378025b003f89c5945f5ab 100644 (file)
jsonb_to_tsvector_byid(PG_FUNCTION_ARGS)
{
Oid cfgId = PG_GETARG_OID(0);
- Jsonb *jb = PG_GETARG_JSONB(1);
+ Jsonb *jb = PG_GETARG_JSONB_P(1);
TSVector result;
TSVectorBuildState state;
ParsedText prs;
Datum
jsonb_to_tsvector(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
Oid cfgId;
cfgId = getTSCurrentConfig(true);
PG_RETURN_DATUM(DirectFunctionCall2(jsonb_to_tsvector_byid,
ObjectIdGetDatum(cfgId),
- JsonbGetDatum(jb)));
+ JsonbPGetDatum(jb)));
}
Datum
index c9ce80a91af0cac2b54b465d3a6bf6bcf7ff1054..523c3edd7d17a19d4c1497065305bcf83b793d45 100644 (file)
ts_headline_jsonb_byid_opt(PG_FUNCTION_ARGS)
{
Oid tsconfig = PG_GETARG_OID(0);
- Jsonb *jb = PG_GETARG_JSONB(1);
+ Jsonb *jb = PG_GETARG_JSONB_P(1);
TSQuery query = PG_GETARG_TSQUERY(2);
text *opt = (PG_NARGS() > 3 && PG_GETARG_POINTER(3)) ? PG_GETARG_TEXT_P(3) : NULL;
Jsonb *out;
@@ -424,7 +424,7 @@ ts_headline_jsonb_byid_opt(PG_FUNCTION_ARGS)
pfree(prs.stopsel);
}
- PG_RETURN_JSONB(out);
+ PG_RETURN_JSONB_P(out);
}
Datum
index f256c7f13db943c340ae02fc1946a3b2774879b9..31583f9033fb091fcae10e6a4f543a1c8c8a488a 100644 (file)
@@ -394,11 +394,11 @@ DatumGetExpandedArrayX(Datum d, ArrayMetaState *metacache)
}
/*
- * DatumGetAnyArray: return either an expanded array or a detoasted varlena
+ * DatumGetAnyArrayP: return either an expanded array or a detoasted varlena
* array. The result must not be modified in-place.
*/
AnyArrayType *
-DatumGetAnyArray(Datum d)
+DatumGetAnyArrayP(Datum d)
{
ExpandedArrayHeader *eah;
index 2a4de41bbc0b303bb3177827687d7c2eab1ca65f..e4101c9af0c7d471ed240346f4d8425514b9ebcd 100644 (file)
Datum
array_out(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
Oid element_type = AARR_ELEMTYPE(v);
int typlen;
bool typbyval;
Datum
array_send(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
Oid element_type = AARR_ELEMTYPE(v);
int typlen;
bool typbyval;
Datum
array_ndims(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
/* Sanity check: does it look like an array at all? */
if (AARR_NDIM(v) <= 0 || AARR_NDIM(v) > MAXDIM)
Datum
array_dims(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
char *p;
int i;
int *dimv,
Datum
array_lower(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
int reqdim = PG_GETARG_INT32(1);
int *lb;
int result;
Datum
array_upper(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
int reqdim = PG_GETARG_INT32(1);
int *dimv,
*lb;
Datum
array_length(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
int reqdim = PG_GETARG_INT32(1);
int *dimv;
int result;
Datum
array_cardinality(PG_FUNCTION_ARGS)
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
PG_RETURN_INT32(ArrayGetNItems(AARR_NDIM(v), AARR_DIMS(v)));
}
@@ -3147,7 +3147,7 @@ array_map(FunctionCallInfo fcinfo, Oid retType, ArrayMapState *amstate)
elog(ERROR, "invalid nargs: %d", fcinfo->nargs);
if (PG_ARGISNULL(0))
elog(ERROR, "null input array");
- v = PG_GETARG_ANY_ARRAY(0);
+ v = PG_GETARG_ANY_ARRAY_P(0);
inpType = AARR_ELEMTYPE(v);
ndim = AARR_NDIM(v);
Datum
array_eq(PG_FUNCTION_ARGS)
{
- AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
- AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
+ AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
+ AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
Oid collation = PG_GET_COLLATION();
int ndims1 = AARR_NDIM(array1);
int ndims2 = AARR_NDIM(array2);
static int
array_cmp(FunctionCallInfo fcinfo)
{
- AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
- AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
+ AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
+ AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
Oid collation = PG_GET_COLLATION();
int ndims1 = AARR_NDIM(array1);
int ndims2 = AARR_NDIM(array2);
Datum
hash_array(PG_FUNCTION_ARGS)
{
- AnyArrayType *array = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
int ndims = AARR_NDIM(array);
int *dims = AARR_DIMS(array);
Oid element_type = AARR_ELEMTYPE(array);
Datum
hash_array_extended(PG_FUNCTION_ARGS)
{
- AnyArrayType *array = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *array = PG_GETARG_ANY_ARRAY_P(0);
uint64 seed = PG_GETARG_INT64(1);
int ndims = AARR_NDIM(array);
int *dims = AARR_DIMS(array);
@@ -4260,8 +4260,8 @@ array_contain_compare(AnyArrayType *array1, AnyArrayType *array2, Oid collation,
Datum
arrayoverlap(PG_FUNCTION_ARGS)
{
- AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
- AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
+ AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
+ AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
Oid collation = PG_GET_COLLATION();
bool result;
Datum
arraycontains(PG_FUNCTION_ARGS)
{
- AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
- AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
+ AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
+ AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
Oid collation = PG_GET_COLLATION();
bool result;
Datum
arraycontained(PG_FUNCTION_ARGS)
{
- AnyArrayType *array1 = PG_GETARG_ANY_ARRAY(0);
- AnyArrayType *array2 = PG_GETARG_ANY_ARRAY(1);
+ AnyArrayType *array1 = PG_GETARG_ANY_ARRAY_P(0);
+ AnyArrayType *array2 = PG_GETARG_ANY_ARRAY_P(1);
Oid collation = PG_GET_COLLATION();
bool result;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL())
{
- AnyArrayType *v = PG_GETARG_ANY_ARRAY(0);
+ AnyArrayType *v = PG_GETARG_ANY_ARRAY_P(0);
int reqdim = PG_GETARG_INT32(1);
int *lb,
*dimv;
* and not before. (If no detoast happens, we assume the originally
* passed array will stick around till then.)
*/
- arr = PG_GETARG_ANY_ARRAY(0);
+ arr = PG_GETARG_ANY_ARRAY_P(0);
/* allocate memory for user context */
fctx = (array_unnest_fctx *) palloc(sizeof(array_unnest_fctx));
index 1eb7f3d6f9d52192687aeeedc07635ea76da72bc..95db89553891a6489fc1b53ac1f023367899aa55 100644 (file)
Datum
jsonb_out(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
char *out;
out = JsonbToCString(NULL, &jb->root, VARSIZE(jb));
Datum
jsonb_send(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
StringInfoData buf;
StringInfo jtext = makeStringInfo();
int version = 1;
Datum
jsonb_typeof(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
JsonbIterator *it;
JsonbValue v;
char *result;
@@ -878,7 +878,7 @@ datum_to_jsonb(Datum val, bool is_null, JsonbInState *result,
break;
case JSONBTYPE_JSONB:
{
- Jsonb *jsonb = DatumGetJsonb(val);
+ Jsonb *jsonb = DatumGetJsonbP(val);
JsonbIterator *it;
it = JsonbIteratorInit(&jsonb->root);
index 8e8e8fd850a5d9d0001e33b6bbd9579f4c30f4f7..4e1ba10e9c1a5241b352c624d9c01a149ef095ec 100644 (file)
@@ -66,7 +66,7 @@ gin_compare_jsonb(PG_FUNCTION_ARGS)
Datum
gin_extract_jsonb(PG_FUNCTION_ARGS)
{
- Jsonb *jb = (Jsonb *) PG_GETARG_JSONB(0);
+ Jsonb *jb = (Jsonb *) PG_GETARG_JSONB_P(0);
int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
int total = 2 * JB_ROOT_COUNT(jb);
JsonbIterator *it;
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
- /* Jsonb *query = PG_GETARG_JSONB(2); */
+ /* Jsonb *query = PG_GETARG_JSONB_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
@@ -268,7 +268,7 @@ gin_triconsistent_jsonb(PG_FUNCTION_ARGS)
GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
- /* Jsonb *query = PG_GETARG_JSONB(2); */
+ /* Jsonb *query = PG_GETARG_JSONB_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
@@ -329,7 +329,7 @@ gin_triconsistent_jsonb(PG_FUNCTION_ARGS)
Datum
gin_extract_jsonb_path(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
int total = 2 * JB_ROOT_COUNT(jb);
JsonbIterator *it;
@@ -454,7 +454,7 @@ gin_consistent_jsonb_path(PG_FUNCTION_ARGS)
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
- /* Jsonb *query = PG_GETARG_JSONB(2); */
+ /* Jsonb *query = PG_GETARG_JSONB_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
@@ -492,7 +492,7 @@ gin_triconsistent_jsonb_path(PG_FUNCTION_ARGS)
GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
- /* Jsonb *query = PG_GETARG_JSONB(2); */
+ /* Jsonb *query = PG_GETARG_JSONB_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
index 52a7e19a542f4f8b470216c8cffda1d6285a05ad..d54a07d20441ab11abff3fbd1ab070ad194f82ef 100644 (file)
Datum
jsonb_exists(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
text *key = PG_GETARG_TEXT_PP(1);
JsonbValue kval;
JsonbValue *v = NULL;
Datum
jsonb_exists_any(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
int i;
Datum *key_datums;
@@ -79,7 +79,7 @@ jsonb_exists_any(PG_FUNCTION_ARGS)
Datum
jsonb_exists_all(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
int i;
Datum *key_datums;
Datum
jsonb_contains(PG_FUNCTION_ARGS)
{
- Jsonb *val = PG_GETARG_JSONB(0);
- Jsonb *tmpl = PG_GETARG_JSONB(1);
+ Jsonb *val = PG_GETARG_JSONB_P(0);
+ Jsonb *tmpl = PG_GETARG_JSONB_P(1);
JsonbIterator *it1,
*it2;
jsonb_contained(PG_FUNCTION_ARGS)
{
/* Commutator of "contains" */
- Jsonb *tmpl = PG_GETARG_JSONB(0);
- Jsonb *val = PG_GETARG_JSONB(1);
+ Jsonb *tmpl = PG_GETARG_JSONB_P(0);
+ Jsonb *val = PG_GETARG_JSONB_P(1);
JsonbIterator *it1,
*it2;
Datum
jsonb_ne(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) != 0);
Datum
jsonb_lt(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) < 0);
Datum
jsonb_gt(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) > 0);
Datum
jsonb_le(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) <= 0);
Datum
jsonb_ge(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) >= 0);
Datum
jsonb_eq(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
bool res;
res = (compareJsonbContainers(&jba->root, &jbb->root) == 0);
Datum
jsonb_cmp(PG_FUNCTION_ARGS)
{
- Jsonb *jba = PG_GETARG_JSONB(0);
- Jsonb *jbb = PG_GETARG_JSONB(1);
+ Jsonb *jba = PG_GETARG_JSONB_P(0);
+ Jsonb *jbb = PG_GETARG_JSONB_P(1);
int res;
res = compareJsonbContainers(&jba->root, &jbb->root);
Datum
jsonb_hash(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
JsonbIterator *it;
JsonbValue v;
JsonbIteratorToken r;
Datum
jsonb_hash_extended(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
uint64 seed = PG_GETARG_INT64(1);
JsonbIterator *it;
JsonbValue v;
{
switch (r)
{
- /* Rotation is left to JsonbHashScalarValueExtended() */
+ /* Rotation is left to JsonbHashScalarValueExtended() */
case WJB_BEGIN_ARRAY:
hash ^= ((uint64) JB_FARRAY) << 32 | JB_FARRAY;
break;
index 68feeb2c5b55a9badb97af8e4c7874c106fff0e9..d36fd9e9290756d301809d71c7ea62955f640bd7 100644 (file)
if (SRF_IS_FIRSTCALL())
{
MemoryContext oldcontext;
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
bool skipNested = false;
JsonbIterator *it;
JsonbValue v;
Datum
jsonb_object_field(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
text *key = PG_GETARG_TEXT_PP(1);
JsonbValue *v;
VARSIZE_ANY_EXHDR(key));
if (v != NULL)
- PG_RETURN_JSONB(JsonbValueToJsonb(v));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(v));
PG_RETURN_NULL();
}
@@ -739,7 +739,7 @@ json_object_field_text(PG_FUNCTION_ARGS)
Datum
jsonb_object_field_text(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
text *key = PG_GETARG_TEXT_PP(1);
JsonbValue *v;
Datum
jsonb_array_element(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
int element = PG_GETARG_INT32(1);
JsonbValue *v;
v = getIthJsonbValueFromContainer(&jb->root, element);
if (v != NULL)
- PG_RETURN_JSONB(JsonbValueToJsonb(v));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(v));
PG_RETURN_NULL();
}
@@ -848,7 +848,7 @@ json_array_element_text(PG_FUNCTION_ARGS)
Datum
jsonb_array_element_text(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
int element = PG_GETARG_INT32(1);
JsonbValue *v;
static Datum
get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
ArrayType *path = PG_GETARG_ARRAYTYPE_P(1);
Jsonb *res;
Datum *pathtext;
@@ -1435,7 +1435,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
else
{
/* not text mode - just hand back the jsonb */
- PG_RETURN_JSONB(jb);
+ PG_RETURN_JSONB_P(jb);
}
}
@@ -1533,7 +1533,7 @@ get_jsonb_path_all(FunctionCallInfo fcinfo, bool as_text)
else
{
/* not text mode - just hand back the jsonb */
- PG_RETURN_JSONB(res);
+ PG_RETURN_JSONB_P(res);
}
}
Datum
jsonb_array_length(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
if (JB_ROOT_IS_SCALAR(jb))
ereport(ERROR,
static Datum
each_worker_jsonb(FunctionCallInfo fcinfo, const char *funcname, bool as_text)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
ReturnSetInfo *rsi;
Tuplestorestate *tuple_store;
TupleDesc tupdesc;
elements_worker_jsonb(FunctionCallInfo fcinfo, const char *funcname,
bool as_text)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
ReturnSetInfo *rsi;
Tuplestorestate *tuple_store;
TupleDesc tupdesc;
@@ -2799,7 +2799,7 @@ populate_scalar(ScalarIOData *io, Oid typid, int32 typmod, JsValue *jsv)
{
Jsonb *jsonb = JsonbValueToJsonb(jbv); /* directly use jsonb */
- return JsonbGetDatum(jsonb);
+ return JsonbPGetDatum(jsonb);
}
/* convert jsonb to string for typio call */
else if (typid == JSONOID && jbv->type != jbvBinary)
@@ -3235,7 +3235,7 @@ populate_record_worker(FunctionCallInfo fcinfo, const char *funcname,
}
else
{
- Jsonb *jb = PG_GETARG_JSONB(json_arg_num);
+ Jsonb *jb = PG_GETARG_JSONB_P(json_arg_num);
jsv.val.jsonb = &jbv;
@@ -3552,7 +3552,7 @@ populate_recordset_worker(FunctionCallInfo fcinfo, const char *funcname,
}
else
{
- Jsonb *jb = PG_GETARG_JSONB(json_arg_num);
+ Jsonb *jb = PG_GETARG_JSONB_P(json_arg_num);
JsonbIterator *it;
JsonbValue v;
bool skipNested = false;
Datum
jsonb_strip_nulls(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
JsonbIterator *it;
JsonbParseState *parseState = NULL;
JsonbValue *res = NULL;
@@ -4013,7 +4013,7 @@ addJsonbToParseState(JsonbParseState **jbps, Jsonb *jb)
Datum
jsonb_pretty(PG_FUNCTION_ARGS)
{
- Jsonb *jb = PG_GETARG_JSONB(0);
+ Jsonb *jb = PG_GETARG_JSONB_P(0);
StringInfo str = makeStringInfo();
JsonbToCStringIndent(str, &jb->root, VARSIZE(jb));
Datum
jsonb_concat(PG_FUNCTION_ARGS)
{
- Jsonb *jb1 = PG_GETARG_JSONB(0);
- Jsonb *jb2 = PG_GETARG_JSONB(1);
+ Jsonb *jb1 = PG_GETARG_JSONB_P(0);
+ Jsonb *jb2 = PG_GETARG_JSONB_P(1);
JsonbParseState *state = NULL;
JsonbValue *res;
JsonbIterator *it1,
if (JB_ROOT_IS_OBJECT(jb1) == JB_ROOT_IS_OBJECT(jb2))
{
if (JB_ROOT_COUNT(jb1) == 0 && !JB_ROOT_IS_SCALAR(jb2))
- PG_RETURN_JSONB(jb2);
+ PG_RETURN_JSONB_P(jb2);
else if (JB_ROOT_COUNT(jb2) == 0 && !JB_ROOT_IS_SCALAR(jb1))
- PG_RETURN_JSONB(jb1);
+ PG_RETURN_JSONB_P(jb1);
}
it1 = JsonbIteratorInit(&jb1->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
Datum
jsonb_delete(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
text *key = PG_GETARG_TEXT_PP(1);
char *keyptr = VARDATA_ANY(key);
int keylen = VARSIZE_ANY_EXHDR(key);
errmsg("cannot delete from scalar")));
if (JB_ROOT_COUNT(in) == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
/*
Datum
jsonb_delete_array(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
ArrayType *keys = PG_GETARG_ARRAYTYPE_P(1);
Datum *keys_elems;
bool *keys_nulls;
errmsg("cannot delete from scalar")));
if (JB_ROOT_COUNT(in) == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
deconstruct_array(keys, TEXTOID, -1, false, 'i',
&keys_elems, &keys_nulls, &keys_len);
if (keys_len == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
/*
Datum
jsonb_delete_idx(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
int idx = PG_GETARG_INT32(1);
JsonbParseState *state = NULL;
JsonbIterator *it;
errmsg("cannot delete from object using integer index")));
if (JB_ROOT_COUNT(in) == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
}
if (idx >= n)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
pushJsonbValue(&state, r, NULL);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
/*
Datum
jsonb_set(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
ArrayType *path = PG_GETARG_ARRAYTYPE_P(1);
- Jsonb *newval = PG_GETARG_JSONB(2);
+ Jsonb *newval = PG_GETARG_JSONB_P(2);
bool create = PG_GETARG_BOOL(3);
JsonbValue *res = NULL;
Datum *path_elems;
errmsg("cannot set path in scalar")));
if (JB_ROOT_COUNT(in) == 0 && !create)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
deconstruct_array(path, TEXTOID, -1, false, 'i',
&path_elems, &path_nulls, &path_len);
if (path_len == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
Datum
jsonb_delete_path(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
ArrayType *path = PG_GETARG_ARRAYTYPE_P(1);
JsonbValue *res = NULL;
Datum *path_elems;
errmsg("cannot delete path in scalar")));
if (JB_ROOT_COUNT(in) == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
deconstruct_array(path, TEXTOID, -1, false, 'i',
&path_elems, &path_nulls, &path_len);
if (path_len == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
/*
Datum
jsonb_insert(PG_FUNCTION_ARGS)
{
- Jsonb *in = PG_GETARG_JSONB(0);
+ Jsonb *in = PG_GETARG_JSONB_P(0);
ArrayType *path = PG_GETARG_ARRAYTYPE_P(1);
- Jsonb *newval = PG_GETARG_JSONB(2);
+ Jsonb *newval = PG_GETARG_JSONB_P(2);
bool after = PG_GETARG_BOOL(3);
JsonbValue *res = NULL;
Datum *path_elems;
&path_elems, &path_nulls, &path_len);
if (path_len == 0)
- PG_RETURN_JSONB(in);
+ PG_RETURN_JSONB_P(in);
it = JsonbIteratorInit(&in->root);
Assert(res != NULL);
- PG_RETURN_JSONB(JsonbValueToJsonb(res));
+ PG_RETURN_JSONB_P(JsonbValueToJsonb(res));
}
/*
index dae505159ee76dd5af39c3d3cf61b69af3719a23..d0aa33c010bc31431c7181b90e18d225f8e384e5 100644 (file)
/* serialize and canonicalize */
range = make_range(cache->typcache, &lower, &upper, flags & RANGE_EMPTY);
- PG_RETURN_RANGE(range);
+ PG_RETURN_RANGE_P(range);
}
Datum
range_out(PG_FUNCTION_ARGS)
{
- RangeType *range = PG_GETARG_RANGE(0);
+ RangeType *range = PG_GETARG_RANGE_P(0);
char *output_str;
RangeIOData *cache;
char flags;
/* serialize and canonicalize */
range = make_range(cache->typcache, &lower, &upper, flags & RANGE_EMPTY);
- PG_RETURN_RANGE(range);
+ PG_RETURN_RANGE_P(range);
}
Datum
range_send(PG_FUNCTION_ARGS)
{
- RangeType *range = PG_GETARG_RANGE(0);
+ RangeType *range = PG_GETARG_RANGE_P(0);
StringInfo buf = makeStringInfo();
RangeIOData *cache;
char flags;
range = make_range(typcache, &lower, &upper, false);
- PG_RETURN_RANGE(range);
+ PG_RETURN_RANGE_P(range);
}
/* Construct general range value from three arguments */
range = make_range(typcache, &lower, &upper, false);
- PG_RETURN_RANGE(range);
+ PG_RETURN_RANGE_P(range);
}
Datum
range_lower(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
TypeCacheEntry *typcache;
RangeBound lower;
RangeBound upper;
Datum
range_upper(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
TypeCacheEntry *typcache;
RangeBound lower;
RangeBound upper;
Datum
range_empty(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
char flags = range_get_flags(r1);
PG_RETURN_BOOL(flags & RANGE_EMPTY);
Datum
range_lower_inc(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
char flags = range_get_flags(r1);
PG_RETURN_BOOL(flags & RANGE_LB_INC);
Datum
range_upper_inc(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
char flags = range_get_flags(r1);
PG_RETURN_BOOL(flags & RANGE_UB_INC);
Datum
range_lower_inf(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
char flags = range_get_flags(r1);
PG_RETURN_BOOL(flags & RANGE_LB_INF);
Datum
range_upper_inf(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
char flags = range_get_flags(r1);
PG_RETURN_BOOL(flags & RANGE_UB_INF);
Datum
range_contains_elem(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
Datum val = PG_GETARG_DATUM(1);
TypeCacheEntry *typcache;
elem_contained_by_range(PG_FUNCTION_ARGS)
{
Datum val = PG_GETARG_DATUM(0);
- RangeType *r = PG_GETARG_RANGE(1);
+ RangeType *r = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
@@ -587,8 +587,8 @@ range_eq_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_eq(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -607,8 +607,8 @@ range_ne_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_ne(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
Datum
range_contains(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
Datum
range_contained_by(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -671,8 +671,8 @@ range_before_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_before(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -709,8 +709,8 @@ range_after_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_after(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -810,8 +810,8 @@ range_adjacent_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_adjacent(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -856,8 +856,8 @@ range_overlaps_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_overlaps(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -897,8 +897,8 @@ range_overleft_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_overleft(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
@@ -938,8 +938,8 @@ range_overright_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Datum
range_overright(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
Datum
range_minus(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
RangeBound lower1,
lower2;
/* if either is empty, r1 is the correct answer */
if (empty1 || empty2)
- PG_RETURN_RANGE(r1);
+ PG_RETURN_RANGE_P(r1);
cmp_l1l2 = range_cmp_bounds(typcache, &lower1, &lower2);
cmp_l1u2 = range_cmp_bounds(typcache, &lower1, &upper2);
errmsg("result of range difference would not be contiguous")));
if (cmp_l1u2 > 0 || cmp_u1l2 < 0)
- PG_RETURN_RANGE(r1);
+ PG_RETURN_RANGE_P(r1);
if (cmp_l1l2 >= 0 && cmp_u1u2 <= 0)
- PG_RETURN_RANGE(make_empty_range(typcache));
+ PG_RETURN_RANGE_P(make_empty_range(typcache));
if (cmp_l1l2 <= 0 && cmp_u1l2 >= 0 && cmp_u1u2 <= 0)
{
lower2.inclusive = !lower2.inclusive;
lower2.lower = false; /* it will become the upper bound */
- PG_RETURN_RANGE(make_range(typcache, &lower1, &lower2, false));
+ PG_RETURN_RANGE_P(make_range(typcache, &lower1, &lower2, false));
}
if (cmp_l1l2 >= 0 && cmp_u1u2 >= 0 && cmp_l1u2 <= 0)
{
upper2.inclusive = !upper2.inclusive;
upper2.lower = true; /* it will become the lower bound */
- PG_RETURN_RANGE(make_range(typcache, &upper2, &upper1, false));
+ PG_RETURN_RANGE_P(make_range(typcache, &upper2, &upper1, false));
}
elog(ERROR, "unexpected case in range_minus");
@@ -1068,13 +1068,13 @@ range_union_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2,
Datum
range_union(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
- PG_RETURN_RANGE(range_union_internal(typcache, r1, r2, true));
+ PG_RETURN_RANGE_P(range_union_internal(typcache, r1, r2, true));
}
/*
Datum
range_merge(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
- PG_RETURN_RANGE(range_union_internal(typcache, r1, r2, false));
+ PG_RETURN_RANGE_P(range_union_internal(typcache, r1, r2, false));
}
/* set intersection */
Datum
range_intersect(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
RangeBound lower1,
lower2;
range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
if (empty1 || empty2 || !DatumGetBool(range_overlaps(fcinfo)))
- PG_RETURN_RANGE(make_empty_range(typcache));
+ PG_RETURN_RANGE_P(make_empty_range(typcache));
if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0)
result_lower = &lower1;
else
result_upper = &upper2;
- PG_RETURN_RANGE(make_range(typcache, result_lower, result_upper, false));
+ PG_RETURN_RANGE_P(make_range(typcache, result_lower, result_upper, false));
}
/* Btree support */
Datum
range_cmp(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
TypeCacheEntry *typcache;
RangeBound lower1,
lower2;
Datum
hash_range(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
uint32 result;
TypeCacheEntry *typcache;
TypeCacheEntry *scache;
Datum
hash_range_extended(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
Datum seed = PG_GETARG_DATUM(1);
uint64 result;
TypeCacheEntry *typcache;
Datum
int4range_canonical(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
TypeCacheEntry *typcache;
RangeBound lower;
RangeBound upper;
range_deserialize(typcache, r, &lower, &upper, &empty);
if (empty)
- PG_RETURN_RANGE(r);
+ PG_RETURN_RANGE_P(r);
if (!lower.infinite && !lower.inclusive)
{
upper.inclusive = false;
}
- PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
+ PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper, false));
}
Datum
int8range_canonical(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
TypeCacheEntry *typcache;
RangeBound lower;
RangeBound upper;
range_deserialize(typcache, r, &lower, &upper, &empty);
if (empty)
- PG_RETURN_RANGE(r);
+ PG_RETURN_RANGE_P(r);
if (!lower.infinite && !lower.inclusive)
{
upper.inclusive = false;
}
- PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
+ PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper, false));
}
Datum
daterange_canonical(PG_FUNCTION_ARGS)
{
- RangeType *r = PG_GETARG_RANGE(0);
+ RangeType *r = PG_GETARG_RANGE_P(0);
TypeCacheEntry *typcache;
RangeBound lower;
RangeBound upper;
range_deserialize(typcache, r, &lower, &upper, &empty);
if (empty)
- PG_RETURN_RANGE(r);
+ PG_RETURN_RANGE_P(r);
if (!lower.infinite && !lower.inclusive)
{
upper.inclusive = false;
}
- PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
+ PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper, false));
}
/*
@@ -1799,8 +1799,8 @@ make_range(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper,
/* no need to call canonical on empty ranges ... */
if (OidIsValid(typcache->rng_canonical_finfo.fn_oid) &&
!RangeIsEmpty(range))
- range = DatumGetRangeType(FunctionCall1(&typcache->rng_canonical_finfo,
- RangeTypeGetDatum(range)));
+ range = DatumGetRangeTypeP(FunctionCall1(&typcache->rng_canonical_finfo,
+ RangeTypePGetDatum(range)));
return range;
}
index a1f4f4d37229c4ffa31721521f8fd3246af09078..cb2d5a3b73ae2009c6e32f8c379b25e4586173dc 100644 (file)
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
- RangeType *key = DatumGetRangeType(entry->key);
+ RangeType *key = DatumGetRangeTypeP(entry->key);
TypeCacheEntry *typcache;
/* All operators served by this function are exact */
TypeCacheEntry *typcache;
int i;
- result_range = DatumGetRangeType(ent[0].key);
+ result_range = DatumGetRangeTypeP(ent[0].key);
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(result_range));
for (i = 1; i < entryvec->n; i++)
{
result_range = range_super_union(typcache, result_range,
- DatumGetRangeType(ent[i].key));
+ DatumGetRangeTypeP(ent[i].key));
}
- PG_RETURN_RANGE(result_range);
+ PG_RETURN_RANGE_P(result_range);
}
/* compress, decompress, fetch are no-ops */
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *penalty = (float *) PG_GETARG_POINTER(2);
- RangeType *orig = DatumGetRangeType(origentry->key);
- RangeType *new = DatumGetRangeType(newentry->key);
+ RangeType *orig = DatumGetRangeTypeP(origentry->key);
+ RangeType *new = DatumGetRangeTypeP(newentry->key);
TypeCacheEntry *typcache;
bool has_subtype_diff;
RangeBound orig_lower,
int total_count;
/* use first item to look up range type's info */
- pred_left = DatumGetRangeType(entryvec->vector[FirstOffsetNumber].key);
+ pred_left = DatumGetRangeTypeP(entryvec->vector[FirstOffsetNumber].key);
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(pred_left));
maxoff = entryvec->n - 1;
memset(count_in_classes, 0, sizeof(count_in_classes));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- RangeType *range = DatumGetRangeType(entryvec->vector[i].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[i].key);
count_in_classes[get_gist_range_class(range)]++;
}
Datum
range_gist_same(PG_FUNCTION_ARGS)
{
- RangeType *r1 = PG_GETARG_RANGE(0);
- RangeType *r2 = PG_GETARG_RANGE(1);
+ RangeType *r1 = PG_GETARG_RANGE_P(0);
+ RangeType *r2 = PG_GETARG_RANGE_P(1);
bool *result = (bool *) PG_GETARG_POINTER(2);
/*
@@ -787,39 +787,39 @@ range_gist_consistent_int(TypeCacheEntry *typcache, StrategyNumber strategy,
switch (strategy)
{
case RANGESTRAT_BEFORE:
- if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeTypeP(query)))
return false;
return (!range_overright_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeTypeP(query)));
case RANGESTRAT_OVERLEFT:
- if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeTypeP(query)))
return false;
return (!range_after_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeTypeP(query)));
case RANGESTRAT_OVERLAPS:
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_OVERRIGHT:
- if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeTypeP(query)))
return false;
return (!range_before_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeTypeP(query)));
case RANGESTRAT_AFTER:
- if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeTypeP(query)))
return false;
return (!range_overleft_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeTypeP(query)));
case RANGESTRAT_ADJACENT:
- if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeTypeP(query)))
return false;
if (range_adjacent_internal(typcache, key,
- DatumGetRangeType(query)))
+ DatumGetRangeTypeP(query)))
return true;
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINS:
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINED_BY:
/*
@@ -830,7 +830,7 @@ range_gist_consistent_int(TypeCacheEntry *typcache, StrategyNumber strategy,
if (RangeIsOrContainsEmpty(key))
return true;
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINS_ELEM:
return range_contains_elem_internal(typcache, key, query);
case RANGESTRAT_EQ:
@@ -839,10 +839,10 @@ range_gist_consistent_int(TypeCacheEntry *typcache, StrategyNumber strategy,
* If query is empty, descend only if the key is or contains any
* empty ranges. Otherwise, descend if key contains query.
*/
- if (RangeIsEmpty(DatumGetRangeType(query)))
+ if (RangeIsEmpty(DatumGetRangeTypeP(query)))
return RangeIsOrContainsEmpty(key);
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
default:
elog(ERROR, "unrecognized range strategy: %d", strategy);
return false; /* keep compiler quiet */
@@ -860,32 +860,32 @@ range_gist_consistent_leaf(TypeCacheEntry *typcache, StrategyNumber strategy,
{
case RANGESTRAT_BEFORE:
return range_before_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_OVERLEFT:
return range_overleft_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_OVERLAPS:
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_OVERRIGHT:
return range_overright_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_AFTER:
return range_after_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_ADJACENT:
return range_adjacent_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINS:
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINED_BY:
return range_contained_by_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeTypeP(query));
case RANGESTRAT_CONTAINS_ELEM:
return range_contains_elem_internal(typcache, key, query);
case RANGESTRAT_EQ:
- return range_eq_internal(typcache, key, DatumGetRangeType(query));
+ return range_eq_internal(typcache, key, DatumGetRangeTypeP(query));
default:
elog(ERROR, "unrecognized range strategy: %d", strategy);
return false; /* keep compiler quiet */
@@ -915,7 +915,7 @@ range_gist_fallback_split(TypeCacheEntry *typcache,
v->spl_nright = 0;
for (i = FirstOffsetNumber; i <= maxoff; i++)
{
- RangeType *range = DatumGetRangeType(entryvec->vector[i].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[i].key);
if (i < split_idx)
PLACE_LEFT(range, i);
@@ -923,8 +923,8 @@ range_gist_fallback_split(TypeCacheEntry *typcache,
PLACE_RIGHT(range, i);
}
- v->spl_ldatum = RangeTypeGetDatum(left_range);
- v->spl_rdatum = RangeTypeGetDatum(right_range);
+ v->spl_ldatum = RangeTypePGetDatum(left_range);
+ v->spl_rdatum = RangeTypePGetDatum(right_range);
}
/*
@@ -951,7 +951,7 @@ range_gist_class_split(TypeCacheEntry *typcache,
v->spl_nright = 0;
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- RangeType *range = DatumGetRangeType(entryvec->vector[i].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[i].key);
int class;
/* Get class of range */
@@ -967,8 +967,8 @@ range_gist_class_split(TypeCacheEntry *typcache,
}
}
- v->spl_ldatum = RangeTypeGetDatum(left_range);
- v->spl_rdatum = RangeTypeGetDatum(right_range);
+ v->spl_ldatum = RangeTypePGetDatum(left_range);
+ v->spl_rdatum = RangeTypePGetDatum(right_range);
}
/*
@@ -1000,7 +1000,7 @@ range_gist_single_sorting_split(TypeCacheEntry *typcache,
*/
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- RangeType *range = DatumGetRangeType(entryvec->vector[i].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[i].key);
RangeBound bound2;
bool empty;
@@ -1026,7 +1026,7 @@ range_gist_single_sorting_split(TypeCacheEntry *typcache,
for (i = 0; i < maxoff; i++)
{
int idx = sortItems[i].index;
- RangeType *range = DatumGetRangeType(entryvec->vector[idx].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[idx].key);
if (i < split_idx)
PLACE_LEFT(range, idx);
@@ -1034,8 +1034,8 @@ range_gist_single_sorting_split(TypeCacheEntry *typcache,
PLACE_RIGHT(range, idx);
}
- v->spl_ldatum = RangeTypeGetDatum(left_range);
- v->spl_rdatum = RangeTypeGetDatum(right_range);
+ v->spl_ldatum = RangeTypePGetDatum(left_range);
+ v->spl_rdatum = RangeTypePGetDatum(right_range);
}
/*
@@ -1102,7 +1102,7 @@ range_gist_double_sorting_split(TypeCacheEntry *typcache,
/* Fill arrays of bounds */
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- RangeType *range = DatumGetRangeType(entryvec->vector[i].key);
+ RangeType *range = DatumGetRangeTypeP(entryvec->vector[i].key);
bool empty;
range_deserialize(typcache, range,
@@ -1277,7 +1277,7 @@ range_gist_double_sorting_split(TypeCacheEntry *typcache,
/*
* Get upper and lower bounds along selected axis.
*/
- range = DatumGetRangeType(entryvec->vector[i].key);
+ range = DatumGetRangeTypeP(entryvec->vector[i].key);
range_deserialize(typcache, range, &lower, &upper, &empty);
@@ -1347,7 +1347,7 @@ range_gist_double_sorting_split(TypeCacheEntry *typcache,
{
int idx = common_entries[i].index;
- range = DatumGetRangeType(entryvec->vector[idx].key);
+ range = DatumGetRangeTypeP(entryvec->vector[idx].key);
/*
* Check if we have to place this entry in either group to achieve
index ed13c27fcb8e9533fead1f3df593c4234bd051cc..cba8974dbe6d4f5c3d6f0bd4313e5318c56e5833 100644 (file)
/* Both sides are the same range type */
typcache = range_get_typcache(fcinfo, vardata.vartype);
- constrange = DatumGetRangeType(((Const *) other)->constvalue);
+ constrange = DatumGetRangeTypeP(((Const *) other)->constvalue);
}
/*
@@ -406,7 +406,7 @@ calc_hist_selectivity(TypeCacheEntry *typcache, VariableStatData *vardata,
hist_upper = (RangeBound *) palloc(sizeof(RangeBound) * nhist);
for (i = 0; i < nhist; i++)
{
- range_deserialize(typcache, DatumGetRangeType(hslot.values[i]),
+ range_deserialize(typcache, DatumGetRangeTypeP(hslot.values[i]),
&hist_lower[i], &hist_upper[i], &empty);
/* The histogram should not contain any empty ranges */
if (empty)
index e82c4e1a9e15db0ee4a1704a4cce93a799e24dbc..d934105d322d1a3342d1277ad15c83a572df13f9 100644 (file)
{
spgChooseIn *in = (spgChooseIn *) PG_GETARG_POINTER(0);
spgChooseOut *out = (spgChooseOut *) PG_GETARG_POINTER(1);
- RangeType *inRange = DatumGetRangeType(in->datum),
+ RangeType *inRange = DatumGetRangeTypeP(in->datum),
*centroid;
int16 quadrant;
TypeCacheEntry *typcache;
out->resultType = spgMatchNode;
/* nodeN will be set by core */
out->result.matchNode.levelAdd = 0;
- out->result.matchNode.restDatum = RangeTypeGetDatum(inRange);
+ out->result.matchNode.restDatum = RangeTypePGetDatum(inRange);
PG_RETURN_VOID();
}
else
out->result.matchNode.nodeN = 1;
out->result.matchNode.levelAdd = 1;
- out->result.matchNode.restDatum = RangeTypeGetDatum(inRange);
+ out->result.matchNode.restDatum = RangeTypePGetDatum(inRange);
PG_RETURN_VOID();
}
- centroid = DatumGetRangeType(in->prefixDatum);
+ centroid = DatumGetRangeTypeP(in->prefixDatum);
quadrant = getQuadrant(typcache, centroid, inRange);
Assert(quadrant <= in->nNodes);
out->resultType = spgMatchNode;
out->result.matchNode.nodeN = quadrant - 1;
out->result.matchNode.levelAdd = 1;
- out->result.matchNode.restDatum = RangeTypeGetDatum(inRange);
+ out->result.matchNode.restDatum = RangeTypePGetDatum(inRange);
PG_RETURN_VOID();
}
@@ -213,7 +213,7 @@ spg_range_quad_picksplit(PG_FUNCTION_ARGS)
*upperBounds;
typcache = range_get_typcache(fcinfo,
- RangeTypeGetOid(DatumGetRangeType(in->datums[0])));
+ RangeTypeGetOid(DatumGetRangeTypeP(in->datums[0])));
/* Allocate memory for bounds */
lowerBounds = palloc(sizeof(RangeBound) * in->nTuples);
@@ -223,7 +223,7 @@ spg_range_quad_picksplit(PG_FUNCTION_ARGS)
/* Deserialize bounds of ranges, count non-empty ranges */
for (i = 0; i < in->nTuples; i++)
{
- range_deserialize(typcache, DatumGetRangeType(in->datums[i]),
+ range_deserialize(typcache, DatumGetRangeTypeP(in->datums[i]),
&lowerBounds[j], &upperBounds[j], &empty);
if (!empty)
j++;
@@ -249,9 +249,9 @@ spg_range_quad_picksplit(PG_FUNCTION_ARGS)
/* Place all ranges into node 0 */
for (i = 0; i < in->nTuples; i++)
{
- RangeType *range = DatumGetRangeType(in->datums[i]);
+ RangeType *range = DatumGetRangeTypeP(in->datums[i]);
- out->leafTupleDatums[i] = RangeTypeGetDatum(range);
+ out->leafTupleDatums[i] = RangeTypePGetDatum(range);
out->mapTuplesToNodes[i] = 0;
}
PG_RETURN_VOID();
@@ -267,7 +267,7 @@ spg_range_quad_picksplit(PG_FUNCTION_ARGS)
centroid = range_serialize(typcache, &lowerBounds[nonEmptyCount / 2],
&upperBounds[nonEmptyCount / 2], false);
out->hasPrefix = true;
- out->prefixDatum = RangeTypeGetDatum(centroid);
+ out->prefixDatum = RangeTypePGetDatum(centroid);
/* Create node for empty ranges only if it is a root node */
out->nNodes = (in->level == 0) ? 5 : 4;
*/
for (i = 0; i < in->nTuples; i++)
{
- RangeType *range = DatumGetRangeType(in->datums[i]);
+ RangeType *range = DatumGetRangeTypeP(in->datums[i]);
int16 quadrant = getQuadrant(typcache, centroid, range);
- out->leafTupleDatums[i] = RangeTypeGetDatum(range);
+ out->leafTupleDatums[i] = RangeTypePGetDatum(range);
out->mapTuplesToNodes[i] = quadrant - 1;
}
@@ -347,7 +347,7 @@ spg_range_quad_inner_consistent(PG_FUNCTION_ARGS)
*/
if (strategy != RANGESTRAT_CONTAINS_ELEM)
empty = RangeIsEmpty(
- DatumGetRangeType(in->scankeys[i].sk_argument));
+ DatumGetRangeTypeP(in->scankeys[i].sk_argument));
else
empty = false;
@@ -415,9 +415,9 @@ spg_range_quad_inner_consistent(PG_FUNCTION_ARGS)
RangeType *centroid;
/* This node has a centroid. Fetch it. */
- centroid = DatumGetRangeType(in->prefixDatum);
+ centroid = DatumGetRangeTypeP(in->prefixDatum);
typcache = range_get_typcache(fcinfo,
- RangeTypeGetOid(DatumGetRangeType(centroid)));
+ RangeTypeGetOid(DatumGetRangeTypeP(centroid)));
range_deserialize(typcache, centroid, ¢roidLower, ¢roidUpper,
¢roidEmpty);
@@ -482,7 +482,7 @@ spg_range_quad_inner_consistent(PG_FUNCTION_ARGS)
}
else
{
- range = DatumGetRangeType(in->scankeys[i].sk_argument);
+ range = DatumGetRangeTypeP(in->scankeys[i].sk_argument);
range_deserialize(typcache, range, &lower, &upper, &empty);
}
@@ -558,7 +558,7 @@ spg_range_quad_inner_consistent(PG_FUNCTION_ARGS)
*/
if (in->traversalValue != (Datum) 0)
{
- prevCentroid = DatumGetRangeType(in->traversalValue);
+ prevCentroid = DatumGetRangeTypeP(in->traversalValue);
range_deserialize(typcache, prevCentroid,
&prevLower, &prevUpper, &prevEmpty);
}
@@ -921,7 +921,7 @@ spg_range_quad_leaf_consistent(PG_FUNCTION_ARGS)
{
spgLeafConsistentIn *in = (spgLeafConsistentIn *) PG_GETARG_POINTER(0);
spgLeafConsistentOut *out = (spgLeafConsistentOut *) PG_GETARG_POINTER(1);
- RangeType *leafRange = DatumGetRangeType(in->leafDatum);
+ RangeType *leafRange = DatumGetRangeTypeP(in->leafDatum);
TypeCacheEntry *typcache;
bool res;
int i;
@@ -945,35 +945,35 @@ spg_range_quad_leaf_consistent(PG_FUNCTION_ARGS)
{
case RANGESTRAT_BEFORE:
res = range_before_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_OVERLEFT:
res = range_overleft_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_OVERLAPS:
res = range_overlaps_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_OVERRIGHT:
res = range_overright_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_AFTER:
res = range_after_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_ADJACENT:
res = range_adjacent_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_CONTAINS:
res = range_contains_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_CONTAINED_BY:
res = range_contained_by_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
case RANGESTRAT_CONTAINS_ELEM:
res = range_contains_elem_internal(typcache, leafRange,
@@ -981,7 +981,7 @@ spg_range_quad_leaf_consistent(PG_FUNCTION_ARGS)
break;
case RANGESTRAT_EQ:
res = range_eq_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeTypeP(keyDatum));
break;
default:
elog(ERROR, "unrecognized range strategy: %d",
index 324bbe48e5fe8876f8de750f7bf7687c19bb30c8..3efd982d1b2653543f5fb5df29010a495abc7c4f 100644 (file)
@@ -144,7 +144,7 @@ compute_range_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc,
total_width += VARSIZE_ANY(DatumGetPointer(value));
/* Get range and deserialize it for further analysis. */
- range = DatumGetRangeType(value);
+ range = DatumGetRangeTypeP(value);
range_deserialize(typcache, range, &lower, &upper, &empty);
if (!empty)
index d8b86f63931ed1cf01b02a0a351ded94b6fba1fe..732d87f22ffb81d118a50e24b31be760a5922075 100644 (file)
Datum
gtsvectorout(PG_FUNCTION_ARGS)
{
- SignTSVector *key = (SignTSVector *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_POINTER(0)));
+ SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(PG_GETARG_POINTER(0));
char *outbuf;
if (outbuf_maxlen == 0)
gtsvector_decompress(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- SignTSVector *key = (SignTSVector *) DatumGetPointer(PG_DETOAST_DATUM(entry->key));
+ SignTSVector *key = (SignTSVector *) PG_DETOAST_DATUM(entry->key);
if (key != (SignTSVector *) DatumGetPointer(entry->key))
{
index 61a67a21e36472a8720a4ab6324b74ed5cb072ac..d6d3c582b6a8613443a04c6fade0e075a24ec353 100644 (file)
@@ -252,7 +252,7 @@ typedef struct ArrayIteratorData *ArrayIterator;
#define PG_RETURN_EXPANDED_ARRAY(x) PG_RETURN_DATUM(EOHPGetRWDatum(&(x)->hdr))
/* fmgr macros for AnyArrayType (ie, get either varlena or expanded form) */
-#define PG_GETARG_ANY_ARRAY(n) DatumGetAnyArray(PG_GETARG_DATUM(n))
+#define PG_GETARG_ANY_ARRAY_P(n) DatumGetAnyArrayP(PG_GETARG_DATUM(n))
/*
* Access macros for varlena array header fields.
@@ -440,7 +440,7 @@ extern Datum expand_array(Datum arraydatum, MemoryContext parentcontext,
extern ExpandedArrayHeader *DatumGetExpandedArray(Datum d);
extern ExpandedArrayHeader *DatumGetExpandedArrayX(Datum d,
ArrayMetaState *metacache);
-extern AnyArrayType *DatumGetAnyArray(Datum d);
+extern AnyArrayType *DatumGetAnyArrayP(Datum d);
extern void deconstruct_expanded_array(ExpandedArrayHeader *eah);
#endif /* ARRAY_H */
index 24f491663bb2ec7ec0078a5263ccc247316746a5..d639bbc960e51b12cf053a6c1f75875c7b977b98 100644 (file)
#define JGIN_MAXLENGTH 125 /* max length of text part before hashing */
/* Convenience macros */
-#define DatumGetJsonb(d) ((Jsonb *) PG_DETOAST_DATUM(d))
-#define JsonbGetDatum(p) PointerGetDatum(p)
-#define PG_GETARG_JSONB(x) DatumGetJsonb(PG_GETARG_DATUM(x))
-#define PG_RETURN_JSONB(x) PG_RETURN_POINTER(x)
+#define DatumGetJsonbP(d) ((Jsonb *) PG_DETOAST_DATUM(d))
+#define JsonbPGetDatum(p) PointerGetDatum(p)
+#define PG_GETARG_JSONB_P(x) DatumGetJsonbP(PG_GETARG_DATUM(x))
+#define PG_RETURN_JSONB_P(x) PG_RETURN_POINTER(x)
typedef struct JsonbPair JsonbPair;
typedef struct JsonbValue JsonbValue;
index 554488931703dfc78b85f10dd25093fa7372dd1f..1ef5e542536d7e3a6408a339fa36804a48357932 100644 (file)
/*
* fmgr macros for range type objects
*/
-#define DatumGetRangeType(X) ((RangeType *) PG_DETOAST_DATUM(X))
-#define DatumGetRangeTypeCopy(X) ((RangeType *) PG_DETOAST_DATUM_COPY(X))
-#define RangeTypeGetDatum(X) PointerGetDatum(X)
-#define PG_GETARG_RANGE(n) DatumGetRangeType(PG_GETARG_DATUM(n))
-#define PG_GETARG_RANGE_COPY(n) DatumGetRangeTypeCopy(PG_GETARG_DATUM(n))
-#define PG_RETURN_RANGE(x) return RangeTypeGetDatum(x)
+#define DatumGetRangeTypeP(X) ((RangeType *) PG_DETOAST_DATUM(X))
+#define DatumGetRangeTypePCopy(X) ((RangeType *) PG_DETOAST_DATUM_COPY(X))
+#define RangeTypePGetDatum(X) PointerGetDatum(X)
+#define PG_GETARG_RANGE_P(n) DatumGetRangeTypeP(PG_GETARG_DATUM(n))
+#define PG_GETARG_RANGE_P_COPY(n) DatumGetRangeTypePCopy(PG_GETARG_DATUM(n))
+#define PG_RETURN_RANGE_P(x) return RangeTypePGetDatum(x)
/* Operator strategy numbers used in the GiST and SP-GiST range opclasses */
/* Numbers are chosen to match up operator names with existing usages */