DefineCustomRealVariable("auto_explain.sample_rate",
"Fraction of queries to process.",
- NULL,
- &auto_explain_sample_rate,
- 1.0,
- 0.0,
- 1.0,
- PGC_SUSET,
- 0,
- NULL,
- NULL,
- NULL);
+ NULL,
+ &auto_explain_sample_rate,
+ 1.0,
+ 0.0,
+ 1.0,
+ PGC_SUSET,
+ 0,
+ NULL,
+ NULL,
+ NULL);
EmitWarningsOnPlaceholders("auto_explain");
explain_ExecutorStart(QueryDesc *queryDesc, int eflags)
{
/*
- * For rate sampling, randomly choose top-level statement. Either
- * all nested statements will be explained or none will.
+ * For rate sampling, randomly choose top-level statement. Either all
+ * nested statements will be explained or none will.
*/
if (auto_explain_log_min_duration >= 0 && nesting_level == 0)
current_query_sampled = (random() < auto_explain_sample_rate *
- MAX_RANDOM_VALUE);
+ MAX_RANDOM_VALUE);
if (auto_explain_enabled() && current_query_sampled)
{
typedef struct
{
BloomState blstate; /* bloom index state */
- MemoryContext tmpCtx; /* temporary memory context reset after
- * each tuple */
+ MemoryContext tmpCtx; /* temporary memory context reset after each
+ * tuple */
char data[BLCKSZ]; /* cached page */
int64 count; /* number of tuples in cached page */
-} BloomBuildState;
+} BloomBuildState;
/*
* Flush page cached in BloomBuildState.
bloomBuildCallback, (void *) &buildstate);
/*
- * There are could be some items in cached page. Flush this page
- * if needed.
+ * There are could be some items in cached page. Flush this page if
+ * needed.
*/
if (buildstate.count > 0)
flushCachedPage(index, &buildstate);
/* Opaque for bloom pages */
typedef struct BloomPageOpaqueData
{
- OffsetNumber maxoff; /* number of index tuples on page */
- uint16 flags; /* see bit definitions below */
- uint16 unused; /* placeholder to force maxaligning of size
- * of BloomPageOpaqueData and to place
- * bloom_page_id exactly at the end of page
- */
- uint16 bloom_page_id; /* for identification of BLOOM indexes */
-} BloomPageOpaqueData;
+ OffsetNumber maxoff; /* number of index tuples on page */
+ uint16 flags; /* see bit definitions below */
+ uint16 unused; /* placeholder to force maxaligning of size of
+ * BloomPageOpaqueData and to place
+ * bloom_page_id exactly at the end of page */
+ uint16 bloom_page_id; /* for identification of BLOOM indexes */
+} BloomPageOpaqueData;
typedef BloomPageOpaqueData *BloomPageOpaque;
{
int32 vl_len_; /* varlena header (do not touch directly!) */
int bloomLength; /* length of signature in words (not bits!) */
- int bitSize[INDEX_MAX_KEYS]; /* # of bits generated for each
- * index key */
-} BloomOptions;
+ int bitSize[INDEX_MAX_KEYS]; /* # of bits generated for
+ * each index key */
+} BloomOptions;
/*
* FreeBlockNumberArray - array of block numbers sized so that metadata fill
uint16 nEnd;
BloomOptions opts;
FreeBlockNumberArray notFullPage;
-} BloomMetaPageData;
+} BloomMetaPageData;
/* Magic number to distinguish bloom pages among anothers */
#define BLOOM_MAGICK_NUMBER (0xDBAC0DED)
* precompute it
*/
Size sizeOfBloomTuple;
-} BloomState;
+} BloomState;
#define BloomPageGetFreeSpace(state, page) \
(BLCKSZ - MAXALIGN(SizeOfPageHeaderData) \
{
ItemPointerData heapPtr;
BloomSignatureWord sign[FLEXIBLE_ARRAY_MEMBER];
-} BloomTuple;
+} BloomTuple;
#define BLOOMTUPLEHDRSZ offsetof(BloomTuple, sign)
/* Opaque data structure for bloom index scan */
typedef struct BloomScanOpaqueData
{
- BloomSignatureWord *sign; /* Scan signature */
+ BloomSignatureWord *sign; /* Scan signature */
BloomState state;
-} BloomScanOpaqueData;
+} BloomScanOpaqueData;
typedef BloomScanOpaqueData *BloomScanOpaque;
/* blutils.c */
extern void _PG_init(void);
extern Datum blhandler(PG_FUNCTION_ARGS);
-extern void initBloomState(BloomState * state, Relation index);
+extern void initBloomState(BloomState *state, Relation index);
extern void BloomFillMetapage(Relation index, Page metaPage);
extern void BloomInitMetapage(Relation index);
extern void BloomInitPage(Page page, uint16 flags);
extern Buffer BloomNewBuffer(Relation index);
-extern void signValue(BloomState * state, BloomSignatureWord * sign, Datum value, int attno);
-extern BloomTuple *BloomFormTuple(BloomState * state, ItemPointer iptr, Datum *values, bool *isnull);
-extern bool BloomPageAddItem(BloomState * state, Page page, BloomTuple * tuple);
+extern void signValue(BloomState *state, BloomSignatureWord *sign, Datum value, int attno);
+extern BloomTuple *BloomFormTuple(BloomState *state, ItemPointer iptr, Datum *values, bool *isnull);
+extern bool BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple);
/* blvalidate.c */
extern bool blvalidate(Oid opclassoid);
/* Kind of relation options for bloom index */
static relopt_kind bl_relopt_kind;
+
/* parse table for fillRelOptions */
static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS + 1];
* October 1988, p. 1195.
*----------
*/
- int32 hi, lo, x;
+ int32 hi,
+ lo,
+ x;
/* Must be in [1, 0x7ffffffe] range at this point. */
hi = next / 127773;
/* Iterate over the tuples */
itup = itupPtr = BloomPageGetTuple(&state, page, FirstOffsetNumber);
itupEnd = BloomPageGetTuple(&state, page,
- OffsetNumberNext(BloomPageGetMaxOffset(page)));
+ OffsetNumberNext(BloomPageGetMaxOffset(page)));
while (itup < itupEnd)
{
/* Do we have to delete this tuple? */
}
Assert(itupPtr == BloomPageGetTuple(&state, page,
- OffsetNumberNext(BloomPageGetMaxOffset(page))));
+ OffsetNumberNext(BloomPageGetMaxOffset(page))));
/*
- * Add page to notFullPage list if we will not mark page as deleted and
- * there is a free space on it
+ * Add page to notFullPage list if we will not mark page as deleted
+ * and there is a free space on it
*/
if (BloomPageGetMaxOffset(page) != 0 &&
BloomPageGetFreeSpace(&state, page) > state.sizeOfBloomTuple &&
AcquireSampleRowsFunc *func,
BlockNumber *totalpages);
static bool fileIsForeignScanParallelSafe(PlannerInfo *root, RelOptInfo *rel,
- RangeTblEntry *rte);
+ RangeTblEntry *rte);
/*
* Helper functions
/*
* fileIsForeignScanParallelSafe
- * Reading a file in a parallel worker should work just the same as
- * reading it in the leader, so mark scans safe.
+ * Reading a file in a parallel worker should work just the same as
+ * reading it in the leader, so mark scans safe.
*/
static bool
fileIsForeignScanParallelSafe(PlannerInfo *root, RelOptInfo *rel,
- RangeTblEntry *rte)
+ RangeTblEntry *rte)
{
return true;
}
unsigned check;
/*
- * The number should come in this format: 978-0-000-00000-0
- * or may be an ISBN-13 number, 979-..., which does not have a short
- * representation. Do the short output version if possible.
+ * The number should come in this format: 978-0-000-00000-0 or may be an
+ * ISBN-13 number, 979-..., which does not have a short representation. Do
+ * the short output version if possible.
*/
if (strncmp("978-", isn, 4) == 0)
{
else
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
- errmsg("illegal character '%c' in t_bits string", str[off])));
+ errmsg("illegal character '%c' in t_bits string", str[off])));
if (off % 8 == 7)
bits[off / 8] = byte;
lp_offset == MAXALIGN(lp_offset) &&
lp_offset + lp_len <= raw_page_size)
{
- HeapTupleHeader tuphdr;
- bytea *tuple_data_bytea;
- int tuple_data_len;
+ HeapTupleHeader tuphdr;
+ bytea *tuple_data_bytea;
+ int tuple_data_len;
/* Extract information from the tuple header */
tuple_data_bytea = (bytea *) palloc(tuple_data_len + VARHDRSZ);
SET_VARSIZE(tuple_data_bytea, tuple_data_len + VARHDRSZ);
memcpy(VARDATA(tuple_data_bytea), (char *) tuphdr + tuphdr->t_hoff,
- tuple_data_len);
+ tuple_data_len);
values[13] = PointerGetDatum(tuple_data_bytea);
/*
*/
static Datum
tuple_data_split_internal(Oid relid, char *tupdata,
- uint16 tupdata_len, uint16 t_infomask,
- uint16 t_infomask2, bits8 *t_bits,
- bool do_detoast)
+ uint16 tupdata_len, uint16 t_infomask,
+ uint16 t_infomask2, bits8 *t_bits,
+ bool do_detoast)
{
- ArrayBuildState *raw_attrs;
- int nattrs;
- int i;
- int off = 0;
- Relation rel;
- TupleDesc tupdesc;
+ ArrayBuildState *raw_attrs;
+ int nattrs;
+ int i;
+ int off = 0;
+ Relation rel;
+ TupleDesc tupdesc;
/* Get tuple descriptor from relation OID */
rel = relation_open(relid, NoLock);
for (i = 0; i < nattrs; i++)
{
- Form_pg_attribute attr;
- bool is_null;
- bytea *attr_data = NULL;
+ Form_pg_attribute attr;
+ bool is_null;
+ bytea *attr_data = NULL;
attr = tupdesc->attrs[i];
is_null = (t_infomask & HEAP_HASNULL) && att_isnull(i, t_bits);
/*
- * Tuple header can specify less attributes than tuple descriptor
- * as ALTER TABLE ADD COLUMN without DEFAULT keyword does not
- * actually change tuples in pages, so attributes with numbers greater
- * than (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
+ * Tuple header can specify less attributes than tuple descriptor as
+ * ALTER TABLE ADD COLUMN without DEFAULT keyword does not actually
+ * change tuples in pages, so attributes with numbers greater than
+ * (t_infomask2 & HEAP_NATTS_MASK) should be treated as NULL.
*/
if (i >= (t_infomask2 & HEAP_NATTS_MASK))
is_null = true;
if (!is_null)
{
- int len;
+ int len;
if (attr->attlen == -1)
{
off = att_align_pointer(off, tupdesc->attrs[i]->attalign, -1,
tupdata + off);
+
/*
* As VARSIZE_ANY throws an exception if it can't properly
* detect the type of external storage in macros VARTAG_SIZE,
!VARATT_IS_EXTERNAL_ONDISK(tupdata + off) &&
!VARATT_IS_EXTERNAL_INDIRECT(tupdata + off))
ereport(ERROR,
- (errcode(ERRCODE_DATA_CORRUPTED),
- errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
+ (errcode(ERRCODE_DATA_CORRUPTED),
+ errmsg("first byte of varlena attribute is incorrect for attribute %d", i)));
len = VARSIZE_ANY(tupdata + off);
}
if (tupdata_len != off)
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
- errmsg("end of tuple reached without looking at all its data")));
+ errmsg("end of tuple reached without looking at all its data")));
return makeArrayResult(raw_attrs, CurrentMemoryContext);
}
Datum
tuple_data_split(PG_FUNCTION_ARGS)
{
- Oid relid;
- bytea *raw_data;
- uint16 t_infomask;
- uint16 t_infomask2;
- char *t_bits_str;
- bool do_detoast = false;
- bits8 *t_bits = NULL;
- Datum res;
+ Oid relid;
+ bytea *raw_data;
+ uint16 t_infomask;
+ uint16 t_infomask2;
+ char *t_bits_str;
+ bool do_detoast = false;
+ bits8 *t_bits = NULL;
+ Datum res;
relid = PG_GETARG_OID(0);
raw_data = PG_ARGISNULL(1) ? NULL : PG_GETARG_BYTEA_P(1);
*/
if (t_infomask & HEAP_HASNULL)
{
- int bits_str_len;
- int bits_len;
+ int bits_str_len;
+ int bits_len;
bits_len = (t_infomask2 & HEAP_NATTS_MASK) / 8 + 1;
if (!t_bits_str)
Datum
gin_trgm_triconsistent(PG_FUNCTION_ARGS)
{
- GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
+ GinTernaryValue *check = (GinTernaryValue *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
/* text *query = PG_GETARG_TEXT_P(2); */
int32 nkeys = PG_GETARG_INT32(3);
Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
- GinTernaryValue res = GIN_MAYBE;
+ GinTernaryValue res = GIN_MAYBE;
int32 i,
ntrue;
bool *boolcheck;
}
/*
- * See comment in gin_trgm_consistent() about * upper bound formula
+ * See comment in gin_trgm_consistent() about * upper bound
+ * formula
*/
res = (nkeys == 0)
? GIN_FALSE : (((((float4) ntrue) / ((float4) nkeys)) >= nlimit)
- ? GIN_MAYBE : GIN_FALSE);
+ ? GIN_MAYBE : GIN_FALSE);
break;
case ILikeStrategyNumber:
#ifndef IGNORECASE
else
{
/*
- * As trigramsMatchGraph implements a monotonic boolean function,
- * promoting all GIN_MAYBE keys to GIN_TRUE will give a
- * conservative result.
+ * As trigramsMatchGraph implements a monotonic boolean
+ * function, promoting all GIN_MAYBE keys to GIN_TRUE will
+ * give a conservative result.
*/
boolcheck = (bool *) palloc(sizeof(bool) * nkeys);
for (i = 0; i < nkeys; i++)
break;
default:
elog(ERROR, "unrecognized strategy number: %d", strategy);
- res = GIN_FALSE; /* keep compiler quiet */
+ res = GIN_FALSE; /* keep compiler quiet */
break;
}
if (GIST_LEAF(entry))
{ /* all leafs contains orig trgm */
+
/*
* Prevent gcc optimizing the tmpsml variable using volatile
* keyword. Otherwise comparison of nlimit and tmpsml may give
*recheck = strategy == WordDistanceStrategyNumber;
if (GIST_LEAF(entry))
{ /* all leafs contains orig trgm */
+
/*
* Prevent gcc optimizing the sml variable using volatile
* keyword. Otherwise res can differ from the
* word_similarity_dist_op() function.
*/
float4 volatile sml = cnt_sml(qtrg, key, *recheck);
+
res = 1.0 - sml;
}
else if (ISALLTRUE(key))
PG_MODULE_MAGIC;
/* GUC variables */
-double similarity_threshold = 0.3f;
-double word_similarity_threshold = 0.6f;
+double similarity_threshold = 0.3f;
+double word_similarity_threshold = 0.6f;
void _PG_init(void);
/* Trigram with position */
typedef struct
{
- trgm trg;
- int index;
+ trgm trg;
+ int index;
} pos_trgm;
/*
{
/* Define custom GUC variables. */
DefineCustomRealVariable("pg_trgm.similarity_threshold",
- "Sets the threshold used by the %% operator.",
- "Valid range is 0.0 .. 1.0.",
- &similarity_threshold,
- 0.3,
- 0.0,
- 1.0,
- PGC_USERSET,
- 0,
- NULL,
- NULL,
- NULL);
+ "Sets the threshold used by the %% operator.",
+ "Valid range is 0.0 .. 1.0.",
+ &similarity_threshold,
+ 0.3,
+ 0.0,
+ 1.0,
+ PGC_USERSET,
+ 0,
+ NULL,
+ NULL,
+ NULL);
DefineCustomRealVariable("pg_trgm.word_similarity_threshold",
- "Sets the threshold used by the <%% operator.",
- "Valid range is 0.0 .. 1.0.",
- &word_similarity_threshold,
- 0.6,
- 0.0,
- 1.0,
- PGC_USERSET,
- 0,
- NULL,
- NULL,
- NULL);
+ "Sets the threshold used by the <%% operator.",
+ "Valid range is 0.0 .. 1.0.",
+ &word_similarity_threshold,
+ 0.6,
+ 0.0,
+ 1.0,
+ PGC_USERSET,
+ 0,
+ NULL,
+ NULL,
+ NULL);
}
/*
* Make array of positional trigrams from two trigram arrays trg1 and trg2.
*
* trg1: trigram array of search pattern, of length len1. trg1 is required
- * word which positions don't matter and replaced with -1.
+ * word which positions don't matter and replaced with -1.
* trg2: trigram array of text, of length len2. trg2 is haystack where we
- * search and have to store its positions.
+ * search and have to store its positions.
*
* Returns concatenated trigram array.
*/
make_positional_trgm(trgm *trg1, int len1, trgm *trg2, int len2)
{
pos_trgm *result;
- int i, len = len1 + len2;
+ int i,
+ len = len1 + len2;
result = (pos_trgm *) palloc(sizeof(pos_trgm) * len);
static int
comp_ptrgm(const void *v1, const void *v2)
{
- const pos_trgm *p1 = (const pos_trgm *)v1;
- const pos_trgm *p2 = (const pos_trgm *)v2;
- int cmp;
+ const pos_trgm *p1 = (const pos_trgm *) v1;
+ const pos_trgm *p2 = (const pos_trgm *) v2;
+ int cmp;
cmp = CMPTRGM(p1->trg, p2->trg);
if (cmp != 0)
* len2: length of array "trg2" and array "trg2indexes".
* len: length of the array "found".
* check_only: if true then only check existaince of similar search pattern in
- * text.
+ * text.
*
* Returns word similarity.
*/
for (i = 0; i < len2; i++)
{
/* Get index of next trigram */
- int trgindex = trg2indexes[i];
+ int trgindex = trg2indexes[i];
/* Update last position of this trigram */
if (lower >= 0 || found[trgindex])
/* Adjust lower bound if this trigram is present in required substing */
if (found[trgindex])
{
- int prev_lower,
- tmp_ulen2,
- tmp_lower,
- tmp_count;
+ int prev_lower,
+ tmp_ulen2,
+ tmp_lower,
+ tmp_count;
upper = i;
if (lower == -1)
prev_lower = lower;
for (tmp_lower = lower; tmp_lower <= upper; tmp_lower++)
{
- float smlr_tmp = CALCSML(tmp_count, ulen1, tmp_ulen2);
- int tmp_trgindex;
+ float smlr_tmp = CALCSML(tmp_count, ulen1, tmp_ulen2);
+ int tmp_trgindex;
if (smlr_tmp > smlr_cur)
{
lower = tmp_lower;
count = tmp_count;
}
+
/*
* if we only check that word similarity is greater than
- * pg_trgm.word_similarity_threshold we do not need to calculate
- * a maximum similarity.
+ * pg_trgm.word_similarity_threshold we do not need to
+ * calculate a maximum similarity.
*/
if (check_only && smlr_cur >= word_similarity_threshold)
break;
}
smlr_max = Max(smlr_max, smlr_cur);
+
/*
* if we only check that word similarity is greater than
* pg_trgm.word_similarity_threshold we do not need to calculate a
for (tmp_lower = prev_lower; tmp_lower < lower; tmp_lower++)
{
- int tmp_trgindex;
+ int tmp_trgindex;
+
tmp_trgindex = trg2indexes[tmp_lower];
if (lastpos[tmp_trgindex] == tmp_lower)
lastpos[tmp_trgindex] = -1;
* str1: search pattern string, of length slen1 bytes.
* str2: text in which we are looking for a word, of length slen2 bytes.
* check_only: if true then only check existaince of similar search pattern in
- * text.
+ * text.
*
* Returns word similarity.
*/
static float4
calc_word_similarity(char *str1, int slen1, char *str2, int slen2,
- bool check_only)
+ bool check_only)
{
bool *found;
pos_trgm *ptrg;
protect_out_of_mem(slen1 + slen2);
/* Make positional trigrams */
- trg1 = (trgm *) palloc(sizeof(trgm) * (slen1 / 2 + 1) * 3);
- trg2 = (trgm *) palloc(sizeof(trgm) * (slen2 / 2 + 1) * 3);
+ trg1 = (trgm *) palloc(sizeof(trgm) * (slen1 / 2 + 1) *3);
+ trg2 = (trgm *) palloc(sizeof(trgm) * (slen2 / 2 + 1) *3);
len1 = generate_trgm_only(trg1, str1, slen1);
len2 = generate_trgm_only(trg2, str2, slen2);
{
if (i > 0)
{
- int cmp = CMPTRGM(ptrg[i - 1].trg, ptrg[i].trg);
+ int cmp = CMPTRGM(ptrg[i - 1].trg, ptrg[i].trg);
+
if (cmp != 0)
{
if (found[j])
/* Run iterative procedure to find maximum similarity with word */
result = iterate_word_similarity(trg2indexes, found, ulen1, len2, len,
- check_only);
+ check_only);
pfree(trg2indexes);
pfree(found);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
- VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
- false);
+ VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
+ false);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
- VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
- true);
+ VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
+ true);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
- VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
- true);
+ VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
+ true);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
- VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
- false);
+ VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
+ false);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
float4 res;
res = calc_word_similarity(VARDATA_ANY(in2), VARSIZE_ANY_EXHDR(in2),
- VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
- false);
+ VARDATA_ANY(in1), VARSIZE_ANY_EXHDR(in1),
+ false);
PG_FREE_IF_COPY(in1, 0);
PG_FREE_IF_COPY(in2, 1);
typedef struct vbits
{
- BlockNumber next;
- BlockNumber count;
+ BlockNumber next;
+ BlockNumber count;
uint8 bits[FLEXIBLE_ARRAY_MEMBER];
} vbits;
if (SRF_IS_FIRSTCALL())
{
Oid relid = PG_GETARG_OID(0);
- MemoryContext oldcontext;
+ MemoryContext oldcontext;
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
if (SRF_IS_FIRSTCALL())
{
Oid relid = PG_GETARG_OID(0);
- MemoryContext oldcontext;
+ MemoryContext oldcontext;
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
{
Oid relid = PG_GETARG_OID(0);
Relation rel;
- BlockNumber nblocks;
- BlockNumber blkno;
+ BlockNumber nblocks;
+ BlockNumber blkno;
Buffer vmbuffer = InvalidBuffer;
int64 all_visible = 0;
int64 all_frozen = 0;
collect_visibility_data(Oid relid, bool include_pd)
{
Relation rel;
- BlockNumber nblocks;
+ BlockNumber nblocks;
vbits *info;
- BlockNumber blkno;
+ BlockNumber blkno;
Buffer vmbuffer = InvalidBuffer;
- BufferAccessStrategy bstrategy = GetAccessStrategy(BAS_BULKREAD);
+ BufferAccessStrategy bstrategy = GetAccessStrategy(BAS_BULKREAD);
rel = relation_open(relid, AccessShareLock);
nblocks = RelationGetNumberOfBlocks(rel);
- info = palloc0(offsetof(vbits, bits) + nblocks);
+ info = palloc0(offsetof(vbits, bits) +nblocks);
info->next = 0;
info->count = nblocks;
info->bits[blkno] |= (1 << 1);
/*
- * Page-level data requires reading every block, so only get it if
- * the caller needs it. Use a buffer access strategy, too, to prevent
+ * Page-level data requires reading every block, so only get it if the
+ * caller needs it. Use a buffer access strategy, too, to prevent
* cache-trashing.
*/
if (include_pd)
uint8 mode;
uint8 digest_algo;
uint8 salt[8];
- uint8 iter; /* encoded (one-octet) count */
+ uint8 iter; /* encoded (one-octet) count */
/* calculated: */
uint8 key[PGP_MAX_KEY];
uint8 key_len;
for (;;)
{
- PGresult *res;
+ PGresult *res;
while (PQisBusy(conn))
{
- int wc;
+ int wc;
/* Sleep until there's something to do */
wc = WaitLatchOrSocket(MyLatch,
/*
* If a command has been submitted to the remote server by
* using an asynchronous execution function, the command
- * might not have yet completed. Check to see if a command
- * is still being processed by the remote server, and if so,
- * request cancellation of the command.
+ * might not have yet completed. Check to see if a
+ * command is still being processed by the remote server,
+ * and if so, request cancellation of the command.
*/
if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE)
{
if (!PQcancel(cancel, errbuf, sizeof(errbuf)))
ereport(WARNING,
(errcode(ERRCODE_CONNECTION_FAILURE),
- errmsg("could not send cancel request: %s",
- errbuf)));
+ errmsg("could not send cancel request: %s",
+ errbuf)));
PQfreeCancel(cancel);
}
}
entry->have_error = true;
/*
- * If a command has been submitted to the remote server by using an
- * asynchronous execution function, the command might not have yet
- * completed. Check to see if a command is still being processed by
- * the remote server, and if so, request cancellation of the
- * command.
+ * If a command has been submitted to the remote server by using
+ * an asynchronous execution function, the command might not have
+ * yet completed. Check to see if a command is still being
+ * processed by the remote server, and if so, request cancellation
+ * of the command.
*/
if (PQtransactionStatus(entry->conn) == PQTRANS_ACTIVE)
{
/*
* All other system attributes are fetched as 0, except for table OID,
* which is fetched as the local table OID. However, we must be
- * careful; the table could be beneath an outer join, in which case
- * it must go to NULL whenever the rest of the row does.
+ * careful; the table could be beneath an outer join, in which case it
+ * must go to NULL whenever the rest of the row does.
*/
- Oid fetchval = 0;
+ Oid fetchval = 0;
if (varattno == TableOidAttributeNumber)
{
0 - FirstLowInvalidHeapAttributeNumber);
/*
- * In case the whole-row reference is under an outer join then it has to
- * go NULL whenver the rest of the row goes NULL. Deparsing a join query
- * would always involve multiple relations, thus qualify_col would be
- * true.
+ * In case the whole-row reference is under an outer join then it has
+ * to go NULL whenver the rest of the row goes NULL. Deparsing a join
+ * query would always involve multiple relations, thus qualify_col
+ * would be true.
*/
if (qualify_col)
{
/* Complete the CASE WHEN statement started above. */
if (qualify_col)
- appendStringInfo(buf," END");
+ appendStringInfo(buf, " END");
heap_close(rel, NoLock);
bms_free(attrs_used);
}
else if (strcmp(def->defname, "fetch_size") == 0)
{
- int fetch_size;
+ int fetch_size;
- fetch_size = strtol(defGetString(def), NULL,10);
+ fetch_size = strtol(defGetString(def), NULL, 10);
if (fetch_size <= 0)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
/*
* Pull the other remote conditions from the joining relations into join
- * clauses or other remote clauses (remote_conds) of this relation wherever
- * possible. This avoids building subqueries at every join step, which is
- * not currently supported by the deparser logic.
+ * clauses or other remote clauses (remote_conds) of this relation
+ * wherever possible. This avoids building subqueries at every join step,
+ * which is not currently supported by the deparser logic.
*
* For an inner join, clauses from both the relations are added to the
- * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from the
- * outer side are added to remote_conds since those can be evaluated after
- * the join is evaluated. The clauses from inner side are added to the
- * joinclauses, since they need to evaluated while constructing the join.
+ * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from
+ * the outer side are added to remote_conds since those can be evaluated
+ * after the join is evaluated. The clauses from inner side are added to
+ * the joinclauses, since they need to evaluated while constructing the
+ * join.
*
- * For a FULL OUTER JOIN, the other clauses from either relation can not be
- * added to the joinclauses or remote_conds, since each relation acts as an
- * outer relation for the other. Consider such full outer join as
+ * For a FULL OUTER JOIN, the other clauses from either relation can not
+ * be added to the joinclauses or remote_conds, since each relation acts
+ * as an outer relation for the other. Consider such full outer join as
* unshippable because of the reasons mentioned above in this comment.
*
* The joining sides can not have local conditions, thus no need to test
ForeignServer *server;
UserMapping *user; /* only set in use_remote_estimate mode */
- int fetch_size; /* fetch size for this remote table */
+ int fetch_size; /* fetch size for this remote table */
/*
* Name of the relation while EXPLAINing ForeignScan. It is used for join
List *targetAttrs, List *returningList,
List **retrieved_attrs);
extern void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
- Index rtindex, Relation rel,
- List *targetlist,
- List *targetAttrs,
- List *remote_conds,
- List **params_list,
- List *returningList,
- List **retrieved_attrs);
+ Index rtindex, Relation rel,
+ List *targetlist,
+ List *targetAttrs,
+ List *remote_conds,
+ List **params_list,
+ List *returningList,
+ List **retrieved_attrs);
extern void deparseDeleteSql(StringInfo buf, PlannerInfo *root,
Index rtindex, Relation rel,
List *returningList,
List **retrieved_attrs);
extern void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
- Index rtindex, Relation rel,
- List *remote_conds,
- List **params_list,
- List *returningList,
- List **retrieved_attrs);
+ Index rtindex, Relation rel,
+ List *remote_conds,
+ List **params_list,
+ List *returningList,
+ List **retrieved_attrs);
extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
List **retrieved_attrs);
if (nid == NID_undef)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("unknown OpenSSL extension in certificate at position %d",
- call_cntr)));
+ errmsg("unknown OpenSSL extension in certificate at position %d",
+ call_cntr)));
values[0] = CStringGetTextDatum(OBJ_nid2sn(nid));
nulls[0] = false;
static bool pg_decode_filter(LogicalDecodingContext *ctx,
RepOriginId origin_id);
static void pg_decode_message(LogicalDecodingContext *ctx,
- ReorderBufferTXN *txn, XLogRecPtr message_lsn,
- bool transactional, const char *prefix,
- Size sz, const char *message);
+ ReorderBufferTXN *txn, XLogRecPtr message_lsn,
+ bool transactional, const char *prefix,
+ Size sz, const char *message);
void
_PG_init(void)
{
XLogRecPtr lsn = record->EndRecPtr;
Buffer buffer;
- BlockNumber regpgno;
+ BlockNumber regpgno;
Page page;
XLogRedoAction action;
"fillfactor",
"Packs table pages only to this percentage",
RELOPT_KIND_HEAP,
- ShareUpdateExclusiveLock /* since it applies only to later inserts */
+ ShareUpdateExclusiveLock /* since it applies only to later
+ * inserts */
},
HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100
},
"fillfactor",
"Packs btree index pages only to this percentage",
RELOPT_KIND_BTREE,
- ShareUpdateExclusiveLock /* since it applies only to later inserts */
+ ShareUpdateExclusiveLock /* since it applies only to later
+ * inserts */
},
BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100
},
"fillfactor",
"Packs hash index pages only to this percentage",
RELOPT_KIND_HASH,
- ShareUpdateExclusiveLock /* since it applies only to later inserts */
+ ShareUpdateExclusiveLock /* since it applies only to later
+ * inserts */
},
HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100
},
"fillfactor",
"Packs gist index pages only to this percentage",
RELOPT_KIND_GIST,
- ShareUpdateExclusiveLock /* since it applies only to later inserts */
+ ShareUpdateExclusiveLock /* since it applies only to later
+ * inserts */
},
GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100
},
"fillfactor",
"Packs spgist index pages only to this percentage",
RELOPT_KIND_SPGIST,
- ShareUpdateExclusiveLock /* since it applies only to later inserts */
+ ShareUpdateExclusiveLock /* since it applies only to later
+ * inserts */
},
SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100
},
LOCKMODE
AlterTableGetRelOptionsLockLevel(List *defList)
{
- LOCKMODE lockmode = NoLock;
- ListCell *cell;
+ LOCKMODE lockmode = NoLock;
+ ListCell *cell;
if (defList == NIL)
return AccessExclusiveLock;
foreach(cell, defList)
{
- DefElem *def = (DefElem *) lfirst(cell);
- int i;
+ DefElem *def = (DefElem *) lfirst(cell);
+ int i;
for (i = 0; relOpts[i]; i++)
{
int64 nDeletedHeapTuples = 0;
ginxlogDeleteListPages data;
Buffer buffers[GIN_NDELETE_AT_ONCE];
- BlockNumber freespace[GIN_NDELETE_AT_ONCE];
+ BlockNumber freespace[GIN_NDELETE_AT_ONCE];
data.ndeleted = 0;
while (data.ndeleted < GIN_NDELETE_AT_ONCE && blknoToDelete != newHead)
bool inVacuum = (stats == NULL);
/*
- * We would like to prevent concurrent cleanup process. For
- * that we will lock metapage in exclusive mode using LockPage()
- * call. Nobody other will use that lock for metapage, so
- * we keep possibility of concurrent insertion into pending list
+ * We would like to prevent concurrent cleanup process. For that we will
+ * lock metapage in exclusive mode using LockPage() call. Nobody other
+ * will use that lock for metapage, so we keep possibility of concurrent
+ * insertion into pending list
*/
if (inVacuum)
{
/*
- * We are called from [auto]vacuum/analyze or
- * gin_clean_pending_list() and we would like to wait
- * concurrent cleanup to finish.
+ * We are called from [auto]vacuum/analyze or gin_clean_pending_list()
+ * and we would like to wait concurrent cleanup to finish.
*/
LockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
workMemory =
(IsAutoVacuumWorkerProcess() && autovacuum_work_mem != -1) ?
- autovacuum_work_mem : maintenance_work_mem;
+ autovacuum_work_mem : maintenance_work_mem;
}
else
{
/*
- * We are called from regular insert and if we see
- * concurrent cleanup just exit in hope that concurrent
- * process will clean up pending list.
+ * We are called from regular insert and if we see concurrent cleanup
+ * just exit in hope that concurrent process will clean up pending
+ * list.
*/
if (!ConditionalLockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock))
return;
Assert(!GinPageIsDeleted(page));
/*
- * Are we walk through the page which as we remember was a tail when we
- * start our cleanup? But if caller asks us to clean up whole pending
- * list then ignore old tail, we will work until list becomes empty.
+ * Are we walk through the page which as we remember was a tail when
+ * we start our cleanup? But if caller asks us to clean up whole
+ * pending list then ignore old tail, we will work until list becomes
+ * empty.
*/
if (blkno == blknoFinish && full_clean == false)
cleanupFinish = true;
* locking */
/*
- * remove read pages from pending list, at this point all
- * content of read pages is in regular structure
+ * remove read pages from pending list, at this point all content
+ * of read pages is in regular structure
*/
shiftList(index, metabuffer, blkno, fill_fsm, stats);
ReleaseBuffer(metabuffer);
/*
- * As pending list pages can have a high churn rate, it is
- * desirable to recycle them immediately to the FreeSpace Map when
- * ordinary backends clean the list.
+ * As pending list pages can have a high churn rate, it is desirable to
+ * recycle them immediately to the FreeSpace Map when ordinary backends
+ * clean the list.
*/
if (fsm_vac && fill_fsm)
IndexFreeSpaceMapVacuum(index);
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("recovery is in progress"),
- errhint("GIN pending list cannot be cleaned up during recovery.")));
+ errhint("GIN pending list cannot be cleaned up during recovery.")));
/* Must be a GIN index */
if (indexRel->rd_rel->relkind != RELKIND_INDEX ||
&htup->t_self);
/* If we've maxed out our available memory, dump everything to the index */
- if (buildstate->accum.allocatedMemory >= (Size)maintenance_work_mem * 1024L)
+ if (buildstate->accum.allocatedMemory >= (Size) maintenance_work_mem * 1024L)
{
ItemPointerData *list;
Datum key;
{
/* Yes, so initialize stats to zeroes */
stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+
/*
- * and cleanup any pending inserts */
+ * and cleanup any pending inserts
+ */
ginInsertCleanup(&gvs.ginstate, !IsAutoVacuumWorkerProcess(),
false, stats);
}
gistvacuumpage(Relation rel, Page page, Buffer buffer)
{
OffsetNumber deletable[MaxIndexTuplesPerPage];
- int ndeletable = 0;
- OffsetNumber offnum, maxoff;
+ int ndeletable = 0;
+ OffsetNumber offnum,
+ maxoff;
Assert(GistPageIsLeaf(page));
static void
gistkillitems(IndexScanDesc scan)
{
- GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
- Buffer buffer;
- Page page;
- OffsetNumber offnum;
- ItemId iid;
- int i;
- bool killedsomething = false;
+ GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
+ Buffer buffer;
+ Page page;
+ OffsetNumber offnum;
+ ItemId iid;
+ int i;
+ bool killedsomething = false;
Assert(so->curBlkno != InvalidBlockNumber);
Assert(!XLogRecPtrIsInvalid(so->curPageLSN));
page = BufferGetPage(buffer);
/*
- * If page LSN differs it means that the page was modified since the last read.
- * killedItems could be not valid so LP_DEAD hints applying is not safe.
+ * If page LSN differs it means that the page was modified since the last
+ * read. killedItems could be not valid so LP_DEAD hints applying is not
+ * safe.
*/
- if(PageGetLSN(page) != so->curPageLSN)
+ if (PageGetLSN(page) != so->curPageLSN)
{
UnlockReleaseBuffer(buffer);
- so->numKilled = 0; /* reset counter */
+ so->numKilled = 0; /* reset counter */
return;
}
Assert(GistPageIsLeaf(page));
/*
- * Mark all killedItems as dead. We need no additional recheck,
- * because, if page was modified, pageLSN must have changed.
+ * Mark all killedItems as dead. We need no additional recheck, because,
+ * if page was modified, pageLSN must have changed.
*/
for (i = 0; i < so->numKilled; i++)
{
maxoff = PageGetMaxOffsetNumber(page);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- ItemId iid = PageGetItemId(page, i);
+ ItemId iid = PageGetItemId(page, i);
IndexTuple it;
bool match;
bool recheck;
* If the scan specifies not to return killed tuples, then we treat a
* killed tuple as not passing the qual.
*/
- if(scan->ignore_killed_tuples && ItemIdIsDead(iid))
+ if (scan->ignore_killed_tuples && ItemIdIsDead(iid))
continue;
it = (IndexTuple) PageGetItem(page, iid);
+
/*
* Must call gistindex_keytest in tempCxt, and clean up any leftover
* junk afterward.
if (so->killedItems == NULL)
{
MemoryContext oldCxt =
- MemoryContextSwitchTo(so->giststate->scanCxt);
+ MemoryContextSwitchTo(so->giststate->scanCxt);
so->killedItems =
(OffsetNumber *) palloc(MaxIndexTuplesPerPage
- * sizeof(OffsetNumber));
+ * sizeof(OffsetNumber));
MemoryContextSwitchTo(oldCxt);
}
if (so->killedItems == NULL)
{
MemoryContext oldCxt =
- MemoryContextSwitchTo(so->giststate->scanCxt);
+ MemoryContextSwitchTo(so->giststate->scanCxt);
so->killedItems =
(OffsetNumber *) palloc(MaxIndexTuplesPerPage
- * sizeof(OffsetNumber));
+ * sizeof(OffsetNumber));
MemoryContextSwitchTo(oldCxt);
}
ScanKey skey = scan->keyData + i;
/*
- * Copy consistent support function to ScanKey structure
- * instead of function implementing filtering operator.
+ * Copy consistent support function to ScanKey structure instead
+ * of function implementing filtering operator.
*/
fmgr_info_copy(&(skey->sk_func),
&(so->giststate->consistentFn[skey->sk_attno - 1]),
so->orderByTypes[i] = get_func_rettype(skey->sk_func.fn_oid);
/*
- * Copy distance support function to ScanKey structure
- * instead of function implementing ordering operator.
+ * Copy distance support function to ScanKey structure instead of
+ * function implementing ordering operator.
*/
fmgr_info_copy(&(skey->sk_func), finfo, so->giststate->scanCxt);
{
BlockNumber page = InvalidBlockNumber;
BlockNumber sync_startpage = InvalidBlockNumber;
- BlockNumber report_page = InvalidBlockNumber;
+ BlockNumber report_page = InvalidBlockNumber;
ParallelHeapScanDesc parallel_scan;
Assert(scan->rs_parallel);
RelationAddExtraBlocks(Relation relation, BulkInsertState bistate)
{
Page page;
- BlockNumber blockNum = InvalidBlockNumber,
+ BlockNumber blockNum = InvalidBlockNumber,
firstBlock = InvalidBlockNumber;
int extraBlocks = 0;
int lockWaiters = 0;
return;
/*
- * It might seem like multiplying the number of lock waiters by as much
- * as 20 is too aggressive, but benchmarking revealed that smaller numbers
- * were insufficient. 512 is just an arbitrary cap to prevent pathological
- * results.
+ * It might seem like multiplying the number of lock waiters by as much as
+ * 20 is too aggressive, but benchmarking revealed that smaller numbers
+ * were insufficient. 512 is just an arbitrary cap to prevent
+ * pathological results.
*/
extraBlocks = Min(512, lockWaiters * 20);
}
/*
- * Updating the upper levels of the free space map is too expensive
- * to do for every block, but it's worth doing once at the end to make
- * sure that subsequent insertion activity sees all of those nifty free
- * pages we just inserted.
+ * Updating the upper levels of the free space map is too expensive to do
+ * for every block, but it's worth doing once at the end to make sure that
+ * subsequent insertion activity sees all of those nifty free pages we
+ * just inserted.
*
* Note that we're using the freespace value that was reported for the
* last block we added as if it were the freespace value for every block
}
/*
- * In addition to whatever extension we performed above, we always add
- * at least one block to satisfy our own request.
+ * In addition to whatever extension we performed above, we always add at
+ * least one block to satisfy our own request.
*
* XXX This does an lseek - rather expensive - but at the moment it is the
* only way to accurately determine how many blocks are in a relation. Is
OldestXmin = RecentGlobalXmin;
else
OldestXmin =
- TransactionIdLimitedForOldSnapshots(RecentGlobalDataXmin,
- relation);
+ TransactionIdLimitedForOldSnapshots(RecentGlobalDataXmin,
+ relation);
Assert(TransactionIdIsValid(OldestXmin));
uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
Page page;
- uint8 *map;
+ uint8 *map;
#ifdef TRACE_VISIBILITYMAP
elog(DEBUG1, "vm_set %s %d", RelationGetRelationName(rel), heapBlk);
elog(ERROR, "wrong VM buffer passed to visibilitymap_set");
page = BufferGetPage(vmBuf);
- map = (uint8 *)PageGetContents(page);
+ map = (uint8 *) PageGetContents(page);
LockBuffer(vmBuf, BUFFER_LOCK_EXCLUSIVE);
if (flags != (map[mapByte] >> mapOffset & VISIBILITYMAP_VALID_BITS))
* Check for a conflict-in as we would if we were going to
* write to this page. We aren't actually going to write,
* but we want a chance to report SSI conflicts that would
- * otherwise be masked by this unique constraint violation.
+ * otherwise be masked by this unique constraint
+ * violation.
*/
CheckForSerializableConflictIn(rel, NULL, buf);
/*
* Check to see if we need to issue one final WAL record for this index,
- * which may be needed for correctness on a hot standby node when
- * non-MVCC index scans could take place.
+ * which may be needed for correctness on a hot standby node when non-MVCC
+ * index scans could take place.
*
* If the WAL is replayed in hot standby, the replay process needs to get
* cleanup locks on all index leaf pages, just as we've been doing here.
if (ndeletable > 0)
{
/*
- * Notice that the issued XLOG_BTREE_VACUUM WAL record includes all
- * information to the replay code to allow it to get a cleanup lock
- * on all pages between the previous lastBlockVacuumed and this page.
- * This ensures that WAL replay locks all leaf pages at some point,
- * which is important should non-MVCC scans be requested.
- * This is currently unused on standby, but we record it anyway, so
- * that the WAL contains the required information.
+ * Notice that the issued XLOG_BTREE_VACUUM WAL record includes
+ * all information to the replay code to allow it to get a cleanup
+ * lock on all pages between the previous lastBlockVacuumed and
+ * this page. This ensures that WAL replay locks all leaf pages at
+ * some point, which is important should non-MVCC scans be
+ * requested. This is currently unused on standby, but we record
+ * it anyway, so that the WAL contains the required information.
*
* Since we can visit leaf pages out-of-order when recursing,
* replay might end up locking such pages an extra time, but it
xl_btree_vacuum *xlrec = (xl_btree_vacuum *) XLogRecGetData(record);
/*
- * This section of code is thought to be no longer needed, after
- * analysis of the calling paths. It is retained to allow the code
- * to be reinstated if a flaw is revealed in that thinking.
+ * This section of code is thought to be no longer needed, after analysis
+ * of the calling paths. It is retained to allow the code to be reinstated
+ * if a flaw is revealed in that thinking.
*
* If we are running non-MVCC scans using this index we need to do some
* additional work to ensure correctness, which is known as a "pin scan"
* described in more detail in next paragraphs. We used to do the extra
- * work in all cases, whereas we now avoid that work in most cases.
- * If lastBlockVacuumed is set to InvalidBlockNumber then we skip the
+ * work in all cases, whereas we now avoid that work in most cases. If
+ * lastBlockVacuumed is set to InvalidBlockNumber then we skip the
* additional work required for the pin scan.
*
* Avoiding this extra work is important since it requires us to touch
while (ptr < end)
{
- OffsetNumber offset,
- length;
+ OffsetNumber offset,
+ length;
memcpy(&offset, ptr, sizeof(offset));
ptr += sizeof(offset);
xl_logical_message *xlrec = (xl_logical_message *) rec;
appendStringInfo(buf, "%s message size %zu bytes",
- xlrec->transactional ? "transactional" : "nontransactional",
+ xlrec->transactional ? "transactional" : "nontransactional",
xlrec->message_size);
}
}
Oid dbId, Oid tsId,
bool relcacheInitFileInval)
{
- int i;
+ int i;
if (relcacheInitFileInval)
appendStringInfo(buf, "; relcache init file inval dbid %u tsid %u",
if (parsed.nmsgs > 0)
{
standby_desc_invalidations(
- buf, parsed.nmsgs, parsed.msgs, parsed.dbId, parsed.tsId,
- XactCompletionRelcacheInitFileInval(parsed.xinfo));
+ buf, parsed.nmsgs, parsed.msgs, parsed.dbId, parsed.tsId,
+ XactCompletionRelcacheInitFileInval(parsed.xinfo));
}
if (XactCompletionForceSyncCommit(parsed.xinfo))
const struct config_enum_entry wal_level_options[] = {
{"minimal", WAL_LEVEL_MINIMAL, false},
{"replica", WAL_LEVEL_REPLICA, false},
- {"archive", WAL_LEVEL_REPLICA, true}, /* deprecated */
- {"hot_standby", WAL_LEVEL_REPLICA, true}, /* deprecated */
+ {"archive", WAL_LEVEL_REPLICA, true}, /* deprecated */
+ {"hot_standby", WAL_LEVEL_REPLICA, true}, /* deprecated */
{"logical", WAL_LEVEL_LOGICAL, false},
{NULL, 0, false}
};
{
TransactionId xidLastCommit;
CommitTimestampEntry dataLastCommit;
- bool commitTsActive;
+ bool commitTsActive;
} CommitTimestampShared;
CommitTimestampShared *commitTsShared;
* No-op if the module is not active.
*
* An unlocked read here is fine, because in a standby (the only place
- * where the flag can change in flight) this routine is only called by
- * the recovery process, which is also the only process which can change
- * the flag.
+ * where the flag can change in flight) this routine is only called by the
+ * recovery process, which is also the only process which can change the
+ * flag.
*/
if (!commitTsShared->commitTsActive)
return;
int pageno;
/*
- * Nothing to do if module not enabled. Note we do an unlocked read of the
- * flag here, which is okay because this routine is only called from
+ * Nothing to do if module not enabled. Note we do an unlocked read of
+ * the flag here, which is okay because this routine is only called from
* GetNewTransactionId, which is never called in a standby.
*/
Assert(!InRecovery);
{
LWLockAcquire(CommitTsLock, LW_EXCLUSIVE);
if (ShmemVariableCache->oldestCommitTsXid != InvalidTransactionId &&
- TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
+ TransactionIdPrecedes(ShmemVariableCache->oldestCommitTsXid, oldestXact))
ShmemVariableCache->oldestCommitTsXid = oldestXact;
LWLockRelease(CommitTsLock);
}
Buffer buffer; /* registered buffer */
int flags; /* flags for this buffer */
int deltaLen; /* space consumed in delta field */
- char *image; /* copy of page image for modification,
- * do not do it in-place to have aligned
- * memory chunk */
+ char *image; /* copy of page image for modification, do not
+ * do it in-place to have aligned memory chunk */
char delta[MAX_DELTA_SIZE]; /* delta between page images */
} PageData;
char *oldest_datname = get_database_name(oldest_datoid);
/*
- * Immediately kick autovacuum into action as we're already
- * in ERROR territory.
+ * Immediately kick autovacuum into action as we're already in
+ * ERROR territory.
*/
SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg_plural("database with OID %u must be vacuumed before %d more multixact member is used",
"database with OID %u must be vacuumed before %d more multixact members are used",
- MultiXactState->offsetStopLimit - nextOffset + nmembers,
- MultiXactState->oldestMultiXactDB,
+ MultiXactState->offsetStopLimit - nextOffset + nmembers,
+ MultiXactState->oldestMultiXactDB,
MultiXactState->offsetStopLimit - nextOffset + nmembers),
errhint("Execute a database-wide VACUUM in that database with reduced vacuum_multixact_freeze_min_age and vacuum_multixact_freeze_table_age settings.")));
nworkers = 0;
/*
- * If we are running under serializable isolation, we can't use
- * parallel workers, at least not until somebody enhances that mechanism
- * to be parallel-aware.
+ * If we are running under serializable isolation, we can't use parallel
+ * workers, at least not until somebody enhances that mechanism to be
+ * parallel-aware.
*/
if (IsolationIsSerializable())
nworkers = 0;
}
/*
- * We can't finish transaction commit or abort until all of the
- * workers have exited. This means, in particular, that we can't respond
- * to interrupts at this stage.
+ * We can't finish transaction commit or abort until all of the workers
+ * have exited. This means, in particular, that we can't respond to
+ * interrupts at this stage.
*/
HOLD_INTERRUPTS();
WaitForParallelWorkersToExit(pcxt);
if (toc == NULL)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
- errmsg("invalid magic number in dynamic shared memory segment")));
+ errmsg("invalid magic number in dynamic shared memory segment")));
/* Look up fixed parallel state. */
fps = shm_toc_lookup(toc, PARALLEL_KEY_FIXED);
*/
/*
- * Join locking group. We must do this before anything that could try
- * to acquire a heavyweight lock, because any heavyweight locks acquired
- * to this point could block either directly against the parallel group
+ * Join locking group. We must do this before anything that could try to
+ * acquire a heavyweight lock, because any heavyweight locks acquired to
+ * this point could block either directly against the parallel group
* leader or against some process which in turn waits for a lock that
* conflicts with the parallel group leader, causing an undetected
* deadlock. (If we can't join the lock group, the leader has gone away,
sz += MAXALIGN(nslots * sizeof(bool)); /* page_dirty[] */
sz += MAXALIGN(nslots * sizeof(int)); /* page_number[] */
sz += MAXALIGN(nslots * sizeof(int)); /* page_lru_count[] */
- sz += MAXALIGN(nslots * sizeof(LWLockPadded)); /* buffer_locks[] */
+ sz += MAXALIGN(nslots * sizeof(LWLockPadded)); /* buffer_locks[] */
if (nlsns > 0)
sz += MAXALIGN(nslots * nlsns * sizeof(XLogRecPtr)); /* group_lsn[] */
for (slotno = 0; slotno < nslots; slotno++)
{
LWLockInitialize(&shared->buffer_locks[slotno].lock,
- shared->lwlock_tranche_id);
+ shared->lwlock_tranche_id);
shared->page_buffer[slotno] = ptr;
shared->page_status[slotno] = SLRU_PAGE_EMPTY;
startPage++;
/* must account for wraparound */
if (startPage > TransactionIdToPage(MaxTransactionId))
- startPage=0;
+ startPage = 0;
}
(void) ZeroSUBTRANSPage(startPage);
TimestampTz prepared_at; /* time of preparation */
/*
- * Note that we need to keep track of two LSNs for each GXACT.
- * We keep track of the start LSN because this is the address we must
- * use to read state data back from WAL when committing a prepared GXACT.
- * We keep track of the end LSN because that is the LSN we need to wait
- * for prior to commit.
+ * Note that we need to keep track of two LSNs for each GXACT. We keep
+ * track of the start LSN because this is the address we must use to read
+ * state data back from WAL when committing a prepared GXACT. We keep
+ * track of the end LSN because that is the LSN we need to wait for prior
+ * to commit.
*/
- XLogRecPtr prepare_start_lsn; /* XLOG offset of prepare record start */
+ XLogRecPtr prepare_start_lsn; /* XLOG offset of prepare record start */
XLogRecPtr prepare_end_lsn; /* XLOG offset of prepare record end */
Oid owner; /* ID of user that executed the xact */
hdr.nabortrels = smgrGetPendingDeletes(false, &abortrels);
hdr.ninvalmsgs = xactGetCommittedInvalidationMessages(&invalmsgs,
&hdr.initfileinval);
- hdr.gidlen = strlen(gxact->gid) + 1; /* Include '\0' */
+ hdr.gidlen = strlen(gxact->gid) + 1; /* Include '\0' */
save_state_data(&hdr, sizeof(TwoPhaseFileHeader));
save_state_data(gxact->gid, hdr.gidlen);
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
- errdetail("Failed while allocating an XLog reading processor.")));
+ errdetail("Failed while allocating an XLog reading processor.")));
record = XLogReadRecord(xlogreader, lsn, &errormsg);
if (record == NULL)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not read two-phase state from xlog at %X/%X",
- (uint32) (lsn >> 32),
- (uint32) lsn)));
+ (uint32) (lsn >> 32),
+ (uint32) lsn)));
if (XLogRecGetRmid(xlogreader) != RM_XACT_ID ||
(XLogRecGetInfo(xlogreader) & XLOG_XACT_OPMASK) != XLOG_XACT_PREPARE)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("expected two-phase state data is not present in xlog at %X/%X",
- (uint32) (lsn >> 32),
- (uint32) lsn)));
+ (uint32) (lsn >> 32),
+ (uint32) lsn)));
if (len != NULL)
*len = XLogRecGetDataLen(xlogreader);
- *buf = palloc(sizeof(char)*XLogRecGetDataLen(xlogreader));
+ *buf = palloc(sizeof(char) * XLogRecGetDataLen(xlogreader));
memcpy(*buf, XLogRecGetData(xlogreader), sizeof(char) * XLogRecGetDataLen(xlogreader));
XLogReaderFree(xlogreader);
xid = pgxact->xid;
/*
- * Read and validate 2PC state data.
- * State data will typically be stored in WAL files if the LSN is after the
- * last checkpoint record, or moved to disk if for some reason they have
- * lived for a long time.
+ * Read and validate 2PC state data. State data will typically be stored
+ * in WAL files if the LSN is after the last checkpoint record, or moved
+ * to disk if for some reason they have lived for a long time.
*/
if (gxact->ondisk)
buf = ReadTwoPhaseFile(xid, true);
TRACE_POSTGRESQL_TWOPHASE_CHECKPOINT_START();
/*
- * We are expecting there to be zero GXACTs that need to be
- * copied to disk, so we perform all I/O while holding
- * TwoPhaseStateLock for simplicity. This prevents any new xacts
- * from preparing while this occurs, which shouldn't be a problem
- * since the presence of long-lived prepared xacts indicates the
- * transaction manager isn't active.
+ * We are expecting there to be zero GXACTs that need to be copied to
+ * disk, so we perform all I/O while holding TwoPhaseStateLock for
+ * simplicity. This prevents any new xacts from preparing while this
+ * occurs, which shouldn't be a problem since the presence of long-lived
+ * prepared xacts indicates the transaction manager isn't active.
*
- * It's also possible to move I/O out of the lock, but on
- * every error we should check whether somebody committed our
- * transaction in different backend. Let's leave this optimisation
- * for future, if somebody will spot that this place cause
- * bottleneck.
+ * It's also possible to move I/O out of the lock, but on every error we
+ * should check whether somebody committed our transaction in different
+ * backend. Let's leave this optimisation for future, if somebody will
+ * spot that this place cause bottleneck.
*
- * Note that it isn't possible for there to be a GXACT with
- * a prepare_end_lsn set prior to the last checkpoint yet
- * is marked invalid, because of the efforts with delayChkpt.
+ * Note that it isn't possible for there to be a GXACT with a
+ * prepare_end_lsn set prior to the last checkpoint yet is marked invalid,
+ * because of the efforts with delayChkpt.
*/
LWLockAcquire(TwoPhaseStateLock, LW_SHARED);
for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
gxact->prepare_end_lsn <= redo_horizon)
{
char *buf;
- int len;
+ int len;
XlogReadTwoPhaseData(gxact->prepare_start_lsn, &buf, &len);
RecreateTwoPhaseFile(pgxact->xid, buf, len);
TwoPhaseFileHeader *hdr;
TransactionId *subxids;
GlobalTransaction gxact;
- const char *gid;
+ const char *gid;
int i;
xid = (TransactionId) strtoul(clde->d_name, NULL, 16);
/*
* Transactions without an assigned xid can contain invalidation
* messages (e.g. explicit relcache invalidations or catcache
- * invalidations for inplace updates); standbys need to process
- * those. We can't emit a commit record without an xid, and we don't
- * want to force assigning an xid, because that'd be problematic for
- * e.g. vacuum. Hence we emit a bespoke record for the
- * invalidations. We don't want to use that in case a commit record is
- * emitted, so they happen synchronously with commits (besides not
- * wanting to emit more WAL recoreds).
+ * invalidations for inplace updates); standbys need to process those.
+ * We can't emit a commit record without an xid, and we don't want to
+ * force assigning an xid, because that'd be problematic for e.g.
+ * vacuum. Hence we emit a bespoke record for the invalidations. We
+ * don't want to use that in case a commit record is emitted, so they
+ * happen synchronously with commits (besides not wanting to emit more
+ * WAL recoreds).
*/
if (nmsgs != 0)
{
LogStandbyInvalidations(nmsgs, invalMessages,
RelcacheInitFileInval);
- wrote_xlog = true; /* not strictly necessary */
+ wrote_xlog = true; /* not strictly necessary */
}
/*
* this case, but we don't currently try to do that. It would certainly
* cause problems at least in Hot Standby mode, where the
* KnownAssignedXids machinery requires tracking every XID assignment. It
- * might be OK to skip it only when wal_level < replica, but for now
- * we don't.)
+ * might be OK to skip it only when wal_level < replica, but for now we
+ * don't.)
*
* However, if we're doing cleanup of any non-temp rels or committing any
* command that wanted to force sync commit, then we must flush XLOG
/*
* If asked by the primary (because someone is waiting for a synchronous
- * commit = remote_apply), we will need to ask walreceiver to send a
- * reply immediately.
+ * commit = remote_apply), we will need to ask walreceiver to send a reply
+ * immediately.
*/
if (XactCompletionApplyFeedback(parsed->xinfo))
XLogRequestWalReceiverReply();
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid value for recovery parameter \"%s\": \"%s\"",
- "recovery_target_action",
- item->value),
+ errmsg("invalid value for recovery parameter \"%s\": \"%s\"",
+ "recovery_target_action",
+ item->value),
errhint("Valid values are \"pause\", \"promote\", and \"shutdown\".")));
ereport(DEBUG2,
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid value for recovery parameter \"%s\": \"%s\"",
- "recovery_target",
- item->value),
+ errmsg("invalid value for recovery parameter \"%s\": \"%s\"",
+ "recovery_target",
+ item->value),
errhint("The only allowed value is \"immediate\".")));
ereport(DEBUG2,
(errmsg_internal("recovery_target = '%s'",
}
/*
- * For Hot Standby, the WAL must be generated with 'replica' mode, and
- * we must have at least as many backend slots as the primary.
+ * For Hot Standby, the WAL must be generated with 'replica' mode, and we
+ * must have at least as many backend slots as the primary.
*/
if (ArchiveRecoveryRequested && EnableHotStandby)
{
* is no use of such file. There is no harm in retaining it, but it
* is better to get rid of the map file so that we don't have any
* redundant file in data directory and it will avoid any sort of
- * confusion. It seems prudent though to just rename the file out
- * of the way rather than delete it completely, also we ignore any
- * error that occurs in rename operation as even if map file is
- * present without backup_label file, it is harmless.
+ * confusion. It seems prudent though to just rename the file out of
+ * the way rather than delete it completely, also we ignore any error
+ * that occurs in rename operation as even if map file is present
+ * without backup_label file, it is harmless.
*/
if (stat(TABLESPACE_MAP, &st) == 0)
{
unlink(TABLESPACE_MAP_OLD);
if (durable_rename(TABLESPACE_MAP, TABLESPACE_MAP_OLD, DEBUG1) == 0)
ereport(LOG,
- (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
- TABLESPACE_MAP, BACKUP_LABEL_FILE),
- errdetail("File \"%s\" was renamed to \"%s\".",
- TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
+ (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
+ TABLESPACE_MAP, BACKUP_LABEL_FILE),
+ errdetail("File \"%s\" was renamed to \"%s\".",
+ TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
else
ereport(LOG,
- (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
- TABLESPACE_MAP, BACKUP_LABEL_FILE),
- errdetail("Could not rename file \"%s\" to \"%s\": %m.",
- TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
+ (errmsg("ignoring file \"%s\" because no file \"%s\" exists",
+ TABLESPACE_MAP, BACKUP_LABEL_FILE),
+ errdetail("Could not rename file \"%s\" to \"%s\": %m.",
+ TABLESPACE_MAP, TABLESPACE_MAP_OLD)));
}
/*
ereport(DEBUG1,
(errmsg_internal("redo record is at %X/%X; shutdown %s",
(uint32) (checkPoint.redo >> 32), (uint32) checkPoint.redo,
- wasShutdown ? "TRUE" : "FALSE")));
+ wasShutdown ? "TRUE" : "FALSE")));
ereport(DEBUG1,
(errmsg_internal("next transaction ID: %u:%u; next OID: %u",
- checkPoint.nextXidEpoch, checkPoint.nextXid,
- checkPoint.nextOid)));
+ checkPoint.nextXidEpoch, checkPoint.nextXid,
+ checkPoint.nextOid)));
ereport(DEBUG1,
(errmsg_internal("next MultiXactId: %u; next MultiXactOffset: %u",
- checkPoint.nextMulti, checkPoint.nextMultiOffset)));
+ checkPoint.nextMulti, checkPoint.nextMultiOffset)));
ereport(DEBUG1,
- (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
- checkPoint.oldestXid, checkPoint.oldestXidDB)));
+ (errmsg_internal("oldest unfrozen transaction ID: %u, in database %u",
+ checkPoint.oldestXid, checkPoint.oldestXidDB)));
ereport(DEBUG1,
(errmsg_internal("oldest MultiXactId: %u, in database %u",
- checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
+ checkPoint.oldestMulti, checkPoint.oldestMultiDB)));
ereport(DEBUG1,
(errmsg_internal("commit timestamp Xid oldest/newest: %u/%u",
- checkPoint.oldestCommitTsXid,
- checkPoint.newestCommitTsXid)));
+ checkPoint.oldestCommitTsXid,
+ checkPoint.newestCommitTsXid)));
if (!TransactionIdIsNormal(checkPoint.nextXid))
ereport(PANIC,
(errmsg("invalid next transaction ID")));
SpinLockRelease(&XLogCtl->info_lck);
/*
- * If rm_redo called XLogRequestWalReceiverReply, then we
- * wake up the receiver so that it notices the updated
+ * If rm_redo called XLogRequestWalReceiverReply, then we wake
+ * up the receiver so that it notices the updated
* lastReplayedEndRecPtr and sends a reply to the master.
*/
if (doRequestWalReceiverReply)
MemoryContext oldcontext;
/*
- * Label file and tablespace map file need to be long-lived, since they
- * are read in pg_stop_backup.
+ * Label file and tablespace map file need to be long-lived, since
+ * they are read in pg_stop_backup.
*/
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
label_file = makeStringInfo();
MemoryContextSwitchTo(oldcontext);
startpoint = do_pg_start_backup(backupidstr, fast, NULL, label_file,
- dir, NULL, tblspc_map_file, false, true);
+ dir, NULL, tblspc_map_file, false, true);
nonexclusive_backup_running = true;
before_shmem_exit(nonexclusive_base_backup_cleanup, (Datum) 0);
* Note: different from CancelBackup which just cancels online backup mode.
*
* Note: this version is only called to stop an exclusive backup. The function
- * pg_stop_backup_v2 (overloaded as pg_stop_backup in SQL) is called to
- * stop non-exclusive backups.
+ * pg_stop_backup_v2 (overloaded as pg_stop_backup in SQL) is called to
+ * stop non-exclusive backups.
*
* Permission checking for this function is managed through the normal
* GRANT system.
errhint("Did you mean to use pg_stop_backup('f')?")));
/*
- * Exclusive backups were typically started in a different connection,
- * so don't try to verify that exclusive_backup_running is set in this one.
- * Actual verification that an exclusive backup is in fact running is handled
- * inside do_pg_stop_backup.
+ * Exclusive backups were typically started in a different connection, so
+ * don't try to verify that exclusive_backup_running is set in this one.
+ * Actual verification that an exclusive backup is in fact running is
+ * handled inside do_pg_stop_backup.
*/
stoppoint = do_pg_stop_backup(NULL, true, NULL);
Datum
pg_stop_backup_v2(PG_FUNCTION_ARGS)
{
- ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- TupleDesc tupdesc;
+ ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ TupleDesc tupdesc;
Tuplestorestate *tupstore;
- MemoryContext per_query_ctx;
- MemoryContext oldcontext;
- Datum values[3];
- bool nulls[3];
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+ Datum values[3];
+ bool nulls[3];
- bool exclusive = PG_GETARG_BOOL(0);
- XLogRecPtr stoppoint;
+ bool exclusive = PG_GETARG_BOOL(0);
+ XLogRecPtr stoppoint;
/* check to see if caller supports us returning a tuplestore */
if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
errhint("Did you mean to use pg_stop_backup('t')?")));
/*
- * Stop the non-exclusive backup. Return a copy of the backup
- * label and tablespace map so they can be written to disk by
- * the caller.
+ * Stop the non-exclusive backup. Return a copy of the backup label
+ * and tablespace map so they can be written to disk by the caller.
*/
stoppoint = do_pg_stop_backup(label_file->data, true, NULL);
nonexclusive_backup_running = false;
}
/* Stoppoint is included on both exclusive and nonexclusive backups */
- values[0] = LSNGetDatum(stoppoint);
+ values[0] = LSNGetDatum(stoppoint);
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
tuplestore_donestoring(typstore);
if (total_len < SizeOfXLogRecord)
{
report_invalid_record(state,
- "invalid record length at %X/%X: wanted %u, got %u",
+ "invalid record length at %X/%X: wanted %u, got %u",
(uint32) (RecPtr >> 32), (uint32) RecPtr,
(uint32) SizeOfXLogRecord, total_len);
goto err;
if (record->xl_tot_len < SizeOfXLogRecord)
{
report_invalid_record(state,
- "invalid record length at %X/%X: wanted %u, got %u",
+ "invalid record length at %X/%X: wanted %u, got %u",
(uint32) (RecPtr >> 32), (uint32) RecPtr,
(uint32) SizeOfXLogRecord, record->xl_tot_len);
return false;
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized default ACL object type %c", objtype),
- errhint("Valid object types are \"r\", \"S\", \"f\", and \"T\".")));
+ errhint("Valid object types are \"r\", \"S\", \"f\", and \"T\".")));
}
/*
Form_pg_proc proc;
Oid transfn;
Oid finalfn = InvalidOid; /* can be omitted */
- Oid combinefn = InvalidOid; /* can be omitted */
+ Oid combinefn = InvalidOid; /* can be omitted */
Oid serialfn = InvalidOid; /* can be omitted */
- Oid deserialfn = InvalidOid; /* can be omitted */
+ Oid deserialfn = InvalidOid; /* can be omitted */
Oid mtransfn = InvalidOid; /* can be omitted */
Oid minvtransfn = InvalidOid; /* can be omitted */
Oid mfinalfn = InvalidOid; /* can be omitted */
/* handle the combinefn, if supplied */
if (aggcombinefnName)
{
- Oid combineType;
+ Oid combineType;
/*
- * Combine function must have 2 argument, each of which is the
- * trans type
+ * Combine function must have 2 argument, each of which is the trans
+ * type
*/
fnArgs[0] = aggTransType;
fnArgs[1] = aggTransType;
if (combineType != aggTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("return type of combine function %s is not %s",
- NameListToString(aggcombinefnName),
- format_type_be(aggTransType))));
+ errmsg("return type of combine function %s is not %s",
+ NameListToString(aggcombinefnName),
+ format_type_be(aggTransType))));
/*
* A combine function to combine INTERNAL states must accept nulls and
}
/*
- * Validate the serialization function, if present. We must ensure that the
- * return type of this function is the same as the specified serialType.
+ * Validate the serialization function, if present. We must ensure that
+ * the return type of this function is the same as the specified
+ * serialType.
*/
if (aggserialfnName)
{
if (rettype != aggSerialType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("return type of serialization function %s is not %s",
- NameListToString(aggserialfnName),
- format_type_be(aggSerialType))));
+ errmsg("return type of serialization function %s is not %s",
+ NameListToString(aggserialfnName),
+ format_type_be(aggSerialType))));
}
/*
if (rettype != aggTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("return type of deserialization function %s is not %s",
- NameListToString(aggdeserialfnName),
- format_type_be(aggTransType))));
+ errmsg("return type of deserialization function %s is not %s",
+ NameListToString(aggdeserialfnName),
+ format_type_be(aggTransType))));
}
/*
/*
* There's little point in having a serialization/deserialization
* function on aggregates that don't have an internal state, so let's
- * just disallow this as it may help clear up any confusion or needless
- * authoring of these functions.
+ * just disallow this as it may help clear up any confusion or
+ * needless authoring of these functions.
*/
if (transTypeId != INTERNALOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("a serialization type must only be specified when the aggregate transition data type is %s",
- format_type_be(INTERNALOID))));
+ format_type_be(INTERNALOID))));
serialTypeId = typenameTypeId(NULL, serialType);
/*
* We disallow INTERNAL serialType as the whole point of the
- * serialized types is to allow the aggregate state to be output,
- * and we cannot output INTERNAL. This check, combined with the one
- * above ensures that the trans type and serialization type are not the
+ * serialized types is to allow the aggregate state to be output, and
+ * we cannot output INTERNAL. This check, combined with the one above
+ * ensures that the trans type and serialization type are not the
* same.
*/
if (serialTypeId == INTERNALOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("aggregate serialization data type cannot be %s",
+ errmsg("aggregate serialization data type cannot be %s",
format_type_be(serialTypeId))));
/*
*/
if (serialfuncName != NIL)
ereport(ERROR,
- (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("must specify serialization type when specifying serialization function")));
+ (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+ errmsg("must specify serialization type when specifying serialization function")));
/* likewise for the deserialization function */
if (deserialfuncName != NIL)
ereport(ERROR,
- (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("must specify serialization type when specifying deserialization function")));
+ (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
+ errmsg("must specify serialization type when specifying deserialization function")));
}
/*
mfinalfuncExtraArgs,
sortoperatorName, /* sort operator name */
transTypeId, /* transition data type */
- serialTypeId, /* serialization data type */
+ serialTypeId, /* serialization data type */
transSpace, /* transition space */
mtransTypeId, /* transition data type */
mtransSpace, /* transition space */
ObjectAddress
ExecAlterObjectDependsStmt(AlterObjectDependsStmt *stmt, ObjectAddress *refAddress)
{
- ObjectAddress address;
- ObjectAddress refAddr;
- Relation rel;
+ ObjectAddress address;
+ ObjectAddress refAddr;
+ Relation rel;
address =
get_object_address_rv(stmt->objectType, stmt->relation, stmt->objname,
- stmt->objargs, &rel, AccessExclusiveLock, false);
+ stmt->objargs, &rel, AccessExclusiveLock, false);
/*
- * If a relation was involved, it would have been opened and locked.
- * We don't need the relation here, but we'll retain the lock until
- * commit.
+ * If a relation was involved, it would have been opened and locked. We
+ * don't need the relation here, but we'll retain the lock until commit.
*/
if (rel)
heap_close(rel, NoLock);
oldNspOid = DatumGetObjectId(namespace);
/*
- * If the object is already in the correct namespace, we don't need
- * to do anything except fire the object access hook.
+ * If the object is already in the correct namespace, we don't need to do
+ * anything except fire the object access hook.
*/
if (oldNspOid == nspOid)
{
/*
* get_am_type_oid
- * Worker for various get_am_*_oid variants
+ * Worker for various get_am_*_oid variants
*
* If missing_ok is false, throw an error if access method not found. If
* true, just return InvalidOid.
/*
* get_am_oid - given an access method name, look up its OID.
- * The type is not checked.
+ * The type is not checked.
*/
Oid
get_am_oid(const char *amname, bool missing_ok)
*/
if (!inh)
{
- BlockNumber relallvisible;
+ BlockNumber relallvisible;
visibilitymap_count(onerel, &relallvisible, NULL);
if (get_func_rettype(funcoid) != VOIDOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("encoding conversion function %s must return type %s",
- NameListToString(func_name), "void")));
+ errmsg("encoding conversion function %s must return type %s",
+ NameListToString(func_name), "void")));
/* Check we have EXECUTE rights for the function */
aclresult = pg_proc_aclcheck(funcoid, GetUserId(), ACL_EXECUTE);
if (is_from)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("COPY FROM not supported with row-level security"),
+ errmsg("COPY FROM not supported with row-level security"),
errhint("Use INSERT statements instead.")));
/* Build target list */
{
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("DO INSTEAD NOTHING rules are not supported for COPY")));
+ errmsg("DO INSTEAD NOTHING rules are not supported for COPY")));
}
else if (list_length(rewritten) > 1)
{
- ListCell *lc;
+ ListCell *lc;
/* examine queries to determine which error message to issue */
foreach(lc, rewritten)
{
- Query *q = (Query *) lfirst(lc);
+ Query *q = (Query *) lfirst(lc);
if (q->querySource == QSRC_QUAL_INSTEAD_RULE)
ereport(ERROR,
if (q->querySource == QSRC_NON_INSTEAD_RULE)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("DO ALSO rules are not supported for the COPY")));
+ errmsg("DO ALSO rules are not supported for the COPY")));
}
ereport(ERROR,
query->commandType == CMD_DELETE);
ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("COPY query must have a RETURNING clause")));
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("COPY query must have a RETURNING clause")));
}
/* plan the query */
CreateExtensionStmt *ces;
ListCell *lc;
ObjectAddress addr;
- List *cascade_parents;
+ List *cascade_parents;
/* Check extension name validity before trying to cascade */
check_valid_extension_name(curreq);
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("function %s must return type %s",
- NameListToString((List *) handler->arg), "fdw_handler")));
+ NameListToString((List *) handler->arg), "fdw_handler")));
return handlerOid;
}
RelationGetRelationName(matviewRel));
/*
- * Check that there is a unique index with no WHERE clause on
- * one or more columns of the materialized view if CONCURRENTLY
- * is specified.
+ * Check that there is a unique index with no WHERE clause on one or more
+ * columns of the materialized view if CONCURRENTLY is specified.
*/
if (concurrent)
{
- List *indexoidlist = RelationGetIndexList(matviewRel);
- ListCell *indexoidscan;
+ List *indexoidlist = RelationGetIndexList(matviewRel);
+ ListCell *indexoidscan;
bool hasUniqueIndex = false;
foreach(indexoidscan, indexoidlist)
{
Oid indexoid = lfirst_oid(indexoidscan);
Relation indexRel;
- Form_pg_index indexStruct;
+ Form_pg_index indexStruct;
indexRel = index_open(indexoid, AccessShareLock);
indexStruct = indexRel->rd_index;
if (!hasUniqueIndex)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
- errmsg("cannot refresh materialized view \"%s\" concurrently",
- quote_qualified_identifier(get_namespace_name(RelationGetNamespace(matviewRel)),
- RelationGetRelationName(matviewRel))),
+ errmsg("cannot refresh materialized view \"%s\" concurrently",
+ quote_qualified_identifier(get_namespace_name(RelationGetNamespace(matviewRel)),
+ RelationGetRelationName(matviewRel))),
errhint("Create a unique index with no WHERE clause on one or more columns of the materialized view.")));
}
/*
* There must be at least one unique index on the matview.
*
- * ExecRefreshMatView() checks that after taking the exclusive lock on
- * the matview. So at least one unique index is guaranteed to exist here
+ * ExecRefreshMatView() checks that after taking the exclusive lock on the
+ * matview. So at least one unique index is guaranteed to exist here
* because the lock is still being held.
*/
Assert(foundUniqueIndex);
if (get_func_rettype(restrictionOid) != FLOAT8OID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("restriction estimator function %s must return type %s",
- NameListToString(restrictionName), "float8")));
+ errmsg("restriction estimator function %s must return type %s",
+ NameListToString(restrictionName), "float8")));
/* Require EXECUTE rights for the estimator */
aclresult = pg_proc_aclcheck(restrictionOid, GetUserId(), ACL_EXECUTE);
if (get_func_rettype(joinOid) != FLOAT8OID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("join estimator function %s must return type %s",
- NameListToString(joinName), "float8")));
+ errmsg("join estimator function %s must return type %s",
+ NameListToString(joinName), "float8")));
/* Require EXECUTE rights for the estimator */
aclresult = pg_proc_aclcheck(joinOid, GetUserId(), ACL_EXECUTE);
/* Must own relation. */
if (pg_class_ownercheck(relid, GetUserId()))
- noperm = false; /* user is allowed to modify this policy */
+ noperm = false; /* user is allowed to modify this policy */
else
ereport(WARNING,
(errcode(ERRCODE_WARNING_PRIVILEGE_NOT_REVOKED),
*/
if (!noperm && num_roles > 0)
{
- int i, j;
+ int i,
+ j;
Oid *roles = (Oid *) ARR_DATA_PTR(policy_roles);
Datum *role_oids;
char *qual_value;
Node *qual_expr;
- List *qual_parse_rtable = NIL;
+ List *qual_parse_rtable = NIL;
char *with_check_value;
Node *with_check_qual;
- List *with_check_parse_rtable = NIL;
+ List *with_check_parse_rtable = NIL;
Datum values[Natts_pg_policy];
bool isnull[Natts_pg_policy];
bool replaces[Natts_pg_policy];
/*
* All of the dependencies will be removed from the policy and then
- * re-added. In order to get them correct, we need to extract out
- * the expressions in the policy and construct a parsestate just
- * enough to build the range table(s) to then pass to
- * recordDependencyOnExpr().
+ * re-added. In order to get them correct, we need to extract out the
+ * expressions in the policy and construct a parsestate just enough to
+ * build the range table(s) to then pass to recordDependencyOnExpr().
*/
/* Get policy qual, to update dependencies */
value_datum = heap_getattr(tuple, Anum_pg_policy_polqual,
- RelationGetDescr(pg_policy_rel), &attr_isnull);
+ RelationGetDescr(pg_policy_rel), &attr_isnull);
if (!attr_isnull)
{
ParseState *qual_pstate;
/* Get WITH CHECK qual, to update dependencies */
value_datum = heap_getattr(tuple, Anum_pg_policy_polwithcheck,
- RelationGetDescr(pg_policy_rel), &attr_isnull);
+ RelationGetDescr(pg_policy_rel), &attr_isnull);
if (!attr_isnull)
{
ParseState *with_check_pstate;
heap_close(pg_policy_rel, RowExclusiveLock);
- return(noperm || num_roles > 0);
+ return (noperm || num_roles > 0);
}
/*
/* Get policy command */
polcmd_datum = heap_getattr(policy_tuple, Anum_pg_policy_polcmd,
- RelationGetDescr(pg_policy_rel),
- &polcmd_isnull);
+ RelationGetDescr(pg_policy_rel),
+ &polcmd_isnull);
Assert(!polcmd_isnull);
polcmd = DatumGetChar(polcmd_datum);
}
else
{
- Oid *roles;
+ Oid *roles;
Datum roles_datum;
bool attr_isnull;
ArrayType *policy_roles;
/*
- * We need to pull the set of roles this policy applies to from
- * what's in the catalog, so that we can recreate the dependencies
- * correctly for the policy.
+ * We need to pull the set of roles this policy applies to from what's
+ * in the catalog, so that we can recreate the dependencies correctly
+ * for the policy.
*/
roles_datum = heap_getattr(policy_tuple, Anum_pg_policy_polroles,
}
else
{
- Datum value_datum;
- bool attr_isnull;
+ Datum value_datum;
+ bool attr_isnull;
/*
* We need to pull the USING expression and build the range table for
- * the policy from what's in the catalog, so that we can recreate
- * the dependencies correctly for the policy.
+ * the policy from what's in the catalog, so that we can recreate the
+ * dependencies correctly for the policy.
*/
/* Check if the policy has a USING expr */
}
else
{
- Datum value_datum;
- bool attr_isnull;
+ Datum value_datum;
+ bool attr_isnull;
/*
* We need to pull the WITH CHECK expression and build the range table
if (funcrettype != LANGUAGE_HANDLEROID)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("function %s must return type %s",
- NameListToString(funcname), "language_handler")));
+ errmsg("function %s must return type %s",
+ NameListToString(funcname), "language_handler")));
}
else
{
else
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("function %s must return type %s",
- NameListToString(stmt->plhandler), "language_handler")));
+ errmsg("function %s must return type %s",
+ NameListToString(stmt->plhandler), "language_handler")));
}
/* validate the inline function */
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
- * NOTE that this is cool only because we have ShareRowExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because we have ShareRowExclusiveLock on
+ * the relation, so the trigger set won't be changing underneath us.
*/
if (!isInternal)
{
{
/* backwards-compatibility hack */
ereport(WARNING,
- (errmsg("changing return type of function %s from %s to %s",
- NameListToString(inputName), "opaque", typeName)));
+ (errmsg("changing return type of function %s from %s to %s",
+ NameListToString(inputName), "opaque", typeName)));
SetFunctionReturnType(inputOid, typoid);
}
else
{
/* backwards-compatibility hack */
ereport(WARNING,
- (errmsg("changing return type of function %s from %s to %s",
- NameListToString(outputName), "opaque", "cstring")));
+ (errmsg("changing return type of function %s from %s to %s",
+ NameListToString(outputName), "opaque", "cstring")));
SetFunctionReturnType(outputOid, CSTRINGOID);
}
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("type output function %s must return type %s",
- NameListToString(outputName), "cstring")));
+ errmsg("type output function %s must return type %s",
+ NameListToString(outputName), "cstring")));
}
if (receiveOid)
{
if (resulttype != BYTEAOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("type send function %s must return type %s",
- NameListToString(sendName), "bytea")));
+ errmsg("type send function %s must return type %s",
+ NameListToString(sendName), "bytea")));
}
/*
if (get_func_rettype(procOid) != BOOLOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("type analyze function %s must return type %s",
- NameListToString(procname), "boolean")));
+ errmsg("type analyze function %s must return type %s",
+ NameListToString(procname), "boolean")));
return procOid;
}
typTup = (Form_pg_type) GETSTRUCT(tup);
/*
- * If it's a composite type, invoke ATExecChangeOwner so that we fix up the
- * pg_class entry properly. That will call back to AlterTypeOwnerInternal
- * to take care of the pg_type entry(s).
+ * If it's a composite type, invoke ATExecChangeOwner so that we fix up
+ * the pg_class entry properly. That will call back to
+ * AlterTypeOwnerInternal to take care of the pg_type entry(s).
*/
if (typTup->typtype == TYPTYPE_COMPOSITE)
ATExecChangeOwner(typTup->typrelid, newOwnerId, true, AccessExclusiveLock);
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("must be superuser to change bypassrls attribute")));
+ errmsg("must be superuser to change bypassrls attribute")));
}
else
{
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("role name \"%s\" is reserved",
- stmt->role),
- errdetail("Role names starting with \"pg_\" are reserved.")));
+ stmt->role),
+ errdetail("Role names starting with \"pg_\" are reserved.")));
/*
* Check the pg_authid relation to be certain the role doesn't already
if (rolspec->roletype != ROLESPEC_CSTRING)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("cannot use special role specifier in DROP ROLE")));
+ errmsg("cannot use special role specifier in DROP ROLE")));
role = rolspec->rolename;
tuple = SearchSysCache1(AUTHNAME, PointerGetDatum(role));
errmsg("current user cannot be renamed")));
/*
- * Check that the user is not trying to rename a system role and
- * not trying to rename a role into the reserved "pg_" namespace.
+ * Check that the user is not trying to rename a system role and not
+ * trying to rename a role into the reserved "pg_" namespace.
*/
if (IsReservedName(NameStr(authform->rolname)))
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("role name \"%s\" is reserved",
- NameStr(authform->rolname)),
- errdetail("Role names starting with \"pg_\" are reserved.")));
+ NameStr(authform->rolname)),
+ errdetail("Role names starting with \"pg_\" are reserved.")));
if (IsReservedName(newname))
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("role name \"%s\" is reserved",
- newname),
- errdetail("Role names starting with \"pg_\" are reserved.")));
+ newname),
+ errdetail("Role names starting with \"pg_\" are reserved.")));
/* make sure the new name doesn't exist */
if (SearchSysCacheExists1(AUTHNAME, CStringGetDatum(newname)))
}
/*
- * If the all-visible page is turned out to be all-frozen but not marked,
- * we should so mark it. Note that all_frozen is only valid if all_visible
- * is true, so we must check both.
+ * If the all-visible page is turned out to be all-frozen but not
+ * marked, we should so mark it. Note that all_frozen is only valid
+ * if all_visible is true, so we must check both.
*/
else if (all_visible_according_to_vm && all_visible && all_frozen &&
!VM_ALL_FROZEN(onerel, blkno, &vmbuffer))
possibly_freeable = vacrelstats->rel_pages - vacrelstats->nonempty_pages;
if (possibly_freeable > 0 &&
(possibly_freeable >= REL_TRUNCATE_MINIMUM ||
- possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION) &&
+ possibly_freeable >= vacrelstats->rel_pages / REL_TRUNCATE_FRACTION) &&
old_snapshot_threshold < 0)
return true;
else
ReleaseSysCache(roleTup);
/*
- * Verify that session user is allowed to become this role, but
- * skip this in parallel mode, where we must blindly recreate the
- * parallel leader's state.
+ * Verify that session user is allowed to become this role, but skip
+ * this in parallel mode, where we must blindly recreate the parallel
+ * leader's state.
*/
if (!InitializingParallelWorker &&
!is_member_of_role(GetSessionUserId(), roleid))
return false;
/*
- * Parallel-aware nodes return a subset of the tuples in each worker,
- * and in general we can't expect to have enough bookkeeping state to
- * know which ones we returned in this worker as opposed to some other
- * worker.
+ * Parallel-aware nodes return a subset of the tuples in each worker, and
+ * in general we can't expect to have enough bookkeeping state to know
+ * which ones we returned in this worker as opposed to some other worker.
*/
if (node->parallel_aware)
return false;
{
TransactionId xwait;
ItemPointerData ctid_wait;
- XLTW_Oper reason_wait;
+ XLTW_Oper reason_wait;
Datum existing_values[INDEX_MAX_KEYS];
bool existing_isnull[INDEX_MAX_KEYS];
char *error_new;
if (wco->polname != NULL)
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
- wco->polname, wco->relname)));
+ errmsg("new row violates row-level security policy \"%s\" for table \"%s\"",
+ wco->polname, wco->relname)));
else
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("new row violates row-level security policy for table \"%s\"",
- wco->relname)));
+ errmsg("new row violates row-level security policy for table \"%s\"",
+ wco->relname)));
break;
case WCO_RLS_CONFLICT_CHECK:
if (wco->polname != NULL)
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
- wco->polname, wco->relname)));
+ errmsg("new row violates row-level security policy \"%s\" (USING expression) for table \"%s\"",
+ wco->polname, wco->relname)));
else
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
- wco->relname)));
+ errmsg("new row violates row-level security policy (USING expression) for table \"%s\"",
+ wco->relname)));
break;
default:
elog(ERROR, "unrecognized WCO kind: %u", wco->kind);
typedef struct ExecParallelEstimateContext
{
ParallelContext *pcxt;
- int nnodes;
+ int nnodes;
} ExecParallelEstimateContext;
/* Context object for ExecParallelInitializeDSM. */
{
ParallelContext *pcxt;
SharedExecutorInstrumentation *instrumentation;
- int nnodes;
+ int nnodes;
} ExecParallelInitializeDSMContext;
/* Helper functions that run in the parallel leader. */
static bool ExecParallelEstimate(PlanState *node,
ExecParallelEstimateContext *e);
static bool ExecParallelInitializeDSM(PlanState *node,
- ExecParallelInitializeDSMContext *d);
+ ExecParallelInitializeDSMContext *d);
static shm_mq_handle **ExecParallelSetupTupleQueues(ParallelContext *pcxt,
bool reinitialize);
static bool ExecParallelRetrieveInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation);
+ SharedExecutorInstrumentation *instrumentation);
/* Helper functions that run in the parallel worker. */
static void ParallelQueryMain(dsm_segment *seg, shm_toc *toc);
/* Estimate space for tuple queues. */
shm_toc_estimate_chunk(&pcxt->estimator,
- mul_size(PARALLEL_TUPLE_QUEUE_SIZE, pcxt->nworkers));
+ mul_size(PARALLEL_TUPLE_QUEUE_SIZE, pcxt->nworkers));
shm_toc_estimate_keys(&pcxt->estimator, 1);
/*
- * Give parallel-aware nodes a chance to add to the estimates, and get
- * a count of how many PlanState nodes there are.
+ * Give parallel-aware nodes a chance to add to the estimates, and get a
+ * count of how many PlanState nodes there are.
*/
e.pcxt = pcxt;
e.nnodes = 0;
pei->tqueue = ExecParallelSetupTupleQueues(pcxt, false);
/*
- * If instrumentation options were supplied, allocate space for the
- * data. It only gets partially initialized here; the rest happens
- * during ExecParallelInitializeDSM.
+ * If instrumentation options were supplied, allocate space for the data.
+ * It only gets partially initialized here; the rest happens during
+ * ExecParallelInitializeDSM.
*/
if (estate->es_instrument)
{
Instrumentation *instrument;
- int i;
+ int i;
instrumentation = shm_toc_allocate(pcxt->toc, instrumentation_len);
instrumentation->instrument_options = estate->es_instrument;
*/
static bool
ExecParallelRetrieveInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation)
+ SharedExecutorInstrumentation *instrumentation)
{
Instrumentation *instrument;
- int i;
- int n;
- int ibytes;
- int plan_node_id = planstate->plan->plan_node_id;
+ int i;
+ int n;
+ int ibytes;
+ int plan_node_id = planstate->plan->plan_node_id;
/* Find the instumentation for this node. */
for (i = 0; i < instrumentation->num_plan_nodes; ++i)
void
ExecParallelFinish(ParallelExecutorInfo *pei)
{
- int i;
+ int i;
if (pei->finished)
return;
*/
static bool
ExecParallelReportInstrumentation(PlanState *planstate,
- SharedExecutorInstrumentation *instrumentation)
+ SharedExecutorInstrumentation *instrumentation)
{
- int i;
- int plan_node_id = planstate->plan->plan_node_id;
+ int i;
+ int plan_node_id = planstate->plan->plan_node_id;
Instrumentation *instrument;
InstrEndLoop(planstate->instrument);
/*
* If we shuffled the plan_node_id values in ps_instrument into sorted
- * order, we could use binary search here. This might matter someday
- * if we're pushing down sufficiently large plan trees. For now, do it
- * the slow, dumb way.
+ * order, we could use binary search here. This might matter someday if
+ * we're pushing down sufficiently large plan trees. For now, do it the
+ * slow, dumb way.
*/
for (i = 0; i < instrumentation->num_plan_nodes; ++i)
if (instrumentation->plan_node_id[i] == plan_node_id)
stmt = queryTree->utilityStmt;
else
stmt = (Node *) pg_plan_query(queryTree,
- fcache->readonly_func ? CURSOR_OPT_PARALLEL_OK : 0,
- NULL);
+ fcache->readonly_func ? CURSOR_OPT_PARALLEL_OK : 0,
+ NULL);
/* Precheck all commands for validity in a function */
if (IsA(stmt, TransactionStmt))
AggStatePerGroup pergroupstate,
Datum *resultVal, bool *resultIsNull);
static void finalize_partialaggregate(AggState *aggstate,
- AggStatePerAgg peragg,
- AggStatePerGroup pergroupstate,
- Datum *resultVal, bool *resultIsNull);
+ AggStatePerAgg peragg,
+ AggStatePerGroup pergroupstate,
+ Datum *resultVal, bool *resultIsNull);
static void prepare_projection_slot(AggState *aggstate,
TupleTableSlot *slot,
int currentSet);
if (OidIsValid(pertrans->deserialfn_oid))
{
/*
- * Don't call a strict deserialization function with NULL input.
- * A strict deserialization function and a null value means we skip
- * calling the combine function for this state. We assume that this
- * would be a waste of time and effort anyway so just skip it.
+ * Don't call a strict deserialization function with NULL input. A
+ * strict deserialization function and a null value means we skip
+ * calling the combine function for this state. We assume that
+ * this would be a waste of time and effort anyway so just skip
+ * it.
*/
if (pertrans->deserialfn.fn_strict && slot->tts_isnull[0])
continue;
else
{
- FunctionCallInfo dsinfo = &pertrans->deserialfn_fcinfo;
- MemoryContext oldContext;
+ FunctionCallInfo dsinfo = &pertrans->deserialfn_fcinfo;
+ MemoryContext oldContext;
dsinfo->arg[0] = slot->tts_values[0];
dsinfo->argnull[0] = slot->tts_isnull[0];
AggStatePerGroup pergroupstate,
Datum *resultVal, bool *resultIsNull)
{
- AggStatePerTrans pertrans = &aggstate->pertrans[peragg->transno];
- MemoryContext oldContext;
+ AggStatePerTrans pertrans = &aggstate->pertrans[peragg->transno];
+ MemoryContext oldContext;
oldContext = MemoryContextSwitchTo(aggstate->ss.ps.ps_ExprContext->ecxt_per_tuple_memory);
/*
- * serialfn_oid will be set if we must serialize the input state
- * before calling the combine function on the state.
+ * serialfn_oid will be set if we must serialize the input state before
+ * calling the combine function on the state.
*/
if (OidIsValid(pertrans->serialfn_oid))
{
else
{
FunctionCallInfo fcinfo = &pertrans->serialfn_fcinfo;
+
fcinfo->arg[0] = pergroupstate->transValue;
fcinfo->argnull[0] = pergroupstate->transValueIsNull;
/* If result is pass-by-ref, make sure it is in the right context. */
if (!peragg->resulttypeByVal && !*resultIsNull &&
!MemoryContextContains(CurrentMemoryContext,
- DatumGetPointer(*resultVal)))
+ DatumGetPointer(*resultVal)))
*resultVal = datumCopy(*resultVal,
peragg->resulttypeByVal,
peragg->resulttypeLen);
*
* 1. An aggregate function appears more than once in query:
*
- * SELECT SUM(x) FROM ... HAVING SUM(x) > 0
+ * SELECT SUM(x) FROM ... HAVING SUM(x) > 0
*
- * Since the aggregates are the identical, we only need to calculate
- * the calculate it once. Both aggregates will share the same 'aggno'
- * value.
+ * Since the aggregates are the identical, we only need to calculate
+ * the calculate it once. Both aggregates will share the same 'aggno'
+ * value.
*
* 2. Two different aggregate functions appear in the query, but the
- * aggregates have the same transition function and initial value, but
- * different final function:
+ * aggregates have the same transition function and initial value, but
+ * different final function:
*
- * SELECT SUM(x), AVG(x) FROM ...
+ * SELECT SUM(x), AVG(x) FROM ...
*
- * In this case we must create a new peragg for the varying aggregate,
- * and need to call the final functions separately, but can share the
- * same transition state.
+ * In this case we must create a new peragg for the varying aggregate,
+ * and need to call the final functions separately, but can share the
+ * same transition state.
*
* For either of these optimizations to be valid, the aggregate's
* arguments must be the same, including any modifiers such as ORDER BY,
*/
existing_transno = find_compatible_pertrans(aggstate, aggref,
transfn_oid, aggtranstype,
- serialfn_oid, deserialfn_oid,
- initValue, initValueIsNull,
+ serialfn_oid, deserialfn_oid,
+ initValue, initValueIsNull,
same_input_transnos);
if (existing_transno != -1)
{
/*
* The serialization and deserialization functions must match, if
* present, as we're unable to share the trans state for aggregates
- * which will serialize or deserialize into different formats. Remember
- * that these will be InvalidOid if they're not required for this agg
- * node.
+ * which will serialize or deserialize into different formats.
+ * Remember that these will be InvalidOid if they're not required for
+ * this agg node.
*/
if (aggserialfn != pertrans->serialfn_oid ||
aggdeserialfn != pertrans->deserialfn_oid)
/*
* If chgParam of subnode is not null then plan will be re-scanned by
- * first ExecProcNode. outerPlan may also be NULL, in which case there
- * is nothing to rescan at all.
+ * first ExecProcNode. outerPlan may also be NULL, in which case there is
+ * nothing to rescan at all.
*/
if (outerPlan != NULL && outerPlan->chgParam == NULL)
ExecReScan(outerPlan);
/*
* Initialize the parallel context and workers on first execution. We do
* this on first execution rather than during node initialization, as it
- * needs to allocate large dynamic segment, so it is better to do if it
- * is really needed.
+ * needs to allocate large dynamic segment, so it is better to do if it is
+ * really needed.
*/
if (!node->initialized)
{
Gather *gather = (Gather *) node->ps.plan;
/*
- * Sometimes we might have to run without parallelism; but if
- * parallel mode is active then we can try to fire up some workers.
+ * Sometimes we might have to run without parallelism; but if parallel
+ * mode is active then we can try to fire up some workers.
*/
if (gather->num_workers > 0 && IsInParallelMode())
{
}
else
{
- /* No workers? Then never mind. */
+ /* No workers? Then never mind. */
ExecShutdownGatherWorkers(node);
}
}
static HeapTuple
gather_readnext(GatherState *gatherstate)
{
- int waitpos = gatherstate->nextreader;
+ int waitpos = gatherstate->nextreader;
for (;;)
{
tup = TupleQueueReaderNext(reader, true, &readerdone);
/*
- * If this reader is done, remove it. If all readers are done,
- * clean up remaining worker state.
+ * If this reader is done, remove it. If all readers are done, clean
+ * up remaining worker state.
*/
if (readerdone)
{
/* Shut down tuple queue readers before shutting down workers. */
if (node->reader != NULL)
{
- int i;
+ int i;
for (i = 0; i < node->nreaders; ++i)
DestroyTupleQueueReader(node->reader[i]);
ExecReScanGather(GatherState *node)
{
/*
- * Re-initialize the parallel workers to perform rescan of relation.
- * We want to gracefully shutdown all the workers so that they
- * should be able to propagate any error or other information to master
- * backend before dying. Parallel context will be reused for rescan.
+ * Re-initialize the parallel workers to perform rescan of relation. We
+ * want to gracefully shutdown all the workers so that they should be able
+ * to propagate any error or other information to master backend before
+ * dying. Parallel context will be reused for rescan.
*/
ExecShutdownGatherWorkers(node);
/*
* Note that it is possible that the target tuple has been modified in
* this session, after the above heap_lock_tuple. We choose to not error
- * out in that case, in line with ExecUpdate's treatment of similar
- * cases. This can happen if an UPDATE is triggered from within
- * ExecQual(), ExecWithCheckOptions() or ExecProject() above, e.g. by
- * selecting from a wCTE in the ON CONFLICT's SET.
+ * out in that case, in line with ExecUpdate's treatment of similar cases.
+ * This can happen if an UPDATE is triggered from within ExecQual(),
+ * ExecWithCheckOptions() or ExecProject() above, e.g. by selecting from a
+ * wCTE in the ON CONFLICT's SET.
*/
/* Execute UPDATE with projection */
/* Initialize the usesFdwDirectModify flag */
resultRelInfo->ri_usesFdwDirectModify = bms_is_member(i,
- node->fdwDirectModifyPlans);
+ node->fdwDirectModifyPlans);
/*
* Verify result relation is a valid target for the current operation
if (scandesc == NULL)
{
/*
- * We reach here if the scan is not parallel, or if we're executing
- * a scan that was intended to be parallel serially.
+ * We reach here if the scan is not parallel, or if we're executing a
+ * scan that was intended to be parallel serially.
*/
scandesc = heap_beginscan(node->ss.ss_currentRelation,
estate->es_snapshot,
* open that relation and acquire appropriate lock on it.
*/
currentRelation = ExecOpenScanRelation(estate,
- ((SeqScan *) node->ss.ps.plan)->scanrelid,
+ ((SeqScan *) node->ss.ps.plan)->scanrelid,
eflags);
node->ss.ss_currentRelation = currentRelation;
scan = node->ss.ss_currentScanDesc;
if (scan != NULL)
- heap_rescan(scan, /* scan desc */
- NULL); /* new scan keys */
+ heap_rescan(scan, /* scan desc */
+ NULL); /* new scan keys */
ExecScanReScan((ScanState *) node);
}
ParallelContext *pcxt)
{
EState *estate = node->ss.ps.state;
- ParallelHeapScanDesc pscan;
+ ParallelHeapScanDesc pscan;
pscan = shm_toc_allocate(pcxt->toc, node->pscan_len);
heap_parallelscan_initialize(pscan,
void
ExecSeqScanInitializeWorker(SeqScanState *node, shm_toc *toc)
{
- ParallelHeapScanDesc pscan;
+ ParallelHeapScanDesc pscan;
pscan = shm_toc_lookup(toc, node->ss.ps.plan->plan_node_id);
node->ss.ss_currentScanDesc =
/* build expression trees using actual argument & result types */
build_aggregate_transfn_expr(inputTypes,
numArguments,
- 0, /* no ordered-set window functions yet */
- false, /* no variadic window functions yet */
+ 0, /* no ordered-set window functions yet */
+ false, /* no variadic window functions yet */
wfunc->wintype,
wfunc->inputcollid,
transfn_oid,
TQUEUE_REMAP_ARRAY, /* array */
TQUEUE_REMAP_RANGE, /* range */
TQUEUE_REMAP_RECORD /* composite type, named or anonymous */
-} RemapClass;
+} RemapClass;
typedef struct
{
int natts;
RemapClass mapping[FLEXIBLE_ARRAY_MEMBER];
-} RemapInfo;
+} RemapInfo;
typedef struct
{
char mode;
TupleDesc tupledesc;
RemapInfo *remapinfo;
-} TQueueDestReceiver;
+} TQueueDestReceiver;
typedef struct RecordTypemodMap
{
int remotetypmod;
int localtypmod;
-} RecordTypemodMap;
+} RecordTypemodMap;
struct TupleQueueReader
{
#define TUPLE_QUEUE_MODE_CONTROL 'c'
#define TUPLE_QUEUE_MODE_DATA 'd'
-static void tqueueWalk(TQueueDestReceiver * tqueue, RemapClass walktype,
+static void tqueueWalk(TQueueDestReceiver *tqueue, RemapClass walktype,
Datum value);
-static void tqueueWalkRecord(TQueueDestReceiver * tqueue, Datum value);
-static void tqueueWalkArray(TQueueDestReceiver * tqueue, Datum value);
-static void tqueueWalkRange(TQueueDestReceiver * tqueue, Datum value);
-static void tqueueSendTypmodInfo(TQueueDestReceiver * tqueue, int typmod,
+static void tqueueWalkRecord(TQueueDestReceiver *tqueue, Datum value);
+static void tqueueWalkArray(TQueueDestReceiver *tqueue, Datum value);
+static void tqueueWalkRange(TQueueDestReceiver *tqueue, Datum value);
+static void tqueueSendTypmodInfo(TQueueDestReceiver *tqueue, int typmod,
TupleDesc tupledesc);
static void TupleQueueHandleControlMessage(TupleQueueReader *reader,
Size nbytes, char *data);
static HeapTuple TupleQueueHandleDataMessage(TupleQueueReader *reader,
Size nbytes, HeapTupleHeader data);
static HeapTuple TupleQueueRemapTuple(TupleQueueReader *reader,
- TupleDesc tupledesc, RemapInfo * remapinfo,
+ TupleDesc tupledesc, RemapInfo *remapinfo,
HeapTuple tuple);
static Datum TupleQueueRemap(TupleQueueReader *reader, RemapClass remapclass,
Datum value);
* Invoke the appropriate walker function based on the given RemapClass.
*/
static void
-tqueueWalk(TQueueDestReceiver * tqueue, RemapClass walktype, Datum value)
+tqueueWalk(TQueueDestReceiver *tqueue, RemapClass walktype, Datum value)
{
check_stack_depth();
* contained therein.
*/
static void
-tqueueWalkRecord(TQueueDestReceiver * tqueue, Datum value)
+tqueueWalkRecord(TQueueDestReceiver *tqueue, Datum value)
{
HeapTupleHeader tup;
Oid typeid;
* contained therein.
*/
static void
-tqueueWalkArray(TQueueDestReceiver * tqueue, Datum value)
+tqueueWalkArray(TQueueDestReceiver *tqueue, Datum value)
{
ArrayType *arr = DatumGetArrayTypeP(value);
Oid typeid = ARR_ELEMTYPE(arr);
* contained therein.
*/
static void
-tqueueWalkRange(TQueueDestReceiver * tqueue, Datum value)
+tqueueWalkRange(TQueueDestReceiver *tqueue, Datum value)
{
RangeType *range = DatumGetRangeType(value);
Oid typeid = RangeTypeGetOid(range);
* already done so previously.
*/
static void
-tqueueSendTypmodInfo(TQueueDestReceiver * tqueue, int typmod,
+tqueueSendTypmodInfo(TQueueDestReceiver *tqueue, int typmod,
TupleDesc tupledesc)
{
StringInfoData buf;
*/
static HeapTuple
TupleQueueRemapTuple(TupleQueueReader *reader, TupleDesc tupledesc,
- RemapInfo * remapinfo, HeapTuple tuple)
+ RemapInfo *remapinfo, HeapTuple tuple)
{
Datum *values;
bool *isnull;
retval = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
hostinfo, sizeof(hostinfo), NULL, 0,
- port->hba->pam_use_hostname ? 0 : NI_NUMERICHOST | NI_NUMERICSERV);
+ port->hba->pam_use_hostname ? 0 : NI_NUMERICHOST | NI_NUMERICSERV);
if (retval != 0)
{
ereport(WARNING,
{
ereport(LOG,
(errmsg("pam_set_item(PAM_RHOST) failed: %s",
- pam_strerror(pamh, retval))));
+ pam_strerror(pamh, retval))));
pam_passwd = NULL;
return STATUS_ERROR;
}
static int
CheckBSDAuth(Port *port, char *user)
{
- char *passwd;
- int retval;
+ char *passwd;
+ int retval;
/* Send regular password request to client, and get the response */
sendAuthRequest(port, AUTH_REQ_PASSWORD);
radius_add_attribute(packet, RADIUS_NAS_IDENTIFIER, (unsigned char *) identifier, strlen(identifier));
/*
- * RADIUS password attributes are calculated as:
- * e[0] = p[0] XOR MD5(secret + Request Authenticator)
- * for the first group of 16 octets, and then:
- * e[i] = p[i] XOR MD5(secret + e[i-1])
- * for the following ones (if necessary)
+ * RADIUS password attributes are calculated as: e[0] = p[0] XOR
+ * MD5(secret + Request Authenticator) for the first group of 16 octets,
+ * and then: e[i] = p[i] XOR MD5(secret + e[i-1]) for the following ones
+ * (if necessary)
*/
encryptedpasswordlen = ((strlen(passwd) + RADIUS_VECTOR_LENGTH - 1) / RADIUS_VECTOR_LENGTH) * RADIUS_VECTOR_LENGTH;
cryptvector = palloc(strlen(port->hba->radiussecret) + RADIUS_VECTOR_LENGTH);
for (i = 0; i < encryptedpasswordlen; i += RADIUS_VECTOR_LENGTH)
{
memcpy(cryptvector + strlen(port->hba->radiussecret), md5trailer, RADIUS_VECTOR_LENGTH);
- /* .. and for subsequent iterations the result of the previous XOR (calculated below) */
+
+ /*
+ * .. and for subsequent iterations the result of the previous XOR
+ * (calculated below)
+ */
md5trailer = encryptedpassword + i;
if (!pg_md5_binary(cryptvector, strlen(port->hba->radiussecret) + RADIUS_VECTOR_LENGTH, encryptedpassword + i))
return STATUS_ERROR;
}
- for (j = i; j < i+RADIUS_VECTOR_LENGTH; j++)
+ for (j = i; j < i + RADIUS_VECTOR_LENGTH; j++)
{
if (j < strlen(passwd))
encryptedpassword[j] = passwd[j] ^ encryptedpassword[j];
(buf.st_uid == 0 && buf.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO)))
ereport(FATAL,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("private key file \"%s\" has group or world access",
- ssl_key_file),
+ errmsg("private key file \"%s\" has group or world access",
+ ssl_key_file),
errdetail("File must have permissions u=rw (0600) or less if owned by the database user, or permissions u=rw,g=r (0640) or less if owned by root.")));
#endif
else
ereport(FATAL,
(errmsg("could not load SSL certificate revocation list file \"%s\": %s",
- ssl_crl_file, SSLerrmessage(ERR_get_error()))));
+ ssl_crl_file, SSLerrmessage(ERR_get_error()))));
}
}
port->ssl_in_use = true;
aloop:
+
/*
* Prepare to call SSL_get_error() by clearing thread's OpenSSL error
* queue. In general, the current thread's error queue must be empty
- * before the TLS/SSL I/O operation is attempted, or SSL_get_error()
- * will not work reliably. An extension may have failed to clear the
+ * before the TLS/SSL I/O operation is attempted, or SSL_get_error() will
+ * not work reliably. An extension may have failed to clear the
* per-thread error queue following another call to an OpenSSL I/O
* routine.
*/
/*
* Other clients of OpenSSL in the backend may fail to call
- * ERR_get_error(), but we always do, so as to not cause problems
- * for OpenSSL clients that don't call ERR_clear_error()
- * defensively. Be sure that this happens by calling now.
- * SSL_get_error() relies on the OpenSSL per-thread error queue
- * being intact, so this is the earliest possible point
- * ERR_get_error() may be called.
+ * ERR_get_error(), but we always do, so as to not cause problems for
+ * OpenSSL clients that don't call ERR_clear_error() defensively. Be
+ * sure that this happens by calling now. SSL_get_error() relies on
+ * the OpenSSL per-thread error queue being intact, so this is the
+ * earliest possible point ERR_get_error() may be called.
*/
ecode = ERR_get_error();
switch (err)
/* In blocking mode, wait until the socket is ready */
if (n < 0 && !port->noblock && (errno == EWOULDBLOCK || errno == EAGAIN))
{
- WaitEvent event;
+ WaitEvent event;
Assert(waitfor);
ModifyWaitEvent(FeBeWaitSet, 0, waitfor, NULL);
- WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */, &event, 1);
+ WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */ , &event, 1);
/*
* If the postmaster has died, it's not safe to continue running,
* because it is the postmaster's job to kill us if some other backend
* exists uncleanly. Moreover, we won't run very well in this state;
* helper processes like walwriter and the bgwriter will exit, so
- * performance may be poor. Finally, if we don't exit, pg_ctl will
- * be unable to restart the postmaster without manual intervention,
- * so no new connections can be accepted. Exiting clears the deck
- * for a postmaster restart.
+ * performance may be poor. Finally, if we don't exit, pg_ctl will be
+ * unable to restart the postmaster without manual intervention, so no
+ * new connections can be accepted. Exiting clears the deck for a
+ * postmaster restart.
*
- * (Note that we only make this check when we would otherwise sleep
- * on our latch. We might still continue running for a while if the
+ * (Note that we only make this check when we would otherwise sleep on
+ * our latch. We might still continue running for a while if the
* postmaster is killed in mid-query, or even through multiple queries
* if we never have to wait for read. We don't want to burn too many
* cycles checking for this very rare condition, and this should cause
if (event.events & WL_POSTMASTER_DEATH)
ereport(FATAL,
(errcode(ERRCODE_ADMIN_SHUTDOWN),
- errmsg("terminating connection due to unexpected postmaster exit")));
+ errmsg("terminating connection due to unexpected postmaster exit")));
/* Handle interrupt. */
if (event.events & WL_LATCH_SET)
if (n < 0 && !port->noblock && (errno == EWOULDBLOCK || errno == EAGAIN))
{
- WaitEvent event;
+ WaitEvent event;
Assert(waitfor);
ModifyWaitEvent(FeBeWaitSet, 0, waitfor, NULL);
- WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */, &event, 1);
+ WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */ , &event, 1);
/* See comments in secure_read. */
if (event.events & WL_POSTMASTER_DEATH)
ereport(FATAL,
(errcode(ERRCODE_ADMIN_SHUTDOWN),
- errmsg("terminating connection due to unexpected postmaster exit")));
+ errmsg("terminating connection due to unexpected postmaster exit")));
/* Handle interrupt. */
if (event.events & WL_LATCH_SET)
if (PqCommReadingMsg)
ereport(FATAL,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
- errmsg("terminating connection because protocol synchronization was lost")));
+ errmsg("terminating connection because protocol synchronization was lost")));
PqCommReadingMsg = true;
}
/*
* If the message queue is already gone, just ignore the message. This
- * doesn't necessarily indicate a problem; for example, DEBUG messages
- * can be generated late in the shutdown sequence, after all DSMs have
- * already been detached.
+ * doesn't necessarily indicate a problem; for example, DEBUG messages can
+ * be generated late in the shutdown sequence, after all DSMs have already
+ * been detached.
*/
if (pq_mq == NULL)
return 0;
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
#if defined(_M_AMD64) && _MSC_VER == 1800
+
/*
- * Avoid crashing in certain floating-point operations if
- * we were compiled for x64 with MS Visual Studio 2013 and
- * are running on Windows prior to 7/2008R2 SP1 on an
- * AVX2-capable CPU.
+ * Avoid crashing in certain floating-point operations if we were
+ * compiled for x64 with MS Visual Studio 2013 and are running on
+ * Windows prior to 7/2008R2 SP1 on an AVX2-capable CPU.
*
- * Ref: https://connect.microsoft.com/VisualStudio/feedback/details/811093/visual-studio-2013-rtm-c-x64-code-generation-bug-for-avx2-instructions
+ * Ref:
+ * https://connect.microsoft.com/VisualStudio/feedback/details/811093/v
+ * isual-studio-2013-rtm-c-x64-code-generation-bug-for-avx2-instruction
+ * s
*/
if (!IsWindows7SP1OrGreater())
{
_set_FMA3_enable(0);
}
-#endif /* defined(_M_AMD64) && _MSC_VER == 1800 */
+#endif /* defined(_M_AMD64) && _MSC_VER == 1800 */
}
#endif /* WIN32 */
return true;
break;
case T_CustomScan:
- foreach (lc, ((CustomScanState *) planstate)->custom_ps)
+ foreach(lc, ((CustomScanState *) planstate)->custom_ps)
{
if (walker((PlanState *) lfirst(lc), context))
return true;
Size
EstimateParamListSpace(ParamListInfo paramLI)
{
- int i;
- Size sz = sizeof(int);
+ int i;
+ Size sz = sizeof(int);
if (paramLI == NULL || paramLI->numParams <= 0)
return sz;
typeOid = prm->ptype;
}
- sz = add_size(sz, sizeof(Oid)); /* space for type OID */
+ sz = add_size(sz, sizeof(Oid)); /* space for type OID */
sz = add_size(sz, sizeof(uint16)); /* space for pflags */
/* space for datum/isnull */
typByVal = true;
}
sz = add_size(sz,
- datumEstimateSpace(prm->value, prm->isnull, typByVal, typLen));
+ datumEstimateSpace(prm->value, prm->isnull, typByVal, typLen));
}
return sz;
READ_BITMAPSET_FIELD(custom_relids);
/* Lookup CustomScanMethods by CustomName */
- token = pg_strtok(&length); /* skip methods: */
- token = pg_strtok(&length); /* CustomName */
+ token = pg_strtok(&length); /* skip methods: */
+ token = pg_strtok(&length); /* CustomName */
custom_name = nullable_string(token, length);
methods = GetCustomScanMethods(custom_name, false);
local_node->methods = methods;
{
const ExtensibleNodeMethods *methods;
ExtensibleNode *local_node;
- const char *extnodename;
+ const char *extnodename;
+
READ_TEMP_LOCALS();
- token = pg_strtok(&length); /* skip: extnodename */
- token = pg_strtok(&length); /* get extnodename */
+ token = pg_strtok(&length); /* skip: extnodename */
+ token = pg_strtok(&length); /* get extnodename */
extnodename = nullable_string(token, length);
if (!extnodename)
set_base_rel_consider_startup(root);
/*
- * Generate access paths for the base rels. set_base_rel_sizes also
- * sets the consider_parallel flag for each baserel, if appropriate.
+ * Generate access paths for the base rels. set_base_rel_sizes also sets
+ * the consider_parallel flag for each baserel, if appropriate.
*/
set_base_rel_sizes(root);
set_base_rel_pathlists(root);
/*
* set_base_rel_sizes
* Set the size estimates (rows and widths) for each base-relation entry.
- * Also determine whether to consider parallel paths for base relations.
+ * Also determine whether to consider parallel paths for base relations.
*
* We do this in a separate pass over the base rels so that rowcount
* estimates are available for parameterized path generation, and also so
switch (rte->rtekind)
{
case RTE_RELATION:
+
/*
* Currently, parallel workers can't access the leader's temporary
* tables. We could possibly relax this if the wrote all of its
*/
if (rte->tablesample != NULL)
{
- Oid proparallel = func_parallel(rte->tablesample->tsmhandler);
+ Oid proparallel = func_parallel(rte->tablesample->tsmhandler);
if (proparallel != PROPARALLEL_SAFE)
return;
break;
case RTE_SUBQUERY:
+
/*
* Subplans currently aren't passed to workers. Even if they
- * were, the subplan might be using parallelism internally, and
- * we can't support nested Gather nodes at present. Finally,
- * we don't have a good way of knowing whether the subplan
- * involves any parallel-restricted operations. It would be
- * nice to relax this restriction some day, but it's going to
- * take a fair amount of work.
+ * were, the subplan might be using parallelism internally, and we
+ * can't support nested Gather nodes at present. Finally, we
+ * don't have a good way of knowing whether the subplan involves
+ * any parallel-restricted operations. It would be nice to relax
+ * this restriction some day, but it's going to take a fair amount
+ * of work.
*/
return;
break;
case RTE_VALUES:
+
/*
* The data for a VALUES clause is stored in the plan tree itself,
* so scanning it in a worker is fine.
break;
case RTE_CTE:
+
/*
* CTE tuplestores aren't shared among parallel workers, so we
* force all CTE scans to happen in the leader. Also, populating
}
/*
- * If there's anything in baserestrictinfo that's parallel-restricted,
- * we give up on parallelizing access to this relation. We could consider
+ * If there's anything in baserestrictinfo that's parallel-restricted, we
+ * give up on parallelizing access to this relation. We could consider
* instead postponing application of the restricted quals until we're
* above all the parallelism in the plan tree, but it's not clear that
* this would be a win in very many cases, and it might be tricky to make
return;
/*
- * If the relation's outputs are not parallel-safe, we must give up.
- * In the common case where the relation only outputs Vars, this check is
+ * If the relation's outputs are not parallel-safe, we must give up. In
+ * the common case where the relation only outputs Vars, this check is
* very cheap; otherwise, we have to do more work.
*/
if (rel->reltarget_has_non_vars &&
int parallel_workers = 0;
/*
- * Decide on the numebr of workers to request for this append path. For
- * now, we just use the maximum value from among the members. It
+ * Decide on the numebr of workers to request for this append path.
+ * For now, we just use the maximum value from among the members. It
* might be useful to use a higher number if the Append node were
* smart enough to spread out the workers, but it currently isn't.
*/
* Run generate_gather_paths() for each just-processed joinrel. We
* could not do this earlier because both regular and partial paths
* can get added to a particular joinrel at multiple times within
- * join_search_one_level. After that, we're done creating paths
- * for the joinrel, so run set_cheapest().
+ * join_search_one_level. After that, we're done creating paths for
+ * the joinrel, so run set_cheapest().
*/
foreach(lc, root->join_rel_level[lev])
{
* We might not really need a Result node here. There are several ways
* that this can happen. For example, MergeAppend doesn't project, so we
* would have thought that we needed a projection to attach resjunk sort
- * columns to its output ... but create_merge_append_plan might have
- * added those same resjunk sort columns to both MergeAppend and its
- * children. Alternatively, apply_projection_to_path might have created
- * a projection path as the subpath of a Gather node even though the
- * subpath was projection-capable. So, if the subpath is capable of
- * projection or the desired tlist is the same expression-wise as the
- * subplan's, just jam it in there. We'll have charged for a Result that
- * doesn't actually appear in the plan, but that's better than having a
- * Result we don't need.
+ * columns to its output ... but create_merge_append_plan might have added
+ * those same resjunk sort columns to both MergeAppend and its children.
+ * Alternatively, apply_projection_to_path might have created a projection
+ * path as the subpath of a Gather node even though the subpath was
+ * projection-capable. So, if the subpath is capable of projection or the
+ * desired tlist is the same expression-wise as the subplan's, just jam it
+ * in there. We'll have charged for a Result that doesn't actually appear
+ * in the plan, but that's better than having a Result we don't need.
*/
if (is_projection_capable_path(best_path->subpath) ||
tlist_same_exprs(tlist, subplan->targetlist))
/*
* If a join between foreign relations was pushed down, remember it. The
* push-down safety of the join depends upon the server and user mapping
- * being same. That can change between planning and execution time, in which
- * case the plan should be invalidated.
+ * being same. That can change between planning and execution time, in
+ * which case the plan should be invalidated.
*/
if (scan_relid == 0)
root->glob->hasForeignJoin = true;
/*
* Replace any outer-relation variables with nestloop params in the qual,
* fdw_exprs and fdw_recheck_quals expressions. We do this last so that
- * the FDW doesn't have to be involved. (Note that parts of fdw_exprs
- * or fdw_recheck_quals could have come from join clauses, so doing this
+ * the FDW doesn't have to be involved. (Note that parts of fdw_exprs or
+ * fdw_recheck_quals could have come from join clauses, so doing this
* beforehand on the scan_clauses wouldn't work.) We assume
* fdw_scan_tlist contains no such variables.
*/
* 0, but there can be no Var with relid 0 in the rel's targetlist or the
* restriction clauses, so we skip this in that case. Note that any such
* columns in base relations that were joined are assumed to be contained
- * in fdw_scan_tlist.) This is a bit of a kluge and might go away someday,
- * so we intentionally leave it out of the API presented to FDWs.
+ * in fdw_scan_tlist.) This is a bit of a kluge and might go away
+ * someday, so we intentionally leave it out of the API presented to FDWs.
*/
scan_plan->fsSystemCol = false;
if (scan_relid > 0)
plan->righttree = NULL;
node->num_workers = nworkers;
node->single_copy = single_copy;
- node->invisible = false;
+ node->invisible = false;
return node;
}
List *rollup_lists,
List *rollup_groupclauses);
static void set_grouped_rel_consider_parallel(PlannerInfo *root,
- RelOptInfo *grouped_rel,
- PathTarget *target);
+ RelOptInfo *grouped_rel,
+ PathTarget *target);
static Size estimate_hashagg_tablesize(Path *path, AggClauseCosts *agg_costs,
- double dNumGroups);
+ double dNumGroups);
static RelOptInfo *create_grouping_paths(PlannerInfo *root,
RelOptInfo *input_rel,
PathTarget *target,
static PathTarget *make_group_input_target(PlannerInfo *root,
PathTarget *final_target);
static PathTarget *make_partialgroup_input_target(PlannerInfo *root,
- PathTarget *final_target);
+ PathTarget *final_target);
static List *postprocess_setop_tlist(List *new_tlist, List *orig_tlist);
static List *select_active_windows(PlannerInfo *root, WindowFuncLists *wflists);
static PathTarget *make_window_input_target(PlannerInfo *root,
* findable from the PlannerInfo struct; anything else the FDW wants
* to know should be obtainable via "root".
*
- * Note: CustomScan providers, as well as FDWs that don't want to
- * use this hook, can use the create_upper_paths_hook; see below.
+ * Note: CustomScan providers, as well as FDWs that don't want to use
+ * this hook, can use the create_upper_paths_hook; see below.
*/
if (current_rel->fdwroutine &&
current_rel->fdwroutine->GetForeignUpperPaths)
/*
* All that's left to check now is to make sure all aggregate functions
- * support partial mode. If there's no aggregates then we can skip checking
- * that.
+ * support partial mode. If there's no aggregates then we can skip
+ * checking that.
*/
if (!parse->hasAggs)
grouped_rel->consider_parallel = true;
/*
* Determine whether it's possible to perform sort-based implementations
- * of grouping. (Note that if groupClause is empty, grouping_is_sortable()
- * is trivially true, and all the pathkeys_contained_in() tests will
- * succeed too, so that we'll consider every surviving input path.)
+ * of grouping. (Note that if groupClause is empty,
+ * grouping_is_sortable() is trivially true, and all the
+ * pathkeys_contained_in() tests will succeed too, so that we'll consider
+ * every surviving input path.)
*/
can_sort = grouping_is_sortable(parse->groupClause);
*/
if (grouped_rel->consider_parallel)
{
- Path *cheapest_partial_path = linitial(input_rel->partial_pathlist);
+ Path *cheapest_partial_path = linitial(input_rel->partial_pathlist);
/*
* Build target list for partial aggregate paths. We cannot reuse the
if (parse->hasAggs)
add_partial_path(grouped_rel, (Path *)
- create_agg_path(root,
- grouped_rel,
- path,
- partial_grouping_target,
- parse->groupClause ? AGG_SORTED : AGG_PLAIN,
- parse->groupClause,
- NIL,
- &agg_partial_costs,
- dNumPartialGroups,
- false,
- false,
- true));
+ create_agg_path(root,
+ grouped_rel,
+ path,
+ partial_grouping_target,
+ parse->groupClause ? AGG_SORTED : AGG_PLAIN,
+ parse->groupClause,
+ NIL,
+ &agg_partial_costs,
+ dNumPartialGroups,
+ false,
+ false,
+ true));
else
add_partial_path(grouped_rel, (Path *)
- create_group_path(root,
- grouped_rel,
- path,
- partial_grouping_target,
- parse->groupClause,
- NIL,
- dNumPartialGroups));
+ create_group_path(root,
+ grouped_rel,
+ path,
+ partial_grouping_target,
+ parse->groupClause,
+ NIL,
+ dNumPartialGroups));
}
}
}
if (hashaggtablesize < work_mem * 1024L)
{
add_partial_path(grouped_rel, (Path *)
- create_agg_path(root,
- grouped_rel,
- cheapest_partial_path,
- partial_grouping_target,
- AGG_HASHED,
- parse->groupClause,
- NIL,
- &agg_partial_costs,
- dNumPartialGroups,
- false,
- false,
- true));
+ create_agg_path(root,
+ grouped_rel,
+ cheapest_partial_path,
+ partial_grouping_target,
+ AGG_HASHED,
+ parse->groupClause,
+ NIL,
+ &agg_partial_costs,
+ dNumPartialGroups,
+ false,
+ false,
+ true));
}
}
}
/*
* Now generate a complete GroupAgg Path atop of the cheapest partial
- * path. We need only bother with the cheapest path here, as the output
- * of Gather is never sorted.
+ * path. We need only bother with the cheapest path here, as the
+ * output of Gather is never sorted.
*/
if (grouped_rel->partial_pathlist)
{
- Path *path = (Path *) linitial(grouped_rel->partial_pathlist);
- double total_groups = path->rows * path->parallel_workers;
+ Path *path = (Path *) linitial(grouped_rel->partial_pathlist);
+ double total_groups = path->rows * path->parallel_workers;
path = (Path *) create_gather_path(root,
grouped_rel,
&total_groups);
/*
- * Gather is always unsorted, so we'll need to sort, unless there's
- * no GROUP BY clause, in which case there will only be a single
- * group.
+ * Gather is always unsorted, so we'll need to sort, unless
+ * there's no GROUP BY clause, in which case there will only be a
+ * single group.
*/
if (parse->groupClause)
path = (Path *) create_sort_path(root,
if (parse->hasAggs)
add_path(grouped_rel, (Path *)
- create_agg_path(root,
- grouped_rel,
- path,
- target,
- parse->groupClause ? AGG_SORTED : AGG_PLAIN,
- parse->groupClause,
- (List *) parse->havingQual,
- &agg_final_costs,
- dNumGroups,
- true,
- true,
- true));
+ create_agg_path(root,
+ grouped_rel,
+ path,
+ target,
+ parse->groupClause ? AGG_SORTED : AGG_PLAIN,
+ parse->groupClause,
+ (List *) parse->havingQual,
+ &agg_final_costs,
+ dNumGroups,
+ true,
+ true,
+ true));
else
add_path(grouped_rel, (Path *)
- create_group_path(root,
- grouped_rel,
- path,
- target,
- parse->groupClause,
- (List *) parse->havingQual,
- dNumGroups));
+ create_group_path(root,
+ grouped_rel,
+ path,
+ target,
+ parse->groupClause,
+ (List *) parse->havingQual,
+ dNumGroups));
}
}
/*
* Provided that the estimated size of the hashtable does not exceed
* work_mem, we'll generate a HashAgg Path, although if we were unable
- * to sort above, then we'd better generate a Path, so that we at least
- * have one.
+ * to sort above, then we'd better generate a Path, so that we at
+ * least have one.
*/
if (hashaggtablesize < work_mem * 1024L ||
grouped_rel->pathlist == NIL)
{
/*
- * We just need an Agg over the cheapest-total input path, since input
- * order won't matter.
+ * We just need an Agg over the cheapest-total input path, since
+ * input order won't matter.
*/
add_path(grouped_rel, (Path *)
create_agg_path(root, grouped_rel,
/*
* Generate a HashAgg Path atop of the cheapest partial path. Once
- * again, we'll only do this if it looks as though the hash table won't
- * exceed work_mem.
+ * again, we'll only do this if it looks as though the hash table
+ * won't exceed work_mem.
*/
if (grouped_rel->partial_pathlist)
{
- Path *path = (Path *) linitial(grouped_rel->partial_pathlist);
+ Path *path = (Path *) linitial(grouped_rel->partial_pathlist);
hashaggtablesize = estimate_hashagg_tablesize(path,
&agg_final_costs,
if (hashaggtablesize < work_mem * 1024L)
{
- double total_groups = path->rows * path->parallel_workers;
+ double total_groups = path->rows * path->parallel_workers;
path = (Path *) create_gather_path(root,
grouped_rel,
&total_groups);
add_path(grouped_rel, (Path *)
- create_agg_path(root,
- grouped_rel,
- path,
- target,
- AGG_HASHED,
- parse->groupClause,
- (List *) parse->havingQual,
- &agg_final_costs,
- dNumGroups,
- true,
- true,
- true));
+ create_agg_path(root,
+ grouped_rel,
+ path,
+ target,
+ AGG_HASHED,
+ parse->groupClause,
+ (List *) parse->havingQual,
+ &agg_final_costs,
+ dNumGroups,
+ true,
+ true,
+ true));
}
}
}
continue;
if (aggref->aggvariadic != tlistaggref->aggvariadic)
continue;
+
/*
* it would be harmless to compare aggcombine and aggpartial, but
* it's also unnecessary
} has_parallel_hazard_arg;
static bool aggregates_allow_partial_walker(Node *node,
- partial_agg_context *context);
+ partial_agg_context *context);
static bool contain_agg_clause_walker(Node *node, void *context);
static bool count_agg_clauses_walker(Node *node,
count_agg_clauses_context *context);
static bool contain_volatile_functions_walker(Node *node, void *context);
static bool contain_volatile_functions_not_nextval_walker(Node *node, void *context);
static bool has_parallel_hazard_walker(Node *node,
- has_parallel_hazard_arg *context);
+ has_parallel_hazard_arg *context);
static bool parallel_too_dangerous(char proparallel,
- has_parallel_hazard_arg *context);
+ has_parallel_hazard_arg *context);
static bool typeid_is_temp(Oid typeid);
static bool contain_nonstrict_functions_walker(Node *node, void *context);
static bool contain_leaked_vars_walker(Node *node, void *context);
if (aggref->aggdistinct || aggref->aggorder)
{
context->allowedtype = PAT_DISABLED;
- return true; /* abort search */
+ return true; /* abort search */
}
aggTuple = SearchSysCache1(AGGFNOID,
ObjectIdGetDatum(aggref->aggfnoid));
{
ReleaseSysCache(aggTuple);
context->allowedtype = PAT_DISABLED;
- return true; /* abort search */
+ return true; /* abort search */
}
/*
context->allowedtype = PAT_INTERNAL_ONLY;
ReleaseSysCache(aggTuple);
- return false; /* continue searching */
+ return false; /* continue searching */
}
return expression_tree_walker(node, aggregates_allow_partial_walker,
(void *) context);
bool
has_parallel_hazard(Node *node, bool allow_restricted)
{
- has_parallel_hazard_arg context;
+ has_parallel_hazard_arg context;
context.allow_restricted = allow_restricted;
return has_parallel_hazard_walker(node, &context);
* recurse through Query objects to as to locate parallel-unsafe
* constructs anywhere in the tree.
*
- * Later, we'll be called again for specific quals, possibly after
- * some planning has been done, we may encounter SubPlan, SubLink,
- * or AlternativeSubLink nodes. Currently, there's no need to recurse
- * through these; they can't be unsafe, since we've already cleared
- * the entire query of unsafe operations, and they're definitely
+ * Later, we'll be called again for specific quals, possibly after some
+ * planning has been done, we may encounter SubPlan, SubLink, or
+ * AlternativeSubLink nodes. Currently, there's no need to recurse
+ * through these; they can't be unsafe, since we've already cleared the
+ * entire query of unsafe operations, and they're definitely
* parallel-restricted.
*/
if (IsA(node, Query))
{
- Query *query = (Query *) node;
+ Query *query = (Query *) node;
if (query->rowMarks != NULL)
return true;
has_parallel_hazard_walker,
context, 0);
}
- else if (IsA(node, SubPlan) || IsA(node, SubLink) ||
- IsA(node, AlternativeSubPlan) || IsA(node, Param))
+ else if (IsA(node, SubPlan) ||IsA(node, SubLink) ||
+ IsA(node, AlternativeSubPlan) ||IsA(node, Param))
{
/*
- * Since we don't have the ability to push subplans down to workers
- * at present, we treat subplan references as parallel-restricted.
+ * Since we don't have the ability to push subplans down to workers at
+ * present, we treat subplan references as parallel-restricted.
*/
if (!context->allow_restricted)
return true;
if (IsA(node, RestrictInfo))
{
RestrictInfo *rinfo = (RestrictInfo *) node;
+
return has_parallel_hazard_walker((Node *) rinfo->clause, context);
}
/*
* It is an error for a parallel worker to touch a temporary table in any
- * way, so we can't handle nodes whose type is the rowtype of such a table.
+ * way, so we can't handle nodes whose type is the rowtype of such a
+ * table.
*/
if (!context->allow_restricted)
{
foreach(opid, rcexpr->opnos)
{
- Oid opfuncid = get_opcode(lfirst_oid(opid));
+ Oid opfuncid = get_opcode(lfirst_oid(opid));
+
if (parallel_too_dangerous(func_parallel(opfuncid), context))
return true;
}
static bool
typeid_is_temp(Oid typeid)
{
- Oid relid = get_typ_typrelid(typeid);
+ Oid relid = get_typ_typrelid(typeid);
if (!OidIsValid(relid))
return false;
/*
* WHERE CURRENT OF doesn't contain function calls. Moreover, it
* is important that this can be pushed down into a
- * security_barrier view, since the planner must always generate
- * a TID scan when CURRENT OF is present -- c.f. cost_tidscan.
+ * security_barrier view, since the planner must always generate a
+ * TID scan when CURRENT OF is present -- c.f. cost_tidscan.
*/
return false;
AttrNumber natt;
Oid inferopfamily = InvalidOid; /* OID of opclass opfamily */
Oid inferopcinputtype = InvalidOid; /* OID of opclass input type */
- int nplain = 0; /* # plain attrs observed */
+ int nplain = 0; /* # plain attrs observed */
/*
* If inference specification element lacks collation/opclass, then no
rel->consider_startup = (root->tuple_fraction > 0);
rel->consider_param_startup = false; /* might get changed later */
rel->consider_parallel = false; /* might get changed later */
- rel->rel_parallel_workers = -1; /* set up in GetRelationInfo */
+ rel->rel_parallel_workers = -1; /* set up in GetRelationInfo */
rel->reltarget = create_empty_pathtarget();
rel->reltarget_has_non_vars = false;
rel->pathlist = NIL;
void
apply_partialaggref_adjustment(PathTarget *target)
{
- ListCell *lc;
+ ListCell *lc;
foreach(lc, target->exprs)
{
- Aggref *aggref = (Aggref *) lfirst(lc);
+ Aggref *aggref = (Aggref *) lfirst(lc);
if (IsA(aggref, Aggref))
{
errmsg("column %s.%s does not exist", relname, colname) :
errmsg("column \"%s\" does not exist", colname),
state->rfirst ? closestfirst ?
- errhint("Perhaps you meant to reference the column \"%s.%s\".",
- state->rfirst->eref->aliasname, closestfirst) :
+ errhint("Perhaps you meant to reference the column \"%s.%s\".",
+ state->rfirst->eref->aliasname, closestfirst) :
errhint("There is a column named \"%s\" in table \"%s\", but it cannot be referenced from this part of the query.",
colname, state->rfirst->eref->aliasname) : 0,
parser_errposition(pstate, location)));
bool skipValidation,
bool isAddConstraint);
static void transformCheckConstraints(CreateStmtContext *cxt,
- bool skipValidation);
+ bool skipValidation);
static void transformConstraintAttrs(CreateStmtContext *cxt,
List *constraintList);
static void transformColumnType(CreateStmtContext *cxt, ColumnDef *column);
if (like_found)
{
/*
- * To match INHERITS, the existence of any LIKE table with OIDs
- * causes the new table to have oids. For the same reason,
- * WITH/WITHOUT OIDs is also ignored with LIKE. We prepend
- * because the first oid option list entry is honored. Our
- * prepended WITHOUT OIDS clause will be overridden if an
- * inherited table has oids.
+ * To match INHERITS, the existence of any LIKE table with OIDs causes
+ * the new table to have oids. For the same reason, WITH/WITHOUT OIDs
+ * is also ignored with LIKE. We prepend because the first oid option
+ * list entry is honored. Our prepended WITHOUT OIDS clause will be
+ * overridden if an inherited table has oids.
*/
stmt->options = lcons(makeDefElem("oids",
- (Node *)makeInteger(cxt.hasoids)), stmt->options);
+ (Node *) makeInteger(cxt.hasoids)), stmt->options);
}
foreach(elements, stmt->tableElts)
if (nodeTag(element) == T_Constraint)
transformTableConstraint(&cxt, (Constraint *) element);
}
+
/*
* transformIndexConstraints wants cxt.alist to contain only index
* statements, so transfer anything we already have into save_alist.
/*
* If creating a new table, we can safely skip validation of check
- * constraints, and nonetheless mark them valid. (This will override
- * any user-supplied NOT VALID flag.)
+ * constraints, and nonetheless mark them valid. (This will override any
+ * user-supplied NOT VALID flag.)
*/
if (skipValidation)
{
*
* We use kill(0) for the fallback barrier as we assume that kernels on
* systems old enough to require fallback barrier support will include an
- * appropriate barrier while checking the existence of the postmaster
- * pid.
+ * appropriate barrier while checking the existence of the postmaster pid.
*/
(void) kill(PostmasterPid, 0);
}
* wi_links entry into free list or running list
* wi_dboid OID of the database this worker is supposed to work on
* wi_tableoid OID of the table currently being vacuumed, if any
- * wi_sharedrel flag indicating whether table is marked relisshared
+ * wi_sharedrel flag indicating whether table is marked relisshared
* wi_proc pointer to PGPROC of the running worker, NULL if not started
* wi_launchtime Time at which this worker was launched
* wi_cost_* Vacuum cost-based delay parameters current in this worker
/*
* There are some conditions that we need to check before trying to
- * start a worker. First, we need to make sure that there is a
- * worker slot available. Second, we need to make sure that no
- * other worker failed while starting up.
+ * start a worker. First, we need to make sure that there is a worker
+ * slot available. Second, we need to make sure that no other worker
+ * failed while starting up.
*/
current_time = GetCurrentTimestamp();
beentry->st_activity[pgstat_track_activity_query_size - 1] = '\0';
beentry->st_progress_command = PROGRESS_COMMAND_INVALID;
beentry->st_progress_command_target = InvalidOid;
+
/*
* we don't zero st_progress_param here to save cycles; nobody should
* examine it until st_progress_command has been set to something other
const int64 *val)
{
volatile PgBackendStatus *beentry = MyBEEntry;
- int i;
+ int i;
if (!beentry || !pgstat_track_activities || nparam == 0)
return;
RemovePgTempFiles();
/*
- * Forcibly remove the files signaling a standby promotion
- * request. Otherwise, the existence of those files triggers
- * a promotion too early, whether a user wants that or not.
+ * Forcibly remove the files signaling a standby promotion request.
+ * Otherwise, the existence of those files triggers a promotion too early,
+ * whether a user wants that or not.
*
- * This removal of files is usually unnecessary because they
- * can exist only during a few moments during a standby
- * promotion. However there is a race condition: if pg_ctl promote
- * is executed and creates the files during a promotion,
- * the files can stay around even after the server is brought up
- * to new master. Then, if new standby starts by using the backup
- * taken from that master, the files can exist at the server
+ * This removal of files is usually unnecessary because they can exist
+ * only during a few moments during a standby promotion. However there is
+ * a race condition: if pg_ctl promote is executed and creates the files
+ * during a promotion, the files can stay around even after the server is
+ * brought up to new master. Then, if new standby starts by using the
+ * backup taken from that master, the files can exist at the server
* startup and should be removed in order to avoid an unexpected
* promotion.
*
- * Note that promotion signal files need to be removed before
- * the startup process is invoked. Because, after that, they can
- * be used by postmaster's SIGUSR1 signal handler.
+ * Note that promotion signal files need to be removed before the startup
+ * process is invoked. Because, after that, they can be used by
+ * postmaster's SIGUSR1 signal handler.
*/
RemovePromoteSignalFiles();
else if (!parse_bool(valptr, &am_walsender))
ereport(FATAL,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid value for parameter \"%s\": \"%s\"",
- "replication",
- valptr),
+ errmsg("invalid value for parameter \"%s\": \"%s\"",
+ "replication",
+ valptr),
errhint("Valid values are: \"false\", 0, \"true\", 1, \"database\".")));
}
else
if (pmState == PM_RECOVERY)
{
SignalSomeChildren(SIGTERM, BACKEND_TYPE_BGWORKER);
+
/*
* Only startup, bgwriter, walreceiver, possibly bgworkers,
* and/or checkpointer should be active in this state; we just
/*
* It's possible that this background worker started some OTHER
- * background worker and asked to be notified when that worker
- * started or stopped. If so, cancel any notifications destined
- * for the now-dead backend.
+ * background worker and asked to be notified when that worker started
+ * or stopped. If so, cancel any notifications destined for the
+ * now-dead backend.
*/
if (rw->rw_backend->bgworker_notify)
BackgroundWorkerStopNotifications(rw->rw_pid);
rw->rw_crashed_at = 0;
/*
- * Allocate and assign the Backend element. Note we
- * must do this before forking, so that we can handle out of
- * memory properly.
+ * Allocate and assign the Backend element. Note we must do this
+ * before forking, so that we can handle out of memory properly.
*/
if (!assign_backendlist_entry(rw))
return;
TimeLineID starttli;
XLogRecPtr endptr;
TimeLineID endtli;
- StringInfo labelfile;
- StringInfo tblspc_map_file = NULL;
+ StringInfo labelfile;
+ StringInfo tblspc_map_file = NULL;
int datadirpathlen;
List *tablespaces = NIL;
case XLOG_INVALIDATIONS:
{
xl_invalidations *invalidations =
- (xl_invalidations *) XLogRecGetData(r);
+ (xl_invalidations *) XLogRecGetData(r);
ReorderBufferImmediateInvalidation(
ctx->reorder, invalidations->nmsgs, invalidations->msgs);
static void
DecodeLogicalMsgOp(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
{
- SnapBuild *builder = ctx->snapshot_builder;
+ SnapBuild *builder = ctx->snapshot_builder;
XLogReaderState *r = buf->record;
- TransactionId xid = XLogRecGetXid(r);
- uint8 info = XLogRecGetInfo(r) & ~XLR_INFO_MASK;
- RepOriginId origin_id = XLogRecGetOrigin(r);
- Snapshot snapshot;
+ TransactionId xid = XLogRecGetXid(r);
+ uint8 info = XLogRecGetInfo(r) & ~XLR_INFO_MASK;
+ RepOriginId origin_id = XLogRecGetOrigin(r);
+ Snapshot snapshot;
xl_logical_message *message;
if (info != XLOG_LOGICAL_MESSAGE)
snapshot = SnapBuildGetOrBuildSnapshot(builder, xid);
ReorderBufferQueueMessage(ctx->reorder, xid, snapshot, buf->endptr,
message->transactional,
- message->message, /* first part of message is prefix */
+ message->message, /* first part of message is
+ * prefix */
message->message_size,
message->message + message->prefix_size);
}
xl_xact_parsed_commit *parsed, TransactionId xid)
{
XLogRecPtr origin_lsn = InvalidXLogRecPtr;
- TimestampTz commit_time = parsed->xact_time;
- RepOriginId origin_id = XLogRecGetOrigin(buf->record);
+ TimestampTz commit_time = parsed->xact_time;
+ RepOriginId origin_id = XLogRecGetOrigin(buf->record);
int i;
if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
static void change_cb_wrapper(ReorderBuffer *cache, ReorderBufferTXN *txn,
Relation relation, ReorderBufferChange *change);
static void message_cb_wrapper(ReorderBuffer *cache, ReorderBufferTXN *txn,
- XLogRecPtr message_lsn, bool transactional,
- const char *prefix, Size message_size, const char *message);
+ XLogRecPtr message_lsn, bool transactional,
+ const char *prefix, Size message_size, const char *message);
static void LoadOutputPlugin(OutputPluginCallbacks *callbacks, char *plugin);
LogLogicalMessage(const char *prefix, const char *message, size_t size,
bool transactional)
{
- xl_logical_message xlrec;
+ xl_logical_message xlrec;
/*
* Force xid to be allocated if we're emitting a transactional message.
uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
if (info != XLOG_LOGICAL_MESSAGE)
- elog(PANIC, "logicalmsg_redo: unknown op code %u", info);
+ elog(PANIC, "logicalmsg_redo: unknown op code %u", info);
/* This is only interesting for logical decoding, see decode.c. */
}
} ReplicationStateCtl;
/* external variables */
-RepOriginId replorigin_session_origin = InvalidRepOriginId; /* assumed identity */
+RepOriginId replorigin_session_origin = InvalidRepOriginId; /* assumed identity */
XLogRecPtr replorigin_session_origin_lsn = InvalidXLogRecPtr;
TimestampTz replorigin_session_origin_timestamp = 0;
}
else
{
- ReorderBufferTXN *txn = NULL;
- volatile Snapshot snapshot_now = snapshot;
+ ReorderBufferTXN *txn = NULL;
+ volatile Snapshot snapshot_now = snapshot;
if (xid != InvalidTransactionId)
txn = ReorderBufferTXNByXid(rb, xid, true, NULL, lsn, true);
BeginInternalSubTransaction("replay");
/*
- * Force invalidations to happen outside of a valid transaction - that
- * way entries will just be marked as invalid without accessing the
- * catalog. That's advantageous because we don't need to setup the
- * full state necessary for catalog access.
+ * Force invalidations to happen outside of a valid transaction - that way
+ * entries will just be marked as invalid without accessing the catalog.
+ * That's advantageous because we don't need to setup the full state
+ * necessary for catalog access.
*/
if (use_subtxn)
AbortCurrentTransaction();
change->data.msg.prefix = MemoryContextAlloc(rb->context,
prefix_size);
memcpy(change->data.msg.prefix, data, prefix_size);
- Assert(change->data.msg.prefix[prefix_size-1] == '\0');
+ Assert(change->data.msg.prefix[prefix_size - 1] == '\0');
data += prefix_size;
/* read the messsage */
memcpy(&change->data.msg.message_size, data, sizeof(Size));
data += sizeof(Size);
change->data.msg.message = MemoryContextAlloc(rb->context,
- change->data.msg.message_size);
+ change->data.msg.message_size);
memcpy(change->data.msg.message, data,
change->data.msg.message_size);
data += change->data.msg.message_size;
ReplicationSlotValidateName(name, ERROR);
/*
- * If some other backend ran this code concurrently with us, we'd likely both
- * allocate the same slot, and that would be bad. We'd also be at risk of
- * missing a name collision. Also, we don't want to try to create a new
- * slot while somebody's busy cleaning up an old one, because we might
- * both be monkeying with the same directory.
+ * If some other backend ran this code concurrently with us, we'd likely
+ * both allocate the same slot, and that would be bad. We'd also be at
+ * risk of missing a name collision. Also, we don't want to try to create
+ * a new slot while somebody's busy cleaning up an old one, because we
+ * might both be monkeying with the same directory.
*/
LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE);
if (active_pid != 0)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_IN_USE),
- errmsg("replication slot \"%s\" is active for PID %d",
- name, active_pid)));
+ errmsg("replication slot \"%s\" is active for PID %d",
+ name, active_pid)));
/* We made this slot active, so it's ours now. */
MyReplicationSlot = slot;
ReplicationSlotMarkDirty(void)
{
ReplicationSlot *slot = MyReplicationSlot;
+
Assert(MyReplicationSlot != NULL);
SpinLockAcquire(&slot->mutex);
pg_create_physical_replication_slot(PG_FUNCTION_ARGS)
{
Name name = PG_GETARG_NAME(0);
- bool immediately_reserve = PG_GETARG_BOOL(1);
+ bool immediately_reserve = PG_GETARG_BOOL(1);
Datum values[2];
bool nulls[2];
TupleDesc tupdesc;
static int SyncRepWakeQueue(bool all, int mode);
static bool SyncRepGetOldestSyncRecPtr(XLogRecPtr *writePtr,
- XLogRecPtr *flushPtr,
- XLogRecPtr *applyPtr,
- bool *am_sync);
+ XLogRecPtr *flushPtr,
+ XLogRecPtr *applyPtr,
+ bool *am_sync);
static int SyncRepGetStandbyPriority(void);
#ifdef USE_ASSERT_CHECKING
/*
* If a wait for synchronous replication is pending, we can neither
* acknowledge the commit nor raise ERROR or FATAL. The latter would
- * lead the client to believe that the transaction aborted, which
- * is not true: it's already committed locally. The former is no good
+ * lead the client to believe that the transaction aborted, which is
+ * not true: it's already committed locally. The former is no good
* either: the client has requested synchronous replication, and is
* entitled to assume that an acknowledged commit is also replicated,
* which might not be true. So in this case we issue a WARNING (which
/*
* If this WALSender is serving a standby that is not on the list of
* potential sync standbys then we have nothing to do. If we are still
- * starting up, still running base backup or the current flush position
- * is still invalid, then leave quickly also.
+ * starting up, still running base backup or the current flush position is
+ * still invalid, then leave quickly also.
*/
if (MyWalSnd->sync_standby_priority == 0 ||
MyWalSnd->state < WALSNDSTATE_STREAMING ||
}
/*
- * We're a potential sync standby. Release waiters if there are
- * enough sync standbys and we are considered as sync.
+ * We're a potential sync standby. Release waiters if there are enough
+ * sync standbys and we are considered as sync.
*/
LWLockAcquire(SyncRepLock, LW_EXCLUSIVE);
/*
- * Check whether we are a sync standby or not, and calculate
- * the oldest positions among all sync standbys.
+ * Check whether we are a sync standby or not, and calculate the oldest
+ * positions among all sync standbys.
*/
got_oldest = SyncRepGetOldestSyncRecPtr(&writePtr, &flushPtr,
&applyPtr, &am_sync);
/*
- * If we are managing a sync standby, though we weren't
- * prior to this, then announce we are now a sync standby.
+ * If we are managing a sync standby, though we weren't prior to this,
+ * then announce we are now a sync standby.
*/
if (announce_next_takeover && am_sync)
{
SyncRepGetOldestSyncRecPtr(XLogRecPtr *writePtr, XLogRecPtr *flushPtr,
XLogRecPtr *applyPtr, bool *am_sync)
{
- List *sync_standbys;
- ListCell *cell;
+ List *sync_standbys;
+ ListCell *cell;
*writePtr = InvalidXLogRecPtr;
*flushPtr = InvalidXLogRecPtr;
}
/*
- * Scan through all sync standbys and calculate the oldest
- * Write, Flush and Apply positions.
+ * Scan through all sync standbys and calculate the oldest Write, Flush
+ * and Apply positions.
*/
- foreach (cell, sync_standbys)
+ foreach(cell, sync_standbys)
{
- WalSnd *walsnd = &WalSndCtl->walsnds[lfirst_int(cell)];
+ WalSnd *walsnd = &WalSndCtl->walsnds[lfirst_int(cell)];
XLogRecPtr write;
XLogRecPtr flush;
XLogRecPtr apply;
List *
SyncRepGetSyncStandbys(bool *am_sync)
{
- List *result = NIL;
- List *pending = NIL;
- int lowest_priority;
- int next_highest_priority;
- int this_priority;
- int priority;
- int i;
- bool am_in_pending = false;
- volatile WalSnd *walsnd; /* Use volatile pointer to prevent
- * code rearrangement */
+ List *result = NIL;
+ List *pending = NIL;
+ int lowest_priority;
+ int next_highest_priority;
+ int this_priority;
+ int priority;
+ int i;
+ bool am_in_pending = false;
+ volatile WalSnd *walsnd; /* Use volatile pointer to prevent code
+ * rearrangement */
/* Set default result */
if (am_sync != NULL)
next_highest_priority = lowest_priority + 1;
/*
- * Find the sync standbys which have the highest priority (i.e, 1).
- * Also store all the other potential sync standbys into the pending list,
- * in order to scan it later and find other sync standbys from it quickly.
+ * Find the sync standbys which have the highest priority (i.e, 1). Also
+ * store all the other potential sync standbys into the pending list, in
+ * order to scan it later and find other sync standbys from it quickly.
*/
for (i = 0; i < max_wal_senders; i++)
{
continue;
/*
- * If the priority is equal to 1, consider this standby as sync
- * and append it to the result. Otherwise append this standby
- * to the pending list to check if it's actually sync or not later.
+ * If the priority is equal to 1, consider this standby as sync and
+ * append it to the result. Otherwise append this standby to the
+ * pending list to check if it's actually sync or not later.
*/
if (this_priority == 1)
{
if (list_length(result) == SyncRepConfig->num_sync)
{
list_free(pending);
- return result; /* Exit if got enough sync standbys */
+ return result; /* Exit if got enough sync standbys */
}
}
else
/*
* Track the highest priority among the standbys in the pending
- * list, in order to use it as the starting priority for later scan
- * of the list. This is useful to find quickly the sync standbys
- * from the pending list later because we can skip unnecessary
- * scans for the unused priorities.
+ * list, in order to use it as the starting priority for later
+ * scan of the list. This is useful to find quickly the sync
+ * standbys from the pending list later because we can skip
+ * unnecessary scans for the unused priorities.
*/
if (this_priority < next_highest_priority)
next_highest_priority = this_priority;
priority = next_highest_priority;
while (priority <= lowest_priority)
{
- ListCell *cell;
- ListCell *prev = NULL;
- ListCell *next;
+ ListCell *cell;
+ ListCell *prev = NULL;
+ ListCell *next;
next_highest_priority = lowest_priority + 1;
/*
* We should always exit here after the scan of pending list
- * starts because we know that the list has enough elements
- * to reach SyncRepConfig->num_sync.
+ * starts because we know that the list has enough elements to
+ * reach SyncRepConfig->num_sync.
*/
if (list_length(result) == SyncRepConfig->num_sync)
{
}
/*
- * Remove the entry for this sync standby from the list
- * to prevent us from looking at the same entry again.
+ * Remove the entry for this sync standby from the list to
+ * prevent us from looking at the same entry again.
*/
pending = list_delete_cell(pending, cell, prev);
*/
Assert(wait_fd != PGINVALID_SOCKET);
rc = WaitLatchOrSocket(&walrcv->latch,
- WL_POSTMASTER_DEATH | WL_SOCKET_READABLE |
+ WL_POSTMASTER_DEATH | WL_SOCKET_READABLE |
WL_TIMEOUT | WL_LATCH_SET,
wait_fd,
NAPTIME_PER_CYCLE);
/*
* The recovery process has asked us to send apply
* feedback now. Make sure the flag is really set to
- * false in shared memory before sending the reply,
- * so we don't miss a new request for a reply.
+ * false in shared memory before sending the reply, so
+ * we don't miss a new request for a reply.
*/
walrcv->force_reply = false;
pg_memory_barrier();
TimeLineID receive_start_tli;
XLogRecPtr received_lsn;
TimeLineID received_tli;
- TimestampTz last_send_time;
- TimestampTz last_receipt_time;
+ TimestampTz last_send_time;
+ TimestampTz last_receipt_time;
XLogRecPtr latest_end_lsn;
- TimestampTz latest_end_time;
+ TimestampTz latest_end_time;
char *slotname;
/* No WAL receiver, just return a tuple with NULL values */
if (!superuser())
{
/*
- * Only superusers can see details. Other users only get the pid
- * value to know whether it is a WAL receiver, but no details.
+ * Only superusers can see details. Other users only get the pid value
+ * to know whether it is a WAL receiver, but no details.
*/
MemSet(&nulls[1], true, PG_STAT_GET_WAL_RECEIVER_COLS - 1);
}
/* Returns the record as Datum */
PG_RETURN_DATUM(HeapTupleGetDatum(
- heap_form_tuple(tupdesc, values, nulls)));
+ heap_form_tuple(tupdesc, values, nulls)));
}
pq_beginmessage(&buf, 'D');
pq_sendint(&buf, 2, 2); /* # of columns */
len = strlen(histfname);
- pq_sendint(&buf, len, 4); /* col1 len */
+ pq_sendint(&buf, len, 4); /* col1 len */
pq_sendbytes(&buf, histfname, len);
fd = OpenTransientFile(path, O_RDONLY | PG_BINARY, 0666);
/* Initialize shared memory status, too */
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
SpinLockAcquire(&walsnd->mutex);
walsnd->sentPtr = sentPtr;
pq_sendint(&buf, 2, 2); /* number of columns */
len = strlen(tli_str);
- pq_sendint(&buf, len, 4); /* length */
+ pq_sendint(&buf, len, 4); /* length */
pq_sendbytes(&buf, tli_str, len);
len = strlen(startpos_str);
/* slot_name */
len = strlen(NameStr(MyReplicationSlot->data.name));
- pq_sendint(&buf, len, 4); /* col1 len */
+ pq_sendint(&buf, len, 4); /* col1 len */
pq_sendbytes(&buf, NameStr(MyReplicationSlot->data.name), len);
/* consistent wal location */
/* Also update the sent position status in shared memory */
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
SpinLockAcquire(&walsnd->mutex);
walsnd->sentPtr = MyReplicationSlot->data.restart_lsn;
* standby.
*/
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
SpinLockAcquire(&walsnd->mutex);
walsnd->write = writePtr;
*/
for (i = 0; i < max_wal_senders; i++)
{
- WalSnd *walsnd = &WalSndCtl->walsnds[i];
+ WalSnd *walsnd = &WalSndCtl->walsnds[i];
SpinLockAcquire(&walsnd->mutex);
*/
if (am_cascading_walsender)
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
bool reload;
SpinLockAcquire(&walsnd->mutex);
/* Update shared memory status */
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
SpinLockAcquire(&walsnd->mutex);
walsnd->sentPtr = sentPtr;
/* Update shared memory status */
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
SpinLockAcquire(&walsnd->mutex);
walsnd->sentPtr = sentPtr;
for (i = 0; i < max_wal_senders; i++)
{
- WalSnd *walsnd = &WalSndCtl->walsnds[i];
+ WalSnd *walsnd = &WalSndCtl->walsnds[i];
if (walsnd->pid == 0)
continue;
void
WalSndSetState(WalSndState state)
{
- WalSnd *walsnd = MyWalSnd;
+ WalSnd *walsnd = MyWalSnd;
Assert(am_walsender);
for (i = 0; i < max_wal_senders; i++)
{
- WalSnd *walsnd = &WalSndCtl->walsnds[i];
+ WalSnd *walsnd = &WalSndCtl->walsnds[i];
XLogRecPtr sentPtr;
XLogRecPtr write;
XLogRecPtr flush;
* any triggers, indexes, child tables, policies, or RLS enabled.
* (Note: these tests are too strict, because they will reject
* relations that once had such but don't anymore. But we don't
- * really care, because this whole business of converting relations
- * to views is just a kluge to allow dump/reload of views that
+ * really care, because this whole business of converting relations to
+ * views is just a kluge to allow dump/reload of views that
* participate in circular dependencies.)
*/
if (event_relation->rd_rel->relkind != RELKIND_VIEW &&
static List *sort_policies_by_name(List *policies);
-static int row_security_policy_cmp(const void *a, const void *b);
+static int row_security_policy_cmp(const void *a, const void *b);
static void add_security_quals(int rt_index,
- List *permissive_policies,
- List *restrictive_policies,
- List **securityQuals,
- bool *hasSubLinks);
+ List *permissive_policies,
+ List *restrictive_policies,
+ List **securityQuals,
+ bool *hasSubLinks);
static void add_with_check_options(Relation rel,
- int rt_index,
- WCOKind kind,
- List *permissive_policies,
- List *restrictive_policies,
- List **withCheckOptions,
- bool *hasSubLinks);
+ int rt_index,
+ WCOKind kind,
+ List *permissive_policies,
+ List *restrictive_policies,
+ List **withCheckOptions,
+ bool *hasSubLinks);
static bool check_role_for_policy(ArrayType *policy_roles, Oid user_id);
rel = heap_open(rte->relid, NoLock);
commandType = rt_index == root->resultRelation ?
- root->commandType : CMD_SELECT;
+ root->commandType : CMD_SELECT;
/*
* In some cases, we need to apply USING policies (which control the
* visibility of records) associated with multiple command types (see
* specific cases below).
*
- * When considering the order in which to apply these USING policies,
- * we prefer to apply higher privileged policies, those which allow the
- * user to lock records (UPDATE and DELETE), first, followed by policies
- * which don't (SELECT).
+ * When considering the order in which to apply these USING policies, we
+ * prefer to apply higher privileged policies, those which allow the user
+ * to lock records (UPDATE and DELETE), first, followed by policies which
+ * don't (SELECT).
*
* Note that the optimizer is free to push down and reorder quals which
* use leakproof functions.
*
* In all cases, if there are no policy clauses allowing access to rows in
- * the table for the specific type of operation, then a single always-false
- * clause (a default-deny policy) will be added (see add_security_quals).
+ * the table for the specific type of operation, then a single
+ * always-false clause (a default-deny policy) will be added (see
+ * add_security_quals).
*/
/*
* For a SELECT, if UPDATE privileges are required (eg: the user has
- * specified FOR [KEY] UPDATE/SHARE), then add the UPDATE USING quals first.
+ * specified FOR [KEY] UPDATE/SHARE), then add the UPDATE USING quals
+ * first.
*
* This way, we filter out any records from the SELECT FOR SHARE/UPDATE
* which the user does not have access to via the UPDATE USING policies,
* a WHERE clause which involves columns from the relation), we collect up
* CMD_SELECT policies and add them via add_security_quals first.
*
- * This way, we filter out any records which are not visible through an ALL
- * or SELECT USING policy.
+ * This way, we filter out any records which are not visible through an
+ * ALL or SELECT USING policy.
*/
if ((commandType == CMD_UPDATE || commandType == CMD_DELETE) &&
rte->requiredPerms & ACL_SELECT)
hasSubLinks);
/*
- * Get and add ALL/SELECT policies, if SELECT rights are required
- * for this relation (eg: when RETURNING is used). These are added as
- * WCO policies rather than security quals to ensure that an error is
+ * Get and add ALL/SELECT policies, if SELECT rights are required for
+ * this relation (eg: when RETURNING is used). These are added as WCO
+ * policies rather than security quals to ensure that an error is
* raised if a policy is violated; otherwise, we might end up silently
* dropping rows to be added.
*/
&select_restrictive_policies);
add_with_check_options(rel, rt_index,
commandType == CMD_INSERT ?
- WCO_RLS_INSERT_CHECK : WCO_RLS_UPDATE_CHECK,
+ WCO_RLS_INSERT_CHECK : WCO_RLS_UPDATE_CHECK,
select_permissive_policies,
select_restrictive_policies,
withCheckOptions,
hasSubLinks);
/*
- * Get and add ALL/SELECT policies, as WCO_RLS_CONFLICT_CHECK
- * WCOs to ensure they are considered when taking the UPDATE
- * path of an INSERT .. ON CONFLICT DO UPDATE, if SELECT
- * rights are required for this relation, also as WCO policies,
- * again, to avoid silently dropping data. See above.
+ * Get and add ALL/SELECT policies, as WCO_RLS_CONFLICT_CHECK WCOs
+ * to ensure they are considered when taking the UPDATE path of an
+ * INSERT .. ON CONFLICT DO UPDATE, if SELECT rights are required
+ * for this relation, also as WCO policies, again, to avoid
+ * silently dropping data. See above.
*/
if (rte->requiredPerms & ACL_SELECT)
{
List *conflict_select_restrictive_policies = NIL;
get_policies_for_relation(rel, CMD_SELECT, user_id,
- &conflict_select_permissive_policies,
+ &conflict_select_permissive_policies,
&conflict_select_restrictive_policies);
add_with_check_options(rel, rt_index,
WCO_RLS_CONFLICT_CHECK,
*/
foreach(item, relation->rd_rsdesc->policies)
{
- bool cmd_matches = false;
- RowSecurityPolicy *policy = (RowSecurityPolicy *) lfirst(item);
+ bool cmd_matches = false;
+ RowSecurityPolicy *policy = (RowSecurityPolicy *) lfirst(item);
/* Always add ALL policies, if they exist. */
if (policy->polcmd == '*')
}
/*
- * Add this policy to the list of permissive policies if it
- * applies to the specified role.
+ * Add this policy to the list of permissive policies if it applies to
+ * the specified role.
*/
if (cmd_matches && check_role_for_policy(policy->roles, user_id))
*permissive_policies = lappend(*permissive_policies, policy);
if (row_security_policy_hook_restrictive)
{
List *hook_policies =
- (*row_security_policy_hook_restrictive) (cmd, relation);
+ (*row_security_policy_hook_restrictive) (cmd, relation);
/*
* We sort restrictive policies by name so that any WCOs they generate
if (row_security_policy_hook_permissive)
{
List *hook_policies =
- (*row_security_policy_hook_permissive) (cmd, relation);
+ (*row_security_policy_hook_permissive) (cmd, relation);
foreach(item, hook_policies)
{
foreach(item, policies)
{
RowSecurityPolicy *policy = (RowSecurityPolicy *) lfirst(item);
+
pols[ii++] = *policy;
}
Expr *rowsec_expr;
/*
- * First collect up the permissive quals. If we do not find any permissive
- * policies then no rows are visible (this is handled below).
+ * First collect up the permissive quals. If we do not find any
+ * permissive policies then no rows are visible (this is handled below).
*/
foreach(item, permissive_policies)
{
/*
* We now know that permissive policies exist, so we can now add
* security quals based on the USING clauses from the restrictive
- * policies. Since these need to be "AND"d together, we can
- * just add them one at a time.
+ * policies. Since these need to be "AND"d together, we can just add
+ * them one at a time.
*/
foreach(item, restrictive_policies)
{
*securityQuals = list_append_unique(*securityQuals, rowsec_expr);
}
else
+
/*
* A permissive policy must exist for rows to be visible at all.
* Therefore, if there were no permissive policies found, return a
List *permissive_quals = NIL;
#define QUAL_FOR_WCO(policy) \
- ( kind != WCO_RLS_CONFLICT_CHECK && \
+ ( kind != WCO_RLS_CONFLICT_CHECK && \
(policy)->with_check_qual != NULL ? \
(policy)->with_check_qual : (policy)->qual )
}
/*
- * There must be at least one permissive qual found or no rows are
- * allowed to be added. This is the same as in add_security_quals.
+ * There must be at least one permissive qual found or no rows are allowed
+ * to be added. This is the same as in add_security_quals.
*
- * If there are no permissive_quals then we fall through and return a single
- * 'false' WCO, preventing all new rows.
+ * If there are no permissive_quals then we fall through and return a
+ * single 'false' WCO, preventing all new rows.
*/
if (permissive_quals != NIL)
{
/*
* It would be nice to include the I/O locks in the BufferDesc, but that
- * would increase the size of a BufferDesc to more than one cache line, and
- * benchmarking has shown that keeping every BufferDesc aligned on a cache
- * line boundary is important for performance. So, instead, the array of
- * I/O locks is allocated in a separate tranche. Because those locks are
- * not highly contentended, we lay out the array with minimal padding.
+ * would increase the size of a BufferDesc to more than one cache line,
+ * and benchmarking has shown that keeping every BufferDesc aligned on a
+ * cache line boundary is important for performance. So, instead, the
+ * array of I/O locks is allocated in a separate tranche. Because those
+ * locks are not highly contentended, we lay out the array with minimal
+ * padding.
*/
size = add_size(size, mul_size(NBuffers, sizeof(LWLockMinimallyPadded)));
/* to allow aligning the above */
TestForOldSnapshot_impl(Snapshot snapshot, Relation relation)
{
if (!IsCatalogRelation(relation)
- && !RelationIsAccessibleInLogicalDecoding(relation)
- && (snapshot)->whenTaken < GetOldSnapshotThresholdTimestamp())
+ && !RelationIsAccessibleInLogicalDecoding(relation)
+ && (snapshot)->whenTaken < GetOldSnapshotThresholdTimestamp())
ereport(ERROR,
(errcode(ERRCODE_SNAPSHOT_TOO_OLD),
errmsg("snapshot too old")));
*/
void
UpdateFreeSpaceMap(Relation rel, BlockNumber startBlkNum,
- BlockNumber endBlkNum, Size freespace)
+ BlockNumber endBlkNum, Size freespace)
{
int new_cat = fsm_space_avail_to_cat(freespace);
FSMAddress addr;
uint16 slot;
- BlockNumber blockNum;
- BlockNumber lastBlkOnPage;
+ BlockNumber blockNum;
+ BlockNumber lastBlkOnPage;
blockNum = startBlkNum;
fsm_update_recursive(rel, addr, new_cat);
/*
- * Get the last block number on this FSM page. If that's greater
- * than or equal to our endBlkNum, we're done. Otherwise, advance
- * to the first block on the next page.
+ * Get the last block number on this FSM page. If that's greater than
+ * or equal to our endBlkNum, we're done. Otherwise, advance to the
+ * first block on the next page.
*/
lastBlkOnPage = fsm_get_lastblckno(rel, addr);
if (lastBlkOnPage >= endBlkNum)
int slot;
/*
- * Get the last slot number on the given address and convert that to
- * block number
+ * Get the last slot number on the given address and convert that to block
+ * number
*/
slot = SlotsPerFSMPage - 1;
return fsm_get_heap_blk(addr, slot);
return;
/*
- * Get the parent page and our slot in the parent page, and
- * update the information in that.
+ * Get the parent page and our slot in the parent page, and update the
+ * information in that.
*/
parent = fsm_get_parent(addr, &parentslot);
fsm_set_and_search(rel, parent, parentslot, new_cat, 0);
}
/*
- * OK, the control segment looks basically valid, so we can use it to
- * get a list of segments that need to be removed.
+ * OK, the control segment looks basically valid, so we can use it to get
+ * a list of segments that need to be removed.
*/
nitems = old_control->nitems;
for (i = 0; i < nitems; ++i)
pgxact->xmin = InvalidTransactionId;
/* must be cleared with xid/xmin: */
pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
- pgxact->delayChkpt = false; /* be sure this is cleared in abort */
+ pgxact->delayChkpt = false; /* be sure this is cleared in abort */
proc->recoveryConflictPending = false;
/* Clear the subtransaction-XID cache too while holding the lock */
/* Walk the list and clear all XIDs. */
while (nextidx != INVALID_PGPROCNO)
{
- PGPROC *proc = &allProcs[nextidx];
- PGXACT *pgxact = &allPgXact[nextidx];
+ PGPROC *proc = &allProcs[nextidx];
+ PGXACT *pgxact = &allPgXact[nextidx];
ProcArrayEndTransactionInternal(proc, pgxact, proc->procArrayGroupMemberXid);
*/
while (wakeidx != INVALID_PGPROCNO)
{
- PGPROC *proc = &allProcs[wakeidx];
+ PGPROC *proc = &allProcs[wakeidx];
wakeidx = pg_atomic_read_u32(&proc->procArrayGroupNext);
pg_atomic_write_u32(&proc->procArrayGroupNext, INVALID_PGPROCNO);
Assert(TransactionIdIsNormal(initializedUptoXID));
/*
- * we set latestObservedXid to the xid SUBTRANS has been initialized up to,
- * so we can extend it from that point onwards in
+ * we set latestObservedXid to the xid SUBTRANS has been initialized up
+ * to, so we can extend it from that point onwards in
* RecordKnownAssignedTransactionIds, and when we get consistent in
* ProcArrayApplyRecoveryInfo().
*/
/*
* We ignore an invalid pxmin because this means that backend has
* no snapshot currently. We hold a Share lock to avoid contention
- * with users taking snapshots. That is not a problem because
- * the current xmin is always at least one higher than the latest
+ * with users taking snapshots. That is not a problem because the
+ * current xmin is always at least one higher than the latest
* removed xid, so any new snapshot would never conflict with the
* test here.
*/
static bool
shm_mq_counterparty_gone(volatile shm_mq *mq, BackgroundWorkerHandle *handle)
{
- bool detached;
- pid_t pid;
+ bool detached;
+ pid_t pid;
/* Acquire the lock just long enough to check the pointer. */
SpinLockAcquire(&mq->mq_mutex);
* We're already behind, so clear a path as quickly as possible.
*/
VirtualTransactionId *backends;
+
backends = GetLockConflicts(&locktag, AccessExclusiveLock);
ResolveRecoveryConflictWithVirtualXIDs(backends,
PROCSIG_RECOVERY_CONFLICT_LOCK);
uint32 partition = LockHashPartition(hashcode);
/*
- * It might seem unsafe to access proclock->groupLeader without a lock,
- * but it's not really. Either we are initializing a proclock on our
- * own behalf, in which case our group leader isn't changing because
- * the group leader for a process can only ever be changed by the
- * process itself; or else we are transferring a fast-path lock to the
- * main lock table, in which case that process can't change it's lock
- * group leader without first releasing all of its locks (and in
+ * It might seem unsafe to access proclock->groupLeader without a
+ * lock, but it's not really. Either we are initializing a proclock
+ * on our own behalf, in which case our group leader isn't changing
+ * because the group leader for a process can only ever be changed by
+ * the process itself; or else we are transferring a fast-path lock to
+ * the main lock table, in which case that process can't change it's
+ * lock group leader without first releasing all of its locks (and in
* particular the one we are currently transferring).
*/
proclock->groupLeader = proc->lockGroupLeader != NULL ?
}
/*
- * Rats. Something conflicts. But it could still be my own lock, or
- * a lock held by another member of my locking group. First, figure out
- * how many conflicts remain after subtracting out any locks I hold
- * myself.
+ * Rats. Something conflicts. But it could still be my own lock, or a
+ * lock held by another member of my locking group. First, figure out how
+ * many conflicts remain after subtracting out any locks I hold myself.
*/
myLocks = proclock->holdMask;
for (i = 1; i <= numLockModes; i++)
/*
* Locks held in conflicting modes by members of our own lock group are
* not real conflicts; we can subtract those out and see if we still have
- * a conflict. This is O(N) in the number of processes holding or awaiting
- * locks on this object. We could improve that by making the shared memory
- * state more complex (and larger) but it doesn't seem worth it.
+ * a conflict. This is O(N) in the number of processes holding or
+ * awaiting locks on this object. We could improve that by making the
+ * shared memory state more complex (and larger) but it doesn't seem worth
+ * it.
*/
procLocks = &(lock->procLocks);
otherproclock = (PROCLOCK *)
proclock->groupLeader == otherproclock->groupLeader &&
(otherproclock->holdMask & conflictMask) != 0)
{
- int intersectMask = otherproclock->holdMask & conflictMask;
+ int intersectMask = otherproclock->holdMask & conflictMask;
for (i = 1; i <= numLockModes; i++)
{
*
* proc->databaseId is set at backend startup time and never changes
* thereafter, so it might be safe to perform this test before
- * acquiring &proc->backendLock. In particular, it's certainly safe to
- * assume that if the target backend holds any fast-path locks, it
+ * acquiring &proc->backendLock. In particular, it's certainly safe
+ * to assume that if the target backend holds any fast-path locks, it
* must have performed a memory-fencing operation (in particular, an
* LWLock acquisition) since setting proc->databaseId. However, it's
* less clear that our backend is certain to have performed a memory
(errhidestmt(true),
errhidecontext(true),
errmsg_internal("%d: %s(%s): excl %u shared %u haswaiters %u waiters %u rOK %d",
- MyProcPid,
- where, MainLWLockNames[id],
- (state & LW_VAL_EXCLUSIVE) != 0,
- state & LW_SHARED_MASK,
- (state & LW_FLAG_HAS_WAITERS) != 0,
- pg_atomic_read_u32(&lock->nwaiters),
- (state & LW_FLAG_RELEASE_OK) != 0)));
+ MyProcPid,
+ where, MainLWLockNames[id],
+ (state & LW_VAL_EXCLUSIVE) != 0,
+ state & LW_SHARED_MASK,
+ (state & LW_FLAG_HAS_WAITERS) != 0,
+ pg_atomic_read_u32(&lock->nwaiters),
+ (state & LW_FLAG_RELEASE_OK) != 0)));
else
ereport(LOG,
(errhidestmt(true),
errhidecontext(true),
errmsg_internal("%d: %s(%s %d): excl %u shared %u haswaiters %u waiters %u rOK %d",
- MyProcPid,
- where, T_NAME(lock), id,
- (state & LW_VAL_EXCLUSIVE) != 0,
- state & LW_SHARED_MASK,
- (state & LW_FLAG_HAS_WAITERS) != 0,
- pg_atomic_read_u32(&lock->nwaiters),
- (state & LW_FLAG_RELEASE_OK) != 0)));
+ MyProcPid,
+ where, T_NAME(lock), id,
+ (state & LW_VAL_EXCLUSIVE) != 0,
+ state & LW_SHARED_MASK,
+ (state & LW_FLAG_HAS_WAITERS) != 0,
+ pg_atomic_read_u32(&lock->nwaiters),
+ (state & LW_FLAG_RELEASE_OK) != 0)));
}
}
(errhidestmt(true),
errhidecontext(true),
errmsg_internal("%s(%s): %s", where,
- MainLWLockNames[id], msg)));
+ MainLWLockNames[id], msg)));
else
ereport(LOG,
(errhidestmt(true),
errhidecontext(true),
errmsg_internal("%s(%s %d): %s", where,
- T_NAME(lock), id, msg)));
+ T_NAME(lock), id, msg)));
}
}
/*
* It is quite possible that user has registered tranche in one of the
- * backends (e.g. by allocating lwlocks in dynamic shared memory) but
- * not all of them, so we can't assume the tranche is registered here.
+ * backends (e.g. by allocating lwlocks in dynamic shared memory) but not
+ * all of them, so we can't assume the tranche is registered here.
*/
if (eventId >= LWLockTranchesAllocated ||
LWLockTrancheArray[eventId]->name == NULL)
void
InitProcess(void)
{
- PGPROC * volatile * procgloballist;
+ PGPROC *volatile * procgloballist;
/*
* ProcGlobal should be set up already (if we are a backend, we inherit
MyPgXact = &ProcGlobal->allPgXact[MyProc->pgprocno];
/*
- * Cross-check that the PGPROC is of the type we expect; if this were
- * not the case, it would get returned to the wrong list.
+ * Cross-check that the PGPROC is of the type we expect; if this were not
+ * the case, it would get returned to the wrong list.
*/
Assert(MyProc->procgloballist == procgloballist);
ProcKill(int code, Datum arg)
{
PGPROC *proc;
- PGPROC * volatile * procgloballist;
+ PGPROC *volatile * procgloballist;
Assert(MyProc != NULL);
*
* A compiled dictionary is stored in the IspellDict structure. Compilation of
* a dictionary is divided into the several steps:
- * - NIImportDictionary() - stores each word of a .dict file in the
- * temporary Spell field.
- * - NIImportAffixes() - stores affix rules of an .affix file in the
- * Affix field (not temporary) if an .affix file has the Ispell format.
- * -> NIImportOOAffixes() - stores affix rules if an .affix file has the
- * Hunspell format. The AffixData field is initialized if AF parameter
- * is defined.
- * - NISortDictionary() - builds a prefix tree (Trie) from the words list
- * and stores it in the Dictionary field. The words list is got from the
- * Spell field. The AffixData field is initialized if AF parameter is not
- * defined.
- * - NISortAffixes():
- * - builds a list of compond affixes from the affix list and stores it
- * in the CompoundAffix.
- * - builds prefix trees (Trie) from the affix list for prefixes and suffixes
- * and stores them in Suffix and Prefix fields.
- * The affix list is got from the Affix field.
+ * - NIImportDictionary() - stores each word of a .dict file in the
+ * temporary Spell field.
+ * - NIImportAffixes() - stores affix rules of an .affix file in the
+ * Affix field (not temporary) if an .affix file has the Ispell format.
+ * -> NIImportOOAffixes() - stores affix rules if an .affix file has the
+ * Hunspell format. The AffixData field is initialized if AF parameter
+ * is defined.
+ * - NISortDictionary() - builds a prefix tree (Trie) from the words list
+ * and stores it in the Dictionary field. The words list is got from the
+ * Spell field. The AffixData field is initialized if AF parameter is not
+ * defined.
+ * - NISortAffixes():
+ * - builds a list of compond affixes from the affix list and stores it
+ * in the CompoundAffix.
+ * - builds prefix trees (Trie) from the affix list for prefixes and suffixes
+ * and stores them in Suffix and Prefix fields.
+ * The affix list is got from the Affix field.
*
* Memory management
* -----------------
cmpspellaffix(const void *s1, const void *s2)
{
return (strcmp((*(SPELL *const *) s1)->p.flag,
- (*(SPELL *const *) s2)->p.flag));
+ (*(SPELL *const *) s2)->p.flag));
}
static int
cmpcmdflag(const void *f1, const void *f2)
{
- CompoundAffixFlag *fv1 = (CompoundAffixFlag *) f1,
- *fv2 = (CompoundAffixFlag *) f2;
+ CompoundAffixFlag *fv1 = (CompoundAffixFlag *) f1,
+ *fv2 = (CompoundAffixFlag *) f2;
Assert(fv1->flagMode == fv2->flagMode);
*
* Depending on the flagMode an affix string can have the following format:
* - FM_CHAR: ABCD
- * Here we have 4 flags: A, B, C and D
+ * Here we have 4 flags: A, B, C and D
* - FM_LONG: ABCDE*
- * Here we have 3 flags: AB, CD and E*
+ * Here we have 3 flags: AB, CD and E*
* - FM_NUM: 200,205,50
- * Here we have 3 flags: 200, 205 and 50
+ * Here we have 3 flags: 200, 205 and 50
*
* Conf: current dictionary.
* sflagset: the set of affix flags. Returns a reference to the start of a next
- * affix flag.
+ * affix flag.
* sflag: returns an affix flag from sflagset.
*/
static void
maxstep = (Conf->flagMode == FM_LONG) ? 2 : 1;
- while(**sflagset)
+ while (**sflagset)
{
switch (Conf->flagMode)
{
{
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("invalid character in affix flag \"%s\"",
- *sflagset)));
+ errmsg("invalid character in affix flag \"%s\"",
+ *sflagset)));
}
*sflagset += pg_mblen(*sflagset);
if (Conf->flagMode == FM_LONG && maxstep > 0)
ereport(ERROR,
- (errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("invalid affix flag \"%s\" with long flag value", sbuf)));
+ (errcode(ERRCODE_CONFIG_FILE_ERROR),
+ errmsg("invalid affix flag \"%s\" with long flag value", sbuf)));
*sflag = '\0';
}
{
char *s,
*pstr;
+
/* Set of affix flags */
const char *flag;
* meter/GMD
*
* The affix rule with the flag S:
- * SFX S y ies [^aeiou]y
+ * SFX S y ies [^aeiou]y
* is not presented here.
*
* The affix rule with the flag M:
- * SFX M 0 's .
+ * SFX M 0 's .
* is presented here.
*
* Conf: current dictionary.
if (flag == 0)
{
/*
- * The word can be formed only with another word.
- * And in the flag parameter there is not a sign
- * that we search compound words.
+ * The word can be formed only with another word. And
+ * in the flag parameter there is not a sign that we
+ * search compound words.
*/
if (StopMiddle->compoundflag & FF_COMPOUNDONLY)
return 0;
* Conf: current dictionary.
* flag: affix flag ('\' in the below example).
* flagflags: set of flags from the flagval field for this affix rule. This set
- * is listed after '/' character in the added string (repl).
+ * is listed after '/' character in the added string (repl).
*
- * For example L flag in the hunspell_sample.affix:
- * SFX \ 0 Y/L [^Y]
+ * For example L flag in the hunspell_sample.affix:
+ * SFX \ 0 Y/L [^Y]
*
* mask: condition for search ('[^Y]' in the above example).
* find: stripping characters from beginning (at prefix) or end (at suffix)
- * of the word ('0' in the above example, 0 means that there is not
- * stripping character).
+ * of the word ('0' in the above example, 0 means that there is not
+ * stripping character).
* repl: adding string after stripping ('Y' in the above example).
* type: FF_SUFFIX or FF_PREFIX.
*/
static void
-NIAddAffix(IspellDict *Conf, const char* flag, char flagflags, const char *mask,
- const char *find, const char *repl, int type)
+NIAddAffix(IspellDict *Conf, const char *flag, char flagflags, const char *mask,
+ const char *find, const char *repl, int type)
{
AFFIX *Affix;
{
if (Conf->flagMode == FM_NUM)
{
- char *next;
- int i;
+ char *next;
+ int i;
i = strtol(s, &next, 10);
if (s == next || errno == ERANGE)
static void
addCompoundAffixFlagValue(IspellDict *Conf, char *s, uint32 val)
{
- CompoundAffixFlag *newValue;
- char sbuf[BUFSIZ];
- char *sflag;
- int clen;
+ CompoundAffixFlag *newValue;
+ char sbuf[BUFSIZ];
+ char *sflag;
+ int clen;
while (*s && t_isspace(s))
s += pg_mblen(s);
Conf->mCompoundAffixFlag *= 2;
Conf->CompoundAffixFlags = (CompoundAffixFlag *)
repalloc((void *) Conf->CompoundAffixFlags,
- Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag));
+ Conf->mCompoundAffixFlag * sizeof(CompoundAffixFlag));
}
else
{
static int
getCompoundAffixFlagValue(IspellDict *Conf, char *s)
{
- uint32 flag = 0;
+ uint32 flag = 0;
CompoundAffixFlag *found,
- key;
- char sflag[BUFSIZ];
- char *flagcur;
+ key;
+ char sflag[BUFSIZ];
+ char *flagcur;
if (Conf->nCompoundAffixFlag == 0)
return 0;
{
if (Conf->useFlagAliases && *s != '\0')
{
- int curaffix;
- char *end;
+ int curaffix;
+ char *end;
curaffix = strtol(s, &end, 10);
if (s == end || errno == ERANGE)
errmsg("invalid affix alias \"%s\"", s)));
if (curaffix > 0 && curaffix <= Conf->nAffixData)
+
/*
- * Do not subtract 1 from curaffix
- * because empty string was added in NIImportOOAffixes
+ * Do not subtract 1 from curaffix because empty string was added
+ * in NIImportOOAffixes
*/
return Conf->AffixData[curaffix];
else
Conf->flagMode = FM_NUM;
else if (STRNCMP(s, "default") != 0)
ereport(ERROR,
- (errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("Ispell dictionary supports only default, "
- "long and num flag value")));
+ (errcode(ERRCODE_CONFIG_FILE_ERROR),
+ errmsg("Ispell dictionary supports only default, "
+ "long and num flag value")));
}
}
naffix = atoi(sflag);
if (naffix == 0)
ereport(ERROR,
- (errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("invalid number of flag vector aliases")));
+ (errcode(ERRCODE_CONFIG_FILE_ERROR),
+ errmsg("invalid number of flag vector aliases")));
/* Also reserve place for empty flag set */
naffix++;
static uint32
makeCompoundFlags(IspellDict *Conf, int affix)
{
- char *str = Conf->AffixData[affix];
+ char *str = Conf->AffixData[affix];
+
return (getCompoundAffixFlagValue(Conf, str) & FF_COMPOUNDFLAGMASK);
}
/* compress affixes */
/*
- * If we use flag aliases then we need to use Conf->AffixData filled
- * in the NIImportOOAffixes().
+ * If we use flag aliases then we need to use Conf->AffixData filled in
+ * the NIImportOOAffixes().
*/
if (Conf->useFlagAliases)
{
for (i = 0; i < Conf->nspell; i++)
{
- char *end;
+ char *end;
if (*Conf->Spell[i]->p.flag != '\0')
{
curaffix++;
Assert(curaffix < naffix);
Conf->AffixData[curaffix] = cpstrdup(Conf,
- Conf->Spell[i]->p.flag);
+ Conf->Spell[i]->p.flag);
}
Conf->Spell[i]->p.d.affix = curaffix;
if (CheckAffix(newword, swrdlen, prefix->aff[j], flag, pnewword, &baselen))
{
/* prefix success */
- char *ff = (prefix->aff[j]->flagflags & suffix->aff[i]->flagflags & FF_CROSSPRODUCT) ?
- VoidString : prefix->aff[j]->flag;
+ char *ff = (prefix->aff[j]->flagflags & suffix->aff[i]->flagflags & FF_CROSSPRODUCT) ?
+ VoidString : prefix->aff[j]->flag;
if (FindWord(Conf, pnewword, ff, flag))
cur += addToResult(forms, cur, pnewword);
typedef struct MorphOpaque
{
- Oid cfg_id;
- int qoperator; /* query operator */
+ Oid cfg_id;
+ int qoperator; /* query operator */
} MorphOpaque;
static void
pushval_morph(Datum opaque, TSQueryParserState state, char *strval, int lenval, int16 weight, bool prefix)
{
- int32 count = 0;
- ParsedText prs;
- uint32 variant,
- pos = 0,
- cntvar = 0,
- cntpos = 0,
- cnt = 0;
- MorphOpaque *data = (MorphOpaque *) DatumGetPointer(opaque);
+ int32 count = 0;
+ ParsedText prs;
+ uint32 variant,
+ pos = 0,
+ cntvar = 0,
+ cntpos = 0,
+ cnt = 0;
+ MorphOpaque *data = (MorphOpaque *) DatumGetPointer(opaque);
prs.lenwords = 4;
prs.curwords = 0;
while (count < prs.curwords)
{
/*
- * Were any stop words removed? If so, fill empty positions
- * with placeholders linked by an appropriate operator.
+ * Were any stop words removed? If so, fill empty positions with
+ * placeholders linked by an appropriate operator.
*/
if (pos > 0 && pos + 1 < prs.words[count].pos.pos)
{
prs.words[count].word,
prs.words[count].len,
weight,
- ((prs.words[count].flags & TSL_PREFIX) || prefix));
+ ((prs.words[count].flags & TSL_PREFIX) || prefix));
pfree(prs.words[count].word);
if (cnt)
pushOperator(state, OP_AND, 0);
Datum
to_tsquery_byid(PG_FUNCTION_ARGS)
{
- text *in = PG_GETARG_TEXT_P(1);
- TSQuery query;
- MorphOpaque data;
+ text *in = PG_GETARG_TEXT_P(1);
+ TSQuery query;
+ MorphOpaque data;
data.cfg_id = PG_GETARG_OID(0);
data.qoperator = OP_AND;
Datum
plainto_tsquery_byid(PG_FUNCTION_ARGS)
{
- text *in = PG_GETARG_TEXT_P(1);
- TSQuery query;
- MorphOpaque data;
+ text *in = PG_GETARG_TEXT_P(1);
+ TSQuery query;
+ MorphOpaque data;
data.cfg_id = PG_GETARG_OID(0);
data.qoperator = OP_AND;
Datum
phraseto_tsquery_byid(PG_FUNCTION_ARGS)
{
- text *in = PG_GETARG_TEXT_P(1);
- TSQuery query;
- MorphOpaque data;
+ text *in = PG_GETARG_TEXT_P(1);
+ TSQuery query;
+ MorphOpaque data;
data.cfg_id = PG_GETARG_OID(0);
data.qoperator = OP_PHRASE;
checkcondition_HL(void *opaque, QueryOperand *val, ExecPhraseData *data)
{
int i;
- hlCheck *checkval = (hlCheck *) opaque;
+ hlCheck *checkval = (hlCheck *) opaque;
for (i = 0; i < checkval->len; i++)
{
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("role \"%s\" is reserved",
- role->rolename),
+ role->rolename),
errdetail("%s", detail_msg)));
else
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("role \"%s\" is reserved",
- role->rolename)));
+ role->rolename)));
}
}
Size
datumEstimateSpace(Datum value, bool isnull, bool typByVal, int typLen)
{
- Size sz = sizeof(int);
+ Size sz = sizeof(int);
if (!isnull)
{
else if (VARATT_IS_EXTERNAL_EXPANDED(value))
{
ExpandedObjectHeader *eoh = DatumGetEOHP(value);
+
sz += EOH_get_flat_size(eoh);
}
else
char **start_address)
{
ExpandedObjectHeader *eoh = NULL;
- int header;
+ int header;
/* Write header word. */
if (isnull)
Datum
datumRestore(char **start_address, bool *isnull)
{
- int header;
- void *d;
+ int header;
+ void *d;
/* Read header word. */
memcpy(&header, *start_address, sizeof(int));
{
Numeric x;
Numeric a = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
- Int32GetDatum(10)));
+ Int32GetDatum(10)));
Numeric b = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
- Int32GetDatum(-Num.multi)));
+ Int32GetDatum(-Num.multi)));
x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
NumericGetDatum(a),
{
double low;
double high;
-} Range;
+} Range;
typedef struct
{
Range left;
Range right;
-} RangeBox;
+} RangeBox;
typedef struct
{
RangeBox range_box_x;
RangeBox range_box_y;
-} RectBox;
+} RectBox;
/*
* Calculate the quadrant
static RectBox *
initRectBox(void)
{
- RectBox *rect_box = (RectBox *) palloc(sizeof(RectBox));
+ RectBox *rect_box = (RectBox *) palloc(sizeof(RectBox));
double infinity = get_float8_infinity();
rect_box->range_box_x.left.low = -infinity;
static RectBox *
nextRectBox(RectBox *rect_box, RangeBox *centroid, uint8 quadrant)
{
- RectBox *next_rect_box = (RectBox *) palloc(sizeof(RectBox));
+ RectBox *next_rect_box = (RectBox *) palloc(sizeof(RectBox));
memcpy(next_rect_box, rect_box, sizeof(RectBox));
overlap2D(RangeBox *range_box, Range *query)
{
return FPge(range_box->right.high, query->low) &&
- FPle(range_box->left.low, query->high);
+ FPle(range_box->left.low, query->high);
}
/* Can any rectangle from rect_box overlap with this argument? */
overlap4D(RectBox *rect_box, RangeBox *query)
{
return overlap2D(&rect_box->range_box_x, &query->left) &&
- overlap2D(&rect_box->range_box_y, &query->right);
+ overlap2D(&rect_box->range_box_y, &query->right);
}
/* Can any range from range_box contain this argument? */
contain2D(RangeBox *range_box, Range *query)
{
return FPge(range_box->right.high, query->high) &&
- FPle(range_box->left.low, query->low);
+ FPle(range_box->left.low, query->low);
}
/* Can any rectangle from rect_box contain this argument? */
static bool
-contain4D(RectBox *rect_box, RangeBox * query)
+contain4D(RectBox *rect_box, RangeBox *query)
{
return contain2D(&rect_box->range_box_x, &query->left) &&
- contain2D(&rect_box->range_box_y, &query->right);
+ contain2D(&rect_box->range_box_y, &query->right);
}
/* Can any range from range_box be contained by this argument? */
contained2D(RangeBox *range_box, Range *query)
{
return FPle(range_box->left.low, query->high) &&
- FPge(range_box->left.high, query->low) &&
- FPle(range_box->right.low, query->high) &&
- FPge(range_box->right.high, query->low);
+ FPge(range_box->left.high, query->low) &&
+ FPle(range_box->right.low, query->high) &&
+ FPge(range_box->right.high, query->low);
}
/* Can any rectangle from rect_box be contained by this argument? */
contained4D(RectBox *rect_box, RangeBox *query)
{
return contained2D(&rect_box->range_box_x, &query->left) &&
- contained2D(&rect_box->range_box_y, &query->right);
+ contained2D(&rect_box->range_box_y, &query->right);
}
/* Can any range from range_box to be lower than this argument? */
lower2D(RangeBox *range_box, Range *query)
{
return FPlt(range_box->left.low, query->low) &&
- FPlt(range_box->right.low, query->low);
+ FPlt(range_box->right.low, query->low);
}
/* Can any range from range_box to be higher than this argument? */
higher2D(RangeBox *range_box, Range *query)
{
return FPgt(range_box->left.high, query->high) &&
- FPgt(range_box->right.high, query->high);
+ FPgt(range_box->right.high, query->high);
}
/* Can any rectangle from rect_box be left of this argument? */
Datum
spg_box_quad_picksplit(PG_FUNCTION_ARGS)
{
- spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
- spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
+ spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
+ spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
BOX *centroid;
int median,
i;
/* Calculate median of all 4D coordinates */
for (i = 0; i < in->nTuples; i++)
{
- BOX *box = DatumGetBoxP(in->datums[i]);
+ BOX *box = DatumGetBoxP(in->datums[i]);
lowXs[i] = box->low.x;
highXs[i] = box->high.x;
out->leafTupleDatums = palloc(sizeof(Datum) * in->nTuples);
/*
- * Assign ranges to corresponding nodes according to quadrants
- * relative to the "centroid" range
+ * Assign ranges to corresponding nodes according to quadrants relative to
+ * the "centroid" range
*/
for (i = 0; i < in->nTuples; i++)
{
- BOX *box = DatumGetBoxP(in->datums[i]);
- uint8 quadrant = getQuadrant(centroid, box);
+ BOX *box = DatumGetBoxP(in->datums[i]);
+ uint8 quadrant = getQuadrant(centroid, box);
out->leafTupleDatums[i] = BoxPGetDatum(box);
out->mapTuplesToNodes[i] = quadrant;
{
spgInnerConsistentIn *in = (spgInnerConsistentIn *) PG_GETARG_POINTER(0);
spgInnerConsistentOut *out = (spgInnerConsistentOut *) PG_GETARG_POINTER(1);
- int i;
- MemoryContext old_ctx;
- RectBox *rect_box;
- uint8 quadrant;
- RangeBox *centroid,
- **queries;
+ int i;
+ MemoryContext old_ctx;
+ RectBox *rect_box;
+ uint8 quadrant;
+ RangeBox *centroid,
+ **queries;
if (in->allTheSame)
{
}
/*
- * We are saving the traversal value or initialize it an unbounded
- * one, if we have just begun to walk the tree.
+ * We are saving the traversal value or initialize it an unbounded one, if
+ * we have just begun to walk the tree.
*/
if (in->traversalValue)
rect_box = in->traversalValue;
rect_box = initRectBox();
/*
- * We are casting the prefix and queries to RangeBoxes for ease of
- * the following operations.
+ * We are casting the prefix and queries to RangeBoxes for ease of the
+ * following operations.
*/
centroid = getRangeBox(DatumGetBoxP(in->prefixDatum));
queries = (RangeBox **) palloc(in->nkeys * sizeof(RangeBox *));
out->traversalValues = (void **) palloc(sizeof(void *) * in->nNodes);
/*
- * We switch memory context, because we want to allocate memory for
- * new traversal values (next_rect_box) and pass these pieces of
- * memory to further call of this function.
+ * We switch memory context, because we want to allocate memory for new
+ * traversal values (next_rect_box) and pass these pieces of memory to
+ * further call of this function.
*/
old_ctx = MemoryContextSwitchTo(in->traversalMemoryContext);
for (quadrant = 0; quadrant < in->nNodes; quadrant++)
{
- RectBox *next_rect_box = nextRectBox(rect_box, centroid, quadrant);
+ RectBox *next_rect_box = nextRectBox(rect_box, centroid, quadrant);
bool flag = true;
for (i = 0; i < in->nkeys; i++)
else
{
/*
- * If this node is not selected, we don't need to keep
- * the next traversal value in the memory context.
+ * If this node is not selected, we don't need to keep the next
+ * traversal value in the memory context.
*/
pfree(next_rect_box);
}
case jbvBool:
if (aScalar->val.boolean == bScalar->val.boolean)
return 0;
- else if (aScalar->val.boolean >bScalar->val.boolean)
+ else if (aScalar->val.boolean > bScalar->val.boolean)
return 1;
else
return -1;
/* Handle negative subscript */
if (element < 0)
{
- uint32 nelements = JB_ROOT_COUNT(jb);
+ uint32 nelements = JB_ROOT_COUNT(jb);
if (-element > nelements)
PG_RETURN_NULL();
/* Handle negative subscript */
if (element < 0)
{
- uint32 nelements = JB_ROOT_COUNT(jb);
+ uint32 nelements = JB_ROOT_COUNT(jb);
if (-element > nelements)
PG_RETURN_NULL();
_state->path_indexes[lex_level] != INT_MIN)
{
/* Negative subscript -- convert to positive-wise subscript */
- int nelements = json_count_array_elements(_state->lex);
+ int nelements = json_count_array_elements(_state->lex);
if (-_state->path_indexes[lex_level] <= nelements)
_state->path_indexes[lex_level] += nelements;
{
/*
* Special case: we should match the entire array. We only need this
- * at the outermost level because at nested levels the match will
- * have been started by the outer field or array element callback.
+ * at the outermost level because at nested levels the match will have
+ * been started by the outer field or array element callback.
*/
_state->result_start = _state->lex->token_start;
}
*it2;
/*
- * If one of the jsonb is empty, just return the other if it's not
- * scalar and both are of the same kind. If it's a scalar or they are
- * of different kinds we need to perform the concatenation even if one is
+ * If one of the jsonb is empty, just return the other if it's not scalar
+ * and both are of the same kind. If it's a scalar or they are of
+ * different kinds we need to perform the concatenation even if one is
* empty.
*/
if (JB_ROOT_IS_OBJECT(jb1) == JB_ROOT_IS_OBJECT(jb2))
it = JsonbIteratorInit(&in->root);
r = JsonbIteratorNext(&it, &v, false);
- Assert (r == WJB_BEGIN_ARRAY);
+ Assert(r == WJB_BEGIN_ARRAY);
n = v.val.array.nElems;
if (idx < 0)
if (level == path_len - 1)
{
/*
- * called from jsonb_insert(), it forbids redefining
- * an existsing value
+ * called from jsonb_insert(), it forbids redefining an
+ * existsing value
*/
if (op_type & (JB_PATH_INSERT_BEFORE | JB_PATH_INSERT_AFTER))
ereport(ERROR,
errhint("Try using the function jsonb_set "
"to replace key value.")));
- r = JsonbIteratorNext(it, &v, true); /* skip value */
+ r = JsonbIteratorNext(it, &v, true); /* skip value */
if (!(op_type & JB_PATH_DELETE))
{
(void) pushJsonbValue(st, WJB_KEY, &k);
/*
* We should keep current value only in case of
- * JB_PATH_INSERT_BEFORE or JB_PATH_INSERT_AFTER
- * because otherwise it should be deleted or replaced
+ * JB_PATH_INSERT_BEFORE or JB_PATH_INSERT_AFTER because
+ * otherwise it should be deleted or replaced
*/
if (op_type & (JB_PATH_INSERT_AFTER | JB_PATH_INSERT_BEFORE))
(void) pushJsonbValue(st, r, &v);
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("string is not a valid identifier: \"%s\"",
text_to_cstring(qualname)),
- errdetail("No valid identifier before \".\".")));
+ errdetail("No valid identifier before \".\".")));
else if (after_dot)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("string is not a valid identifier: \"%s\"",
text_to_cstring(qualname)),
- errdetail("No valid identifier after \".\".")));
+ errdetail("No valid identifier after \".\".")));
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
Datum
numeric_combine(PG_FUNCTION_ARGS)
{
- NumericAggState *state1;
- NumericAggState *state2;
- MemoryContext agg_context;
- MemoryContext old_context;
+ NumericAggState *state1;
+ NumericAggState *state2;
+ MemoryContext agg_context;
+ MemoryContext old_context;
if (!AggCheckCallContext(fcinfo, &agg_context))
elog(ERROR, "aggregate function called in non-aggregate context");
state1->NaNcount += state2->NaNcount;
/*
- * These are currently only needed for moving aggregates, but let's
- * do the right thing anyway...
+ * These are currently only needed for moving aggregates, but let's do
+ * the right thing anyway...
*/
if (state2->maxScale > state1->maxScale)
{
Datum
numeric_avg_combine(PG_FUNCTION_ARGS)
{
- NumericAggState *state1;
- NumericAggState *state2;
- MemoryContext agg_context;
- MemoryContext old_context;
+ NumericAggState *state1;
+ NumericAggState *state2;
+ MemoryContext agg_context;
+ MemoryContext old_context;
if (!AggCheckCallContext(fcinfo, &agg_context))
elog(ERROR, "aggregate function called in non-aggregate context");
state1->NaNcount += state2->NaNcount;
/*
- * These are currently only needed for moving aggregates, but let's
- * do the right thing anyway...
+ * These are currently only needed for moving aggregates, but let's do
+ * the right thing anyway...
*/
if (state2->maxScale > state1->maxScale)
{
Datum
numeric_avg_serialize(PG_FUNCTION_ARGS)
{
- NumericAggState *state;
- StringInfoData buf;
- Datum temp;
- bytea *sumX;
- bytea *result;
+ NumericAggState *state;
+ StringInfoData buf;
+ Datum temp;
+ bytea *sumX;
+ bytea *result;
/* Ensure we disallow calling when not in aggregate context */
if (!AggCheckCallContext(fcinfo, NULL))
pq_sendbytes(&buf, VARDATA(sumX), VARSIZE(sumX) - VARHDRSZ);
/* maxScale */
- pq_sendint(&buf, state->maxScale, 4);
+ pq_sendint(&buf, state->maxScale, 4);
/* maxScaleCount */
pq_sendint64(&buf, state->maxScaleCount);
/*
* numeric_avg_deserialize
- * Deserialize bytea into NumericAggState for numeric aggregates that
+ * Deserialize bytea into NumericAggState for numeric aggregates that
* don't require sumX2. Deserializes bytea into NumericAggState using the
* standard pq API.
*
Datum
numeric_avg_deserialize(PG_FUNCTION_ARGS)
{
- bytea *sstate = PG_GETARG_BYTEA_P(0);
- NumericAggState *result;
- Datum temp;
- StringInfoData buf;
+ bytea *sstate = PG_GETARG_BYTEA_P(0);
+ NumericAggState *result;
+ Datum temp;
+ StringInfoData buf;
if (!AggCheckCallContext(fcinfo, NULL))
elog(ERROR, "aggregate function called in non-aggregate context");
Datum
numeric_serialize(PG_FUNCTION_ARGS)
{
- NumericAggState *state;
- StringInfoData buf;
- Datum temp;
- bytea *sumX;
- bytea *sumX2;
- bytea *result;
+ NumericAggState *state;
+ StringInfoData buf;
+ Datum temp;
+ bytea *sumX;
+ bytea *sumX2;
+ bytea *result;
/* Ensure we disallow calling when not in aggregate context */
if (!AggCheckCallContext(fcinfo, NULL))
pq_sendbytes(&buf, VARDATA(sumX2), VARSIZE(sumX2) - VARHDRSZ);
/* maxScale */
- pq_sendint(&buf, state->maxScale, 4);
+ pq_sendint(&buf, state->maxScale, 4);
/* maxScaleCount */
pq_sendint64(&buf, state->maxScaleCount);
Datum
numeric_deserialize(PG_FUNCTION_ARGS)
{
- bytea *sstate = PG_GETARG_BYTEA_P(0);
- NumericAggState *result;
- Datum temp;
- StringInfoData buf;
+ bytea *sstate = PG_GETARG_BYTEA_P(0);
+ NumericAggState *result;
+ Datum temp;
+ StringInfoData buf;
if (!AggCheckCallContext(fcinfo, NULL))
elog(ERROR, "aggregate function called in non-aggregate context");
{
PolyNumAggState *state1;
PolyNumAggState *state2;
- MemoryContext agg_context;
- MemoryContext old_context;
+ MemoryContext agg_context;
+ MemoryContext old_context;
if (!AggCheckCallContext(fcinfo, &agg_context))
elog(ERROR, "aggregate function called in non-aggregate context");
Datum
numeric_poly_serialize(PG_FUNCTION_ARGS)
{
- PolyNumAggState *state;
- StringInfoData buf;
- bytea *sumX;
- bytea *sumX2;
- bytea *result;
+ PolyNumAggState *state;
+ StringInfoData buf;
+ bytea *sumX;
+ bytea *sumX2;
+ bytea *result;
/* Ensure we disallow calling when not in aggregate context */
if (!AggCheckCallContext(fcinfo, NULL))
free_var(&num);
#else
temp = DirectFunctionCall1(numeric_send,
- NumericGetDatum(make_result(&state->sumX)));
+ NumericGetDatum(make_result(&state->sumX)));
sumX = DatumGetByteaP(temp);
temp = DirectFunctionCall1(numeric_send,
- NumericGetDatum(make_result(&state->sumX2)));
+ NumericGetDatum(make_result(&state->sumX2)));
sumX2 = DatumGetByteaP(temp);
#endif
}
Datum
numeric_poly_deserialize(PG_FUNCTION_ARGS)
{
- bytea *sstate = PG_GETARG_BYTEA_P(0);
- PolyNumAggState *result;
- Datum sumX;
- Datum sumX2;
- StringInfoData buf;
+ bytea *sstate = PG_GETARG_BYTEA_P(0);
+ PolyNumAggState *result;
+ Datum sumX;
+ Datum sumX2;
+ StringInfoData buf;
if (!AggCheckCallContext(fcinfo, NULL))
elog(ERROR, "aggregate function called in non-aggregate context");
/* sumX2 */
sumX2 = DirectFunctionCall3(numeric_recv,
- PointerGetDatum(&buf),
- InvalidOid,
- -1);
+ PointerGetDatum(&buf),
+ InvalidOid,
+ -1);
#ifdef HAVE_INT128
{
- NumericVar num;
+ NumericVar num;
init_var(&num);
set_var_from_num(DatumGetNumeric(sumX), &num);
Datum
int8_avg_combine(PG_FUNCTION_ARGS)
{
- PolyNumAggState *state1;
- PolyNumAggState *state2;
- MemoryContext agg_context;
- MemoryContext old_context;
+ PolyNumAggState *state1;
+ PolyNumAggState *state2;
+ MemoryContext agg_context;
+ MemoryContext old_context;
if (!AggCheckCallContext(fcinfo, &agg_context))
elog(ERROR, "aggregate function called in non-aggregate context");
Datum
int8_avg_serialize(PG_FUNCTION_ARGS)
{
- PolyNumAggState *state;
- StringInfoData buf;
- bytea *sumX;
- bytea *result;
+ PolyNumAggState *state;
+ StringInfoData buf;
+ bytea *sumX;
+ bytea *result;
/* Ensure we disallow calling when not in aggregate context */
if (!AggCheckCallContext(fcinfo, NULL))
sumX = DatumGetByteaP(temp);
#else
temp = DirectFunctionCall1(numeric_send,
- NumericGetDatum(make_result(&state->sumX)));
+ NumericGetDatum(make_result(&state->sumX)));
sumX = DatumGetByteaP(temp);
#endif
}
Datum
int8_avg_deserialize(PG_FUNCTION_ARGS)
{
- bytea *sstate = PG_GETARG_BYTEA_P(0);
- PolyNumAggState *result;
- StringInfoData buf;
- Datum temp;
+ bytea *sstate = PG_GETARG_BYTEA_P(0);
+ PolyNumAggState *result;
+ StringInfoData buf;
+ Datum temp;
if (!AggCheckCallContext(fcinfo, NULL))
elog(ERROR, "aggregate function called in non-aggregate context");
#ifdef HAVE_INT128
{
- NumericVar num;
+ NumericVar num;
init_var(&num);
set_var_from_num(DatumGetNumeric(temp), &num);
#include "utils/inet.h"
#include "utils/timestamp.h"
-#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
+#define UINT32_ACCESS_ONCE(var) ((uint32)(*((volatile uint32 *)&(var))))
/* bogus ... these externs should be in a header file */
extern Datum pg_stat_get_numscans(PG_FUNCTION_ARGS);
int num_backends = pgstat_fetch_stat_numbackends();
int curr_backend;
char *cmd = text_to_cstring(PG_GETARG_TEXT_PP(0));
- ProgressCommandType cmdtype;
+ ProgressCommandType cmdtype;
TupleDesc tupdesc;
Tuplestorestate *tupstore;
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
/* 1-based index */
for (curr_backend = 1; curr_backend <= num_backends; curr_backend++)
{
- LocalPgBackendStatus *local_beentry;
- PgBackendStatus *beentry;
+ LocalPgBackendStatus *local_beentry;
+ PgBackendStatus *beentry;
Datum values[PG_STAT_GET_PROGRESS_COLS];
bool nulls[PG_STAT_GET_PROGRESS_COLS];
int i;
if (has_privs_of_role(GetUserId(), beentry->st_userid))
{
values[2] = ObjectIdGetDatum(beentry->st_progress_command_target);
- for(i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
- values[i+3] = Int64GetDatum(beentry->st_progress_param[i]);
+ for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
+ values[i + 3] = Int64GetDatum(beentry->st_progress_param[i]);
}
else
{
nulls[2] = true;
for (i = 0; i < PGSTAT_NUM_PROGRESS_PARAM; i++)
- nulls[i+3] = true;
+ nulls[i + 3] = true;
}
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
proc = BackendPidGetProc(beentry->st_procpid);
if (proc != NULL)
{
- uint32 raw_wait_event;
+ uint32 raw_wait_event;
raw_wait_event = UINT32_ACCESS_ONCE(proc->wait_event_info);
wait_event_type = pgstat_get_wait_event_type(raw_wait_event);
/* Save previous prefix if needed */
if (needPrevious)
{
- Datum previousCentroid;
+ Datum previousCentroid;
- /* We know, that in->prefixDatum in this place is varlena,
+ /*
+ * We know, that in->prefixDatum in this place is varlena,
* because it's range
*/
previousCentroid = datumCopy(in->prefixDatum, false, -1);
- out->traversalValues[out->nNodes] = (void *)previousCentroid;
+ out->traversalValues[out->nNodes] = (void *) previousCentroid;
}
out->nodeNumbers[out->nNodes] = i - 1;
out->nNodes++;
int j;
/*
- * if any val requiring a weight is used or caller
- * needs position information then set recheck flag
+ * if any val requiring a weight is used or caller needs position
+ * information then set recheck flag
*/
if (val->weight != 0 || data != NULL)
*gcv->need_recheck = true;
return !result;
case OP_PHRASE:
+
/*
- * GIN doesn't contain any information about positions,
- * treat OP_PHRASE as OP_AND with recheck requirement
+ * GIN doesn't contain any information about positions, treat
+ * OP_PHRASE as OP_AND with recheck requirement
*/
*gcv->need_recheck = true;
/* FALL THRU */
#include "utils/pg_crc.h"
/* FTS operator priorities, see ts_type.h */
-const int tsearch_op_priority[OP_COUNT] =
+const int tsearch_op_priority[OP_COUNT] =
{
- 3, /* OP_NOT */
- 2, /* OP_AND */
- 1, /* OP_OR */
- 4 /* OP_PHRASE */
+ 3, /* OP_NOT */
+ 2, /* OP_AND */
+ 1, /* OP_OR */
+ 4 /* OP_PHRASE */
};
struct TSQueryParserStateData
PHRASE_CLOSE,
PHRASE_ERR,
PHRASE_FINISH
- } state = PHRASE_OPEN;
+ } state = PHRASE_OPEN;
- char *ptr = buf;
- char *endptr;
- long l = 1;
+ char *ptr = buf;
+ char *endptr;
+ long l = 1;
while (*ptr)
{
- switch(state)
+ switch (state)
{
case PHRASE_OPEN:
Assert(t_iseq(ptr, '<'));
}
}
- err:
+err:
*distance = -1;
return buf;
}
PushFunction pushval,
Datum opaque)
{
- int8 operator = 0;
- ts_tokentype type;
- int lenval = 0;
- char *strval = NULL;
+ int8 operator = 0;
+ ts_tokentype type;
+ int lenval = 0;
+ char *strval = NULL;
struct
{
- int8 op;
- int16 distance;
- } opstack[STACKDEPTH];
- int lenstack = 0;
- int16 weight = 0;
- bool prefix;
+ int8 op;
+ int16 distance;
+ } opstack[STACKDEPTH];
+ int lenstack = 0;
+ int16 weight = 0;
+ bool prefix;
/* since this function recurses, it could be driven to stack overflow */
check_stack_depth();
}
else if (ptr[*pos].type == QI_VALSTOP)
{
- *needcleanup = true; /* we'll have to remove stop words */
+ *needcleanup = true; /* we'll have to remove stop words */
(*pos)++;
}
else
if (ptr[*pos].qoperator.oper == OP_NOT)
{
- ptr[*pos].qoperator.left = 1; /* fixed offset */
+ ptr[*pos].qoperator.left = 1; /* fixed offset */
(*pos)++;
/* process the only argument */
}
else
{
- QueryOperator *curitem = &ptr[*pos].qoperator;
- int tmp = *pos; /* save current position */
+ QueryOperator *curitem = &ptr[*pos].qoperator;
+ int tmp = *pos; /* save current position */
Assert(curitem->oper == OP_AND ||
curitem->oper == OP_OR ||
curitem->oper == OP_PHRASE);
if (curitem->oper == OP_PHRASE)
- *needcleanup = true; /* push OP_PHRASE down later */
+ *needcleanup = true; /* push OP_PHRASE down later */
(*pos)++;
i = 0;
foreach(cell, state.polstr)
{
- QueryItem *item = (QueryItem *) lfirst(cell);
+ QueryItem *item = (QueryItem *) lfirst(cell);
switch (item->type)
{
findoprnd(ptr, query->size, &needcleanup);
/*
- * QI_VALSTOP nodes should be cleaned and
- * and OP_PHRASE should be pushed down
+ * QI_VALSTOP nodes should be cleaned and and OP_PHRASE should be pushed
+ * down
*/
if (needcleanup)
return cleanup_fakeval_and_phrase(query);
}
else if (in->curpol->qoperator.oper == OP_NOT)
{
- int priority = PRINT_PRIORITY(in->curpol);
+ int priority = PRINT_PRIORITY(in->curpol);
if (priority < parentPriority)
{
in->curpol++;
if (priority < parentPriority ||
(op == OP_PHRASE &&
- (priority == parentPriority || /* phrases are not commutative! */
- parentPriority == OP_PRIORITY(OP_AND))))
+ (priority == parentPriority || /* phrases are not
+ * commutative! */
+ parentPriority == OP_PRIORITY(OP_AND))))
{
needParenthesis = true;
RESIZEBUF(in, 2);
infix(in, priority);
/* print operator & right operand */
- RESIZEBUF(in, 3 + (2 + 10 /* distance */) + (nrm.cur - nrm.buf));
+ RESIZEBUF(in, 3 + (2 + 10 /* distance */ ) + (nrm.cur - nrm.buf));
switch (op)
{
case OP_OR:
nrm.cur = nrm.buf = (char *) palloc(sizeof(char) * nrm.buflen);
*(nrm.cur) = '\0';
nrm.op = GETOPERAND(query);
- infix(&nrm, -1 /* lowest priority */);
+ infix(&nrm, -1 /* lowest priority */ );
PG_FREE_IF_COPY(query, 0);
PG_RETURN_CSTRING(nrm.buf);
Datum
tsqueryrecv(PG_FUNCTION_ARGS)
{
- StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
- TSQuery query;
- int i,
- len;
- QueryItem *item;
- int datalen;
- char *ptr;
- uint32 size;
- const char **operands;
- bool needcleanup;
+ StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
+ TSQuery query;
+ int i,
+ len;
+ QueryItem *item;
+ int datalen;
+ char *ptr;
+ uint32 size;
+ const char **operands;
+ bool needcleanup;
size = pq_getmsgint(buf, sizeof(uint32));
if (size > (MaxAllocSize / sizeof(QueryItem)))
static NODE *
clean_fakeval_intree(NODE *node, char *result, int *adddistance)
{
- char lresult = V_UNKNOWN,
- rresult = V_UNKNOWN;
+ char lresult = V_UNKNOWN,
+ rresult = V_UNKNOWN;
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
}
else
{
- NODE *res = node;
- int ndistance, ldistance = 0, rdistance = 0;
+ NODE *res = node;
+ int ndistance,
+ ldistance = 0,
+ rdistance = 0;
ndistance = (node->valnode->qoperator.oper == OP_PHRASE) ?
- node->valnode->qoperator.distance :
- 0;
+ node->valnode->qoperator.distance :
+ 0;
- node->left = clean_fakeval_intree(node->left,
- &lresult,
- ndistance ? &ldistance : NULL);
+ node->left = clean_fakeval_intree(node->left,
+ &lresult,
+ ndistance ? &ldistance : NULL);
node->right = clean_fakeval_intree(node->right,
&rresult,
ndistance ? &rdistance : NULL);
/*
- * ndistance, ldistance and rdistance are greater than zero
- * if their corresponding nodes are OP_PHRASE
+ * ndistance, ldistance and rdistance are greater than zero if their
+ * corresponding nodes are OP_PHRASE
*/
if (lresult == V_STOP && rresult == V_STOP)
else if (lresult == V_STOP)
{
res = node->right;
+
/*
- * propagate distance from current node to the
- * right upper subtree.
+ * propagate distance from current node to the right upper
+ * subtree.
*/
if (adddistance && ndistance)
*adddistance = rdistance;
else if (rresult == V_STOP)
{
res = node->left;
+
/*
* propagate distance from current node to the upper tree.
*/
static NODE *
copyNODE(NODE *node)
{
- NODE *cnode = palloc(sizeof(NODE));
+ NODE *cnode = palloc(sizeof(NODE));
/* since this function recurses, it could be driven to stack overflow. */
check_stack_depth();
static NODE *
makeNODE(int8 op, NODE *left, NODE *right)
{
- NODE *node = palloc(sizeof(NODE));
+ NODE *node = palloc(sizeof(NODE));
/* zeroing allocation to prevent difference in unused bytes */
node->valnode = palloc0(sizeof(QueryItem));
* <-> () operation since it's needed solely for the phrase operator.
*
* Rules:
- * a <-> (b | c) => (a <-> b) | (a <-> c)
- * (a | b) <-> c => (a <-> c) | (b <-> c)
- * a <-> !b => a & !(a <-> b)
- * !a <-> b => b & !(a <-> b)
+ * a <-> (b | c) => (a <-> b) | (a <-> c)
+ * (a | b) <-> c => (a <-> c) | (b <-> c)
+ * a <-> !b => a & !(a <-> b)
+ * !a <-> b => b & !(a <-> b)
*
* Warnings for readers:
* a <-> b != b <-> a
*
- * a (b c) != (a b) c since the phrase lengths are:
+ * a (b c) != (a b) c since the phrase lengths are:
* n 2n-1
*/
static NODE *
{
/* eliminate NOT sequence */
while (node->valnode->type == QI_OPR &&
- node->valnode->qoperator.oper == node->right->valnode->qoperator.oper)
+ node->valnode->qoperator.oper == node->right->valnode->qoperator.oper)
{
node = node->right->right;
}
}
else if (node->valnode->qoperator.oper == OP_PHRASE)
{
- int16 distance;
- NODE *X;
+ int16 distance;
+ NODE *X;
node->left = normalize_phrase_tree(node->left);
node->right = normalize_phrase_tree(node->right);
if (NODE_PRIORITY(node) <= NODE_PRIORITY(node->right) &&
NODE_PRIORITY(node) <= NODE_PRIORITY(node->left))
- return node;
+ return node;
/*
- * We can't swap left-right and works only with left child
- * because of a <-> b != b <-> a
+ * We can't swap left-right and works only with left child because of
+ * a <-> b != b <-> a
*/
distance = node->valnode->qoperator.distance;
/* no-op */
break;
default:
- elog(ERROR,"Wrong type of tsquery node: %d",
- node->right->valnode->qoperator.oper);
+ elog(ERROR, "Wrong type of tsquery node: %d",
+ node->right->valnode->qoperator.oper);
}
}
* if the node is still OP_PHRASE, check the left subtree,
* otherwise the whole node will be transformed later.
*/
- switch(node->left->valnode->qoperator.oper)
+ switch (node->left->valnode->qoperator.oper)
{
case OP_AND:
- /* (a & b) <-> c => (a <-> c) & (b <-> c) */
+ /* (a & b) <-> c => (a <-> c) & (b <-> c) */
node = makeNODE(OP_AND,
makeNODE(OP_PHRASE,
node->left->left,
/* no-op */
break;
default:
- elog(ERROR,"Wrong type of tsquery node: %d",
- node->left->valnode->qoperator.oper);
+ elog(ERROR, "Wrong type of tsquery node: %d",
+ node->left->valnode->qoperator.oper);
}
}
/* continue transformation */
node = normalize_phrase_tree(node);
}
- else /* AND or OR */
+ else /* AND or OR */
{
node->left = normalize_phrase_tree(node->left);
node->right = normalize_phrase_tree(node->right);
static int32
calcstrlen(NODE *node)
{
- int32 size = 0;
+ int32 size = 0;
if (node->valnode->type == QI_VAL)
{
tsquery_phrase(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(DirectFunctionCall3(
- tsquery_phrase_distance,
- PG_GETARG_DATUM(0),
- PG_GETARG_DATUM(1),
- Int32GetDatum(1)));
+ tsquery_phrase_distance,
+ PG_GETARG_DATUM(0),
+ PG_GETARG_DATUM(1),
+ Int32GetDatum(1)));
}
Datum
/* XXX: What about NOT? */
res = (item->type == QI_OPR && (item->qoperator.oper == OP_AND ||
item->qoperator.oper == OP_PHRASE)) ?
- calc_rank_and(w, t, q) :
- calc_rank_or(w, t, q);
+ calc_rank_and(w, t, q) :
+ calc_rank_or(w, t, q);
if (res < 0)
res = 1e-20f;
typedef struct
{
- union {
- struct { /* compiled doc representation */
+ union
+ {
+ struct
+ { /* compiled doc representation */
QueryItem **items;
int16 nitem;
- } query;
- struct { /* struct is used for preparing doc representation */
+ } query;
+ struct
+ { /* struct is used for preparing doc
+ * representation */
QueryItem *item;
WordEntry *entry;
- } map;
- } data;
- WordEntryPos pos;
+ } map;
+ } data;
+ WordEntryPos pos;
} DocRepresentation;
static int
#define MAXQROPOS MAXENTRYPOS
typedef struct
{
- bool operandexists;
- bool reverseinsert; /* indicates insert order,
- true means descending order */
- uint32 npos;
- WordEntryPos pos[MAXQROPOS];
+ bool operandexists;
+ bool reverseinsert; /* indicates insert order, true means
+ * descending order */
+ uint32 npos;
+ WordEntryPos pos[MAXQROPOS];
} QueryRepresentationOperand;
typedef struct
{
- TSQuery query;
+ TSQuery query;
QueryRepresentationOperand *operandData;
} QueryRepresentation;
static bool
checkcondition_QueryOperand(void *checkval, QueryOperand *val, ExecPhraseData *data)
{
- QueryRepresentation *qr = (QueryRepresentation *) checkval;
- QueryRepresentationOperand *opData = QR_GET_OPERAND_DATA(qr, val);
+ QueryRepresentation *qr = (QueryRepresentation *) checkval;
+ QueryRepresentationOperand *opData = QR_GET_OPERAND_DATA(qr, val);
if (!opData->operandexists)
return false;
static void
resetQueryRepresentation(QueryRepresentation *qr, bool reverseinsert)
{
- int i;
+ int i;
- for(i = 0; i < qr->query->size; i++)
+ for (i = 0; i < qr->query->size; i++)
{
qr->operandData[i].operandexists = false;
qr->operandData[i].reverseinsert = reverseinsert;
static void
fillQueryRepresentationData(QueryRepresentation *qr, DocRepresentation *entry)
{
- int i;
- int lastPos;
+ int i;
+ int lastPos;
QueryRepresentationOperand *opData;
for (i = 0; i < entry->data.query.nitem; i++)
}
lastPos = opData->reverseinsert ?
- (MAXQROPOS - opData->npos) :
- (opData->npos - 1);
+ (MAXQROPOS - opData->npos) :
+ (opData->npos - 1);
if (WEP_GETPOS(opData->pos[lastPos]) != WEP_GETPOS(entry->pos))
{
lastPos = opData->reverseinsert ?
- (MAXQROPOS - 1 - opData->npos) :
- (opData->npos);
+ (MAXQROPOS - 1 - opData->npos) :
+ (opData->npos);
opData->pos[lastPos] = entry->pos;
opData->npos++;
static bool
Cover(DocRepresentation *doc, int len, QueryRepresentation *qr, CoverExt *ext)
{
- DocRepresentation *ptr;
- int lastpos = ext->pos;
- bool found = false;
+ DocRepresentation *ptr;
+ int lastpos = ext->pos;
+ bool found = false;
/*
* since this function recurses, it could be driven to stack overflow.
WordEntry *entry,
*firstentry;
WordEntryPos *post;
- int32 dimt, /* number of 'post' items */
+ int32 dimt, /* number of 'post' items */
j,
i,
nitem;
doc = (DocRepresentation *) palloc(sizeof(DocRepresentation) * len);
/*
- * Iterate through query to make DocRepresentaion for words and it's entries
- * satisfied by query
+ * Iterate through query to make DocRepresentaion for words and it's
+ * entries satisfied by query
*/
for (i = 0; i < qr->query->size; i++)
{
if (cur > 0)
{
- DocRepresentation *rptr = doc + 1,
- *wptr = doc,
- storage;
+ DocRepresentation *rptr = doc + 1,
+ *wptr = doc,
+ storage;
/*
* Sort representation in ascending order by pos and entry
while (rptr - doc < cur)
{
- if (rptr->pos == (rptr-1)->pos &&
- rptr->data.map.entry == (rptr-1)->data.map.entry)
+ if (rptr->pos == (rptr - 1)->pos &&
+ rptr->data.map.entry == (rptr - 1)->data.map.entry)
{
storage.data.query.items[storage.data.query.nitem] = rptr->data.map.item;
storage.data.query.nitem++;
qr.query = query;
qr.operandData = (QueryRepresentationOperand *)
- palloc0(sizeof(QueryRepresentationOperand) * query->size);
+ palloc0(sizeof(QueryRepresentationOperand) * query->size);
doc = get_docrep(txt, &qr, &doclen);
if (!doc)
#define STATHDRSIZE (offsetof(TSVectorStat, data))
static Datum tsvector_update_trigger(PG_FUNCTION_ARGS, bool config_column);
-static int tsvector_bsearch(const TSVector tsv, char *lexeme, int lexeme_len);
+static int tsvector_bsearch(const TSVector tsv, char *lexeme, int lexeme_len);
/*
* Order: haspos, len, word, for all positions (pos, weight)
switch (char_weight)
{
- case 'A': case 'a':
+ case 'A':
+ case 'a':
weight = 3;
break;
- case 'B': case 'b':
+ case 'B':
+ case 'b':
weight = 2;
break;
- case 'C': case 'c':
+ case 'C':
+ case 'c':
weight = 1;
break;
- case 'D': case 'd':
+ case 'D':
+ case 'd':
weight = 0;
break;
default:
&dlexemes, &nulls, &nlexemes);
/*
- * Assuming that lexemes array is significantly shorter than tsvector
- * we can iterate through lexemes performing binary search
- * of each lexeme from lexemes in tsvector.
+ * Assuming that lexemes array is significantly shorter than tsvector we
+ * can iterate through lexemes performing binary search of each lexeme
+ * from lexemes in tsvector.
*/
for (i = 0; i < nlexemes; i++)
{
- char *lex;
- int lex_len,
- lex_pos;
+ char *lex;
+ int lex_len,
+ lex_pos;
if (nulls[i])
ereport(ERROR,
if (lex_pos >= 0 && (j = POSDATALEN(tsout, entry + lex_pos)) != 0)
{
WordEntryPos *p = POSDATAPTR(tsout, entry + lex_pos);
+
while (j--)
{
WEP_SETWEIGHT(*p, weight);
while (StopLow < StopHigh)
{
- StopMiddle = (StopLow + StopHigh)/2;
+ StopMiddle = (StopLow + StopHigh) / 2;
cmp = tsCompareString(lexeme, lexeme_len,
- STRPTR(tsv) + arrin[StopMiddle].pos,
- arrin[StopMiddle].len,
- false);
+ STRPTR(tsv) + arrin[StopMiddle].pos,
+ arrin[StopMiddle].len,
+ false);
if (cmp < 0)
StopHigh = StopMiddle;
else if (cmp > 0)
StopLow = StopMiddle + 1;
- else /* found it */
+ else /* found it */
return StopMiddle;
}
*arrout;
char *data = STRPTR(tsv),
*dataout;
- int i, j, k,
+ int i,
+ j,
+ k,
curoff;
/*
* Here we overestimates tsout size, since we don't know exact size
- * occupied by positions and weights. We will set exact size later
- * after a pass through TSVector.
+ * occupied by positions and weights. We will set exact size later after a
+ * pass through TSVector.
*/
tsout = (TSVector) palloc0(VARSIZE(tsv));
arrout = ARRPTR(tsout);
{
/*
* Here we should check whether current i is present in
- * indices_to_delete or not. Since indices_to_delete is already
- * sorted we can advance it index only when we have match.
+ * indices_to_delete or not. Since indices_to_delete is already sorted
+ * we can advance it index only when we have match.
*/
- if (k < indices_count && i == indices_to_delete[k]){
+ if (k < indices_count && i == indices_to_delete[k])
+ {
k++;
continue;
}
curoff += arrin[i].len;
if (arrin[i].haspos)
{
- int len = POSDATALEN(tsv, arrin+i) * sizeof(WordEntryPos) +
- sizeof(uint16);
+ int len = POSDATALEN(tsv, arrin + i) * sizeof(WordEntryPos) +
+ sizeof(uint16);
+
curoff = SHORTALIGN(curoff);
memcpy(dataout + curoff,
STRPTR(tsv) + SHORTALIGN(arrin[i].pos + arrin[i].len),
}
/*
- * After the pass through TSVector k should equals exactly to indices_count.
- * If it isn't then the caller provided us with indices outside of
- * [0, tsv->size) range and estimation of tsout's size is wrong.
+ * After the pass through TSVector k should equals exactly to
+ * indices_count. If it isn't then the caller provided us with indices
+ * outside of [0, tsv->size) range and estimation of tsout's size is
+ * wrong.
*/
Assert(k == indices_count);
TSVector tsin = PG_GETARG_TSVECTOR(0),
tsout;
ArrayType *lexemes = PG_GETARG_ARRAYTYPE_P(1);
- int i, nlex,
+ int i,
+ nlex,
skip_count,
*skip_indices;
Datum *dlexemes;
&dlexemes, &nulls, &nlex);
/*
- * In typical use case array of lexemes to delete is relatively small.
- * So here we optimizing things for that scenario: iterate through lexarr
+ * In typical use case array of lexemes to delete is relatively small. So
+ * here we optimizing things for that scenario: iterate through lexarr
* performing binary search of each lexeme from lexarr in tsvector.
*/
skip_indices = palloc0(nlex * sizeof(int));
for (i = skip_count = 0; i < nlex; i++)
{
- char *lex;
- int lex_len,
- lex_pos;
+ char *lex;
+ int lex_len,
+ lex_pos;
if (nulls[i])
ereport(ERROR,
/*
* Expand tsvector as table with following columns:
- * lexeme: lexeme text
- * positions: integer array of lexeme positions
- * weights: char array of weights corresponding to positions
+ * lexeme: lexeme text
+ * positions: integer array of lexeme positions
+ * weights: char array of weights corresponding to positions
*/
Datum
tsvector_unnest(PG_FUNCTION_ARGS)
{
- FuncCallContext *funcctx;
- TSVector tsin;
+ FuncCallContext *funcctx;
+ TSVector tsin;
if (SRF_IS_FIRSTCALL())
{
Datum values[3];
values[0] = PointerGetDatum(
- cstring_to_text_with_len(data + arrin[i].pos, arrin[i].len)
- );
+ cstring_to_text_with_len(data + arrin[i].pos, arrin[i].len)
+ );
if (arrin[i].haspos)
{
/*
* Internally tsvector stores position and weight in the same
- * uint16 (2 bits for weight, 14 for position). Here we extract that
- * in two separate arrays.
+ * uint16 (2 bits for weight, 14 for position). Here we extract
+ * that in two separate arrays.
*/
posv = _POSVECPTR(tsin, arrin + i);
positions = palloc(posv->npos * sizeof(Datum));
- weights = palloc(posv->npos * sizeof(Datum));
+ weights = palloc(posv->npos * sizeof(Datum));
for (j = 0; j < posv->npos; j++)
{
positions[j] = Int16GetDatum(WEP_GETPOS(posv->pos[j]));
weight = 'D' - WEP_GETWEIGHT(posv->pos[j]);
weights[j] = PointerGetDatum(
- cstring_to_text_with_len(&weight, 1)
- );
+ cstring_to_text_with_len(&weight, 1)
+ );
}
values[1] = PointerGetDatum(
- construct_array(positions, posv->npos, INT2OID, 2, true, 's'));
+ construct_array(positions, posv->npos, INT2OID, 2, true, 's'));
values[2] = PointerGetDatum(
- construct_array(weights, posv->npos, TEXTOID, -1, false, 'i'));
+ construct_array(weights, posv->npos, TEXTOID, -1, false, 'i'));
}
else
{
Datum
tsvector_to_array(PG_FUNCTION_ARGS)
{
- TSVector tsin = PG_GETARG_TSVECTOR(0);
- WordEntry *arrin = ARRPTR(tsin);
- Datum *elements;
- int i;
- ArrayType *array;
+ TSVector tsin = PG_GETARG_TSVECTOR(0);
+ WordEntry *arrin = ARRPTR(tsin);
+ Datum *elements;
+ int i;
+ ArrayType *array;
elements = palloc(tsin->size * sizeof(Datum));
for (i = 0; i < tsin->size; i++)
{
elements[i] = PointerGetDatum(
- cstring_to_text_with_len(STRPTR(tsin) + arrin[i].pos, arrin[i].len)
- );
+ cstring_to_text_with_len(STRPTR(tsin) + arrin[i].pos, arrin[i].len)
+ );
}
array = construct_array(elements, tsin->size, TEXTOID, -1, false, 'i');
for (i = 0; i < nitems; i++)
{
- char *lex = VARDATA(dlexemes[i]);
- int lex_len = VARSIZE_ANY_EXHDR(dlexemes[i]);
+ char *lex = VARDATA(dlexemes[i]);
+ int lex_len = VARSIZE_ANY_EXHDR(dlexemes[i]);
memcpy(cur, lex, lex_len);
arrout[i].haspos = 0;
Datum *dweights;
bool *nulls;
int nweights;
- int i, j;
+ int i,
+ j;
int cur_pos = 0;
char mask = 0;
for (i = 0; i < nweights; i++)
{
- char char_weight;
+ char char_weight;
if (nulls[i])
ereport(ERROR,
char_weight = DatumGetChar(dweights[i]);
switch (char_weight)
{
- case 'A': case 'a':
+ case 'A':
+ case 'a':
mask = mask | 8;
break;
- case 'B': case 'b':
+ case 'B':
+ case 'b':
mask = mask | 4;
break;
- case 'C': case 'c':
+ case 'C':
+ case 'c':
mask = mask | 2;
break;
- case 'D': case 'd':
+ case 'D':
+ case 'd':
mask = mask | 1;
break;
default:
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("unrecognized weight: \"%c\"", char_weight)));
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("unrecognized weight: \"%c\"", char_weight)));
}
}
for (i = j = 0; i < tsin->size; i++)
{
WordEntryPosVector *posvin,
- *posvout;
- int npos = 0;
- int k;
+ *posvout;
+ int npos = 0;
+ int k;
if (!arrin[i].haspos)
continue;
- posvin = _POSVECPTR(tsin, arrin + i);
+ posvin = _POSVECPTR(tsin, arrin + i);
posvout = (WordEntryPosVector *)
- (dataout + SHORTALIGN(cur_pos + arrin[i].len));
+ (dataout + SHORTALIGN(cur_pos + arrin[i].len));
for (k = 0; k < posvin->npos; k++)
{
memcpy(dataout + cur_pos, datain + arrin[i].pos, arrin[i].len);
posvout->npos = npos;
cur_pos += SHORTALIGN(arrin[i].len);
- cur_pos += POSDATALEN(tsout, arrout+j) * sizeof(WordEntryPos) +
- sizeof(uint16);
+ cur_pos += POSDATALEN(tsout, arrout + j) * sizeof(WordEntryPos) +
+ sizeof(uint16);
j++;
}
checkclass_str(CHKVAL *chkval, WordEntry *entry, QueryOperand *val,
ExecPhraseData *data)
{
- bool result = false;
+ bool result = false;
if (entry->haspos && (val->weight || data))
{
- WordEntryPosVector *posvec;
+ WordEntryPosVector *posvec;
/*
* We can't use the _POSVECPTR macro here because the pointer to the
if (val->weight && data)
{
- WordEntryPos *posvec_iter = posvec->pos;
- WordEntryPos *dptr;
+ WordEntryPos *posvec_iter = posvec->pos;
+ WordEntryPos *dptr;
/*
* Filter position information by weights
}
else if (val->weight)
{
- WordEntryPos *posvec_iter = posvec->pos;
+ WordEntryPos *posvec_iter = posvec->pos;
/* Is there a position with a matching weight? */
while (posvec_iter < posvec->pos + posvec->npos)
if (val->weight & (1 << WEP_GETWEIGHT(*posvec_iter)))
{
result = true;
- break; /* no need to go further */
+ break; /* no need to go further */
}
posvec_iter++;
}
}
- else /* data != NULL */
+ else /* data != NULL */
{
data->npos = posvec->npos;
- data->pos = posvec->pos;
+ data->pos = posvec->pos;
data->allocated = false;
result = true;
}
uniqueLongPos(WordEntryPos *pos, int npos)
{
WordEntryPos *pos_iter,
- *result;
+ *result;
if (npos <= 1)
return npos;
if ((!res || data) && val->prefix)
{
- WordEntryPos *allpos = NULL;
- int npos = 0,
- totalpos = 0;
+ WordEntryPos *allpos = NULL;
+ int npos = 0,
+ totalpos = 0;
+
/*
* there was a failed exact search, so we should scan further to find
* a prefix match. We also need to do so if caller needs position info
}
else
{
- ExecPhraseData Ldata = {0, false, NULL},
- Rdata = {0, false, NULL};
- WordEntryPos *Lpos,
- *Rpos,
- *pos_iter = NULL;
+ ExecPhraseData Ldata = {0, false, NULL},
+ Rdata = {0, false, NULL};
+ WordEntryPos *Lpos,
+ *Rpos,
+ *pos_iter = NULL;
Assert(curitem->qoperator.oper == OP_PHRASE);
return false;
/*
- * if at least one of the operands has no position
- * information, fallback to AND operation.
+ * if at least one of the operands has no position information,
+ * fallback to AND operation.
*/
if (Ldata.npos == 0 || Rdata.npos == 0)
return true;
/*
- * Result of the operation is a list of the
- * corresponding positions of RIGHT operand.
+ * Result of the operation is a list of the corresponding positions of
+ * RIGHT operand.
*/
if (data)
{
if (!Rdata.allocated)
+
/*
- * OP_PHRASE is based on the OP_AND, so the number of resulting
- * positions could not be greater than the total amount of operands.
+ * OP_PHRASE is based on the OP_AND, so the number of
+ * resulting positions could not be greater than the total
+ * amount of operands.
*/
data->pos = palloc(sizeof(WordEntryPos) * Min(Ldata.npos, Rdata.npos));
else
*pos_iter = WEP_GETPOS(*Rpos);
pos_iter++;
- break; /* We need to build a unique result
- * array, so go to the next Rpos */
+ break; /* We need to build a unique result
+ * array, so go to the next Rpos */
}
else
{
else
{
/*
- * Go to the next Rpos, because Lpos
- * is ahead of the current Rpos
+ * Go to the next Rpos, because Lpos is ahead of the
+ * current Rpos
*/
break;
}
*/
bool
TS_execute(QueryItem *curitem, void *checkval, bool calcnot,
- bool (*chkcond) (void *checkval, QueryOperand *val, ExecPhraseData *data))
+ bool (*chkcond) (void *checkval, QueryOperand *val, ExecPhraseData *data))
{
/* since this function recurses, it could be driven to stack overflow */
check_stack_depth();
if (curitem->type == QI_VAL)
return chkcond(checkval, (QueryOperand *) curitem,
- NULL /* we don't need position info */);
+ NULL /* we don't need position info */ );
switch (curitem->qoperator.oper)
{
return false;
case OP_PHRASE:
+
/*
* Treat OP_PHRASE as OP_AND here
*/
if (SPI_tuptable == NULL ||
SPI_tuptable->tupdesc->natts != 1 ||
!IsBinaryCoercible(SPI_gettypeid(SPI_tuptable->tupdesc, 1),
- TSVECTOROID))
+ TSVECTOROID))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("ts_stat query must return one tsvector column")));
errmsg("tsvector column \"%s\" does not exist",
trigger->tgargs[0])));
if (!IsBinaryCoercible(SPI_gettypeid(rel->rd_att, tsvector_attr_num),
- TSVECTOROID))
+ TSVECTOROID))
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("column \"%s\" is not of tsvector type",
errmsg("configuration column \"%s\" does not exist",
trigger->tgargs[1])));
if (!IsBinaryCoercible(SPI_gettypeid(rel->rd_att, config_attr_num),
- REGCONFIGOID))
+ REGCONFIGOID))
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("column \"%s\" is not of regconfig type",
static int uuid_internal_cmp(const pg_uuid_t *arg1, const pg_uuid_t *arg2);
static int uuid_fast_cmp(Datum x, Datum y, SortSupport ssup);
static int uuid_cmp_abbrev(Datum x, Datum y, SortSupport ssup);
-static bool uuid_abbrev_abort(int memtupcount, SortSupport ssup);
-static Datum uuid_abbrev_convert(Datum original, SortSupport ssup);
+static bool uuid_abbrev_abort(int memtupcount, SortSupport ssup);
+static Datum uuid_abbrev_convert(Datum original, SortSupport ssup);
Datum
uuid_in(PG_FUNCTION_ARGS)
Datum
uuid_sortsupport(PG_FUNCTION_ARGS)
{
- SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
+ SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
ssup->comparator = uuid_fast_cmp;
ssup->ssup_extra = NULL;
if (ssup->abbreviate)
{
- uuid_sortsupport_state *uss;
- MemoryContext oldcontext;
+ uuid_sortsupport_state *uss;
+ MemoryContext oldcontext;
oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
static bool
uuid_abbrev_abort(int memtupcount, SortSupport ssup)
{
- uuid_sortsupport_state *uss = ssup->ssup_extra;
- double abbr_card;
+ uuid_sortsupport_state *uss = ssup->ssup_extra;
+ double abbr_card;
if (memtupcount < 10000 || uss->input_count < 10000 || !uss->estimating)
return false;
/*
* Target minimum cardinality is 1 per ~2k of non-null inputs. 0.5 row
* fudge factor allows us to abort earlier on genuinely pathological data
- * where we've had exactly one abbreviated value in the first 2k (non-null)
- * rows.
+ * where we've had exactly one abbreviated value in the first 2k
+ * (non-null) rows.
*/
if (abbr_card < uss->input_count / 2000.0 + 0.5)
{
if (trace_sort)
elog(LOG,
"uuid_abbrev: aborting abbreviation at cardinality %f"
- " below threshold %f after " INT64_FORMAT " values (%d rows)",
+ " below threshold %f after " INT64_FORMAT " values (%d rows)",
abbr_card, uss->input_count / 2000.0 + 0.5, uss->input_count,
memtupcount);
#endif
static Datum
uuid_abbrev_convert(Datum original, SortSupport ssup)
{
- uuid_sortsupport_state *uss = ssup->ssup_extra;
- pg_uuid_t *authoritative = DatumGetUUIDP(original);
- Datum res;
+ uuid_sortsupport_state *uss = ssup->ssup_extra;
+ pg_uuid_t *authoritative = DatumGetUUIDP(original);
+ Datum res;
memcpy(&res, authoritative->data, sizeof(Datum));
uss->input_count += 1;
* Byteswap on little-endian machines.
*
* This is needed so that uuid_cmp_abbrev() (an unsigned integer 3-way
- * comparator) works correctly on all platforms. If we didn't do this, the
- * comparator would have to call memcmp() with a pair of pointers to the
- * first byte of each abbreviated key, which is slower.
+ * comparator) works correctly on all platforms. If we didn't do this,
+ * the comparator would have to call memcmp() with a pair of pointers to
+ * the first byte of each abbreviated key, which is slower.
*/
res = DatumBigEndianToNative(res);
/* should not get here, because of previous check */
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("unrecognized format() type specifier \"%c\"",
- *cp),
- errhint("For a single \"%%\" use \"%%%%\".")));
+ errmsg("unrecognized format() type specifier \"%c\"",
+ *cp),
+ errhint("For a single \"%%\" use \"%%%%\".")));
break;
}
}
char
get_rel_persistence(Oid relid)
{
- HeapTuple tp;
- Form_pg_class reltup;
- char result;
+ HeapTuple tp;
+ Form_pg_class reltup;
+ char result;
tp = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
if (!HeapTupleIsValid(tp))
static void PlanCacheFuncCallback(Datum arg, int cacheid, uint32 hashvalue);
static void PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue);
static void PlanCacheUserMappingCallback(Datum arg, int cacheid,
- uint32 hashvalue);
+ uint32 hashvalue);
/*
plansource->is_valid = false;
/*
- &n
projects / postgresql.git / commitdiff