}
qsort((void *) a, l, sizeof(Pairs), comparePairs);
+
+ /*
+ * We can't use qunique here because we have some clean-up code to run on
+ * removed elements.
+ */
ptr = a + 1;
res = a;
while (ptr - a < l)
#include "_int.h"
#include "catalog/pg_type.h"
+#include "lib/qunique.h"
/* arguments are assumed sorted & unique-ified */
bool
ArrayType *
_int_unique(ArrayType *r)
{
- int *tmp,
- *dr,
- *data;
int num = ARRNELEMS(r);
+ bool duplicates_found; /* not used */
- if (num < 2)
- return r;
+ num = qunique_arg(ARRPTR(r), num, sizeof(int), isort_cmp,
+ &duplicates_found);
- data = tmp = dr = ARRPTR(r);
- while (tmp - data < num)
- {
- if (*tmp != *dr)
- *(++dr) = *tmp++;
- else
- tmp++;
- }
- return resize_intArrayType(r, dr + 1 - ARRPTR(r));
+ return resize_intArrayType(r, num);
}
void
#include <ctype.h>
#include "catalog/pg_type.h"
+#include "lib/qunique.h"
#include "trgm.h"
#include "tsearch/ts_locale.h"
#include "utils/lsyscache.h"
return CMPTRGM(a, b);
}
-static int
-unique_array(trgm *a, int len)
-{
- trgm *curend,
- *tmp;
-
- curend = tmp = a;
- while (tmp - a < len)
- if (CMPTRGM(tmp, curend))
- {
- curend++;
- CPTRGM(curend, tmp);
- tmp++;
- }
- else
- tmp++;
-
- return curend + 1 - a;
-}
-
/*
* Finds first word in string, returns pointer to the word,
* endword points to the character after word
if (len > 1)
{
qsort((void *) GETARR(trg), len, sizeof(trgm), comp_trgm);
- len = unique_array(GETARR(trg), len);
+ len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
}
SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len));
if (len > 1)
{
qsort((void *) GETARR(trg), len, sizeof(trgm), comp_trgm);
- len = unique_array(GETARR(trg), len);
+ len = qunique(GETARR(trg), len, sizeof(trgm), comp_trgm);
}
SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, len));
#include "access/reloptions.h"
#include "access/relscan.h"
#include "commands/progress.h"
+#include "lib/qunique.h"
#include "miscadmin.h"
#include "utils/array.h"
#include "utils/datum.h"
Oid elemtype;
RegProcedure cmp_proc;
BTSortArrayContext cxt;
- int last_non_dup;
- int i;
if (nelems <= 1)
return nelems; /* no work to do */
_bt_compare_array_elements, (void *) &cxt);
/* Now scan the sorted elements and remove duplicates */
- last_non_dup = 0;
- for (i = 1; i < nelems; i++)
- {
- int32 compare;
-
- compare = DatumGetInt32(FunctionCall2Coll(&cxt.flinfo,
- cxt.collation,
- elems[last_non_dup],
- elems[i]));
- if (compare != 0)
- elems[++last_non_dup] = elems[i];
- }
-
- return last_non_dup + 1;
+ return qunique_arg(elems, nelems, sizeof(Datum),
+ _bt_compare_array_elements, &cxt);
}
/*
#include "catalog/pg_type.h"
#include "executor/execdebug.h"
#include "executor/nodeTidscan.h"
+#include "lib/qunique.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "storage/bufmgr.h"
*/
if (numTids > 1)
{
- int lastTid;
- int i;
-
/* CurrentOfExpr could never appear OR'd with something else */
Assert(!tidstate->tss_isCurrentOf);
qsort((void *) tidList, numTids, sizeof(ItemPointerData),
itemptr_comparator);
- lastTid = 0;
- for (i = 1; i < numTids; i++)
- {
- if (!ItemPointerEquals(&tidList[lastTid], &tidList[i]))
- tidList[++lastTid] = tidList[i];
- }
- numTids = lastTid + 1;
+ numTids = qunique(tidList, numTids, sizeof(ItemPointerData),
+ itemptr_comparator);
}
tidstate->tss_TidList = tidList;
#include "commands/tablespace.h"
#include "foreign/foreign.h"
#include "funcapi.h"
+#include "lib/qunique.h"
#include "miscadmin.h"
#include "utils/acl.h"
#include "utils/array.h"
Oid *list;
const AclItem *acldat;
int i,
- j,
- k;
+ j;
if (acl == NULL || ACL_NUM(acl) == 0)
{
/* Sort the array */
qsort(list, j, sizeof(Oid), oid_cmp);
- /* Remove duplicates from the array */
- k = 0;
- for (i = 1; i < j; i++)
- {
- if (list[k] != list[i])
- list[++k] = list[i];
- }
-
/*
* We could repalloc the array down to minimum size, but it's hardly worth
* it since it's only transient memory.
*/
*roleids = list;
- return k + 1;
+ /* Remove duplicates from the array */
+ return qunique(list, j, sizeof(Oid), oid_cmp);
}
#include "access/gist.h"
#include "access/heaptoast.h"
+#include "lib/qunique.h"
#include "port/pg_bitutils.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
return (a > b) ? 1 : -1;
}
-/*
- * Removes duplicates from an array of int32. 'l' is
- * size of the input array. Returns the new size of the array.
- */
-static int
-uniqueint(int32 *a, int32 l)
-{
- int32 *ptr,
- *res;
-
- if (l <= 1)
- return l;
-
- ptr = res = a;
-
- qsort((void *) a, l, sizeof(int32), compareint);
-
- while (ptr - a < l)
- if (*ptr != *res)
- *(++res) = *ptr++;
- else
- ptr++;
- return res + 1 - a;
-}
-
static void
makesign(BITVECP sign, SignTSVector *a)
{
ptr++;
}
- len = uniqueint(GETARR(res), val->size);
+ qsort(GETARR(res), val->size, sizeof(int), compareint);
+ len = qunique(GETARR(res), val->size, sizeof(int), compareint);
if (len != val->size)
{
/*
#include "postgres.h"
+#include "lib/qunique.h"
#include "tsearch/ts_utils.h"
#include "utils/builtins.h"
return strcmp(sa, sb);
}
-static int
-remove_duplicates(char **strings, int n)
-{
- if (n <= 1)
- return n;
- else
- {
- int i;
- char *prev = strings[0];
- int new_n = 1;
-
- for (i = 1; i < n; i++)
- {
- if (strcmp(strings[i], prev) != 0)
- {
- strings[new_n++] = strings[i];
- prev = strings[i];
- }
- }
- return new_n;
- }
-}
-
Datum
tsq_mcontains(PG_FUNCTION_ARGS)
{
/* Sort and remove duplicates from both arrays */
qsort(query_values, query_nvalues, sizeof(char *), cmp_string);
- query_nvalues = remove_duplicates(query_values, query_nvalues);
+ query_nvalues = qunique(query_values, query_nvalues, sizeof(char *),
+ cmp_string);
qsort(ex_values, ex_nvalues, sizeof(char *), cmp_string);
- ex_nvalues = remove_duplicates(ex_values, ex_nvalues);
+ ex_nvalues = qunique(ex_values, ex_nvalues, sizeof(char *), cmp_string);
if (ex_nvalues > query_nvalues)
result = false;
}
/*
- * Removes duplicate pos entries. If there's two entries with same pos
- * but different weight, the higher weight is retained.
+ * Removes duplicate pos entries. If there's two entries with same pos but
+ * different weight, the higher weight is retained, so we can't use
+ * qunique here.
*
* Returns new length.
*/
#include "commands/trigger.h"
#include "executor/spi.h"
#include "funcapi.h"
+#include "lib/qunique.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "parser/parse_coerce.h"
*/
if (indices_count > 1)
{
- int kp;
-
qsort(indices_to_delete, indices_count, sizeof(int), compare_int);
- kp = 0;
- for (k = 1; k < indices_count; k++)
- {
- if (indices_to_delete[k] != indices_to_delete[kp])
- indices_to_delete[++kp] = indices_to_delete[k];
- }
- indices_count = ++kp;
+ indices_count = qunique(indices_to_delete, indices_count, sizeof(int),
+ compare_int);
}
/*
bool *nulls;
int nitems,
i,
- j,
tslen,
datalen = 0;
char *cur;
if (nitems > 1)
{
qsort(dlexemes, nitems, sizeof(Datum), compare_text_lexemes);
- j = 0;
- for (i = 1; i < nitems; i++)
- {
- if (compare_text_lexemes(&dlexemes[j], &dlexemes[i]) < 0)
- dlexemes[++j] = dlexemes[i];
- }
- nitems = ++j;
+ nitems = qunique(dlexemes, nitems, sizeof(Datum),
+ compare_text_lexemes);
}
/* Calculate space needed for surviving lexemes. */
return result;
}
-/*
- * Removes duplicate pos entries. We can't use uniquePos() from
- * tsvector.c because array might be longer than MAXENTRYPOS
- *
- * Returns new length.
- */
-static int
-uniqueLongPos(WordEntryPos *pos, int npos)
-{
- WordEntryPos *pos_iter,
- *result;
-
- if (npos <= 1)
- return npos;
-
- qsort((void *) pos, npos, sizeof(WordEntryPos), compareWordEntryPos);
-
- result = pos;
- pos_iter = pos + 1;
- while (pos_iter < pos + npos)
- {
- if (WEP_GETPOS(*pos_iter) != WEP_GETPOS(*result))
- {
- result++;
- *result = WEP_GETPOS(*pos_iter);
- }
-
- pos_iter++;
- }
-
- return result + 1 - pos;
-}
-
/*
* is there value 'val' in array or not ?
*/
{
/* Sort and make unique array of found positions */
data->pos = allpos;
- data->npos = uniqueLongPos(allpos, npos);
+ qsort(data->pos, npos, sizeof(WordEntryPos), compareWordEntryPos);
+ data->npos = qunique(data->pos, npos, sizeof(WordEntryPos),
+ compareWordEntryPos);
data->allocated = true;
}
}
#include "access/xlog.h"
#include "funcapi.h"
#include "miscadmin.h"
+#include "lib/qunique.h"
#include "libpq/pqformat.h"
#include "postmaster/postmaster.h"
#include "storage/lwlock.h"
static void
sort_snapshot(TxidSnapshot *snap)
{
- txid last = 0;
- int nxip,
- idx1,
- idx2;
-
if (snap->nxip > 1)
{
qsort(snap->xip, snap->nxip, sizeof(txid), cmp_txid);
-
- /* remove duplicates */
- nxip = snap->nxip;
- idx1 = idx2 = 0;
- while (idx1 < nxip)
- {
- if (snap->xip[idx1] != last)
- last = snap->xip[idx2++] = snap->xip[idx1];
- else
- snap->nxip--;
- idx1++;
- }
+ snap->nxip = qunique(snap->xip, snap->nxip, sizeof(txid), cmp_txid);
}
}
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
#include "catalog/pg_user_mapping.h"
+#include "lib/qunique.h"
#include "utils/rel.h"
#include "utils/catcache.h"
#include "utils/syscache.h"
InitCatalogCache(void)
{
int cacheId;
- int i,
- j;
StaticAssertStmt(SysCacheSize == (int) lengthof(cacheinfo),
"SysCacheSize does not match syscache.c's array");
/* Sort and de-dup OID arrays, so we can use binary search. */
pg_qsort(SysCacheRelationOid, SysCacheRelationOidSize,
sizeof(Oid), oid_compare);
- for (i = 1, j = 0; i < SysCacheRelationOidSize; i++)
- {
- if (SysCacheRelationOid[i] != SysCacheRelationOid[j])
- SysCacheRelationOid[++j] = SysCacheRelationOid[i];
- }
- SysCacheRelationOidSize = j + 1;
+ SysCacheRelationOidSize =
+ qunique(SysCacheRelationOid, SysCacheRelationOidSize, sizeof(Oid),
+ oid_compare);
pg_qsort(SysCacheSupportingRelOid, SysCacheSupportingRelOidSize,
sizeof(Oid), oid_compare);
- for (i = 1, j = 0; i < SysCacheSupportingRelOidSize; i++)
- {
- if (SysCacheSupportingRelOid[i] != SysCacheSupportingRelOid[j])
- SysCacheSupportingRelOid[++j] = SysCacheSupportingRelOid[i];
- }
- SysCacheSupportingRelOidSize = j + 1;
+ SysCacheSupportingRelOidSize =
+ qunique(SysCacheSupportingRelOid, SysCacheSupportingRelOidSize,
+ sizeof(Oid), oid_compare);
CacheInitialized = true;
}
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * qunique.h
+ * inline array unique functions
+ * Portions Copyright (c) 2019, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * src/include/lib/qunique.h
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef QUNIQUE_H
+#define QUNIQUE_H
+
+/*
+ * Remove duplicates from a pre-sorted array, according to a user-supplied
+ * comparator. Usually the array should have been sorted with qsort() using
+ * the same arguments. Return the new size.
+ */
+static inline size_t
+qunique(void *array, size_t elements, size_t width,
+ int (*compare) (const void *, const void *))
+{
+ char *bytes = (char *) array;
+ size_t i,
+ j;
+
+ if (elements <= 1)
+ return elements;
+
+ for (i = 1, j = 0; i < elements; ++i)
+ {
+ if (compare(bytes + i * width, bytes + j * width) != 0)
+ memcpy(bytes + ++j * width, bytes + i * width, width);
+ }
+
+ return j + 1;
+}
+
+/*
+ * Like qunique(), but takes a comparator with an extra user data argument
+ * which is passed through, for compatibility with qsort_arg().
+ */
+static inline size_t
+qunique_arg(void *array, size_t elements, size_t width,
+ int (*compare) (const void *, const void *, void *),
+ void *arg)
+{
+ char *bytes = (char *) array;
+ size_t i,
+ j;
+
+ if (elements <= 1)
+ return elements;
+
+ for (i = 1, j = 0; i < elements; ++i)
+ {
+ if (compare(bytes + i * width, bytes + j * width, arg) != 0)
+ memcpy(bytes + ++j * width, bytes + i * width, width);
+ }
+
+ return j + 1;
+}
+
+#endif /* QUNIQUE_H */
projects / users / gsingh / postgres.git / commitdiff