total_cost += cpu_tuple_cost * retrieved_rows;
/*
- * If we have LIMIT, we should perfer performing the restriction remotely
+ * If we have LIMIT, we should prefer performing the restriction remotely
* rather than locally, as the former avoids extra row fetches from the
* remote that the latter might cause. But since the core code doesn't
* account for such fetches when estimating the costs of the local
equal only if they consist of the same byte sequence. Nondeterministic
comparison may determine strings to be equal even if they consist of
different bytes. Typical situations include case-insensitive comparison,
- accent-insensitive comparison, as well as comparion of strings in
+ accent-insensitive comparison, as well as comparison of strings in
different Unicode normal forms. It is up to the collation provider to
actually implement such insensitive comparisons; the deterministic flag
only determines whether ties are to be broken using bytewise comparison.
</entry>
</row>
<row>
- <entry><structfield>current_locked_pid</structfield></entry>
+ <entry><structfield>current_locker_pid</structfield></entry>
<entry><type>bigint</type></entry>
<entry>
Process ID of the locker currently being waited for.
(that is, <structfield>t_natts</structfield> bits altogether). In this list of bits, a
1 bit indicates not-null, a 0 bit is a null. When the bitmap is not
present, all columns are assumed not-null.
- The object ID is only present if the <firstterm>HEAP_HASOID</firstterm> bit
+ The object ID is only present if the <firstterm>HEAP_HASOID_OLD</firstterm> bit
is set in <structfield>t_infomask</structfield>. If present, it appears just
before the <structfield>t_hoff</structfield> boundary. Any padding needed to make
<structfield>t_hoff</structfield> a MAXALIGN multiple will appear between the null
* (In a !heapkeyspace index, there can be multiple pages with the same
* high key, where the new tuple could legitimately be placed on. In
* that case, the caller passes the first page containing duplicates,
- * just like when checkinunique=true. If that page doesn't have enough
+ * just like when checkingunique=true. If that page doesn't have enough
* room for the new tuple, this function moves right, trying to find a
* legal page that does.)
*
* _bt_preprocess_keys(), above, about how this is done.
*
* Forward scan callers can pass a high key tuple in the hopes of having
- * us set *continuescanthat to false, and avoiding an unnecessary visit to
+ * us set *continuescan to false, and avoiding an unnecessary visit to
* the page to the right.
*
* scan: index scan descriptor (containing a search-type scankey)
else if (contain_volatile_functions(cstate->whereClause))
{
/*
- * Can't support multi-inserts if there are any volatile funcation
+ * Can't support multi-inserts if there are any volatile function
* expressions in WHERE clause. Similarly to the trigger case above,
* such expressions may query the table we're inserting into.
*/
/*
* Removing constraints can affect SELECTs that have been
- * optimised assuming the constraint holds true. See also
+ * optimized assuming the constraint holds true. See also
* CloneFkReferenced.
*/
case AT_DropConstraint: /* as DROP INDEX */
* inputslot - tuple for processing - this can be the slot from
* EvalPlanQualSlot(), for the increased efficiency.
*
- * This tests whether the tuple in inputslot still matches the relvant
+ * This tests whether the tuple in inputslot still matches the relevant
* quals. For that result to be useful, typically the input tuple has to be
* last row version (otherwise the result isn't particularly useful) and
* locked (otherwise the result might be out of date). That's typically
* NB: If materialize is true, modifications of the returned tuple are
* allowed. But it depends on the type of the slot whether such modifications
* will also affect the slot's contents. While that is not the nicest
- * behaviour, all such modifcations are in the process of being removed.
+ * behaviour, all such modifications are in the process of being removed.
*/
HeapTuple
ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
* tuple should be considered as read-only.
*
* If that callback is not supported, it calls copy_minimal_tuple callback
- * which is expected to return a copy of minimal tuple represnting the
+ * which is expected to return a copy of minimal tuple representing the
* contents of the slot. In this case *shouldFree is set to true,
* indicating the caller that it should free the memory consumed by the
* minimal tuple. In this case the returned minimal tuple may be written
LLVMBuildBitCast(b,
v_slot,
l_ptr(StructMinimalTupleTableSlot),
- "minimalslotslot");
+ "minimalslot");
v_slotoffp = LLVMBuildStructGEP(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_OFF, "");
v_tupleheaderp =
l_load_struct_gep(b, v_minimalslot, FIELDNO_MINIMALTUPLETABLESLOT_TUPLE,
errmsg("GSSAPI encryption only supports gss, trust, or reject authentication"),
errcontext("line %d of configuration file \"%s\"",
line_num, HbaFileName)));
- *err_msg = "GSSAPI encryption only supports gss, trust, or reject authenticaion";
+ *err_msg = "GSSAPI encryption only supports gss, trust, or reject authentication";
return NULL;
}
}
/*
- * Remove the file signaling a log rotateion request.
+ * Remove the file signaling a log rotation request.
*/
void
RemoveLogrotateSignalFiles(void)
memcpy(ptr, &tmp, info[dim].typlen);
ptr += info[dim].typlen;
}
- else if (info[dim].typlen > 0) /* pased by reference */
+ else if (info[dim].typlen > 0) /* passed by reference */
{
/* no special alignment needed, treated as char array */
memcpy(ptr, DatumGetPointer(value), info[dim].typlen);
}
/*
- * Interfact to float8in_internal_opt_error() without "have_error" argument.
+ * Interface to float8in_internal_opt_error() without "have_error" argument.
*/
double
float8in_internal(char *num, char **endptr_p,
{
while (s[++i] != '}' && i < l)
ch = (ch << 4) | hexval(s[i]);
- i++; /* ski p '}' */
+ i++; /* skip '}' */
}
else /* parse '\uXXXX' */
{
break;
default:
- elog(ERROR, "unexcpected GUC type: %d", conf->vartype);
+ elog(ERROR, "unexpected GUC type: %d", conf->vartype);
}
/* skip GUC variables that match the built-in default */
# AM occurs. To achieve that we create a table with the standard
# AM, test AM, standard AM. That guarantees that there needs to be
# a SET interspersed. Then use a regex that prevents interspersed
- # SET ...; statements, followed by the exptected CREATE TABLE. Not
+ # SET ...; statements, followed by the expected CREATE TABLE. Not
# pretty, but seems hard to do better in this framework.
'CREATE TABLE regress_pg_dump_table_am' => {
create_order => 12,
Datum *values; /* item values */
} MCVItem;
-/* multivariate MCV list - essentally an array of MCV items */
+/* multivariate MCV list - essentially an array of MCV items */
typedef struct MCVList
{
uint32 magic; /* magic constant marker */
* Support functions to parse/construct binary value.
* Unlike many other representation of expression the first/main
* node is not an operation but left operand of expression. That
- * allows to implement cheep follow-path descending in jsonb
+ * allows to implement cheap follow-path descending in jsonb
* structure and then execute operator with right operand
*/
/* All "broken" PQExpBuffers point to this string. */
static const char oom_buffer[1] = "";
-/* Need a char * for unconstify() compatiblity */
+/* Need a char * for unconstify() compatibility */
static const char *oom_buffer_ptr = oom_buffer;
static bool appendPQExpBufferVA(PQExpBuffer str, const char *fmt, va_list args) pg_attribute_printf(2, 0);
projects / postgresql / commitdiff