Line data Source code
1 : /*
2 : * contrib/btree_gist/btree_bit.c
3 : */
4 : #include "postgres.h"
5 :
6 : #include "btree_gist.h"
7 : #include "btree_utils_var.h"
8 : #include "utils/fmgrprotos.h"
9 : #include "utils/sortsupport.h"
10 : #include "utils/varbit.h"
11 : #include "varatt.h"
12 :
13 : /* GiST support functions */
14 10 : PG_FUNCTION_INFO_V1(gbt_bit_compress);
15 10 : PG_FUNCTION_INFO_V1(gbt_bit_union);
16 10 : PG_FUNCTION_INFO_V1(gbt_bit_picksplit);
17 10 : PG_FUNCTION_INFO_V1(gbt_bit_consistent);
18 10 : PG_FUNCTION_INFO_V1(gbt_bit_penalty);
19 10 : PG_FUNCTION_INFO_V1(gbt_bit_same);
20 8 : PG_FUNCTION_INFO_V1(gbt_bit_sortsupport);
21 8 : PG_FUNCTION_INFO_V1(gbt_varbit_sortsupport);
22 :
23 :
24 : /* define for comparison */
25 :
26 : static bool
27 1800 : gbt_bitgt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
28 : {
29 1800 : return DatumGetBool(DirectFunctionCall2(bitgt,
30 : PointerGetDatum(a),
31 : PointerGetDatum(b)));
32 : }
33 :
34 : static bool
35 1800 : gbt_bitge(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
36 : {
37 1800 : return DatumGetBool(DirectFunctionCall2(bitge,
38 : PointerGetDatum(a),
39 : PointerGetDatum(b)));
40 : }
41 :
42 : static bool
43 600 : gbt_biteq(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
44 : {
45 600 : return DatumGetBool(DirectFunctionCall2(biteq,
46 : PointerGetDatum(a),
47 : PointerGetDatum(b)));
48 : }
49 :
50 : static bool
51 1200 : gbt_bitle(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
52 : {
53 1200 : return DatumGetBool(DirectFunctionCall2(bitle,
54 : PointerGetDatum(a),
55 : PointerGetDatum(b)));
56 : }
57 :
58 : static bool
59 1200 : gbt_bitlt(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
60 : {
61 1200 : return DatumGetBool(DirectFunctionCall2(bitlt,
62 : PointerGetDatum(a),
63 : PointerGetDatum(b)));
64 : }
65 :
66 : static int32
67 29414 : gbt_bitcmp(const void *a, const void *b, Oid collation, FmgrInfo *flinfo)
68 : {
69 29414 : return DatumGetInt32(DirectFunctionCall2(byteacmp,
70 : PointerGetDatum(a),
71 : PointerGetDatum(b)));
72 : }
73 :
74 :
75 : static bytea *
76 7276 : gbt_bit_xfrm(bytea *leaf)
77 : {
78 7276 : bytea *out = leaf;
79 7276 : int sz = VARBITBYTES(leaf) + VARHDRSZ;
80 7276 : int padded_sz = INTALIGN(sz);
81 :
82 7276 : out = (bytea *) palloc(padded_sz);
83 : /* initialize the padding bytes to zero */
84 23598 : while (sz < padded_sz)
85 16322 : ((char *) out)[sz++] = 0;
86 7276 : SET_VARSIZE(out, padded_sz);
87 7276 : memcpy(VARDATA(out), VARBITS(leaf), VARBITBYTES(leaf));
88 7276 : return out;
89 : }
90 :
91 :
92 :
93 :
94 : static GBT_VARKEY *
95 7196 : gbt_bit_l2n(GBT_VARKEY *leaf, FmgrInfo *flinfo)
96 : {
97 7196 : GBT_VARKEY *out = leaf;
98 7196 : GBT_VARKEY_R r = gbt_var_key_readable(leaf);
99 : bytea *o;
100 :
101 7196 : o = gbt_bit_xfrm(r.lower);
102 7196 : r.upper = r.lower = o;
103 7196 : out = gbt_var_key_copy(&r);
104 7196 : pfree(o);
105 :
106 7196 : return out;
107 : }
108 :
109 : static const gbtree_vinfo tinfo =
110 : {
111 : gbt_t_bit,
112 : 0,
113 : true,
114 : gbt_bitgt,
115 : gbt_bitge,
116 : gbt_biteq,
117 : gbt_bitle,
118 : gbt_bitlt,
119 : gbt_bitcmp,
120 : gbt_bit_l2n
121 : };
122 :
123 :
124 : /**************************************************
125 : * GiST support functions
126 : **************************************************/
127 :
128 : Datum
129 2416 : gbt_bit_compress(PG_FUNCTION_ARGS)
130 : {
131 2416 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
132 :
133 2416 : PG_RETURN_POINTER(gbt_var_compress(entry, &tinfo));
134 : }
135 :
136 : Datum
137 6680 : gbt_bit_consistent(PG_FUNCTION_ARGS)
138 : {
139 6680 : GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
140 6680 : void *query = DatumGetByteaP(PG_GETARG_DATUM(1));
141 6680 : StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
142 :
143 : /* Oid subtype = PG_GETARG_OID(3); */
144 6680 : bool *recheck = (bool *) PG_GETARG_POINTER(4);
145 : bool retval;
146 6680 : GBT_VARKEY *key = (GBT_VARKEY *) DatumGetPointer(entry->key);
147 6680 : GBT_VARKEY_R r = gbt_var_key_readable(key);
148 :
149 : /* All cases served by this function are exact */
150 6680 : *recheck = false;
151 :
152 6680 : if (GIST_LEAF(entry))
153 6600 : retval = gbt_var_consistent(&r, query, strategy, PG_GET_COLLATION(),
154 : true, &tinfo, fcinfo->flinfo);
155 : else
156 : {
157 80 : bytea *q = gbt_bit_xfrm((bytea *) query);
158 :
159 80 : retval = gbt_var_consistent(&r, q, strategy, PG_GET_COLLATION(),
160 : false, &tinfo, fcinfo->flinfo);
161 : }
162 6680 : PG_RETURN_BOOL(retval);
163 : }
164 :
165 : Datum
166 4 : gbt_bit_union(PG_FUNCTION_ARGS)
167 : {
168 4 : GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
169 4 : int32 *size = (int *) PG_GETARG_POINTER(1);
170 :
171 4 : PG_RETURN_POINTER(gbt_var_union(entryvec, size, PG_GET_COLLATION(),
172 : &tinfo, fcinfo->flinfo));
173 : }
174 :
175 : Datum
176 12 : gbt_bit_picksplit(PG_FUNCTION_ARGS)
177 : {
178 12 : GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
179 12 : GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
180 :
181 12 : gbt_var_picksplit(entryvec, v, PG_GET_COLLATION(),
182 : &tinfo, fcinfo->flinfo);
183 12 : PG_RETURN_POINTER(v);
184 : }
185 :
186 : Datum
187 0 : gbt_bit_same(PG_FUNCTION_ARGS)
188 : {
189 0 : Datum d1 = PG_GETARG_DATUM(0);
190 0 : Datum d2 = PG_GETARG_DATUM(1);
191 0 : bool *result = (bool *) PG_GETARG_POINTER(2);
192 :
193 0 : *result = gbt_var_same(d1, d2, PG_GET_COLLATION(), &tinfo, fcinfo->flinfo);
194 0 : PG_RETURN_POINTER(result);
195 : }
196 :
197 : Datum
198 0 : gbt_bit_penalty(PG_FUNCTION_ARGS)
199 : {
200 0 : GISTENTRY *o = (GISTENTRY *) PG_GETARG_POINTER(0);
201 0 : GISTENTRY *n = (GISTENTRY *) PG_GETARG_POINTER(1);
202 0 : float *result = (float *) PG_GETARG_POINTER(2);
203 :
204 0 : PG_RETURN_POINTER(gbt_var_penalty(result, o, n, PG_GET_COLLATION(),
205 : &tinfo, fcinfo->flinfo));
206 : }
207 :
208 : static int
209 22676 : gbt_bit_ssup_cmp(Datum x, Datum y, SortSupport ssup)
210 : {
211 22676 : GBT_VARKEY *key1 = PG_DETOAST_DATUM(x);
212 22676 : GBT_VARKEY *key2 = PG_DETOAST_DATUM(y);
213 :
214 22676 : GBT_VARKEY_R arg1 = gbt_var_key_readable(key1);
215 22676 : GBT_VARKEY_R arg2 = gbt_var_key_readable(key2);
216 : Datum result;
217 :
218 : /* for leaf items we expect lower == upper, so only compare lower */
219 22676 : result = DirectFunctionCall2(byteacmp,
220 : PointerGetDatum(arg1.lower),
221 : PointerGetDatum(arg2.lower));
222 :
223 22676 : GBT_FREE_IF_COPY(key1, x);
224 22676 : GBT_FREE_IF_COPY(key2, y);
225 :
226 22676 : return DatumGetInt32(result);
227 : }
228 :
229 : Datum
230 2 : gbt_bit_sortsupport(PG_FUNCTION_ARGS)
231 : {
232 2 : SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
233 :
234 2 : ssup->comparator = gbt_bit_ssup_cmp;
235 2 : ssup->ssup_extra = NULL;
236 :
237 2 : PG_RETURN_VOID();
238 : }
239 :
240 : Datum
241 2 : gbt_varbit_sortsupport(PG_FUNCTION_ARGS)
242 : {
243 2 : SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
244 :
245 2 : ssup->comparator = gbt_bit_ssup_cmp;
246 2 : ssup->ssup_extra = NULL;
247 :
248 2 : PG_RETURN_VOID();
249 : }
|
