provided by Andrew.
PG_MODULE_MAGIC;
/* GUC variables */
-static int auto_explain_log_min_duration = -1; /* msec or -1 */
+static int auto_explain_log_min_duration = -1; /* msec or -1 */
static bool auto_explain_log_analyze = false;
static bool auto_explain_log_verbose = false;
static bool auto_explain_log_nested_statements = false;
static int nesting_level = 0;
/* Saved hook values in case of unload */
-static ExecutorStart_hook_type prev_ExecutorStart = NULL;
-static ExecutorRun_hook_type prev_ExecutorRun = NULL;
-static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+static ExecutorStart_hook_type prev_ExecutorStart = NULL;
+static ExecutorRun_hook_type prev_ExecutorRun = NULL;
+static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
#define auto_explain_enabled() \
(auto_explain_log_min_duration >= 0 && \
(nesting_level == 0 || auto_explain_log_nested_statements))
-void _PG_init(void);
-void _PG_fini(void);
+void _PG_init(void);
+void _PG_fini(void);
static void explain_ExecutorStart(QueryDesc *queryDesc, int eflags);
static void explain_ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction,
- long count);
+ ScanDirection direction,
+ long count);
static void explain_ExecutorEnd(QueryDesc *queryDesc);
{
/* Define custom GUC variables. */
DefineCustomIntVariable("auto_explain.log_min_duration",
- "Sets the minimum execution time above which plans will be logged.",
- "Zero prints all plans. -1 turns this feature off.",
+ "Sets the minimum execution time above which plans will be logged.",
+ "Zero prints all plans. -1 turns this feature off.",
&auto_explain_log_min_duration,
-1,
-1, INT_MAX / 1000,
if (auto_explain_enabled())
{
/*
- * Set up to track total elapsed time in ExecutorRun. Make sure
- * the space is allocated in the per-query context so it will go
- * away at ExecutorEnd.
+ * Set up to track total elapsed time in ExecutorRun. Make sure the
+ * space is allocated in the per-query context so it will go away at
+ * ExecutorEnd.
*/
if (queryDesc->totaltime == NULL)
{
{
if (queryDesc->totaltime && auto_explain_enabled())
{
- double msec;
+ double msec;
/*
- * Make sure stats accumulation is done. (Note: it's okay if
- * several levels of hook all do this.)
+ * Make sure stats accumulation is done. (Note: it's okay if several
+ * levels of hook all do this.)
*/
InstrEndLoop(queryDesc->totaltime);
msec = queryDesc->totaltime->total * 1000.0;
if (msec >= auto_explain_log_min_duration)
{
- StringInfoData buf;
+ StringInfoData buf;
initStringInfo(&buf);
ExplainPrintPlan(&buf, queryDesc,
- queryDesc->doInstrument && auto_explain_log_analyze,
+ queryDesc->doInstrument && auto_explain_log_analyze,
auto_explain_log_verbose);
/* Remove last line break */
typedef struct TypeInfo
{
- bool is_varlena;
- Datum (*leftmostvalue)(void);
- Datum (*typecmp)(FunctionCallInfo);
+ bool is_varlena;
+ Datum (*leftmostvalue) (void);
+ Datum (*typecmp) (FunctionCallInfo);
} TypeInfo;
typedef struct QueryInfo
{
- StrategyNumber strategy;
- Datum datum;
+ StrategyNumber strategy;
+ Datum datum;
} QueryInfo;
#define GIN_EXTRACT_VALUE(type) \
PG_FUNCTION_INFO_V1(gin_extract_value_##type); \
-Datum gin_extract_value_##type(PG_FUNCTION_ARGS); \
+Datum gin_extract_value_##type(PG_FUNCTION_ARGS); \
Datum \
gin_extract_value_##type(PG_FUNCTION_ARGS) \
{ \
#define GIN_EXTRACT_QUERY(type) \
PG_FUNCTION_INFO_V1(gin_extract_query_##type); \
-Datum gin_extract_query_##type(PG_FUNCTION_ARGS); \
+Datum gin_extract_query_##type(PG_FUNCTION_ARGS); \
Datum \
gin_extract_query_##type(PG_FUNCTION_ARGS) \
{ \
int32 *nentries = (int32 *) PG_GETARG_POINTER(1); \
StrategyNumber strategy = PG_GETARG_UINT16(2); \
bool **partialmatch = (bool **) PG_GETARG_POINTER(3); \
- Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4); \
+ Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4); \
Datum *entries = (Datum *) palloc(sizeof(Datum)); \
QueryInfo *data = (QueryInfo *) palloc(sizeof(QueryInfo)); \
bool *ptr_partialmatch; \
*/
#define GIN_COMPARE_PREFIX(type) \
PG_FUNCTION_INFO_V1(gin_compare_prefix_##type); \
-Datum gin_compare_prefix_##type(PG_FUNCTION_ARGS); \
+Datum gin_compare_prefix_##type(PG_FUNCTION_ARGS); \
Datum \
gin_compare_prefix_##type(PG_FUNCTION_ARGS) \
{ \
cmp; \
\
cmp = DatumGetInt32(DirectFunctionCall2( \
- TypeInfo_##type.typecmp, \
- (data->strategy == BTLessStrategyNumber || \
+ TypeInfo_##type.typecmp, \
+ (data->strategy == BTLessStrategyNumber || \
data->strategy == BTLessEqualStrategyNumber) \
- ? data->datum : a, \
+ ? data->datum : a, \
b)); \
\
switch (data->strategy) \
res = 1; \
break; \
default: \
- elog(ERROR, "unrecognized strategy number: %d", \
+ elog(ERROR, "unrecognized strategy number: %d", \
data->strategy); \
res = 0; \
} \
PG_FUNCTION_INFO_V1(gin_btree_consistent);
-Datum gin_btree_consistent(PG_FUNCTION_ARGS);
+Datum gin_btree_consistent(PG_FUNCTION_ARGS);
Datum
gin_btree_consistent(PG_FUNCTION_ARGS)
{
- bool *recheck = (bool *) PG_GETARG_POINTER(5);
+ bool *recheck = (bool *) PG_GETARG_POINTER(5);
*recheck = false;
PG_RETURN_BOOL(true);
return Int16GetDatum(SHRT_MIN);
}
static TypeInfo TypeInfo_int2 = {false, leftmostvalue_int2, btint2cmp};
+
GIN_SUPPORT(int2)
static Datum
return Int32GetDatum(INT_MIN);
}
static TypeInfo TypeInfo_int4 = {false, leftmostvalue_int4, btint4cmp};
+
GIN_SUPPORT(int4)
static Datum
leftmostvalue_int8(void)
{
/*
- * Use sequence's definition to keep compatibility.
- * Another way may make a problem with INT64_IS_BUSTED
+ * Use sequence's definition to keep compatibility. Another way may make a
+ * problem with INT64_IS_BUSTED
*/
return Int64GetDatum(SEQ_MINVALUE);
}
static TypeInfo TypeInfo_int8 = {false, leftmostvalue_int8, btint8cmp};
+
GIN_SUPPORT(int8)
static Datum
return Float4GetDatum(-get_float4_infinity());
}
static TypeInfo TypeInfo_float4 = {false, leftmostvalue_float4, btfloat4cmp};
+
GIN_SUPPORT(float4)
static Datum
return Float8GetDatum(-get_float8_infinity());
}
static TypeInfo TypeInfo_float8 = {false, leftmostvalue_float8, btfloat8cmp};
+
GIN_SUPPORT(float8)
static Datum
leftmostvalue_money(void)
{
/*
- * Use sequence's definition to keep compatibility.
- * Another way may make a problem with INT64_IS_BUSTED
+ * Use sequence's definition to keep compatibility. Another way may make a
+ * problem with INT64_IS_BUSTED
*/
return Int64GetDatum(SEQ_MINVALUE);
}
static TypeInfo TypeInfo_money = {false, leftmostvalue_money, cash_cmp};
+
GIN_SUPPORT(money)
static Datum
return ObjectIdGetDatum(0);
}
static TypeInfo TypeInfo_oid = {false, leftmostvalue_oid, btoidcmp};
+
GIN_SUPPORT(oid)
static Datum
return TimestampGetDatum(DT_NOBEGIN);
}
static TypeInfo TypeInfo_timestamp = {false, leftmostvalue_timestamp, timestamp_cmp};
+
GIN_SUPPORT(timestamp)
static TypeInfo TypeInfo_timestamptz = {false, leftmostvalue_timestamp, timestamp_cmp};
+
GIN_SUPPORT(timestamptz)
static Datum
return TimeADTGetDatum(0);
}
static TypeInfo TypeInfo_time = {false, leftmostvalue_time, time_cmp};
+
GIN_SUPPORT(time)
static Datum
leftmostvalue_timetz(void)
{
- TimeTzADT *v = palloc(sizeof(TimeTzADT));
+ TimeTzADT *v = palloc(sizeof(TimeTzADT));
v->time = 0;
- v->zone = -24*3600; /* XXX is that true? */
+ v->zone = -24 * 3600; /* XXX is that true? */
return TimeTzADTPGetDatum(v);
}
static TypeInfo TypeInfo_timetz = {false, leftmostvalue_timetz, timetz_cmp};
+
GIN_SUPPORT(timetz)
static Datum
return DateADTGetDatum(DATEVAL_NOBEGIN);
}
static TypeInfo TypeInfo_date = {false, leftmostvalue_date, date_cmp};
+
GIN_SUPPORT(date)
static Datum
leftmostvalue_interval(void)
{
- Interval *v = palloc(sizeof(Interval));
+ Interval *v = palloc(sizeof(Interval));
v->time = DT_NOBEGIN;
v->day = 0;
return IntervalPGetDatum(v);
}
static TypeInfo TypeInfo_interval = {false, leftmostvalue_interval, interval_cmp};
+
GIN_SUPPORT(interval)
static Datum
leftmostvalue_macaddr(void)
{
- macaddr *v = palloc0(sizeof(macaddr));
+ macaddr *v = palloc0(sizeof(macaddr));
return MacaddrPGetDatum(v);
}
static TypeInfo TypeInfo_macaddr = {false, leftmostvalue_macaddr, macaddr_cmp};
+
GIN_SUPPORT(macaddr)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_inet = {true, leftmostvalue_inet, network_cmp};
+
GIN_SUPPORT(inet)
static TypeInfo TypeInfo_cidr = {true, leftmostvalue_inet, network_cmp};
+
GIN_SUPPORT(cidr)
static Datum
return PointerGetDatum(cstring_to_text_with_len("", 0));
}
static TypeInfo TypeInfo_text = {true, leftmostvalue_text, bttextcmp};
+
GIN_SUPPORT(text)
static Datum
return CharGetDatum(SCHAR_MIN);
}
static TypeInfo TypeInfo_char = {false, leftmostvalue_char, btcharcmp};
+
GIN_SUPPORT(char)
static TypeInfo TypeInfo_bytea = {true, leftmostvalue_text, byteacmp};
+
GIN_SUPPORT(bytea)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_bit = {true, leftmostvalue_bit, bitcmp};
+
GIN_SUPPORT(bit)
static Datum
Int32GetDatum(-1));
}
static TypeInfo TypeInfo_varbit = {true, leftmostvalue_varbit, bitcmp};
+
GIN_SUPPORT(varbit)
/*
#define NUMERIC_IS_LEFTMOST(x) ((x) == NULL)
PG_FUNCTION_INFO_V1(gin_numeric_cmp);
-Datum gin_numeric_cmp(PG_FUNCTION_ARGS);
+Datum gin_numeric_cmp(PG_FUNCTION_ARGS);
Datum
gin_numeric_cmp(PG_FUNCTION_ARGS)
{
- Numeric a = (Numeric)PG_GETARG_POINTER(0);
- Numeric b = (Numeric)PG_GETARG_POINTER(1);
- int res = 0;
+ Numeric a = (Numeric) PG_GETARG_POINTER(0);
+ Numeric b = (Numeric) PG_GETARG_POINTER(1);
+ int res = 0;
- if ( NUMERIC_IS_LEFTMOST(a) )
+ if (NUMERIC_IS_LEFTMOST(a))
{
- res = ( NUMERIC_IS_LEFTMOST(b) ) ? 0 : -1;
+ res = (NUMERIC_IS_LEFTMOST(b)) ? 0 : -1;
}
- else if ( NUMERIC_IS_LEFTMOST(b) )
+ else if (NUMERIC_IS_LEFTMOST(b))
{
res = 1;
}
}
static TypeInfo TypeInfo_numeric = {true, leftmostvalue_numeric, gin_numeric_cmp};
+
GIN_SUPPORT(numeric)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
static GBT_VARKEY *
-gbt_bit_l2n(GBT_VARKEY * leaf)
+gbt_bit_l2n(GBT_VARKEY *leaf)
{
GBT_VARKEY *out = leaf;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval = FALSE;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetByteaP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Cash lower;
Cash upper;
-} cashKEY;
+} cashKEY;
/*
** Cash ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Cash query = PG_GETARG_CASH(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
cashKEY *kkk = (cashKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
DateADT lower;
DateADT upper;
-} dateKEY;
+} dateKEY;
/*
** date ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
DateADT query = PG_GETARG_DATEADT(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
dateKEY *kkk = (dateKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
float4 lower;
float4 upper;
-} float4KEY;
+} float4KEY;
/*
** float4 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
float4 query = PG_GETARG_FLOAT4(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
float4KEY *kkk = (float4KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
float8 lower;
float8 upper;
-} float8KEY;
+} float8KEY;
/*
** float8 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
float8 query = PG_GETARG_FLOAT8(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
float8KEY *kkk = (float8KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef __BTREE_GIST_H__
#define __BTREE_GIST_H__
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
double lower;
double upper;
-} inetKEY;
+} inetKEY;
/*
** inet ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
double query = convert_network_to_scalar(PG_GETARG_DATUM(1), INETOID);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
inetKEY *kkk = (inetKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are inexact */
*recheck = true;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(gbt_num_consistent(&key, (void *) &query,
&strategy, GIST_LEAF(entry), &tinfo));
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int16 lower;
int16 upper;
-} int16KEY;
+} int16KEY;
/*
** int16 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int16 query = PG_GETARG_INT16(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int16KEY *kkk = (int16KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int32 lower;
int32 upper;
-} int32KEY;
+} int32KEY;
/*
** int32 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int32 query = PG_GETARG_INT32(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int32KEY *kkk = (int32KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
int64 lower;
int64 upper;
-} int64KEY;
+} int64KEY;
/*
** int64 ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
int64 query = PG_GETARG_INT64(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
int64KEY *kkk = (int64KEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Interval lower,
upper;
-} intvKEY;
+} intvKEY;
/*
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Interval *query = PG_GETARG_INTERVAL_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
intvKEY *kkk = (intvKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
macaddr lower;
macaddr upper;
-} macKEY;
+} macKEY;
/*
** OID ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
macaddr *query = (macaddr *) PG_GETARG_POINTER(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
macKEY *kkk = (macKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetNumeric(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Oid lower;
Oid upper;
-} oidKEY;
+} oidKEY;
/*
** OID ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Oid query = PG_GETARG_OID(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
oidKEY *kkk = (oidKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_var.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetTextP(PG_GETARG_DATUM(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
void *query = (void *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
TimeADT lower;
TimeADT upper;
-} timeKEY;
+} timeKEY;
/*
** time ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeADT query = PG_GETARG_TIMEADT(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TimeTzADT *query = PG_GETARG_TIMETZADT_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
timeKEY *kkk = (timeKEY *) DatumGetPointer(entry->key);
qqq = (query->time + query->zone);
#endif
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &qqq, &strategy, GIST_LEAF(entry), &tinfo)
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(newentry->upper),
- TimeADTGetDatumFast(origentry->upper)));
+ TimeADTGetDatumFast(newentry->upper),
+ TimeADTGetDatumFast(origentry->upper)));
res = INTERVAL_TO_SEC(intr);
res = Max(res, 0);
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(origentry->lower),
- TimeADTGetDatumFast(newentry->lower)));
+ TimeADTGetDatumFast(origentry->lower),
+ TimeADTGetDatumFast(newentry->lower)));
res2 = INTERVAL_TO_SEC(intr);
res2 = Max(res2, 0);
{
intr = DatumGetIntervalP(DirectFunctionCall2(
time_mi_time,
- TimeADTGetDatumFast(origentry->upper),
- TimeADTGetDatumFast(origentry->lower)));
+ TimeADTGetDatumFast(origentry->upper),
+ TimeADTGetDatumFast(origentry->lower)));
*result += FLT_MIN;
*result += (float) (res / (res + INTERVAL_TO_SEC(intr)));
*result *= (FLT_MAX / (((GISTENTRY *) PG_GETARG_POINTER(0))->rel->rd_att->natts + 1));
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
{
Timestamp lower;
Timestamp upper;
-} tsKEY;
+} tsKEY;
/*
** timestamp ops
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Timestamp query = PG_GETARG_TIMESTAMP(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
tsKEY *kkk = (tsKEY *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk->lower;
- key.upper = (GBT_NUMKEY *) & kkk->upper;
+ key.lower = (GBT_NUMKEY *) &kkk->lower;
+ key.upper = (GBT_NUMKEY *) &kkk->upper;
PG_RETURN_BOOL(
gbt_num_consistent(&key, (void *) &query, &strategy, GIST_LEAF(entry), &tinfo)
gbt_tstz_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
- TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
+ TimestampTz query = PG_GETARG_TIMESTAMPTZ(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
char *kkk = (char *) DatumGetPointer(entry->key);
/* All cases served by this function are exact */
*recheck = false;
- key.lower = (GBT_NUMKEY *) & kkk[0];
- key.upper = (GBT_NUMKEY *) & kkk[MAXALIGN(tinfo.size)];
+ key.lower = (GBT_NUMKEY *) &kkk[0];
+ key.upper = (GBT_NUMKEY *) &kkk[MAXALIGN(tinfo.size)];
qqq = tstz_to_ts_gmt(query);
PG_RETURN_BOOL(
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
#include "btree_utils_num.h"
GISTENTRY *
-gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo * tinfo)
+gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry, const gbtree_ninfo *tinfo)
{
if (entry->leafkey)
{
*/
void *
-gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec, const gbtree_ninfo * tinfo)
+gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec, const gbtree_ninfo *tinfo)
{
int i,
numranges;
*/
bool
-gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b, const gbtree_ninfo * tinfo)
+gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R b1,
void
-gbt_num_bin_union(Datum *u, GBT_NUMKEY * e, const gbtree_ninfo * tinfo)
+gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo)
{
GBT_NUMKEY_R rd;
bool
gbt_num_consistent(
- const GBT_NUMKEY_R * key,
+ const GBT_NUMKEY_R *key,
const void *query,
const StrategyNumber *strategy,
bool is_leaf,
- const gbtree_ninfo * tinfo
+ const gbtree_ninfo *tinfo
)
{
GIST_SPLITVEC *
gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_ninfo * tinfo)
+ const gbtree_ninfo *tinfo)
{
OffsetNumber i,
maxoff = entryvec->n - 1;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef __BTREE_UTILS_NUM_H__
#define __BTREE_UTILS_NUM_H__
{
const GBT_NUMKEY *lower,
*upper;
-} GBT_NUMKEY_R;
+} GBT_NUMKEY_R;
/* for sorting */
{
int i;
GBT_NUMKEY *t;
-} Nsrt;
+} Nsrt;
/* type description */
bool (*f_le) (const void *, const void *); /* less equal */
bool (*f_lt) (const void *, const void *); /* less then */
int (*f_cmp) (const void *, const void *); /* key compare function */
-} gbtree_ninfo;
+} gbtree_ninfo;
/*
#endif
-extern bool gbt_num_consistent(const GBT_NUMKEY_R * key, const void *query,
+extern bool gbt_num_consistent(const GBT_NUMKEY_R *key, const void *query,
const StrategyNumber *strategy, bool is_leaf,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
extern GIST_SPLITVEC *gbt_num_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
extern GISTENTRY *gbt_num_compress(GISTENTRY *retval, GISTENTRY *entry,
- const gbtree_ninfo * tinfo);
+ const gbtree_ninfo *tinfo);
-extern void *gbt_num_union(GBT_NUMKEY * out, const GistEntryVector *entryvec,
- const gbtree_ninfo * tinfo);
+extern void *gbt_num_union(GBT_NUMKEY *out, const GistEntryVector *entryvec,
+ const gbtree_ninfo *tinfo);
-extern bool gbt_num_same(const GBT_NUMKEY * a, const GBT_NUMKEY * b,
- const gbtree_ninfo * tinfo);
+extern bool gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b,
+ const gbtree_ninfo *tinfo);
-extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY * e,
- const gbtree_ninfo * tinfo);
+extern void gbt_num_bin_union(Datum *u, GBT_NUMKEY *e,
+ const gbtree_ninfo *tinfo);
#endif
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "btree_gist.h"
/* Returns a better readable representaion of variable key ( sets pointer ) */
GBT_VARKEY_R
-gbt_var_key_readable(const GBT_VARKEY * k)
+gbt_var_key_readable(const GBT_VARKEY *k)
{
GBT_VARKEY_R r;
GBT_VARKEY *
-gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node)
+gbt_var_key_copy(const GBT_VARKEY_R *u, bool force_node)
{
GBT_VARKEY *r = NULL;
static GBT_VARKEY *
-gbt_var_leaf2node(GBT_VARKEY * leaf, const gbtree_vinfo * tinfo)
+gbt_var_leaf2node(GBT_VARKEY *leaf, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *out = leaf;
* returns the common prefix length of a node key
*/
static int32
-gbt_var_node_cp_len(const GBT_VARKEY * node, const gbtree_vinfo * tinfo)
+gbt_var_node_cp_len(const GBT_VARKEY *node, const gbtree_vinfo *tinfo)
{
GBT_VARKEY_R r = gbt_var_key_readable(node);
* returns true, if query matches prefix ( common prefix )
*/
static bool
-gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo * tinfo)
+gbt_bytea_pf_match(const bytea *pf, const bytea *query, const gbtree_vinfo *tinfo)
{
bool out = FALSE;
*/
static bool
-gbt_var_node_pf_match(const GBT_VARKEY_R * node, const bytea *query, const gbtree_vinfo * tinfo)
+gbt_var_node_pf_match(const GBT_VARKEY_R *node, const bytea *query, const gbtree_vinfo *tinfo)
{
return (tinfo->trnc && (
* cpf_length .. common prefix length
*/
static GBT_VARKEY *
-gbt_var_node_truncate(const GBT_VARKEY * node, int32 cpf_length, const gbtree_vinfo * tinfo)
+gbt_var_node_truncate(const GBT_VARKEY *node, int32 cpf_length, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *out = NULL;
GBT_VARKEY_R r = gbt_var_key_readable(node);
void
-gbt_var_bin_union(Datum *u, GBT_VARKEY * e, const gbtree_vinfo * tinfo)
+gbt_var_bin_union(Datum *u, GBT_VARKEY *e, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *nk = NULL;
GISTENTRY *
-gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo)
+gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo)
{
GISTENTRY *retval;
GBT_VARKEY *
-gbt_var_union(const GistEntryVector *entryvec, int32 *size, const gbtree_vinfo * tinfo)
+gbt_var_union(const GistEntryVector *entryvec, int32 *size, const gbtree_vinfo *tinfo)
{
int i = 0,
bool
-gbt_var_same(bool *result, const Datum d1, const Datum d2, const gbtree_vinfo * tinfo)
+gbt_var_same(bool *result, const Datum d1, const Datum d2, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *t1 = (GBT_VARKEY *) DatumGetPointer(d1);
float *
-gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, const gbtree_vinfo * tinfo)
+gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n, const gbtree_vinfo *tinfo)
{
GBT_VARKEY *orge = (GBT_VARKEY *) DatumGetPointer(o->key);
}
GIST_SPLITVEC *
-gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo * tinfo)
+gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v, const gbtree_vinfo *tinfo)
{
OffsetNumber i,
maxoff = entryvec->n - 1;
*/
bool
gbt_var_consistent(
- GBT_VARKEY_R * key,
+ GBT_VARKEY_R *key,
const void *query,
const StrategyNumber *strategy,
bool is_leaf,
- const gbtree_vinfo * tinfo
+ const gbtree_vinfo *tinfo
)
{
bool retval = FALSE;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef __BTREE_UTILS_VAR_H__
#define __BTREE_UTILS_VAR_H__
{
bytea *lower,
*upper;
-} GBT_VARKEY_R;
+} GBT_VARKEY_R;
/* used for key sorting */
typedef struct
{
int i;
GBT_VARKEY *t;
-} Vsrt;
+} Vsrt;
/*
type description
bool (*f_lt) (const void *, const void *); /* less then */
int32 (*f_cmp) (const bytea *, const bytea *); /* node compare */
GBT_VARKEY *(*f_l2n) (GBT_VARKEY *); /* convert leaf to node */
-} gbtree_vinfo;
+} gbtree_vinfo;
-extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY * k);
+extern GBT_VARKEY_R gbt_var_key_readable(const GBT_VARKEY *k);
-extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R * u, bool force_node);
+extern GBT_VARKEY *gbt_var_key_copy(const GBT_VARKEY_R *u, bool force_node);
-extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo * tinfo);
+extern GISTENTRY *gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo);
extern GBT_VARKEY *gbt_var_union(const GistEntryVector *entryvec, int32 *size,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern bool gbt_var_same(bool *result, const Datum d1, const Datum d2,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern float *gbt_var_penalty(float *res, const GISTENTRY *o, const GISTENTRY *n,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
-extern bool gbt_var_consistent(GBT_VARKEY_R * key, const void *query,
+extern bool gbt_var_consistent(GBT_VARKEY_R *key, const void *query,
const StrategyNumber *strategy, bool is_leaf,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
extern GIST_SPLITVEC *gbt_var_picksplit(const GistEntryVector *entryvec, GIST_SPLITVEC *v,
- const gbtree_vinfo * tinfo);
-extern void gbt_var_bin_union(Datum *u, GBT_VARKEY * e,
- const gbtree_vinfo * tinfo);
+ const gbtree_vinfo *tinfo);
+extern void gbt_var_bin_union(Datum *u, GBT_VARKEY *e,
+ const gbtree_vinfo *tinfo);
#endif
typedef struct chkpass
{
char password[16];
-} chkpass;
+} chkpass;
/*
* Various forward declarations:
#endif
/*
- * ====================
- * FORWARD DECLARATIONS
- * ====================
+ * ====================
+ * FORWARD DECLARATIONS
+ * ====================
*/
-static int32 citextcmp (text *left, text *right);
-extern Datum citext_cmp (PG_FUNCTION_ARGS);
-extern Datum citext_hash (PG_FUNCTION_ARGS);
-extern Datum citext_eq (PG_FUNCTION_ARGS);
-extern Datum citext_ne (PG_FUNCTION_ARGS);
-extern Datum citext_gt (PG_FUNCTION_ARGS);
-extern Datum citext_ge (PG_FUNCTION_ARGS);
-extern Datum citext_lt (PG_FUNCTION_ARGS);
-extern Datum citext_le (PG_FUNCTION_ARGS);
-extern Datum citext_smaller (PG_FUNCTION_ARGS);
-extern Datum citext_larger (PG_FUNCTION_ARGS);
+static int32 citextcmp(text *left, text *right);
+extern Datum citext_cmp(PG_FUNCTION_ARGS);
+extern Datum citext_hash(PG_FUNCTION_ARGS);
+extern Datum citext_eq(PG_FUNCTION_ARGS);
+extern Datum citext_ne(PG_FUNCTION_ARGS);
+extern Datum citext_gt(PG_FUNCTION_ARGS);
+extern Datum citext_ge(PG_FUNCTION_ARGS);
+extern Datum citext_lt(PG_FUNCTION_ARGS);
+extern Datum citext_le(PG_FUNCTION_ARGS);
+extern Datum citext_smaller(PG_FUNCTION_ARGS);
+extern Datum citext_larger(PG_FUNCTION_ARGS);
/*
- * =================
- * UTILITY FUNCTIONS
- * =================
+ * =================
+ * UTILITY FUNCTIONS
+ * =================
*/
/*
* Returns int32 negative, zero, or positive.
*/
static int32
-citextcmp (text *left, text *right)
+citextcmp(text *left, text *right)
{
- char *lcstr, *rcstr;
- int32 result;
+ char *lcstr,
+ *rcstr;
+ int32 result;
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- result = varstr_cmp(lcstr, strlen(lcstr),
- rcstr, strlen(rcstr));
+ result = varstr_cmp(lcstr, strlen(lcstr),
+ rcstr, strlen(rcstr));
- pfree(lcstr);
- pfree(rcstr);
+ pfree(lcstr);
+ pfree(rcstr);
- return result;
+ return result;
}
/*
- * ==================
- * INDEXING FUNCTIONS
- * ==================
+ * ==================
+ * INDEXING FUNCTIONS
+ * ==================
*/
PG_FUNCTION_INFO_V1(citext_cmp);
Datum
citext_cmp(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- int32 result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ int32 result;
- result = citextcmp(left, right);
+ result = citextcmp(left, right);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_INT32(result);
+ PG_RETURN_INT32(result);
}
PG_FUNCTION_INFO_V1(citext_hash);
Datum
citext_hash(PG_FUNCTION_ARGS)
{
- text *txt = PG_GETARG_TEXT_PP(0);
- char *str;
- Datum result;
+ text *txt = PG_GETARG_TEXT_PP(0);
+ char *str;
+ Datum result;
- str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt));
- result = hash_any((unsigned char *) str, strlen(str));
- pfree(str);
+ str = str_tolower(VARDATA_ANY(txt), VARSIZE_ANY_EXHDR(txt));
+ result = hash_any((unsigned char *) str, strlen(str));
+ pfree(str);
- /* Avoid leaking memory for toasted inputs */
- PG_FREE_IF_COPY(txt, 0);
+ /* Avoid leaking memory for toasted inputs */
+ PG_FREE_IF_COPY(txt, 0);
- PG_RETURN_DATUM(result);
+ PG_RETURN_DATUM(result);
}
/*
- * ==================
- * OPERATOR FUNCTIONS
- * ==================
+ * ==================
+ * OPERATOR FUNCTIONS
+ * ==================
*/
PG_FUNCTION_INFO_V1(citext_eq);
Datum
citext_eq(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- char *lcstr, *rcstr;
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ char *lcstr,
+ *rcstr;
+ bool result;
- /* We can't compare lengths in advance of downcasing ... */
+ /* We can't compare lengths in advance of downcasing ... */
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- /*
- * Since we only care about equality or not-equality, we can
- * avoid all the expense of strcoll() here, and just do bitwise
- * comparison.
- */
- result = (strcmp(lcstr, rcstr) == 0);
+ /*
+ * Since we only care about equality or not-equality, we can avoid all the
+ * expense of strcoll() here, and just do bitwise comparison.
+ */
+ result = (strcmp(lcstr, rcstr) == 0);
- pfree(lcstr);
- pfree(rcstr);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ pfree(lcstr);
+ pfree(rcstr);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_ne);
Datum
citext_ne(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- char *lcstr, *rcstr;
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ char *lcstr,
+ *rcstr;
+ bool result;
- /* We can't compare lengths in advance of downcasing ... */
+ /* We can't compare lengths in advance of downcasing ... */
- lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
- rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
+ lcstr = str_tolower(VARDATA_ANY(left), VARSIZE_ANY_EXHDR(left));
+ rcstr = str_tolower(VARDATA_ANY(right), VARSIZE_ANY_EXHDR(right));
- /*
- * Since we only care about equality or not-equality, we can
- * avoid all the expense of strcoll() here, and just do bitwise
- * comparison.
- */
- result = (strcmp(lcstr, rcstr) != 0);
+ /*
+ * Since we only care about equality or not-equality, we can avoid all the
+ * expense of strcoll() here, and just do bitwise comparison.
+ */
+ result = (strcmp(lcstr, rcstr) != 0);
- pfree(lcstr);
- pfree(rcstr);
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ pfree(lcstr);
+ pfree(rcstr);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_lt);
Datum
citext_lt(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) < 0;
+ result = citextcmp(left, right) < 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_le);
Datum
citext_le(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) <= 0;
+ result = citextcmp(left, right) <= 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_gt);
Datum
citext_gt(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) > 0;
+ result = citextcmp(left, right) > 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
PG_FUNCTION_INFO_V1(citext_ge);
Datum
citext_ge(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- bool result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ bool result;
- result = citextcmp(left, right) >= 0;
+ result = citextcmp(left, right) >= 0;
- PG_FREE_IF_COPY(left, 0);
- PG_FREE_IF_COPY(right, 1);
+ PG_FREE_IF_COPY(left, 0);
+ PG_FREE_IF_COPY(right, 1);
- PG_RETURN_BOOL(result);
+ PG_RETURN_BOOL(result);
}
/*
- * ===================
- * AGGREGATE FUNCTIONS
- * ===================
+ * ===================
+ * AGGREGATE FUNCTIONS
+ * ===================
*/
PG_FUNCTION_INFO_V1(citext_smaller);
Datum
citext_smaller(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- text *result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ text *result;
- result = citextcmp(left, right) < 0 ? left : right;
- PG_RETURN_TEXT_P(result);
+ result = citextcmp(left, right) < 0 ? left : right;
+ PG_RETURN_TEXT_P(result);
}
PG_FUNCTION_INFO_V1(citext_larger);
Datum
citext_larger(PG_FUNCTION_ARGS)
{
- text *left = PG_GETARG_TEXT_PP(0);
- text *right = PG_GETARG_TEXT_PP(1);
- text *result;
+ text *left = PG_GETARG_TEXT_PP(0);
+ text *right = PG_GETARG_TEXT_PP(1);
+ text *result;
- result = citextcmp(left, right) > 0 ? left : right;
- PG_RETURN_TEXT_P(result);
+ result = citextcmp(left, right) > 0 ? left : right;
+ PG_RETURN_TEXT_P(result);
}
/*
** For internal use only
*/
-int32 cube_cmp_v0(NDBOX * a, NDBOX * b);
-bool cube_contains_v0(NDBOX * a, NDBOX * b);
-bool cube_overlap_v0(NDBOX * a, NDBOX * b);
-NDBOX *cube_union_v0(NDBOX * a, NDBOX * b);
-void rt_cube_size(NDBOX * a, double *sz);
-NDBOX *g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep);
-bool g_cube_leaf_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
-bool g_cube_internal_consistent(NDBOX * key, NDBOX * query, StrategyNumber strategy);
+int32 cube_cmp_v0(NDBOX *a, NDBOX *b);
+bool cube_contains_v0(NDBOX *a, NDBOX *b);
+bool cube_overlap_v0(NDBOX *a, NDBOX *b);
+NDBOX *cube_union_v0(NDBOX *a, NDBOX *b);
+void rt_cube_size(NDBOX *a, double *sz);
+NDBOX *g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep);
+bool g_cube_leaf_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
+bool g_cube_internal_consistent(NDBOX *key, NDBOX *query, StrategyNumber strategy);
/*
** Auxiliary funxtions
dur = ARRPTR(ur);
dll = ARRPTR(ll);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
dur = ARRPTR(ur);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
dx = (int4 *) ARR_DATA_PTR(idx);
dim = ARRNELEMS(idx);
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2 * dim;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
NDBOX *query = PG_GETARG_NDBOX(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool res;
** SUPPORT ROUTINES
*/
bool
-g_cube_leaf_consistent(NDBOX * key,
- NDBOX * query,
+g_cube_leaf_consistent(NDBOX *key,
+ NDBOX *query,
StrategyNumber strategy)
{
bool retval;
}
bool
-g_cube_internal_consistent(NDBOX * key,
- NDBOX * query,
+g_cube_internal_consistent(NDBOX *key,
+ NDBOX *query,
StrategyNumber strategy)
{
bool retval;
}
NDBOX *
-g_cube_binary_union(NDBOX * r1, NDBOX * r2, int *sizep)
+g_cube_binary_union(NDBOX *r1, NDBOX *r2, int *sizep)
{
NDBOX *retval;
/* cube_union_v0 */
NDBOX *
-cube_union_v0(NDBOX * a, NDBOX * b)
+cube_union_v0(NDBOX *a, NDBOX *b)
{
int i;
NDBOX *result;
}
void
-rt_cube_size(NDBOX * a, double *size)
+rt_cube_size(NDBOX *a, double *size)
{
int i,
j;
/* make up a metric in which one box will be 'lower' than the other
-- this can be useful for sorting and to determine uniqueness */
int32
-cube_cmp_v0(NDBOX * a, NDBOX * b)
+cube_cmp_v0(NDBOX *a, NDBOX *b)
{
int i;
int dim;
/* Contains */
/* Box(A) CONTAINS Box(B) IFF pt(A) < pt(B) */
bool
-cube_contains_v0(NDBOX * a, NDBOX * b)
+cube_contains_v0(NDBOX *a, NDBOX *b)
{
int i;
/* Overlap */
/* Box(A) Overlap Box(B) IFF (pt(a)LL < pt(B)UR) && (pt(b)LL < pt(a)UR) */
bool
-cube_overlap_v0(NDBOX * a, NDBOX * b)
+cube_overlap_v0(NDBOX *a, NDBOX *b)
{
int i;
dim = n;
if (a->dim > dim)
dim = a->dim;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * dim * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * dim * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = dim;
NDBOX *result;
int size;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = 1;
NDBOX *result;
int size;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * 2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * 2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = 1;
int size;
int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = c->dim + 1;
int size;
int i;
- size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2;
+ size = offsetof(NDBOX, x[0]) +sizeof(double) * (c->dim + 1) *2;
result = (NDBOX *) palloc0(size);
SET_VARSIZE(result, size);
result->dim = c->dim + 1;
int32 vl_len_; /* varlena header (do not touch directly!) */
unsigned int dim;
double x[1];
-} NDBOX;
+} NDBOX;
#define DatumGetNDBOX(x) ((NDBOX*)DatumGetPointer(x))
#define PG_GETARG_NDBOX(x) DatumGetNDBOX( PG_DETOAST_DATUM(PG_GETARG_DATUM(x)) )
PGconn *conn; /* Hold the remote connection */
int openCursorCount; /* The number of open cursors */
bool newXactForCursor; /* Opened a transaction for a cursor */
-} remoteConn;
+} remoteConn;
/*
* Internal declarations
static Datum dblink_record_internal(FunctionCallInfo fcinfo, bool is_async);
static remoteConn *getConnectionByName(const char *name);
static HTAB *createConnHash(void);
-static void createNewConnection(const char *name, remoteConn * rconn);
+static void createNewConnection(const char *name, remoteConn *rconn);
static void deleteConnection(const char *name);
static char **get_pkey_attnames(Oid relid, int16 *numatts);
static char **get_text_array_contents(ArrayType *array, int *numitems);
{
char name[NAMEDATALEN];
remoteConn *rconn;
-} remoteConnHashEnt;
+} remoteConnHashEnt;
/* initial number of connection hashes */
#define NUMCONN 16
funcctx = SRF_FIRSTCALL_INIT();
/*
- * Try to execute the query. Note that since libpq uses malloc,
- * the PGresult will be long-lived even though we are still in
- * a short-lived memory context.
+ * Try to execute the query. Note that since libpq uses malloc, the
+ * PGresult will be long-lived even though we are still in a
+ * short-lived memory context.
*/
res = PQexec(conn, buf.data);
if (!res ||
"the specified FROM clause rowtype")));
/*
- * fast track when no results. We could exit earlier, but then
- * we'd not report error if the result tuple type is wrong.
+ * fast track when no results. We could exit earlier, but then we'd
+ * not report error if the result tuple type is wrong.
*/
if (funcctx->max_calls < 1)
{
/* shouldn't happen */
elog(ERROR, "wrong number of arguments");
}
- else /* is_async */
+ else /* is_async */
{
/* get async result */
if (PG_NARGS() == 2)
if (!conn)
DBLINK_CONN_NOT_AVAIL;
- /* synchronous query, or async result retrieval */
- if (!is_async)
- res = PQexec(conn, sql);
- else
- {
- res = PQgetResult(conn);
- /* NULL means we're all done with the async results */
- if (!res)
- {
- MemoryContextSwitchTo(oldcontext);
- SRF_RETURN_DONE(funcctx);
- }
- }
-
- if (!res ||
- (PQresultStatus(res) != PGRES_COMMAND_OK &&
- PQresultStatus(res) != PGRES_TUPLES_OK))
+ /* synchronous query, or async result retrieval */
+ if (!is_async)
+ res = PQexec(conn, sql);
+ else
+ {
+ res = PQgetResult(conn);
+ /* NULL means we're all done with the async results */
+ if (!res)
{
- dblink_res_error(conname, res, "could not execute query", fail);
- if (freeconn)
- PQfinish(conn);
MemoryContextSwitchTo(oldcontext);
SRF_RETURN_DONE(funcctx);
}
+ }
- if (PQresultStatus(res) == PGRES_COMMAND_OK)
- {
- is_sql_cmd = true;
-
- /* need a tuple descriptor representing one TEXT column */
- tupdesc = CreateTemplateTupleDesc(1, false);
- TupleDescInitEntry(tupdesc, (AttrNumber) 1, "status",
- TEXTOID, -1, 0);
-
- /*
- * and save a copy of the command status string to return as
- * our result tuple
- */
- sql_cmd_status = PQcmdStatus(res);
- funcctx->max_calls = 1;
- }
- else
- funcctx->max_calls = PQntuples(res);
-
- /* got results, keep track of them */
- funcctx->user_fctx = res;
-
- /* if needed, close the connection to the database and cleanup */
+ if (!res ||
+ (PQresultStatus(res) != PGRES_COMMAND_OK &&
+ PQresultStatus(res) != PGRES_TUPLES_OK))
+ {
+ dblink_res_error(conname, res, "could not execute query", fail);
if (freeconn)
PQfinish(conn);
+ MemoryContextSwitchTo(oldcontext);
+ SRF_RETURN_DONE(funcctx);
+ }
- if (!is_sql_cmd)
- {
- /* get a tuple descriptor for our result type */
- switch (get_call_result_type(fcinfo, NULL, &tupdesc))
- {
- case TYPEFUNC_COMPOSITE:
- /* success */
- break;
- case TYPEFUNC_RECORD:
- /* failed to determine actual type of RECORD */
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("function returning record called in context "
- "that cannot accept type record")));
- break;
- default:
- /* result type isn't composite */
- elog(ERROR, "return type must be a row type");
- break;
- }
+ if (PQresultStatus(res) == PGRES_COMMAND_OK)
+ {
+ is_sql_cmd = true;
- /* make sure we have a persistent copy of the tupdesc */
- tupdesc = CreateTupleDescCopy(tupdesc);
- }
+ /* need a tuple descriptor representing one TEXT column */
+ tupdesc = CreateTemplateTupleDesc(1, false);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 1, "status",
+ TEXTOID, -1, 0);
/*
- * check result and tuple descriptor have the same number of
- * columns
+ * and save a copy of the command status string to return as our
+ * result tuple
*/
- if (PQnfields(res) != tupdesc->natts)
- ereport(ERROR,
- (errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("remote query result rowtype does not match "
- "the specified FROM clause rowtype")));
+ sql_cmd_status = PQcmdStatus(res);
+ funcctx->max_calls = 1;
+ }
+ else
+ funcctx->max_calls = PQntuples(res);
- /* fast track when no results */
- if (funcctx->max_calls < 1)
+ /* got results, keep track of them */
+ funcctx->user_fctx = res;
+
+ /* if needed, close the connection to the database and cleanup */
+ if (freeconn)
+ PQfinish(conn);
+
+ if (!is_sql_cmd)
+ {
+ /* get a tuple descriptor for our result type */
+ switch (get_call_result_type(fcinfo, NULL, &tupdesc))
{
- if (res)
- PQclear(res);
- MemoryContextSwitchTo(oldcontext);
- SRF_RETURN_DONE(funcctx);
+ case TYPEFUNC_COMPOSITE:
+ /* success */
+ break;
+ case TYPEFUNC_RECORD:
+ /* failed to determine actual type of RECORD */
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("function returning record called in context "
+ "that cannot accept type record")));
+ break;
+ default:
+ /* result type isn't composite */
+ elog(ERROR, "return type must be a row type");
+ break;
}
- /* store needed metadata for subsequent calls */
- attinmeta = TupleDescGetAttInMetadata(tupdesc);
- funcctx->attinmeta = attinmeta;
+ /* make sure we have a persistent copy of the tupdesc */
+ tupdesc = CreateTupleDescCopy(tupdesc);
+ }
+ /*
+ * check result and tuple descriptor have the same number of columns
+ */
+ if (PQnfields(res) != tupdesc->natts)
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("remote query result rowtype does not match "
+ "the specified FROM clause rowtype")));
+
+ /* fast track when no results */
+ if (funcctx->max_calls < 1)
+ {
+ if (res)
+ PQclear(res);
MemoryContextSwitchTo(oldcontext);
+ SRF_RETURN_DONE(funcctx);
+ }
+
+ /* store needed metadata for subsequent calls */
+ attinmeta = TupleDescGetAttInMetadata(tupdesc);
+ funcctx->attinmeta = attinmeta;
+
+ MemoryContextSwitchTo(oldcontext);
}
rawstr_text = cstring_to_text(rawstr);
result_text = DatumGetTextP(DirectFunctionCall1(quote_literal,
- PointerGetDatum(rawstr_text)));
+ PointerGetDatum(rawstr_text)));
result = text_to_cstring(result_text);
return result;
rawstr_text = cstring_to_text(rawstr);
result_text = DatumGetTextP(DirectFunctionCall1(quote_ident,
- PointerGetDatum(rawstr_text)));
+ PointerGetDatum(rawstr_text)));
result = text_to_cstring(result_text);
return result;
}
static void
-createNewConnection(const char *name, remoteConn * rconn)
+createNewConnection(const char *name, remoteConn *rconn)
{
remoteConnHashEnt *hentry;
bool found;
}
/*
- * For non-superusers, insist that the connstr specify a password. This
+ * For non-superusers, insist that the connstr specify a password. This
* prevents a password from being picked up from .pgpass, a service file,
* the environment, etc. We don't want the postgres user's passwords
* to be accessible to non-superusers.
{
if (!superuser())
{
- PQconninfoOption *options;
- PQconninfoOption *option;
- bool connstr_gives_password = false;
+ PQconninfoOption *options;
+ PQconninfoOption *option;
+ bool connstr_gives_password = false;
options = PQconninfoParse(connstr, NULL);
if (options)
if (!connstr_gives_password)
ereport(ERROR,
- (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
- errmsg("password is required"),
- errdetail("Non-superusers must provide a password in the connection string.")));
+ (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED),
+ errmsg("password is required"),
+ errdetail("Non-superusers must provide a password in the connection string.")));
}
}
dblink_context_conname = conname;
ereport(level,
- (errcode(sqlstate),
- message_primary ? errmsg("%s", message_primary) : errmsg("unknown error"),
- message_detail ? errdetail("%s", message_detail) : 0,
- message_hint ? errhint("%s", message_hint) : 0,
- message_context ? errcontext("%s", message_context) : 0,
- errcontext("Error occurred on dblink connection named \"%s\": %s.",
- dblink_context_conname, dblink_context_msg)));
+ (errcode(sqlstate),
+ message_primary ? errmsg("%s", message_primary) : errmsg("unknown error"),
+ message_detail ? errdetail("%s", message_detail) : 0,
+ message_hint ? errhint("%s", message_hint) : 0,
+ message_context ? errcontext("%s", message_context) : 0,
+ errcontext("Error occurred on dblink connection named \"%s\": %s.",
+ dblink_context_conname, dblink_context_msg)));
}
/*
static char *
get_connect_string(const char *servername)
{
- ForeignServer *foreign_server = NULL;
- UserMapping *user_mapping;
- ListCell *cell;
- StringInfo buf = makeStringInfo();
+ ForeignServer *foreign_server = NULL;
+ UserMapping *user_mapping;
+ ListCell *cell;
+ StringInfo buf = makeStringInfo();
ForeignDataWrapper *fdw;
- AclResult aclresult;
+ AclResult aclresult;
/* first gather the server connstr options */
if (strlen(servername) < NAMEDATALEN)
if (foreign_server)
{
- Oid serverid = foreign_server->serverid;
- Oid fdwid = foreign_server->fdwid;
- Oid userid = GetUserId();
+ Oid serverid = foreign_server->serverid;
+ Oid fdwid = foreign_server->fdwid;
+ Oid userid = GetUserId();
user_mapping = GetUserMapping(userid, serverid);
- fdw = GetForeignDataWrapper(fdwid);
+ fdw = GetForeignDataWrapper(fdwid);
/* Check permissions, user must have usage on the server. */
aclresult = pg_foreign_server_aclcheck(serverid, userid, ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_FOREIGN_SERVER, foreign_server->servername);
- foreach (cell, fdw->options)
+ foreach(cell, fdw->options)
{
- DefElem *def = lfirst(cell);
+ DefElem *def = lfirst(cell);
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
- foreach (cell, foreign_server->options)
+ foreach(cell, foreign_server->options)
{
- DefElem *def = lfirst(cell);
-
+ DefElem *def = lfirst(cell);
+
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
-
- foreach (cell, user_mapping->options)
+
+ foreach(cell, user_mapping->options)
{
-
- DefElem *def = lfirst(cell);
-
+
+ DefElem *def = lfirst(cell);
+
appendStringInfo(buf, "%s='%s' ", def->defname,
escape_param_str(strVal(def->arg)));
}
static char *
escape_param_str(const char *str)
{
- const char *cp;
- StringInfo buf = makeStringInfo();
+ const char *cp;
+ StringInfo buf = makeStringInfo();
for (cp = str; *cp; cp++)
{
{
int maxlen;
bool rejectlong;
-} DictInt;
+} DictInt;
PG_FUNCTION_INFO_V1(dintdict_init);
* distance between the points in miles on earth's surface
*
* If float8 is passed-by-value, the oldstyle version-0 calling convention
- * is unportable, so we use version-1. However, if it's passed-by-reference,
+ * is unportable, so we use version-1. However, if it's passed-by-reference,
* continue to use oldstyle. This is just because we'd like earthdistance
* to serve as a canary for any unintentional breakage of version-0 functions
* with float8 results.
#ifdef USE_FLOAT8_BYVAL
Datum geo_distance(PG_FUNCTION_ARGS);
+
PG_FUNCTION_INFO_V1(geo_distance);
Datum
result = geo_distance_internal(pt1, pt2);
PG_RETURN_FLOAT8(result);
}
-
-#else /* !USE_FLOAT8_BYVAL */
+#else /* !USE_FLOAT8_BYVAL */
double *geo_distance(Point *pt1, Point *pt2);
return resultp;
}
-#endif /* USE_FLOAT8_BYVAL */
+#endif /* USE_FLOAT8_BYVAL */
int free_string_on_destroy;
}
- metastring;
+metastring;
/*
* remaining perl module funcs unchanged except for declaring them static
static void
-DestroyMetaString(metastring * s)
+DestroyMetaString(metastring *s)
{
if (s == NULL)
return;
static void
-IncreaseBuffer(metastring * s, int chars_needed)
+IncreaseBuffer(metastring *s, int chars_needed)
{
META_REALLOC(s->str, (s->bufsize + chars_needed + 10), char);
assert(s->str != NULL);
static void
-MakeUpper(metastring * s)
+MakeUpper(metastring *s)
{
char *i;
static int
-IsVowel(metastring * s, int pos)
+IsVowel(metastring *s, int pos)
{
char c;
static int
-SlavoGermanic(metastring * s)
+SlavoGermanic(metastring *s)
{
if ((char *) strstr(s->str, "W"))
return 1;
static char
-GetAt(metastring * s, int pos)
+GetAt(metastring *s, int pos)
{
if ((pos < 0) || (pos >= s->length))
return '\0';
static void
-SetAt(metastring * s, int pos, char c)
+SetAt(metastring *s, int pos, char c)
{
if ((pos < 0) || (pos >= s->length))
return;
Caveats: the START value is 0 based
*/
static int
-StringAt(metastring * s, int start, int length,...)
+StringAt(metastring *s, int start, int length,...)
{
char *test;
char *pos;
static void
-MetaphAdd(metastring * s, char *new_str)
+MetaphAdd(metastring *s, char *new_str)
{
int add_length;
*/
#define MAX_LEVENSHTEIN_STRLEN 255
-static int levenshtein_internal(const char *s, const char *t,
- int ins_c, int del_c, int sub_c);
+static int levenshtein_internal(const char *s, const char *t,
+ int ins_c, int del_c, int sub_c);
/*
/*
* levenshtein_internal - Calculates Levenshtein distance metric
- * between supplied strings. Generally
- * (1, 1, 1) penalty costs suffices common
- * cases, but your mileage may vary.
+ * between supplied strings. Generally
+ * (1, 1, 1) penalty costs suffices common
+ * cases, but your mileage may vary.
*/
static int
levenshtein_internal(const char *s, const char *t,
int ins_c, int del_c, int sub_c)
{
- int m, n;
- int *prev;
- int *curr;
- int i, j;
+ int m,
+ n;
+ int *prev;
+ int *curr;
+ int i,
+ j;
const char *x;
const char *y;
n = strlen(t);
/*
- * If either m or n is 0, the answer is the other value. This makes
- * sense since it would take that many insertions to build a matching
- * string
+ * If either m or n is 0, the answer is the other value. This makes sense
+ * since it would take that many insertions to build a matching string
*/
if (!m)
return n;
++n;
/*
- * Instead of building an (m+1)x(n+1) array, we'll use two
- * different arrays of size m+1 for storing accumulated values.
- * At each step one represents the "previous" row and one is the
- * "current" row of the notional large array.
+ * Instead of building an (m+1)x(n+1) array, we'll use two different
+ * arrays of size m+1 for storing accumulated values. At each step one
+ * represents the "previous" row and one is the "current" row of the
+ * notional large array.
*/
prev = (int *) palloc(2 * m * sizeof(int));
curr = prev + m;
/* Loop through rows of the notional array */
for (y = t, j = 1; j < n; y++, j++)
{
- int *temp;
+ int *temp;
/*
- * First cell must increment sequentially, as we're on the
- * j'th row of the (m+1)x(n+1) array.
+ * First cell must increment sequentially, as we're on the j'th row of
+ * the (m+1)x(n+1) array.
*/
curr[0] = j;
-
+
for (x = s, i = 1; i < m; x++, i++)
{
- int ins;
- int del;
- int sub;
+ int ins;
+ int del;
+ int sub;
/* Calculate costs for probable operations. */
- ins = prev[i] + ins_c; /* Insertion */
- del = curr[i-1] + del_c; /* Deletion */
- sub = prev[i-1] + ((*x == *y) ? 0 : sub_c); /* Substitution */
+ ins = prev[i] + ins_c; /* Insertion */
+ del = curr[i - 1] + del_c; /* Deletion */
+ sub = prev[i - 1] + ((*x == *y) ? 0 : sub_c); /* Substitution */
/* Take the one with minimum cost. */
curr[i] = Min(ins, del);
}
/*
- * Because the final value was swapped from the previous row to
- * the current row, that's where we'll find it.
+ * Because the final value was swapped from the previous row to the
+ * current row, that's where we'll find it.
*/
- return prev[m-1];
+ return prev[m - 1];
}
Datum
levenshtein_with_costs(PG_FUNCTION_ARGS)
{
- char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
- char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
- int ins_c = PG_GETARG_INT32(2);
- int del_c = PG_GETARG_INT32(3);
- int sub_c = PG_GETARG_INT32(4);
+ char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
+ char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
+ int ins_c = PG_GETARG_INT32(2);
+ int del_c = PG_GETARG_INT32(3);
+ int sub_c = PG_GETARG_INT32(4);
PG_RETURN_INT32(levenshtein_internal(src, dst, ins_c, del_c, sub_c));
}
Datum
levenshtein(PG_FUNCTION_ARGS)
{
- char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
- char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
+ char *src = TextDatumGetCString(PG_GETARG_DATUM(0));
+ char *dst = TextDatumGetCString(PG_GETARG_DATUM(1));
PG_RETURN_INT32(levenshtein_internal(src, dst, 1, 1, 1));
}
static int
-_metaphone(char *word, /* IN */
+_metaphone(char *word, /* IN */
int max_phonemes,
- char **phoned_word) /* OUT */
+ char **phoned_word) /* OUT */
{
int w_idx = 0; /* point in the phonization we're at. */
int p_idx = 0; /* end of the phoned phrase */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Both POSIX and CRC32 checksums */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef _CRC32_H
#define _CRC32_H
uint32
valisnull:1,
pos:31;
-} HEntry;
+} HEntry;
/* these are determined by the sizes of the keylen and vallen fields */
/* in struct HEntry and struct Pairs */
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} HStore;
+} HStore;
#define HSHRDSIZE (VARHDRSZ + sizeof(int4))
#define CALCDATASIZE(x, lenstr) ( (x) * sizeof(HEntry) + HSHRDSIZE + (lenstr) )
uint16 vallen;
bool isnull;
bool needfree;
-} Pairs;
+} Pairs;
int comparePairs(const void *a, const void *b);
-int uniquePairs(Pairs * a, int4 l, int4 *buflen);
+int uniquePairs(Pairs *a, int4 l, int4 *buflen);
-size_t hstoreCheckKeyLen(size_t len);
-size_t hstoreCheckValLen(size_t len);
+size_t hstoreCheckKeyLen(size_t len);
+size_t hstoreCheckValLen(size_t len);
#define HStoreContainsStrategyNumber 7
#define HStoreExistsStrategyNumber 9
-#endif /* __HSTORE_H__ */
+#endif /* __HSTORE_H__ */
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
HStore *query = PG_GETARG_HS(2);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
bool *recheck = (bool *) PG_GETARG_POINTER(5);
int i;
/*
- * Index lost information about correspondence of keys
- * and values, so we need recheck
+ * Index lost information about correspondence of keys and values, so
+ * we need recheck
*/
*recheck = true;
for (i = 0; res && i < 2 * query->size; i++)
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 flag;
char data[1];
-} GISTTYPE;
+} GISTTYPE;
#define ALLISTRUE 0x04
}
static int
-hemdist(GISTTYPE * a, GISTTYPE * b)
+hemdist(GISTTYPE *a, GISTTYPE *b)
{
if (ISALLTRUE(a))
{
}
static int4
-unionkey(BITVECP sbase, GISTTYPE * add)
+unionkey(BITVECP sbase, GISTTYPE *add)
{
int4 i;
BITVECP sadd = GETSIGN(add);
{
GISTTYPE *entry = (GISTTYPE *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool res = true;
Pairs *pairs;
int pcur;
int plen;
-} HSParser;
+} HSParser;
#define RESIZEPRSBUF \
do { \
#define GV_WAITESCESCIN 4
static bool
-get_val(HSParser * state, bool ignoreeq, bool *escaped)
+get_val(HSParser *state, bool ignoreeq, bool *escaped)
{
int st = GV_WAITVAL;
static void
-parse_hstore(HSParser * state)
+parse_hstore(HSParser *state)
{
int st = WKEY;
bool escaped = false;
}
int
-uniquePairs(Pairs * a, int4 l, int4 *buflen)
+uniquePairs(Pairs *a, int4 l, int4 *buflen)
{
Pairs *ptr,
*res;
}
static void
-freeHSParse(HSParser * state)
+freeHSParse(HSParser *state)
{
int i;
HStore *in = PG_GETARG_HS(0);
int buflen,
i,
- nnulls=0;
+ nnulls = 0;
char *out,
*ptr;
char *base = STRPTR(in);
if (entries[i].valisnull)
nnulls++;
- buflen = (4 /* " */ + 2 /* => */ ) * ( in->size - nnulls ) +
- ( 2 /* " */ + 2 /* => */ + 4 /* NULL */ ) * nnulls +
- 2 /* , */ * ( in->size - 1 ) +
- 2 /* esc */ * (VARSIZE(in) - CALCDATASIZE(in->size, 0)) +
- 1 /* \0 */;
+ buflen = (4 /* " */ + 2 /* => */ ) * (in->size - nnulls) +
+ (2 /* " */ + 2 /* => */ + 4 /* NULL */ ) * nnulls +
+ 2 /* , */ * (in->size - 1) +
+ 2 /* esc */ * (VARSIZE(in) - CALCDATASIZE(in->size, 0)) +
+ 1 /* \0 */ ;
out = ptr = palloc(buflen);
for (i = 0; i < in->size; i++)
static HEntry *
-findkey(HStore * hs, char *key, int keylen)
+findkey(HStore *hs, char *key, int keylen)
{
HEntry *StopLow = ARRPTR(hs);
HEntry *StopHigh = StopLow + hs->size;
{
HStore *hs;
int i;
-} AKStore;
+} AKStore;
static void
-setup_firstcall(FuncCallContext *funcctx, HStore * hs)
+setup_firstcall(FuncCallContext *funcctx, HStore *hs)
{
MemoryContext oldcontext;
AKStore *st;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef ___INT_H__
#define ___INT_H__
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 flag;
char data[1];
-} GISTTYPE;
+} GISTTYPE;
#define ALLISTRUE 0x04
int2 type;
int2 left;
int4 val;
-} ITEM;
+} ITEM;
typedef struct
{
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} QUERYTYPE;
+} QUERYTYPE;
#define HDRSIZEQT (VARHDRSZ + sizeof(int4))
#define COMPUTESIZE(size) ( HDRSIZEQT + size * sizeof(ITEM) )
#define OPEN 4
#define CLOSE 5
-bool signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot);
-bool execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot);
-bool ginconsistent(QUERYTYPE * query, bool *check);
-int4 shorterquery(ITEM * q, int4 len);
+bool signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot);
+bool execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot);
+bool ginconsistent(QUERYTYPE *query, bool *check);
+int4 shorterquery(ITEM *q, int4 len);
int compASC(const void *a, const void *b);
qsort((void*)ARRPTR(a), ARRNELEMS(a),sizeof(int4), \
(direction) ? compASC : compDESC )
-#endif /* ___INT_H__ */
+#endif /* ___INT_H__ */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
NODE *str;
/* number in str */
int4 num;
-} WORKSTATE;
+} WORKSTATE;
/*
* get token from query string
*/
static int4
-gettoken(WORKSTATE * state, int4 *val)
+gettoken(WORKSTATE *state, int4 *val)
{
char nnn[16],
*curnnn;
* push new one in polish notation reverse view
*/
static void
-pushquery(WORKSTATE * state, int4 type, int4 val)
+pushquery(WORKSTATE *state, int4 type, int4 val)
{
NODE *tmp = (NODE *) palloc(sizeof(NODE));
* make polish notation of query
*/
static int4
-makepol(WORKSTATE * state)
+makepol(WORKSTATE *state)
{
int4 val,
type;
* is there value 'val' in array or not ?
*/
static bool
-checkcondition_arr(void *checkval, ITEM * item)
+checkcondition_arr(void *checkval, ITEM *item)
{
int4 *StopLow = ((CHKVAL *) checkval)->arrb;
int4 *StopHigh = ((CHKVAL *) checkval)->arre;
}
static bool
-checkcondition_bit(void *checkval, ITEM * item)
+checkcondition_bit(void *checkval, ITEM *item)
{
return GETBIT(checkval, HASHVAL(item->val));
}
* check for boolean condition
*/
static bool
-execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * item))
+execute(ITEM *curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM *item))
{
if (curitem->type == VAL)
* signconsistent & execconsistent called by *_consistent
*/
bool
-signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot)
+signconsistent(QUERYTYPE *query, BITVEC sign, bool calcnot)
{
return execute(
GETQUERY(query) + query->size - 1,
}
bool
-execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot)
+execconsistent(QUERYTYPE *query, ArrayType *array, bool calcnot)
{
CHKVAL chkval;
} GinChkVal;
static bool
-checkcondition_gin(void *checkval, ITEM * item)
+checkcondition_gin(void *checkval, ITEM *item)
{
GinChkVal *gcv = (GinChkVal *) checkval;
}
bool
-ginconsistent(QUERYTYPE * query, bool *check)
+ginconsistent(QUERYTYPE *query, bool *check)
{
GinChkVal gcv;
ITEM *items = GETQUERY(query);
}
static void
-findoprnd(ITEM * ptr, int4 *pos)
+findoprnd(ITEM *ptr, int4 *pos)
{
#ifdef BS_DEBUG
elog(DEBUG3, (ptr[*pos].type == OPR) ?
}
static int4
-countdroptree(ITEM * q, int4 pos)
+countdroptree(ITEM *q, int4 pos)
{
if (q[pos].type == VAL)
return 1;
* we can modify query tree for clearing
*/
int4
-shorterquery(ITEM * q, int4 len)
+shorterquery(ITEM *q, int4 len)
{
int4 index,
posnot,
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "postgres.h"
{
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
bool *recheck = (bool *) PG_GETARG_POINTER(5);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
ArrayType *query = (ArrayType *) PG_DETOAST_DATUM_COPY(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
** intbig functions
*********************************************************************/
static bool
-_intbig_overlap(GISTTYPE * a, ArrayType *b)
+_intbig_overlap(GISTTYPE *a, ArrayType *b)
{
int num = ARRNELEMS(b);
int4 *ptr = ARRPTR(b);
}
static bool
-_intbig_contains(GISTTYPE * a, ArrayType *b)
+_intbig_contains(GISTTYPE *a, ArrayType *b)
{
int num = ARRNELEMS(b);
int4 *ptr = ARRPTR(b);
}
static int
-hemdist(GISTTYPE * a, GISTTYPE * b)
+hemdist(GISTTYPE *a, GISTTYPE *b)
{
if (ISALLTRUE(a))
{
}
static int4
-unionkey(BITVECP sbase, GISTTYPE * add)
+unionkey(BITVECP sbase, GISTTYPE *add)
{
int4 i;
BITVECP sadd = GETSIGN(add);
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
ArrayType *query = (ArrayType *) PG_DETOAST_DATUM(PG_GETARG_POINTER(1));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool retval;
INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC
};
-static const char * const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
+static const char *const isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"};
static bool g_weak = false;
static bool g_initialized = false;
* If errorOK is true, just return "false" for bad input.
*/
static bool
-ean2isn(ean13 ean, bool errorOK, ean13 * result, enum isn_type accept)
+ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept)
{
enum isn_type type = INVALID;
* (even if the check digit is valid)
*/
static bool
-string2ean(const char *str, bool errorOK, ean13 * result,
+string2ean(const char *str, bool errorOK, ean13 *result,
enum isn_type accept)
{
bool digit,
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* GiST support for ltree[]
static void
-hashing(BITVECP sign, ltree * t)
+hashing(BITVECP sign, ltree *t)
{
int tlen = t->numlevel;
ltree_level *cur = LTREE_FIRST(t);
}
static int4
-unionkey(BITVECP sbase, ltree_gist * add)
+unionkey(BITVECP sbase, ltree_gist *add)
{
int4 i;
BITVECP sadd = LTG_SIGN(add);
}
static int
-hemdist(ltree_gist * a, ltree_gist * b)
+hemdist(ltree_gist *a, ltree_gist *b)
{
if (LTG_ISALLTRUE(a))
{
}
static bool
-gist_te(ltree_gist * key, ltree * query)
+gist_te(ltree_gist *key, ltree *query)
{
ltree_level *curq = LTREE_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static bool
-checkcondition_bit(void *checkval, ITEM * val)
+checkcondition_bit(void *checkval, ITEM *val)
{
return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(checkval, AHASHVAL(val->val)) : true;
}
static bool
-gist_qtxt(ltree_gist * key, ltxtquery * query)
+gist_qtxt(ltree_gist *key, ltxtquery *query)
{
if (LTG_ISALLTRUE(key))
return true;
}
static bool
-gist_qe(ltree_gist * key, lquery * query)
+gist_qe(ltree_gist *key, lquery *query)
{
lquery_level *curq = LQUERY_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static bool
-_arrq_cons(ltree_gist * key, ArrayType *_query)
+_arrq_cons(ltree_gist *key, ArrayType *_query)
{
lquery *query = (lquery *) ARR_DATA_PTR(_query);
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
char *query = (char *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1)));
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* op function for ltree[]
#define NEXTVAL(x) ( (ltree*)( (char*)(x) + INTALIGN( VARSIZE(x) ) ) )
static bool
-array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree ** found)
+array_iterator(ArrayType *la, PGCALL2 callback, void *param, ltree **found)
{
int num = ArrayGetNItems(ARR_NDIM(la), ARR_DIMS(la));
ltree *item = (ltree *) ARR_DATA_PTR(la);
int nt;
int posq;
int post;
-} FieldNot;
+} FieldNot;
static char *
getlexeme(char *start, char *end, int *len)
{
char *ptr;
- int charlen;
-
- while (start < end && (charlen = pg_mblen(start)) == 1 && t_iseq(start,'_') )
+ int charlen;
+
+ while (start < end && (charlen = pg_mblen(start)) == 1 && t_iseq(start, '_'))
start += charlen;
ptr = start;
if (ptr >= end)
return NULL;
- while (ptr < end && !( (charlen = pg_mblen(ptr)) == 1 && t_iseq(ptr, '_') ) )
+ while (ptr < end && !((charlen = pg_mblen(ptr)) == 1 && t_iseq(ptr, '_')))
ptr += charlen;
*len = ptr - start;
}
bool
-compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
+ compare_subnode(ltree_level *t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend)
{
char *endt = t->name + t->len;
char *endq = qn + len;
int
ltree_strncasecmp(const char *a, const char *b, size_t s)
{
- char *al = str_tolower(a, s);
- char *bl = str_tolower(b, s);
- int res;
-
- res = strncmp(al, bl,s);
+ char *al = str_tolower(a, s);
+ char *bl = str_tolower(b, s);
+ int res;
+
+ res = strncmp(al, bl, s);
pfree(al);
pfree(bl);
}
static bool
-checkLevel(lquery_level * curq, ltree_level * curt)
+checkLevel(lquery_level *curq, ltree_level *curt)
{
int (*cmpptr) (const char *, const char *, size_t);
lquery_variant *curvar = LQL_FIRST(curq);
};
static bool
-checkCond(lquery_level * curq, int query_numlevel, ltree_level * curt, int tree_numlevel, FieldNot * ptr)
+checkCond(lquery_level *curq, int query_numlevel, ltree_level *curt, int tree_numlevel, FieldNot *ptr)
{
uint32 low_pos = 0,
high_pos = 0,
{
uint16 len;
char name[1];
-} ltree_level;
+} ltree_level;
#define LEVEL_HDRSIZE (offsetof(ltree_level,name))
#define LEVEL_NEXT(x) ( (ltree_level*)( ((char*)(x)) + MAXALIGN(((ltree_level*)(x))->len + LEVEL_HDRSIZE) ) )
int32 vl_len_; /* varlena header (do not touch directly!) */
uint16 numlevel;
char data[1];
-} ltree;
+} ltree;
#define LTREE_HDRSIZE MAXALIGN( offsetof(ltree, data) )
#define LTREE_FIRST(x) ( (ltree_level*)( ((char*)(x))+LTREE_HDRSIZE ) )
uint16 len;
uint8 flag;
char name[1];
-} lquery_variant;
+} lquery_variant;
#define LVAR_HDRSIZE MAXALIGN(offsetof(lquery_variant, name))
#define LVAR_NEXT(x) ( (lquery_variant*)( ((char*)(x)) + MAXALIGN(((lquery_variant*)(x))->len) + LVAR_HDRSIZE ) )
uint16 low;
uint16 high;
char variants[1];
-} lquery_level;
+} lquery_level;
#define LQL_HDRSIZE MAXALIGN( offsetof(lquery_level,variants) )
#define LQL_NEXT(x) ( (lquery_level*)( ((char*)(x)) + MAXALIGN(((lquery_level*)(x))->totallen) ) )
uint16 firstgood;
uint16 flag;
char data[1];
-} lquery;
+} lquery;
#define LQUERY_HDRSIZE MAXALIGN( offsetof(lquery, data) )
#define LQUERY_FIRST(x) ( (lquery_level*)( ((char*)(x))+LQUERY_HDRSIZE ) )
#define LQUERY_HASNOT 0x01
-#define ISALNUM(x) ( t_isalpha(x) || t_isdigit(x) || ( pg_mblen(x) == 1 && t_iseq((x), '_') ) )
+#define ISALNUM(x) ( t_isalpha(x) || t_isdigit(x) || ( pg_mblen(x) == 1 && t_iseq((x), '_') ) )
/* full text query */
/* user-friendly value */
uint8 length;
uint16 distance;
-} ITEM;
+} ITEM;
/*
*Storage:
int32 vl_len_; /* varlena header (do not touch directly!) */
int4 size;
char data[1];
-} ltxtquery;
+} ltxtquery;
#define HDRSIZEQT MAXALIGN(VARHDRSZ + sizeof(int4))
#define COMPUTESIZE(size,lenofoperand) ( HDRSIZEQT + (size) * sizeof(ITEM) + (lenofoperand) )
/* Util function */
Datum ltree_in(PG_FUNCTION_ARGS);
-bool ltree_execute(ITEM * curitem, void *checkval,
- bool calcnot, bool (*chkcond) (void *checkval, ITEM * val));
+bool ltree_execute(ITEM *curitem, void *checkval,
+ bool calcnot, bool (*chkcond) (void *checkval, ITEM *val));
-int ltree_compare(const ltree * a, const ltree * b);
-bool inner_isparent(const ltree * c, const ltree * p);
-bool compare_subnode(ltree_level * t, char *q, int len,
- int (*cmpptr) (const char *, const char *, size_t), bool anyend);
-ltree *lca_inner(ltree ** a, int len);
-int ltree_strncasecmp(const char *a, const char *b, size_t s);
+int ltree_compare(const ltree *a, const ltree *b);
+bool inner_isparent(const ltree *c, const ltree *p);
+bool compare_subnode(ltree_level *t, char *q, int len,
+ int (*cmpptr) (const char *, const char *, size_t), bool anyend);
+ltree *lca_inner(ltree **a, int len);
+int ltree_strncasecmp(const char *a, const char *b, size_t s);
#define PG_GETARG_LTREE(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x))))
#define PG_GETARG_LTREE_COPY(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x))))
int32 vl_len_; /* varlena header (do not touch directly!) */
uint32 flag;
char data[1];
-} ltree_gist;
+} ltree_gist;
#define LTG_ONENODE 0x01
#define LTG_ALLTRUE 0x02
}
static void
-hashing(BITVECP sign, ltree * t)
+hashing(BITVECP sign, ltree *t)
{
int tlen = t->numlevel;
ltree_level *cur = LTREE_FIRST(t);
{
int index;
ltree *r;
-} RIX;
+} RIX;
static int
treekey_cmp(const void *a, const void *b)
}
static bool
-gist_isparent(ltree_gist * key, ltree * query)
+gist_isparent(ltree_gist *key, ltree *query)
{
int4 numlevel = query->numlevel;
int i;
}
static ltree *
-copy_ltree(ltree * src)
+copy_ltree(ltree *src)
{
ltree *dst = (ltree *) palloc(VARSIZE(src));
}
static bool
-gist_ischild(ltree_gist * key, ltree * query)
+gist_ischild(ltree_gist *key, ltree *query)
{
ltree *left = copy_ltree(LTG_GETLNODE(key));
ltree *right = copy_ltree(LTG_GETRNODE(key));
}
static bool
-gist_qe(ltree_gist * key, lquery * query)
+gist_qe(ltree_gist *key, lquery *query)
{
lquery_level *curq = LQUERY_FIRST(query);
BITVECP sign = LTG_SIGN(key);
}
static int
-gist_tqcmp(ltree * t, lquery * q)
+gist_tqcmp(ltree *t, lquery *q)
{
ltree_level *al = LTREE_FIRST(t);
lquery_level *ql = LQUERY_FIRST(q);
}
static bool
-gist_between(ltree_gist * key, lquery * query)
+gist_between(ltree_gist *key, lquery *query)
{
if (query->firstgood == 0)
return true;
}
static bool
-checkcondition_bit(void *checkval, ITEM * val)
+checkcondition_bit(void *checkval, ITEM *val)
{
return (FLG_CANLOOKSIGN(val->flag)) ? GETBIT(checkval, HASHVAL(val->val)) : true;
}
static bool
-gist_qtxt(ltree_gist * key, ltxtquery * query)
+gist_qtxt(ltree_gist *key, ltxtquery *query)
{
if (LTG_ISALLTRUE(key))
return true;
}
static bool
-arrq_cons(ltree_gist * key, ArrayType *_query)
+arrq_cons(ltree_gist *key, ArrayType *_query)
{
lquery *query = (lquery *) ARR_DATA_PTR(_query);
int num = ArrayGetNItems(ARR_NDIM(_query), ARR_DIMS(_query));
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
ltree_gist *key = (ltree_gist *) DatumGetPointer(entry->key);
typedef struct
{
char *start;
- int len; /* length in bytes */
+ int len; /* length in bytes */
int flag;
- int wlen; /* length in characters */
-} nodeitem;
+ int wlen; /* length in characters */
+} nodeitem;
#define LTPRS_WAITNAME 0
#define LTPRS_WAITDELIM 1
int state = LTPRS_WAITNAME;
ltree *result;
ltree_level *curlevel;
- int charlen;
- int pos=0;
+ int charlen;
+ int pos = 0;
ptr = buf;
while (*ptr)
{
charlen = pg_mblen(ptr);
- if ( charlen == 1 && t_iseq(ptr, '.') )
+ if (charlen == 1 && t_iseq(ptr, '.'))
num++;
- ptr+=charlen;
+ ptr += charlen;
}
list = lptr = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
}
else if (state == LTPRS_WAITDELIM)
{
- if ( charlen == 1 && t_iseq(ptr, '.') )
+ if (charlen == 1 && t_iseq(ptr, '.'))
{
lptr->len = ptr - lptr->start;
if (lptr->wlen > 255)
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
lptr++;
/* internal error */
elog(ERROR, "internal error in parser");
- ptr+=charlen;
+ ptr += charlen;
lptr->wlen++;
pos++;
}
bool hasnot = false;
bool wasbad = false;
int charlen;
- int pos=0;
+ int pos = 0;
ptr = buf;
while (*ptr)
{
charlen = pg_mblen(ptr);
- if ( charlen == 1 )
+ if (charlen == 1)
{
if (t_iseq(ptr, '.'))
num++;
numOR++;
}
- ptr+=charlen;
+ ptr += charlen;
}
num++;
state = LQPRS_WAITDELIM;
curqlevel->numvar = 1;
}
- else if (charlen==1 && t_iseq(ptr, '!'))
+ else if (charlen == 1 && t_iseq(ptr, '!'))
{
GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
lptr->start = ptr + 1;
curqlevel->flag |= LQL_NOT;
hasnot = true;
}
- else if (charlen==1 && t_iseq(ptr, '*'))
+ else if (charlen == 1 && t_iseq(ptr, '*'))
state = LQPRS_WAITOPEN;
else
UNCHAR;
}
else if (state == LQPRS_WAITDELIM)
{
- if (charlen==1 && t_iseq(ptr, '@'))
+ if (charlen == 1 && t_iseq(ptr, '@'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_INCASE;
curqlevel->flag |= LVAR_INCASE;
}
- else if (charlen==1 && t_iseq(ptr, '*'))
+ else if (charlen == 1 && t_iseq(ptr, '*'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_ANYEND;
curqlevel->flag |= LVAR_ANYEND;
}
- else if (charlen==1 && t_iseq(ptr, '%'))
+ else if (charlen == 1 && t_iseq(ptr, '%'))
{
if (lptr->start == ptr)
UNCHAR;
lptr->flag |= LVAR_SUBLEXEME;
curqlevel->flag |= LVAR_SUBLEXEME;
}
- else if (charlen==1 && t_iseq(ptr, '|'))
+ else if (charlen == 1 && t_iseq(ptr, '|'))
{
lptr->len = ptr - lptr->start -
((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
state = LQPRS_WAITVAR;
}
- else if (charlen==1 && t_iseq(ptr, '.'))
+ else if (charlen == 1 && t_iseq(ptr, '.'))
{
lptr->len = ptr - lptr->start -
((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
errmsg("name of level is too long"),
errdetail("Name length is %d, must "
"be < 256, in position %d.",
- lptr->wlen, pos)));
+ lptr->wlen, pos)));
state = LQPRS_WAITLEVEL;
curqlevel = NEXTLEV(curqlevel);
}
else if (state == LQPRS_WAITOPEN)
{
- if (charlen==1 && t_iseq(ptr, '{'))
+ if (charlen == 1 && t_iseq(ptr, '{'))
state = LQPRS_WAITFNUM;
- else if (charlen==1 && t_iseq(ptr, '.'))
+ else if (charlen == 1 && t_iseq(ptr, '.'))
{
curqlevel->low = 0;
curqlevel->high = 0xffff;
}
else if (state == LQPRS_WAITFNUM)
{
- if (charlen==1 && t_iseq(ptr, ','))
+ if (charlen == 1 && t_iseq(ptr, ','))
state = LQPRS_WAITSNUM;
else if (t_isdigit(ptr))
{
curqlevel->high = atoi(ptr);
state = LQPRS_WAITCLOSE;
}
- else if (charlen==1 && t_iseq(ptr, '}'))
+ else if (charlen == 1 && t_iseq(ptr, '}'))
{
curqlevel->high = 0xffff;
state = LQPRS_WAITEND;
}
else if (state == LQPRS_WAITCLOSE)
{
- if (charlen==1 && t_iseq(ptr, '}'))
+ if (charlen == 1 && t_iseq(ptr, '}'))
state = LQPRS_WAITEND;
else if (!t_isdigit(ptr))
UNCHAR;
}
else if (state == LQPRS_WAITND)
{
- if (charlen==1 && t_iseq(ptr, '}'))
+ if (charlen == 1 && t_iseq(ptr, '}'))
{
curqlevel->high = curqlevel->low;
state = LQPRS_WAITEND;
}
- else if (charlen==1 && t_iseq(ptr, ','))
+ else if (charlen == 1 && t_iseq(ptr, ','))
state = LQPRS_WAITSNUM;
else if (!t_isdigit(ptr))
UNCHAR;
}
else if (state == LQPRS_WAITEND)
{
- if (charlen==1 && t_iseq(ptr, '.'))
+ if (charlen == 1 && t_iseq(ptr, '.'))
{
state = LQPRS_WAITLEVEL;
curqlevel = NEXTLEV(curqlevel);
/* internal error */
elog(ERROR, "internal error in parser");
- ptr+=charlen;
- if ( state == LQPRS_WAITDELIM )
+ ptr += charlen;
+ if (state == LQPRS_WAITDELIM)
lptr->wlen++;
pos++;
}
Datum ltreeparentsel(PG_FUNCTION_ARGS);
int
-ltree_compare(const ltree * a, const ltree * b)
+ltree_compare(const ltree *a, const ltree *b)
{
ltree_level *al = LTREE_FIRST(a);
ltree_level *bl = LTREE_FIRST(b);
}
bool
-inner_isparent(const ltree * c, const ltree * p)
+inner_isparent(const ltree *c, const ltree *p)
{
ltree_level *cl = LTREE_FIRST(c);
ltree_level *pl = LTREE_FIRST(p);
static ltree *
-inner_subltree(ltree * t, int4 startpos, int4 endpos)
+inner_subltree(ltree *t, int4 startpos, int4 endpos)
{
char *start = NULL,
*end = NULL;
}
static ltree *
-ltree_concat(ltree * a, ltree * b)
+ltree_concat(ltree *a, ltree *b)
{
ltree *r;
}
ltree *
-lca_inner(ltree ** a, int len)
+lca_inner(ltree **a, int len)
{
int tmp,
num = ((*a)->numlevel) ? (*a)->numlevel - 1 : 0;
else if (hist_size < 100)
{
/*
- * For histogram sizes from 10 to 100, we combine the
- * histogram and default selectivities, putting increasingly
- * more trust in the histogram for larger sizes.
+ * For histogram sizes from 10 to 100, we combine the histogram
+ * and default selectivities, putting increasingly more trust in
+ * the histogram for larger sizes.
*/
- double hist_weight = hist_size / 100.0;
+ double hist_weight = hist_size / 100.0;
selec = selec * hist_weight +
DEFAULT_PARENT_SEL * (1.0 - hist_weight);
int4 sumlen;
char *op;
char *curop;
-} QPRS_STATE;
+} QPRS_STATE;
/*
* get token from query string
*/
static int4
-gettoken_query(QPRS_STATE * state, int4 *val, int4 *lenval, char **strval, uint16 *flag)
+gettoken_query(QPRS_STATE *state, int4 *val, int4 *lenval, char **strval, uint16 *flag)
{
- int charlen;
+ int charlen;
- for(;;)
+ for (;;)
{
charlen = pg_mblen(state->buf);
switch (state->state)
{
case WAITOPERAND:
- if (charlen==1 && t_iseq(state->buf, '!'))
+ if (charlen == 1 && t_iseq(state->buf, '!'))
{
(state->buf)++;
*val = (int4) '!';
return OPR;
}
- else if (charlen==1 && t_iseq(state->buf, '('))
+ else if (charlen == 1 && t_iseq(state->buf, '('))
{
state->count++;
(state->buf)++;
errmsg("modificators syntax error")));
*lenval += charlen;
}
- else if (charlen==1 && t_iseq(state->buf, '%'))
+ else if (charlen == 1 && t_iseq(state->buf, '%'))
*flag |= LVAR_SUBLEXEME;
- else if (charlen==1 && t_iseq(state->buf, '@'))
+ else if (charlen == 1 && t_iseq(state->buf, '@'))
*flag |= LVAR_INCASE;
- else if (charlen==1 && t_iseq(state->buf, '*'))
+ else if (charlen == 1 && t_iseq(state->buf, '*'))
*flag |= LVAR_ANYEND;
else
{
}
break;
case WAITOPERATOR:
- if (charlen==1 && ( t_iseq(state->buf, '&') || t_iseq(state->buf, '|') ))
+ if (charlen == 1 && (t_iseq(state->buf, '&') || t_iseq(state->buf, '|')))
{
state->state = WAITOPERAND;
*val = (int4) *(state->buf);
(state->buf)++;
return OPR;
}
- else if (charlen==1 && t_iseq(state->buf, ')'))
+ else if (charlen == 1 && t_iseq(state->buf, ')'))
{
(state->buf)++;
state->count--;
}
else if (*(state->buf) == '\0')
return (state->count) ? ERR : END;
- else if (charlen==1 && !t_iseq(state->buf, ' '))
+ else if (charlen == 1 && !t_iseq(state->buf, ' '))
return ERR;
break;
default:
* push new one in polish notation reverse view
*/
static void
-pushquery(QPRS_STATE * state, int4 type, int4 val, int4 distance, int4 lenval, uint16 flag)
+pushquery(QPRS_STATE *state, int4 type, int4 val, int4 distance, int4 lenval, uint16 flag)
{
NODE *tmp = (NODE *) palloc(sizeof(NODE));
* This function is used for query_txt parsing
*/
static void
-pushval_asis(QPRS_STATE * state, int type, char *strval, int lenval, uint16 flag)
+pushval_asis(QPRS_STATE *state, int type, char *strval, int lenval, uint16 flag)
{
if (lenval > 0xffff)
ereport(ERROR,
* make polish notaion of query
*/
static int4
-makepol(QPRS_STATE * state)
+makepol(QPRS_STATE *state)
{
int4 val = 0,
type;
}
static void
-findoprnd(ITEM * ptr, int4 *pos)
+findoprnd(ITEM *ptr, int4 *pos)
{
if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
{
* check for boolean condition
*/
bool
-ltree_execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * val))
+ltree_execute(ITEM *curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM *val))
{
if (curitem->type == VAL)
return (*chkcond) (checkval, curitem);
} CHKVAL;
static bool
-checkcondition_str(void *checkval, ITEM * val)
+checkcondition_str(void *checkval, ITEM *val)
{
ltree_level *level = LTREE_FIRST(((CHKVAL *) checkval)->node);
int tlen = ((CHKVAL *) checkval)->node->numlevel;
char **array;
int num;
int alloc;
-} eary;
+} eary;
/* these are the opts structures for command line params */
struct options
void get_opts(int, char **, struct options *);
void *myalloc(size_t size);
char *mystrdup(const char *str);
-void add_one_elt(char *eltname, eary * eary);
-char *get_comma_elts(eary * eary);
+void add_one_elt(char *eltname, eary *eary);
+char *get_comma_elts(eary *eary);
PGconn *sql_conn(struct options *);
int sql_exec(PGconn *, const char *sql, bool quiet);
void sql_exec_dumpalldbs(PGconn *, struct options *);
* Add one element to a (possibly empty) eary struct.
*/
void
-add_one_elt(char *eltname, eary * eary)
+add_one_elt(char *eltname, eary *eary)
{
if (eary->alloc == 0)
{
- eary->alloc = 8;
- eary->array = (char **) myalloc(8 * sizeof(char *));
+ eary ->alloc = 8;
+ eary ->array = (char **) myalloc(8 * sizeof(char *));
}
else if (eary->num >= eary->alloc)
{
- eary->alloc *= 2;
- eary->array = (char **)
- realloc(eary->array, eary->alloc * sizeof(char *));
+ eary ->alloc *= 2;
+ eary ->array = (char **)
+ realloc(eary->array, eary->alloc * sizeof(char *));
+
if (!eary->array)
{
fprintf(stderr, "out of memory");
}
}
- eary->array[eary->num] = mystrdup(eltname);
- eary->num++;
+ eary ->array[eary->num] = mystrdup(eltname);
+ eary ->num++;
}
/*
* SQL statement.
*/
char *
-get_comma_elts(eary * eary)
+get_comma_elts(eary *eary)
{
char *ret,
*ptr;
new_pass = false;
conn = PQsetdbLogin(my_opts->hostname,
my_opts->port,
- NULL, /* options */
- NULL, /* tty */
+ NULL, /* options */
+ NULL, /* tty */
my_opts->dbname,
my_opts->username,
password);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* btreefuncs.c
} btpo;
uint16 btpo_flags;
BTCycleId btpo_cycleid;
-} BTPageStat;
+} BTPageStat;
/* -------------------------------------------------
* -------------------------------------------------
*/
static void
-GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat * stat)
+GetBTPageStatistics(BlockNumber blkno, Buffer buffer, BTPageStat *stat)
{
Page page = BufferGetPage(buffer);
PageHeader phdr = (PageHeader) page;
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the
* owning session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot access temporary tables of other sessions")));
+ errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
#include "miscadmin.h"
#include "funcapi.h"
-Datum fsm_page_contents(PG_FUNCTION_ARGS);
+Datum fsm_page_contents(PG_FUNCTION_ARGS);
/*
* Dumps the contents of a FSM page.
initStringInfo(&sinfo);
- for(i=0; i < NodesPerPage; i++)
+ for (i = 0; i < NodesPerPage; i++)
{
if (fsmpage->fp_nodes[i] != 0)
appendStringInfo(&sinfo, "%d: %d\n", i, fsmpage->fp_nodes[i]);
TupleDesc tupd;
Page page;
uint16 offset;
-} heap_page_items_state;
+} heap_page_items_state;
Datum
heap_page_items(PG_FUNCTION_ARGS)
(((char *) tuphdr->t_bits) -((char *) tuphdr));
values[11] = CStringGetTextDatum(
- bits_to_text(tuphdr->t_bits, bits_len * 8));
+ bits_to_text(tuphdr->t_bits, bits_len * 8));
}
else
nulls[11] = true;
Datum page_header(PG_FUNCTION_ARGS);
static bytea *get_raw_page_internal(text *relname, ForkNumber forknum,
- BlockNumber blkno);
+ BlockNumber blkno);
/*
RelationGetRelationName(rel))));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
bool isvalid;
bool isdirty;
uint16 usagecount;
-} BufferCachePagesRec;
+} BufferCachePagesRec;
/*
{
TupleDesc tupdesc;
BufferCachePagesRec *record;
-} BufferCachePagesContext;
+} BufferCachePagesContext;
/*
Datum
pg_freespace(PG_FUNCTION_ARGS)
{
- Oid relid = PG_GETARG_OID(0);
- int64 blkno = PG_GETARG_INT64(1);
- int16 freespace;
- Relation rel;
+ Oid relid = PG_GETARG_OID(0);
+ int64 blkno = PG_GETARG_INT64(1);
+ int16 freespace;
+ Relation rel;
rel = relation_open(relid, AccessShareLock);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* pg_standby.c
#define SmartFailover 1
#define FastFailover 2
-static int Failover = NoFailover;
+static int Failover = NoFailover;
#define RESTORE_COMMAND_COPY 0
#define RESTORE_COMMAND_LINK 1
/*
* Windows 'cp' sets the final file size before the copy is
- * complete, and not yet ready to be opened by pg_standby.
- * So we wait for sleeptime secs before attempting to restore.
- * If that is not enough, we will rely on the retry/holdoff
- * mechanism. GNUWin32's cp does not have this problem.
+ * complete, and not yet ready to be opened by pg_standby. So we
+ * wait for sleeptime secs before attempting to restore. If that
+ * is not enough, we will rely on the retry/holdoff mechanism.
+ * GNUWin32's cp does not have this problem.
*/
pg_usleep(sleeptime * 1000000L);
#endif
if (restartWALFileName)
{
/*
- * Don't do cleanup if the restartWALFileName provided
- * is later than the xlog file requested. This is an error
- * and we must not remove these files from archive.
- * This shouldn't happen, but better safe than sorry.
+ * Don't do cleanup if the restartWALFileName provided is later than
+ * the xlog file requested. This is an error and we must not remove
+ * these files from archive. This shouldn't happen, but better safe
+ * than sorry.
*/
if (strcmp(restartWALFileName, nextWALFileName) > 0)
return false;
* CheckForExternalTrigger()
*
* Is there a trigger file? Sets global 'Failover' variable to indicate
- * what kind of a trigger file it was. A "fast" trigger file is turned
- * into a "smart" file as a side-effect.
+ * what kind of a trigger file it was. A "fast" trigger file is turned
+ * into a "smart" file as a side-effect.
*/
static void
CheckForExternalTrigger(void)
{
- char buf[32];
- int fd;
- int len;
+ char buf[32];
+ int fd;
+ int len;
/*
* Look for a trigger file, if that option has been selected
/*
* An empty trigger file performs smart failover. There's a little race
- * condition here: if the writer of the trigger file has just created
- * the file, but not yet written anything to it, we'll treat that as
- * smart shutdown even if the other process was just about to write "fast"
- * to it. But that's fine: we'll restore one more WAL file, and when we're
+ * condition here: if the writer of the trigger file has just created the
+ * file, but not yet written anything to it, we'll treat that as smart
+ * shutdown even if the other process was just about to write "fast" to
+ * it. But that's fine: we'll restore one more WAL file, and when we're
* invoked next time, we'll see the word "fast" and fail over immediately.
*/
if (stat_buf.st_size == 0)
fflush(stderr);
return;
}
-
+
if ((len = read(fd, buf, sizeof(buf))) < 0)
{
fprintf(stderr, "WARNING: could not read \"%s\": %s\n",
return;
}
buf[len] = '\0';
-
+
if (strncmp(buf, "smart", 5) == 0)
{
Failover = SmartFailover;
close(fd);
return;
}
-
+
if (strncmp(buf, "fast", 4) == 0)
{
Failover = FastFailover;
fflush(stderr);
/*
- * Turn it into a "smart" trigger by truncating the file. Otherwise
- * if the server asks us again to restore a segment that was restored
+ * Turn it into a "smart" trigger by truncating the file. Otherwise if
+ * the server asks us again to restore a segment that was restored
* restored already, we would return "not found" and upset the server.
*/
if (ftruncate(fd, 0) < 0)
return;
}
close(fd);
-
+
fprintf(stderr, "WARNING: invalid content in \"%s\"\n", triggerPath);
fflush(stderr);
return;
printf("Usage:\n");
printf(" %s [OPTION]... ARCHIVELOCATION NEXTWALFILE XLOGFILEPATH [RESTARTWALFILE]\n", progname);
printf("\n"
- "with main intended use as a restore_command in the recovery.conf:\n"
+ "with main intended use as a restore_command in the recovery.conf:\n"
" restore_command = 'pg_standby [OPTION]... ARCHIVELOCATION %%f %%p %%r'\n"
"e.g.\n"
" restore_command = 'pg_standby -l /mnt/server/archiverdir %%f %%p %%r'\n");
* You can send SIGUSR1 to trigger failover.
*
* Postmaster uses SIGQUIT to request immediate shutdown. The default
- * action is to core dump, but we don't want that, so trap it and
- * commit suicide without core dump.
+ * action is to core dump, but we don't want that, so trap it and commit
+ * suicide without core dump.
*
- * We used to use SIGINT and SIGQUIT to trigger failover, but that
- * turned out to be a bad idea because postmaster uses SIGQUIT to
- * request immediate shutdown. We still trap SIGINT, but that may
- * change in a future release.
+ * We used to use SIGINT and SIGQUIT to trigger failover, but that turned
+ * out to be a bad idea because postmaster uses SIGQUIT to request
+ * immediate shutdown. We still trap SIGINT, but that may change in a
+ * future release.
*/
(void) signal(SIGUSR1, sighandler);
- (void) signal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
+ (void) signal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
#ifndef WIN32
(void) signal(SIGQUIT, sigquit_handler);
#endif
{
/*
* Once we have restored this file successfully we can remove some
- * prior WAL files. If this restore fails we musn't remove any file
- * because some of them will be requested again immediately after
- * the failed restore, or when we restart recovery.
+ * prior WAL files. If this restore fails we musn't remove any
+ * file because some of them will be requested again immediately
+ * after the failed restore, or when we restart recovery.
*/
if (RestoreWALFileForRecovery())
{
*/
typedef struct pgssEntry
{
- pgssHashKey key; /* hash key of entry - MUST BE FIRST */
+ pgssHashKey key; /* hash key of entry - MUST BE FIRST */
Counters counters; /* the statistics for this query */
slock_t mutex; /* protects the counters only */
char query[1]; /* VARIABLE LENGTH ARRAY - MUST BE LAST */
/*---- Local variables ----*/
/* Current nesting depth of ExecutorRun calls */
-static int nested_level = 0;
+static int nested_level = 0;
+
/* Saved hook values in case of unload */
-static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
-static ExecutorStart_hook_type prev_ExecutorStart = NULL;
-static ExecutorRun_hook_type prev_ExecutorRun = NULL;
-static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+static shmem_startup_hook_type prev_shmem_startup_hook = NULL;
+static ExecutorStart_hook_type prev_ExecutorStart = NULL;
+static ExecutorRun_hook_type prev_ExecutorRun = NULL;
+static ExecutorEnd_hook_type prev_ExecutorEnd = NULL;
+
/* Links to shared memory state */
-static pgssSharedState *pgss = NULL;
-static HTAB *pgss_hash = NULL;
+static pgssSharedState *pgss = NULL;
+static HTAB *pgss_hash = NULL;
/*---- GUC variables ----*/
/*---- Function declarations ----*/
-void _PG_init(void);
-void _PG_fini(void);
+void _PG_init(void);
+void _PG_fini(void);
-Datum pg_stat_statements_reset(PG_FUNCTION_ARGS);
-Datum pg_stat_statements(PG_FUNCTION_ARGS);
+Datum pg_stat_statements_reset(PG_FUNCTION_ARGS);
+Datum pg_stat_statements(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(pg_stat_statements_reset);
PG_FUNCTION_INFO_V1(pg_stat_statements);
static void pgss_shmem_shutdown(int code, Datum arg);
static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags);
static void pgss_ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction,
- long count);
+ ScanDirection direction,
+ long count);
static void pgss_ExecutorEnd(QueryDesc *queryDesc);
static uint32 pgss_hash_fn(const void *key, Size keysize);
-static int pgss_match_fn(const void *key1, const void *key2, Size keysize);
+static int pgss_match_fn(const void *key1, const void *key2, Size keysize);
static void pgss_store(const char *query,
- const Instrumentation *instr, uint32 rows);
-static Size pgss_memsize(void);
+ const Instrumentation *instr, uint32 rows);
+static Size pgss_memsize(void);
static pgssEntry *entry_alloc(pgssHashKey *key);
static void entry_dealloc(void);
static void entry_reset(void);
{
/*
* In order to create our shared memory area, we have to be loaded via
- * shared_preload_libraries. If not, fall out without hooking into
- * any of the main system. (We don't throw error here because it seems
- * useful to allow the pg_stat_statements functions to be created even
- * when the module isn't active. The functions must protect themselves
- * against being called then, however.)
+ * shared_preload_libraries. If not, fall out without hooking into any of
+ * the main system. (We don't throw error here because it seems useful to
+ * allow the pg_stat_statements functions to be created even when the
+ * module isn't active. The functions must protect themselves against
+ * being called then, however.)
*/
if (!process_shared_preload_libraries_in_progress)
return;
* Define (or redefine) custom GUC variables.
*/
DefineCustomIntVariable("pg_stat_statements.max",
- "Sets the maximum number of statements tracked by pg_stat_statements.",
+ "Sets the maximum number of statements tracked by pg_stat_statements.",
NULL,
&pgss_max,
1000,
NULL);
DefineCustomEnumVariable("pg_stat_statements.track",
- "Selects which statements are tracked by pg_stat_statements.",
+ "Selects which statements are tracked by pg_stat_statements.",
NULL,
&pgss_track,
PGSS_TRACK_TOP,
NULL);
DefineCustomBoolVariable("pg_stat_statements.save",
- "Save pg_stat_statements statistics across server shutdowns.",
+ "Save pg_stat_statements statistics across server shutdowns.",
NULL,
&pgss_save,
true,
static void
pgss_shmem_startup(void)
{
- bool found;
+ bool found;
HASHCTL info;
FILE *file;
uint32 header;
elog(ERROR, "out of shared memory");
if (!found)
- {
+ {
/* First time through ... */
pgss->lock = LWLockAssign();
pgss->query_size = pgstat_track_activity_query_size;
memset(&info, 0, sizeof(info));
info.keysize = sizeof(pgssHashKey);
- info.entrysize = offsetof(pgssEntry, query) + query_size;
+ info.entrysize = offsetof(pgssEntry, query) +query_size;
info.hash = pgss_hash_fn;
info.match = pgss_match_fn;
pgss_hash = ShmemInitHash("pg_stat_statements hash",
LWLockRelease(AddinShmemInitLock);
/*
- * If we're in the postmaster (or a standalone backend...), set up a
- * shmem exit hook to dump the statistics to disk.
+ * If we're in the postmaster (or a standalone backend...), set up a shmem
+ * exit hook to dump the statistics to disk.
*/
if (!IsUnderPostmaster)
on_shmem_exit(pgss_shmem_shutdown, (Datum) 0);
/*
* Attempt to load old statistics from the dump file.
*
- * Note: we don't bother with locks here, because there should be no
- * other processes running when this is called.
+ * Note: we don't bother with locks here, because there should be no other
+ * processes running when this is called.
*/
if (!pgss_save)
return;
for (i = 0; i < num; i++)
{
pgssEntry temp;
- pgssEntry *entry;
+ pgssEntry *entry;
if (fread(&temp, offsetof(pgssEntry, mutex), 1, file) != 1)
goto error;
static void
pgss_shmem_shutdown(int code, Datum arg)
{
- FILE *file;
- HASH_SEQ_STATUS hash_seq;
- int32 num_entries;
- pgssEntry *entry;
+ FILE *file;
+ HASH_SEQ_STATUS hash_seq;
+ int32 num_entries;
+ pgssEntry *entry;
/* Don't try to dump during a crash. */
if (code)
hash_seq_init(&hash_seq, pgss_hash);
while ((entry = hash_seq_search(&hash_seq)) != NULL)
{
- int len = entry->key.query_len;
+ int len = entry->key.query_len;
if (fwrite(entry, offsetof(pgssEntry, mutex), 1, file) != 1 ||
fwrite(entry->query, 1, len, file) != len)
if (pgss_enabled())
{
/*
- * Set up to track total elapsed time in ExecutorRun. Make sure
- * the space is allocated in the per-query context so it will go
- * away at ExecutorEnd.
+ * Set up to track total elapsed time in ExecutorRun. Make sure the
+ * space is allocated in the per-query context so it will go away at
+ * ExecutorEnd.
*/
if (queryDesc->totaltime == NULL)
{
if (queryDesc->totaltime && pgss_enabled())
{
/*
- * Make sure stats accumulation is done. (Note: it's okay if
- * several levels of hook all do this.)
+ * Make sure stats accumulation is done. (Note: it's okay if several
+ * levels of hook all do this.)
*/
InstrEndLoop(queryDesc->totaltime);
static void
pgss_store(const char *query, const Instrumentation *instr, uint32 rows)
{
- pgssHashKey key;
+ pgssHashKey key;
double usage;
- pgssEntry *entry;
+ pgssEntry *entry;
Assert(query != NULL);
Datum
pg_stat_statements(PG_FUNCTION_ARGS)
{
- ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- TupleDesc tupdesc;
- Tuplestorestate *tupstore;
- MemoryContext per_query_ctx;
- MemoryContext oldcontext;
- Oid userid = GetUserId();
- bool is_superuser = superuser();
- HASH_SEQ_STATUS hash_seq;
- pgssEntry *entry;
+ ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ TupleDesc tupdesc;
+ Tuplestorestate *tupstore;
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+ Oid userid = GetUserId();
+ bool is_superuser = superuser();
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry *entry;
if (!pgss || !pgss_hash)
ereport(ERROR,
if (is_superuser || entry->key.userid == userid)
{
- char *qstr;
+ char *qstr;
qstr = (char *)
pg_do_encoding_conversion((unsigned char *) entry->query,
static Size
pgss_memsize(void)
{
- Size size;
- Size entrysize;
+ Size size;
+ Size entrysize;
size = MAXALIGN(sizeof(pgssSharedState));
- entrysize = offsetof(pgssEntry, query) + pgstat_track_activity_query_size;
+ entrysize = offsetof(pgssEntry, query) +pgstat_track_activity_query_size;
size = add_size(size, hash_estimate_size(pgss_max, entrysize));
return size;
* caller must hold an exclusive lock on pgss->lock
*
* Note: despite needing exclusive lock, it's not an error for the target
- * entry to already exist. This is because pgss_store releases and
+ * entry to already exist. This is because pgss_store releases and
* reacquires lock after failing to find a match; so someone else could
* have made the entry while we waited to get exclusive lock.
*/
entry_alloc(pgssHashKey *key)
{
pgssEntry *entry;
- bool found;
+ bool found;
/* Caller must have clipped query properly */
Assert(key->query_len < pgss->query_size);
static int
entry_cmp(const void *lhs, const void *rhs)
{
- double l_usage = (*(const pgssEntry **)lhs)->counters.usage;
- double r_usage = (*(const pgssEntry **)rhs)->counters.usage;
+ double l_usage = (*(const pgssEntry **) lhs)->counters.usage;
+ double r_usage = (*(const pgssEntry **) rhs)->counters.usage;
if (l_usage < r_usage)
return -1;
static void
entry_dealloc(void)
{
- HASH_SEQ_STATUS hash_seq;
- pgssEntry **entries;
- pgssEntry *entry;
- int nvictims;
- int i;
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry **entries;
+ pgssEntry *entry;
+ int nvictims;
+ int i;
/* Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them. */
static void
entry_reset(void)
{
- HASH_SEQ_STATUS hash_seq;
- pgssEntry *entry;
+ HASH_SEQ_STATUS hash_seq;
+ pgssEntry *entry;
LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef __TRGM_H__
#define __TRGM_H__
*(((char*)(a))+2) = *(((char*)(b))+2); \
} while(0);
-uint32 trgm2int(trgm *ptr);
+uint32 trgm2int(trgm *ptr);
#ifdef KEEPONLYALNUM
#define ISPRINTABLECHAR(a) ( isascii( *(unsigned char*)(a) ) && (isalnum( *(unsigned char*)(a) ) || *(unsigned char*)(a)==' ') )
int32 vl_len_; /* varlena header (do not touch directly!) */
uint8 flag;
char data[1];
-} TRGM;
+} TRGM;
#define TRGMHDRSIZE (VARHDRSZ + sizeof(uint8))
extern float4 trgm_limit;
TRGM *generate_trgm(char *str, int slen);
-float4 cnt_sml(TRGM * trg1, TRGM * trg2);
+float4 cnt_sml(TRGM *trg1, TRGM *trg2);
#endif
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
/*
* Function called from query extracting
*/
- Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
+ Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
- *extra_data = (Pointer*) palloc0(sizeof(Pointer)*(*nentries));
+ *extra_data = (Pointer *) palloc0(sizeof(Pointer) * (*nentries));
- *(int32*)(*extra_data) = trglen;
+ *(int32 *) (*extra_data) = trglen;
}
}
gin_trgm_consistent(PG_FUNCTION_ARGS)
{
bool *check = (bool *) PG_GETARG_POINTER(0);
+
/* StrategyNumber strategy = PG_GETARG_UINT16(1); */
- /* text *query = PG_GETARG_TEXT_P(2); */
+ /* text *query = PG_GETARG_TEXT_P(2); */
/* int32 nkeys = PG_GETARG_INT32(3); */
Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
bool *recheck = (bool *) PG_GETARG_POINTER(5);
/* All cases served by this function are inexact */
*recheck = true;
- trglen = *(int32*)extra_data;
+ trglen = *(int32 *) extra_data;
for (i = 0; i < trglen; i++)
if (check[i])
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
}
static void
-makesign(BITVECP sign, TRGM * a)
+makesign(BITVECP sign, TRGM *a)
{
int4 k,
len = ARRNELEM(a);
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
text *query = PG_GETARG_TEXT_P(1);
+
/* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
TRGM *key = (TRGM *) DatumGetPointer(entry->key);
TRGM *qtrg;
bool res = false;
- char *cache = (char*) fcinfo->flinfo->fn_extra;
+ char *cache = (char *) fcinfo->flinfo->fn_extra;
/* All cases served by this function are exact */
*recheck = false;
- if ( cache == NULL || VARSIZE(cache) != VARSIZE(query) || memcmp( cache, query, VARSIZE(query) ) !=0 )
+ if (cache == NULL || VARSIZE(cache) != VARSIZE(query) || memcmp(cache, query, VARSIZE(query)) != 0)
{
- qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
+ qtrg = generate_trgm(VARDATA(query), VARSIZE(query) - VARHDRSZ);
if (cache)
pfree(cache);
fcinfo->flinfo->fn_extra = MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
- MAXALIGN(VARSIZE(query)) + VARSIZE(qtrg) );
- cache = (char*) fcinfo->flinfo->fn_extra;
+ MAXALIGN(VARSIZE(query)) + VARSIZE(qtrg));
+ cache = (char *) fcinfo->flinfo->fn_extra;
- memcpy( cache, query, VARSIZE(query) );
- memcpy( cache + MAXALIGN(VARSIZE(query)), qtrg, VARSIZE(qtrg) );
+ memcpy(cache, query, VARSIZE(query));
+ memcpy(cache + MAXALIGN(VARSIZE(query)), qtrg, VARSIZE(qtrg));
}
- qtrg = (TRGM*)( cache + MAXALIGN(VARSIZE(query)) );
+ qtrg = (TRGM *) (cache + MAXALIGN(VARSIZE(query)));
if (GIST_LEAF(entry))
{ /* all leafs contains orig trgm */
}
static int4
-unionkey(BITVECP sbase, TRGM * add)
+unionkey(BITVECP sbase, TRGM *add)
{
int4 i;
}
static int
-hemdist(TRGM * a, TRGM * b)
+hemdist(TRGM *a, TRGM *b)
{
if (ISALLTRUE(a))
{
} CACHESIGN;
static void
-fillcache(CACHESIGN *item, TRGM * key)
+fillcache(CACHESIGN *item, TRGM *key)
{
item->allistrue = false;
if (ISARRKEY(key))
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "trgm.h"
#include <ctype.h>
}
static int
-unique_array(trgm * a, int len)
+unique_array(trgm *a, int len)
{
trgm *curend,
*tmp;
}
#ifdef KEEPONLYALNUM
-#define iswordchr(c) (t_isalpha(c) || t_isdigit(c))
+#define iswordchr(c) (t_isalpha(c) || t_isdigit(c))
#else
#define iswordchr(c) (!t_isspace(c))
#endif
* Finds first word in string, returns pointer to the word,
* endword points to the character after word
*/
-static char*
-find_word(char *str, int lenstr, char **endword, int *charlen)
+static char *
+find_word(char *str, int lenstr, char **endword, int *charlen)
{
- char *beginword = str;
+ char *beginword = str;
- while( beginword - str < lenstr && !iswordchr(beginword) )
+ while (beginword - str < lenstr && !iswordchr(beginword))
beginword += pg_mblen(beginword);
if (beginword - str >= lenstr)
*endword = beginword;
*charlen = 0;
- while( *endword - str < lenstr && iswordchr(*endword) )
+ while (*endword - str < lenstr && iswordchr(*endword))
{
*endword += pg_mblen(*endword);
(*charlen)++;
#ifdef USE_WIDE_UPPER_LOWER
static void
-cnt_trigram(trgm *tptr, char *str, int bytelen)
+cnt_trigram(trgm *tptr, char *str, int bytelen)
{
- if ( bytelen == 3 )
+ if (bytelen == 3)
{
- CPTRGM(tptr, str);
+ CPTRGM(tptr, str);
}
else
{
FIN_CRC32(crc);
/*
- * use only 3 upper bytes from crc, hope, it's
- * good enough hashing
+ * use only 3 upper bytes from crc, hope, it's good enough hashing
*/
CPTRGM(tptr, &crc);
}
/*
* Adds trigramm from words (already padded).
*/
-static trgm*
-make_trigrams( trgm *tptr, char *str, int bytelen, int charlen )
+static trgm *
+make_trigrams(trgm *tptr, char *str, int bytelen, int charlen)
{
- char *ptr = str;
+ char *ptr = str;
- if ( charlen < 3 )
+ if (charlen < 3)
return tptr;
#ifdef USE_WIDE_UPPER_LOWER
if (pg_database_encoding_max_length() > 1)
{
- int lenfirst = pg_mblen(str),
- lenmiddle = pg_mblen(str + lenfirst),
- lenlast = pg_mblen(str + lenfirst + lenmiddle);
+ int lenfirst = pg_mblen(str),
+ lenmiddle = pg_mblen(str + lenfirst),
+ lenlast = pg_mblen(str + lenfirst + lenmiddle);
- while( (ptr - str) + lenfirst + lenmiddle + lenlast <= bytelen )
+ while ((ptr - str) + lenfirst + lenmiddle + lenlast <= bytelen)
{
cnt_trigram(tptr, ptr, lenfirst + lenmiddle + lenlast);
ptr += lenfirst;
tptr++;
- lenfirst = lenmiddle;
- lenmiddle = lenlast;
- lenlast = pg_mblen(ptr + lenfirst + lenmiddle);
+ lenfirst = lenmiddle;
+ lenmiddle = lenlast;
+ lenlast = pg_mblen(ptr + lenfirst + lenmiddle);
}
}
else
#endif
{
- Assert( bytelen == charlen );
+ Assert(bytelen == charlen);
while (ptr - str < bytelen - 2 /* number of trigrams = strlen - 2 */ )
{
tptr++;
}
}
-
+
return tptr;
}
int len,
charlen,
bytelen;
- char *bword, *eword;
+ char *bword,
+ *eword;
- trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) * 3);
+ trg = (TRGM *) palloc(TRGMHDRSIZE + sizeof(trgm) * (slen / 2 + 1) *3);
trg->flag = ARRKEY;
SET_VARSIZE(trg, TRGMHDRSIZE);
}
eword = str;
- while( (bword=find_word(eword, slen - (eword-str), &eword, &charlen)) != NULL )
+ while ((bword = find_word(eword, slen - (eword - str), &eword, &charlen)) != NULL)
{
#ifdef IGNORECASE
bword = lowerstr_with_len(bword, eword - bword);
#ifdef IGNORECASE
pfree(bword);
#endif
- buf[LPADDING+bytelen] = ' ';
- buf[LPADDING+bytelen+1] = ' ';
+ buf[LPADDING + bytelen] = ' ';
+ buf[LPADDING + bytelen + 1] = ' ';
/*
* count trigrams
*/
- tptr = make_trigrams( tptr, buf, bytelen + LPADDING + RPADDING,
- charlen + LPADDING + RPADDING );
+ tptr = make_trigrams(tptr, buf, bytelen + LPADDING + RPADDING,
+ charlen + LPADDING + RPADDING);
}
pfree(buf);
uint32
trgm2int(trgm *ptr)
{
- uint32 val = 0;
+ uint32 val = 0;
- val |= *( ((unsigned char*)ptr) );
+ val |= *(((unsigned char *) ptr));
val <<= 8;
- val |= *( ((unsigned char*)ptr) + 1 );
+ val |= *(((unsigned char *) ptr) + 1);
val <<= 8;
- val |= *( ((unsigned char*)ptr) + 2 );
+ val |= *(((unsigned char *) ptr) + 2);
return val;
}
for (i = 0, ptr = GETARR(trg); i < ARRNELEM(trg); i++, ptr++)
{
- text *item = (text *) palloc(VARHDRSZ + Max(12, pg_database_encoding_max_length()*3) );
+ text *item = (text *) palloc(VARHDRSZ + Max(12, pg_database_encoding_max_length() * 3));
- if ( pg_database_encoding_max_length() > 1 && !ISPRINTABLETRGM(ptr) )
+ if (pg_database_encoding_max_length() > 1 && !ISPRINTABLETRGM(ptr))
{
snprintf(VARDATA(item), 12, "0x%06x", trgm2int(ptr));
SET_VARSIZE(item, VARHDRSZ + strlen(VARDATA(item)));
}
float4
-cnt_sml(TRGM * trg1, TRGM * trg2)
+cnt_sml(TRGM *trg1, TRGM *trg2)
{
trgm *ptr1,
*ptr2;
char *login = NULL;
char *dbName;
-volatile bool timer_exceeded = false; /* flag from signal handler */
+volatile bool timer_exceeded = false; /* flag from signal handler */
/* variable definitions */
typedef struct
{
char *name; /* variable name */
char *value; /* its value */
-} Variable;
+} Variable;
#define MAX_FILES 128 /* max number of SQL script files allowed */
struct timeval txn_begin; /* used for measuring latencies */
int use_file; /* index in sql_files for this client */
bool prepared[MAX_FILES];
-} CState;
+} CState;
/*
* queries read from files
typedef enum QueryMode
{
- QUERY_SIMPLE, /* simple query */
- QUERY_EXTENDED, /* extended query */
- QUERY_PREPARED, /* extended query with prepared statements */
+ QUERY_SIMPLE, /* simple query */
+ QUERY_EXTENDED, /* extended query */
+ QUERY_PREPARED, /* extended query with prepared statements */
NUM_QUERYMODE
} QueryMode;
-static QueryMode querymode = QUERY_SIMPLE;
-static const char *QUERYMODE[] = { "simple", "extended", "prepared" };
+static QueryMode querymode = QUERY_SIMPLE;
+static const char *QUERYMODE[] = {"simple", "extended", "prepared"};
typedef struct
{
int type; /* command type (SQL_COMMAND or META_COMMAND) */
int argc; /* number of commands */
char *argv[MAX_ARGS]; /* command list */
-} Command;
+} Command;
Command **sql_files[MAX_FILES]; /* SQL script files */
int num_files; /* number of script files */
/* Calculate total time */
static void
-addTime(struct timeval *t1, struct timeval *t2, struct timeval *result)
+addTime(struct timeval * t1, struct timeval * t2, struct timeval * result)
{
- int sec = t1->tv_sec + t2->tv_sec;
- int usec = t1->tv_usec + t2->tv_usec;
+ int sec = t1->tv_sec + t2->tv_sec;
+ int usec = t1->tv_usec + t2->tv_usec;
+
if (usec >= 1000000)
{
usec -= 1000000;
/* Calculate time difference */
static void
-diffTime(struct timeval *t1, struct timeval *t2, struct timeval *result)
+diffTime(struct timeval * t1, struct timeval * t2, struct timeval * result)
{
- int sec = t1->tv_sec - t2->tv_sec;
- int usec = t1->tv_usec - t2->tv_usec;
+ int sec = t1->tv_sec - t2->tv_sec;
+ int usec = t1->tv_usec - t2->tv_usec;
+
if (usec < 0)
{
usec += 1000000;
" -F NUM fill factor\n"
" -s NUM scaling factor\n"
"\nBenchmarking options:\n"
- " -c NUM number of concurrent database clients (default: 1)\n"
+ " -c NUM number of concurrent database clients (default: 1)\n"
" -C establish new connection for each transaction\n"
" -D VARNAME=VALUE\n"
" define variable for use by custom script\n"
" -N do not update tables \"pgbench_tellers\" and \"pgbench_branches\"\n"
" -s NUM report this scale factor in output\n"
" -S perform SELECT-only transactions\n"
- " -t NUM number of transactions each client runs (default: 10)\n"
+ " -t NUM number of transactions each client runs (default: 10)\n"
" -T NUM duration of benchmark test in seconds\n"
" -v vacuum all four standard tables before tests\n"
"\nCommon options:\n"
/* throw away response from backend */
static void
-discard_response(CState * state)
+discard_response(CState *state)
{
PGresult *res;
/* check to see if the SQL result was good */
static int
-check(CState * state, PGresult *res, int n)
+check(CState *state, PGresult *res, int n)
{
CState *st = &state[n];
}
static char *
-getVariable(CState * st, char *name)
+getVariable(CState *st, char *name)
{
Variable key,
*var;
}
static int
-putVariable(CState * st, char *name, char *value)
+putVariable(CState *st, char *name, char *value)
{
Variable key,
*var;
static char *
parseVariable(const char *sql, int *eaten)
{
- int i = 0;
- char *name;
+ int i = 0;
+ char *name;
do
{
static char *
replaceVariable(char **sql, char *param, int len, char *value)
{
- int valueln = strlen(value);
+ int valueln = strlen(value);
if (valueln > len)
{
- char *tmp;
- size_t offset = param - *sql;
+ char *tmp;
+ size_t offset = param - *sql;
tmp = realloc(*sql, strlen(*sql) - len + valueln + 1);
if (tmp == NULL)
}
static char *
-assignVariables(CState * st, char *sql)
+assignVariables(CState *st, char *sql)
{
char *p,
*name,
p = sql;
while ((p = strchr(p, ':')) != NULL)
{
- int eaten;
+ int eaten;
name = parseVariable(p, &eaten);
if (name == NULL)
{
- while (*p == ':') { p++; }
+ while (*p == ':')
+ {
+ p++;
+ }
continue;
}
static void
getQueryParams(CState *st, const Command *command, const char **params)
{
- int i;
+ int i;
for (i = 0; i < command->argc - 1; i++)
- params[i] = getVariable(st, command->argv[i+1]);
+ params[i] = getVariable(st, command->argv[i + 1]);
}
#define MAX_PREPARE_NAME 32
}
static void
-doCustom(CState * state, int n, int debug)
+doCustom(CState *state, int n, int debug)
{
PGresult *res;
CState *st = &state[n];
if (st->con == NULL)
{
- struct timeval t1, t2, t3;
+ struct timeval t1,
+ t2,
+ t3;
gettimeofday(&t1, NULL);
if ((st->con = doConnect()) == NULL)
if (commands[st->state]->type == SQL_COMMAND)
{
- const Command *command = commands[st->state];
- int r;
+ const Command *command = commands[st->state];
+ int r;
if (querymode == QUERY_SIMPLE)
{
}
else if (querymode == QUERY_EXTENDED)
{
- const char *sql = command->argv[0];
- const char *params[MAX_ARGS];
+ const char *sql = command->argv[0];
+ const char *params[MAX_ARGS];
getQueryParams(st, command, params);
if (debug)
fprintf(stderr, "client %d sending %s\n", n, sql);
r = PQsendQueryParams(st->con, sql, command->argc - 1,
- NULL, params, NULL, NULL, 0);
+ NULL, params, NULL, NULL, 0);
}
else if (querymode == QUERY_PREPARED)
{
if (!st->prepared[st->use_file])
{
- int j;
+ int j;
for (j = 0; commands[j] != NULL; j++)
{
continue;
preparedStatementName(name, st->use_file, j);
res = PQprepare(st->con, name,
- commands[j]->argv[0], commands[j]->argc - 1, NULL);
+ commands[j]->argv[0], commands[j]->argc - 1, NULL);
if (PQresultStatus(res) != PGRES_COMMAND_OK)
fprintf(stderr, "%s", PQerrorMessage(st->con));
PQclear(res);
if (debug)
fprintf(stderr, "client %d sending %s\n", n, name);
r = PQsendQueryPrepared(st->con, name, command->argc - 1,
- params, NULL, NULL, 0);
+ params, NULL, NULL, 0);
}
- else /* unknown sql mode */
+ else /* unknown sql mode */
r = 0;
if (r == 0)
/* discard connections */
static void
-disconnect_all(CState * state)
+disconnect_all(CState *state)
{
int i;
/*
* Note: TPC-B requires at least 100 bytes per row, and the "filler"
* fields in these table declarations were intended to comply with that.
- * But because they default to NULLs, they don't actually take any
- * space. We could fix that by giving them non-null default values.
- * However, that would completely break comparability of pgbench
- * results with prior versions. Since pgbench has never pretended
- * to be fully TPC-B compliant anyway, we stick with the historical
- * behavior.
+ * But because they default to NULLs, they don't actually take any space.
+ * We could fix that by giving them non-null default values. However, that
+ * would completely break comparability of pgbench results with prior
+ * versions. Since pgbench has never pretended to be fully TPC-B
+ * compliant anyway, we stick with the historical behavior.
*/
static char *DDLs[] = {
"drop table if exists pgbench_branches",
p = sql;
while ((p = strchr(p, ':')) != NULL)
{
- char var[12];
- char *name;
- int eaten;
+ char var[12];
+ char *name;
+ int eaten;
name = parseVariable(p, &eaten);
if (name == NULL)
{
- while (*p == ':') { p++; }
+ while (*p == ':')
+ {
+ p++;
+ }
continue;
}
/* print out results */
static void
printResults(
- int ttype, CState * state,
+ int ttype, CState *state,
struct timeval * start_time, struct timeval * end_time)
{
double t1,
CState *state; /* status of clients */
- struct timeval start_time; /* start up time */
- struct timeval end_time; /* end time */
+ struct timeval start_time; /* start up time */
+ struct timeval end_time; /* end time */
int i;
{
if (duration <= 0)
printf("pghost: %s pgport: %s nclients: %d nxacts: %d dbName: %s\n",
- pghost, pgport, nclients, nxacts, dbName);
+ pghost, pgport, nclients, nxacts, dbName);
else
printf("pghost: %s pgport: %s nclients: %d duration: %d dbName: %s\n",
- pghost, pgport, nclients, duration, dbName);
+ pghost, pgport, nclients, duration, dbName);
}
/* opening connection... */
/* warn if we override user-given -s switch */
if (scale_given)
fprintf(stderr,
- "Scale option ignored, using pgbench_branches table count = %d\n",
+ "Scale option ignored, using pgbench_branches table count = %d\n",
scale);
}
if (is_connect == 0)
{
- struct timeval t, now;
+ struct timeval t,
+ now;
/* make connections to the database */
for (i = 0; i < nclients; i++)
if (this_usec > 0 && (min_usec == 0 || this_usec < min_usec))
min_usec = this_usec;
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
+
if (maxsock < sock)
maxsock = sock;
}
disconnect_all(state);
exit(1);
}
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
+
if (maxsock < sock)
maxsock = sock;
}
pqsignal(SIGALRM, handle_sig_alarm);
alarm(seconds);
}
-
-#else /* WIN32 */
+#else /* WIN32 */
static VOID CALLBACK
win32_timer_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
static void
setalarm(int seconds)
{
- HANDLE queue;
- HANDLE timer;
+ HANDLE queue;
+ HANDLE timer;
/* This function will be called at most once, so we can cheat a bit. */
queue = CreateTimerQueue();
- if (seconds > ((DWORD)-1) / 1000 ||
+ if (seconds > ((DWORD) -1) / 1000 ||
!CreateTimerQueueTimer(&timer, queue,
win32_timer_callback, NULL, seconds * 1000, 0,
WT_EXECUTEINTIMERTHREAD | WT_EXECUTEONLYONCE))
}
}
-#endif /* WIN32 */
+#endif /* WIN32 */
static void
blowfish_encrypt(uint32 xL, uint32 xR, uint32 *output,
- BlowfishContext * ctx)
+ BlowfishContext *ctx)
{
uint32 *S0 = ctx->S0;
uint32 *S1 = ctx->S1;
static void
blowfish_decrypt(uint32 xL, uint32 xR, uint32 *output,
- BlowfishContext * ctx)
+ BlowfishContext *ctx)
{
uint32 *S0 = ctx->S0;
uint32 *S1 = ctx->S1;
}
void
-blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx)
+blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx)
{
uint32 xL,
xR,
}
void
-blowfish_setkey(BlowfishContext * ctx,
+blowfish_setkey(BlowfishContext *ctx,
const uint8 *key, short keybytes)
{
uint32 *S0 = ctx->S0;
}
void
-blowfish_setiv(BlowfishContext * ctx, const uint8 *iv)
+blowfish_setiv(BlowfishContext *ctx, const uint8 *iv)
{
ctx->iv0 = GET_32BIT_MSB_FIRST(iv);
ctx->iv1 = GET_32BIT_MSB_FIRST(iv + 4);
P[18];
uint32 iv0,
iv1; /* for CBC mode */
-} BlowfishContext;
+} BlowfishContext;
-void blowfish_setkey(BlowfishContext * ctx, const uint8 *key, short keybytes);
-void blowfish_setiv(BlowfishContext * ctx, const uint8 *iv);
-void blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx);
-void blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext * ctx);
+void blowfish_setkey(BlowfishContext *ctx, const uint8 *key, short keybytes);
+void blowfish_setiv(BlowfishContext *ctx, const uint8 *iv);
+void blowfish_encrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_decrypt_cbc(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_encrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx);
+void blowfish_decrypt_ecb(uint8 *blk, int len, BlowfishContext *ctx);
{
BF_word S[4][0x100];
BF_key P;
-} BF_ctx;
+} BF_ctx;
/*
* Magic IV for 64 Blowfish encryptions that we do at the end.
} while (0)
static int
-BF_decode(BF_word * dst, const char *src, int size)
+BF_decode(BF_word *dst, const char *src, int size)
{
unsigned char *dptr = (unsigned char *) dst;
unsigned char *end = dptr + size;
}
static void
-BF_encode(char *dst, const BF_word * src, int size)
+BF_encode(char *dst, const BF_word *src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
}
static void
-BF_swap(BF_word * x, int count)
+BF_swap(BF_word *x, int count)
{
/* Swap on little-endian hardware, else do nothing */
#ifndef WORDS_BIGENDIAN
#if BF_ASM
-extern void _BF_body_r(BF_ctx * ctx);
+extern void _BF_body_r(BF_ctx *ctx);
#define BF_body() \
_BF_body_r(&data.ctx);
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
static void
-BF_encode(char *dst, const BF_word * src, int size)
+BF_encode(char *dst, const BF_word *src, int size)
{
unsigned char *sptr = (unsigned char *) src;
unsigned char *end = sptr + size;
* initialize state
*/
static void
-init_state(FState * st)
+init_state(FState *st)
{
int i;
* It just needs to change without repeating.
*/
static void
-inc_counter(FState * st)
+inc_counter(FState *st)
{
uint32 *val = (uint32 *) st->counter;
* This is called 'cipher in counter mode'.
*/
static void
-encrypt_counter(FState * st, uint8 *dst)
+encrypt_counter(FState *st, uint8 *dst)
{
ciph_encrypt(&st->ciph, st->counter, dst);
inc_counter(st);
* microseconds.
*/
static int
-enough_time_passed(FState * st)
+enough_time_passed(FState *st)
{
int ok;
struct timeval tv;
* generate new key from all the pools
*/
static void
-reseed(FState * st)
+reseed(FState *st)
{
unsigned k;
unsigned n;
* Pick a random pool. This uses key bytes as random source.
*/
static unsigned
-get_rand_pool(FState * st)
+get_rand_pool(FState *st)
{
unsigned rnd;
* update pools
*/
static void
-add_entropy(FState * st, const uint8 *data, unsigned len)
+add_entropy(FState *st, const uint8 *data, unsigned len)
{
unsigned pos;
uint8 hash[BLOCK];
* Just take 2 next blocks as new key
*/
static void
-rekey(FState * st)
+rekey(FState *st)
{
encrypt_counter(st, st->key);
encrypt_counter(st, st->key + CIPH_BLOCK);
* entropy over all of the components.
*/
static void
-startup_tricks(FState * st)
+startup_tricks(FState *st)
{
int i;
uint8 buf[BLOCK];
}
static void
-extract_data(FState * st, unsigned count, uint8 *dst)
+extract_data(FState *st, unsigned count, uint8 *dst)
{
unsigned n;
unsigned block_nr = 0;
static void s_fake(mp_int z, int value, mp_digit vbuf[]);
/* Compare two runs of digits of given length, returns <0, 0, >0 */
-static int s_cdig(mp_digit * da, mp_digit * db, mp_size len);
+static int s_cdig(mp_digit *da, mp_digit *db, mp_size len);
/* Pack the unsigned digits of v into array t */
static int s_vpack(int v, mp_digit t[]);
/* Unsigned magnitude addition; assumes dc is big enough.
Carry out is returned (no memory allocated). */
-static mp_digit s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc,
+static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned magnitude subtraction. Assumes dc is big enough. */
-static void s_usub(mp_digit * da, mp_digit * db, mp_digit * dc,
+static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned recursive multiplication. Assumes dc is big enough. */
-static int s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc,
+static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned magnitude multiplication. Assumes dc is big enough. */
-static void s_umul(mp_digit * da, mp_digit * db, mp_digit * dc,
+static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b);
/* Unsigned recursive squaring. Assumes dc is big enough. */
-static int s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a);
+static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a);
/* Unsigned magnitude squaring. Assumes dc is big enough. */
-static void s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a);
+static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a);
/* Single digit addition. Assumes a is big enough. */
static void s_dadd(mp_int a, mp_digit b);
static void s_dmul(mp_int a, mp_digit b);
/* Single digit multiplication on buffers; assumes dc is big enough. */
-static void s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc,
+static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc,
mp_size size_a);
/* Single digit division. Replaces a with the quotient,
#if 0
/* Dump a representation of the mp_int to standard output */
void s_print(char *tag, mp_int z);
-void s_print_buf(char *tag, mp_digit * buf, mp_size num);
+void s_print_buf(char *tag, mp_digit *buf, mp_size num);
#endif
/* {{{ get_default_precision() */
/* {{{ s_realloc(old, num) */
static mp_digit *
-s_realloc(mp_digit * old, mp_size num)
+s_realloc(mp_digit *old, mp_size num)
{
mp_digit *new = px_realloc(old, num * sizeof(mp_digit));
/* {{{ s_cdig(da, db, len) */
static int
-s_cdig(mp_digit * da, mp_digit * db, mp_size len)
+s_cdig(mp_digit *da, mp_digit *db, mp_size len)
{
mp_digit *dat = da + len - 1,
*dbt = db + len - 1;
/* {{{ s_uadd(da, db, dc, size_a, size_b) */
static mp_digit
-s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size pos;
/* Add corresponding digits until the shorter number runs out */
for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc)
{
- w = w + (mp_word) * da + (mp_word) * db;
+ w = w + (mp_word) *da + (mp_word) *db;
*dc = LOWER_HALF(w);
w = UPPER_HALF(w);
}
/* {{{ s_usub(da, db, dc, size_a, size_b) */
static void
-s_usub(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size pos;
for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc)
{
w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */
- (mp_word) * da) - w - (mp_word) * db;
+ (mp_word) *da) - w - (mp_word) *db;
*dc = LOWER_HALF(w);
w = (UPPER_HALF(w) == 0);
for ( /* */ ; pos < size_a; ++pos, ++da, ++dc)
{
w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */
- (mp_word) * da) - w;
+ (mp_word) *da) - w;
*dc = LOWER_HALF(w);
w = (UPPER_HALF(w) == 0);
/* {{{ s_kmul(da, db, dc, size_a, size_b) */
static int
-s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size bot_size;
/* {{{ s_umul(da, db, dc, size_a, size_b) */
static void
-s_umul(mp_digit * da, mp_digit * db, mp_digit * dc,
+s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
mp_size size_a, mp_size size_b)
{
mp_size a,
w = 0;
for (b = 0; b < size_b; ++b, ++dbt, ++dct)
{
- w = (mp_word) * da * (mp_word) * dbt + w + (mp_word) * dct;
+ w = (mp_word) *da * (mp_word) *dbt + w + (mp_word) *dct;
*dct = LOWER_HALF(w);
w = UPPER_HALF(w);
/* {{{ s_ksqr(da, dc, size_a) */
static int
-s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a)
+s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a)
{
if (multiply_threshold && size_a > multiply_threshold)
{
/* {{{ s_usqr(da, dc, size_a) */
static void
-s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a)
+s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a)
{
mp_size i,
j;
continue;
/* Take care of the first digit, no rollover */
- w = (mp_word) * dat * (mp_word) * dat + (mp_word) * dct;
+ w = (mp_word) *dat * (mp_word) *dat + (mp_word) *dct;
*dct = LOWER_HALF(w);
w = UPPER_HALF(w);
++dat;
for (j = i + 1; j < size_a; ++j, ++dat, ++dct)
{
- mp_word t = (mp_word) * da * (mp_word) * dat;
- mp_word u = w + (mp_word) * dct,
+ mp_word t = (mp_word) *da * (mp_word) *dat;
+ mp_word u = w + (mp_word) *dct,
ov = 0;
/* Check if doubling t will overflow a word */
mp_digit *da = MP_DIGITS(a);
mp_size ua = MP_USED(a);
- w = (mp_word) * da + b;
+ w = (mp_word) *da + b;
*da++ = LOWER_HALF(w);
w = UPPER_HALF(w);
for (ua -= 1; ua > 0; --ua, ++da)
{
- w = (mp_word) * da + w;
+ w = (mp_word) *da + w;
*da = LOWER_HALF(w);
w = UPPER_HALF(w);
while (ua > 0)
{
- w = (mp_word) * da * b + w;
+ w = (mp_word) *da * b + w;
*da++ = LOWER_HALF(w);
w = UPPER_HALF(w);
--ua;
/* {{{ s_dbmul(da, b, dc, size_a) */
static void
-s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc, mp_size size_a)
+s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a)
{
mp_word w = 0;
while (size_a > 0)
{
- w = (mp_word) * da++ * (mp_word) b + w;
+ w = (mp_word) *da++ * (mp_word) b + w;
*dc++ = LOWER_HALF(w);
w = UPPER_HALF(w);
for (pos = 0, zp = MP_DIGITS(z); pos < tdig; ++pos, ++zp)
{
- w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word) * zp;
+ w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word) *zp;
*zp = LOWER_HALF(w);
w = UPPER_HALF(w) ? 0 : 1;
}
- w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word) * zp;
+ w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word) *zp;
*zp = LOWER_HALF(w);
assert(UPPER_HALF(w) != 0); /* no borrow out should be possible */
}
void
-s_print_buf(char *tag, mp_digit * buf, mp_size num)
+s_print_buf(char *tag, mp_digit *buf, mp_size num)
{
int i;
mp_size alloc;
mp_size used;
mp_sign sign;
-} mpz_t, *mp_int;
+} mpz_t ,
+ *mp_int;
#define MP_DIGITS(Z) ((Z)->digits)
#define MP_ALLOC(Z) ((Z)->alloc)
mp_result mp_int_sqr(mp_int a, mp_int c); /* c = a * a */
mp_result
-mp_int_div(mp_int a, mp_int b, /* q = a / b */
+mp_int_div(mp_int a, mp_int b, /* q = a / b */
mp_int q, mp_int r); /* r = a % b */
mp_result
-mp_int_div_value(mp_int a, int value, /* q = a / value */
+mp_int_div_value(mp_int a, int value, /* q = a / value */
mp_int q, int *r); /* r = a % value */
mp_result
mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */
#if 0
void s_print(char *tag, mp_int z);
-void s_print_buf(char *tag, mp_digit * buf, mp_size num);
+void s_print_buf(char *tag, mp_digit *buf, mp_size num);
#endif
#endif /* end IMATH_H_ */
#include "px.h"
#include "sha2.h"
-void init_sha224(PX_MD * h);
-void init_sha256(PX_MD * h);
-void init_sha384(PX_MD * h);
-void init_sha512(PX_MD * h);
+void init_sha224(PX_MD *h);
+void init_sha256(PX_MD *h);
+void init_sha384(PX_MD *h);
+void init_sha512(PX_MD *h);
/* SHA224 */
static unsigned
-int_sha224_len(PX_MD * h)
+int_sha224_len(PX_MD *h)
{
return SHA224_DIGEST_LENGTH;
}
static unsigned
-int_sha224_block_len(PX_MD * h)
+int_sha224_block_len(PX_MD *h)
{
return SHA224_BLOCK_LENGTH;
}
static void
-int_sha224_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha224_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_reset(PX_MD * h)
+int_sha224_reset(PX_MD *h)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_finish(PX_MD * h, uint8 *dst)
+int_sha224_finish(PX_MD *h, uint8 *dst)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
}
static void
-int_sha224_free(PX_MD * h)
+int_sha224_free(PX_MD *h)
{
SHA224_CTX *ctx = (SHA224_CTX *) h->p.ptr;
/* SHA256 */
static unsigned
-int_sha256_len(PX_MD * h)
+int_sha256_len(PX_MD *h)
{
return SHA256_DIGEST_LENGTH;
}
static unsigned
-int_sha256_block_len(PX_MD * h)
+int_sha256_block_len(PX_MD *h)
{
return SHA256_BLOCK_LENGTH;
}
static void
-int_sha256_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha256_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_reset(PX_MD * h)
+int_sha256_reset(PX_MD *h)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_finish(PX_MD * h, uint8 *dst)
+int_sha256_finish(PX_MD *h, uint8 *dst)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
}
static void
-int_sha256_free(PX_MD * h)
+int_sha256_free(PX_MD *h)
{
SHA256_CTX *ctx = (SHA256_CTX *) h->p.ptr;
/* SHA384 */
static unsigned
-int_sha384_len(PX_MD * h)
+int_sha384_len(PX_MD *h)
{
return SHA384_DIGEST_LENGTH;
}
static unsigned
-int_sha384_block_len(PX_MD * h)
+int_sha384_block_len(PX_MD *h)
{
return SHA384_BLOCK_LENGTH;
}
static void
-int_sha384_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha384_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_reset(PX_MD * h)
+int_sha384_reset(PX_MD *h)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_finish(PX_MD * h, uint8 *dst)
+int_sha384_finish(PX_MD *h, uint8 *dst)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
}
static void
-int_sha384_free(PX_MD * h)
+int_sha384_free(PX_MD *h)
{
SHA384_CTX *ctx = (SHA384_CTX *) h->p.ptr;
/* SHA512 */
static unsigned
-int_sha512_len(PX_MD * h)
+int_sha512_len(PX_MD *h)
{
return SHA512_DIGEST_LENGTH;
}
static unsigned
-int_sha512_block_len(PX_MD * h)
+int_sha512_block_len(PX_MD *h)
{
return SHA512_BLOCK_LENGTH;
}
static void
-int_sha512_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha512_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_reset(PX_MD * h)
+int_sha512_reset(PX_MD *h)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_finish(PX_MD * h, uint8 *dst)
+int_sha512_finish(PX_MD *h, uint8 *dst)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
}
static void
-int_sha512_free(PX_MD * h)
+int_sha512_free(PX_MD *h)
{
SHA512_CTX *ctx = (SHA512_CTX *) h->p.ptr;
/* init functions */
void
-init_sha224(PX_MD * md)
+init_sha224(PX_MD *md)
{
SHA224_CTX *ctx;
}
void
-init_sha256(PX_MD * md)
+init_sha256(PX_MD *md)
{
SHA256_CTX *ctx;
}
void
-init_sha384(PX_MD * md)
+init_sha384(PX_MD *md)
{
SHA384_CTX *ctx;
}
void
-init_sha512(PX_MD * md)
+init_sha512(PX_MD *md)
{
SHA512_CTX *ctx;
#define SHA1_BLOCK_SIZE 64
#define MD5_BLOCK_SIZE 64
-static void init_md5(PX_MD * h);
-static void init_sha1(PX_MD * h);
+static void init_md5(PX_MD *h);
+static void init_sha1(PX_MD *h);
-void init_sha224(PX_MD * h);
-void init_sha256(PX_MD * h);
-void init_sha384(PX_MD * h);
-void init_sha512(PX_MD * h);
+void init_sha224(PX_MD *h);
+void init_sha256(PX_MD *h);
+void init_sha384(PX_MD *h);
+void init_sha512(PX_MD *h);
struct int_digest
{
char *name;
- void (*init) (PX_MD * h);
+ void (*init) (PX_MD *h);
};
static const struct int_digest
/* MD5 */
static unsigned
-int_md5_len(PX_MD * h)
+int_md5_len(PX_MD *h)
{
return MD5_DIGEST_LENGTH;
}
static unsigned
-int_md5_block_len(PX_MD * h)
+int_md5_block_len(PX_MD *h)
{
return MD5_BLOCK_SIZE;
}
static void
-int_md5_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_md5_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
}
static void
-int_md5_reset(PX_MD * h)
+int_md5_reset(PX_MD *h)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
}
static void
-int_md5_finish(PX_MD * h, uint8 *dst)
+int_md5_finish(PX_MD *h, uint8 *dst)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
}
static void
-int_md5_free(PX_MD * h)
+int_md5_free(PX_MD *h)
{
MD5_CTX *ctx = (MD5_CTX *) h->p.ptr;
/* SHA1 */
static unsigned
-int_sha1_len(PX_MD * h)
+int_sha1_len(PX_MD *h)
{
return SHA1_DIGEST_LENGTH;
}
static unsigned
-int_sha1_block_len(PX_MD * h)
+int_sha1_block_len(PX_MD *h)
{
return SHA1_BLOCK_SIZE;
}
static void
-int_sha1_update(PX_MD * h, const uint8 *data, unsigned dlen)
+int_sha1_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
}
static void
-int_sha1_reset(PX_MD * h)
+int_sha1_reset(PX_MD *h)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
}
static void
-int_sha1_finish(PX_MD * h, uint8 *dst)
+int_sha1_finish(PX_MD *h, uint8 *dst)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
}
static void
-int_sha1_free(PX_MD * h)
+int_sha1_free(PX_MD *h)
{
SHA1_CTX *ctx = (SHA1_CTX *) h->p.ptr;
/* init functions */
static void
-init_md5(PX_MD * md)
+init_md5(PX_MD *md)
{
MD5_CTX *ctx;
}
static void
-init_sha1(PX_MD * md)
+init_sha1(PX_MD *md)
{
SHA1_CTX *ctx;
};
static void
-intctx_free(PX_Cipher * c)
+intctx_free(PX_Cipher *c)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
#define MODE_CBC 1
static unsigned
-rj_block_size(PX_Cipher * c)
+rj_block_size(PX_Cipher *c)
{
return 128 / 8;
}
static unsigned
-rj_key_size(PX_Cipher * c)
+rj_key_size(PX_Cipher *c)
{
return 256 / 8;
}
static unsigned
-rj_iv_size(PX_Cipher * c)
+rj_iv_size(PX_Cipher *c)
{
return 128 / 8;
}
static int
-rj_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+rj_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-rj_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+rj_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-rj_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+rj_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
*/
static unsigned
-bf_block_size(PX_Cipher * c)
+bf_block_size(PX_Cipher *c)
{
return 8;
}
static unsigned
-bf_key_size(PX_Cipher * c)
+bf_key_size(PX_Cipher *c)
{
return 448 / 8;
}
static unsigned
-bf_iv_size(PX_Cipher * c)
+bf_iv_size(PX_Cipher *c)
{
return 8;
}
static int
-bf_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+bf_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
}
static int
-bf_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
BlowfishContext *bfctx = &cx->ctx.bf;
}
static int
-bf_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
struct int_ctx *cx = (struct int_ctx *) c->ptr;
BlowfishContext *bfctx = &cx->ctx.bf;
/* PUBLIC FUNCTIONS */
int
-px_find_digest(const char *name, PX_MD ** res)
+px_find_digest(const char *name, PX_MD **res)
{
const struct int_digest *p;
PX_MD *h;
}
int
-px_find_cipher(const char *name, PX_Cipher ** res)
+px_find_cipher(const char *name, PX_Cipher **res)
{
int i;
PX_Cipher *c = NULL;
};
int
-mbuf_avail(MBuf * mbuf)
+mbuf_avail(MBuf *mbuf)
{
return mbuf->data_end - mbuf->read_pos;
}
int
-mbuf_size(MBuf * mbuf)
+mbuf_size(MBuf *mbuf)
{
return mbuf->data_end - mbuf->data;
}
int
-mbuf_tell(MBuf * mbuf)
+mbuf_tell(MBuf *mbuf)
{
return mbuf->read_pos - mbuf->data;
}
int
-mbuf_free(MBuf * mbuf)
+mbuf_free(MBuf *mbuf)
{
if (mbuf->own_data)
{
}
static void
-prepare_room(MBuf * mbuf, int block_len)
+prepare_room(MBuf *mbuf, int block_len)
{
uint8 *newbuf;
unsigned newlen;
}
int
-mbuf_append(MBuf * dst, const uint8 *buf, int len)
+mbuf_append(MBuf *dst, const uint8 *buf, int len)
{
if (dst->no_write)
{
int
-mbuf_grab(MBuf * mbuf, int len, uint8 **data_p)
+mbuf_grab(MBuf *mbuf, int len, uint8 **data_p)
{
if (len > mbuf_avail(mbuf))
len = mbuf_avail(mbuf);
}
int
-mbuf_rewind(MBuf * mbuf)
+mbuf_rewind(MBuf *mbuf)
{
mbuf->read_pos = mbuf->data;
return 0;
}
int
-mbuf_steal_data(MBuf * mbuf, uint8 **data_p)
+mbuf_steal_data(MBuf *mbuf, uint8 **data_p)
{
int len = mbuf_size(mbuf);
};
int
-pullf_create(PullFilter ** pf_p, const PullFilterOps * op, void *init_arg, PullFilter * src)
+pullf_create(PullFilter **pf_p, const PullFilterOps *op, void *init_arg, PullFilter *src)
{
PullFilter *pf;
void *priv;
}
void
-pullf_free(PullFilter * pf)
+pullf_free(PullFilter *pf)
{
if (pf->op->free)
pf->op->free(pf->priv);
/* may return less data than asked, 0 means eof */
int
-pullf_read(PullFilter * pf, int len, uint8 **data_p)
+pullf_read(PullFilter *pf, int len, uint8 **data_p)
{
int res;
}
int
-pullf_read_max(PullFilter * pf, int len, uint8 **data_p, uint8 *tmpbuf)
+pullf_read_max(PullFilter *pf, int len, uint8 **data_p, uint8 *tmpbuf)
{
int res,
total;
* caller wants exatly len bytes and dont bother with references
*/
int
-pullf_read_fixed(PullFilter * src, int len, uint8 *dst)
+pullf_read_fixed(PullFilter *src, int len, uint8 *dst)
{
int res;
uint8 *p;
* read from MBuf
*/
static int
-pull_from_mbuf(void *arg, PullFilter * src, int len,
+pull_from_mbuf(void *arg, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
MBuf *mbuf = arg;
};
int
-pullf_create_mbuf_reader(PullFilter ** mp_p, MBuf * src)
+pullf_create_mbuf_reader(PullFilter **mp_p, MBuf *src)
{
return pullf_create(mp_p, &mbuf_reader, src, NULL);
}
};
int
-pushf_create(PushFilter ** mp_p, const PushFilterOps * op, void *init_arg, PushFilter * next)
+pushf_create(PushFilter **mp_p, const PushFilterOps *op, void *init_arg, PushFilter *next)
{
PushFilter *mp;
void *priv;
}
void
-pushf_free(PushFilter * mp)
+pushf_free(PushFilter *mp)
{
if (mp->op->free)
mp->op->free(mp->priv);
}
void
-pushf_free_all(PushFilter * mp)
+pushf_free_all(PushFilter *mp)
{
PushFilter *tmp;
}
static int
-wrap_process(PushFilter * mp, const uint8 *data, int len)
+wrap_process(PushFilter *mp, const uint8 *data, int len)
{
int res;
/* consumes all data, returns len on success */
int
-pushf_write(PushFilter * mp, const uint8 *data, int len)
+pushf_write(PushFilter *mp, const uint8 *data, int len)
{
int need,
res;
}
int
-pushf_flush(PushFilter * mp)
+pushf_flush(PushFilter *mp)
{
int res;
* write to MBuf
*/
static int
-push_into_mbuf(PushFilter * next, void *arg, const uint8 *data, int len)
+push_into_mbuf(PushFilter *next, void *arg, const uint8 *data, int len)
{
int res = 0;
MBuf *mbuf = arg;
};
int
-pushf_create_mbuf_writer(PushFilter ** res, MBuf * dst)
+pushf_create_mbuf_writer(PushFilter **res, MBuf *dst)
{
return pushf_create(res, &mbuf_filter, dst, NULL);
}
* should return needed buffer size, 0- no buffering, <0 on error if NULL,
* no buffering, and priv=init_arg
*/
- int (*init) (PushFilter * next, void *init_arg, void **priv_p);
+ int (*init) (PushFilter *next, void *init_arg, void **priv_p);
/*
* send data to next. should consume all? if null, it will be simply
* copied (in-place) returns 0 on error
*/
- int (*push) (PushFilter * next, void *priv,
+ int (*push) (PushFilter *next, void *priv,
const uint8 *src, int len);
- int (*flush) (PushFilter * next, void *priv);
+ int (*flush) (PushFilter *next, void *priv);
void (*free) (void *priv);
};
* should return needed buffer size, 0- no buffering, <0 on error if NULL,
* no buffering, and priv=init_arg
*/
- int (*init) (void **priv_p, void *init_arg, PullFilter * src);
+ int (*init) (void **priv_p, void *init_arg, PullFilter *src);
/*
* request data from src, put result ptr to data_p can use ptr from src or
* use buf as work area if NULL in-place copy
*/
- int (*pull) (void *priv, PullFilter * src, int len,
+ int (*pull) (void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen);
void (*free) (void *priv);
};
*/
MBuf *mbuf_create(int len);
MBuf *mbuf_create_from_data(const uint8 *data, int len);
-int mbuf_tell(MBuf * mbuf);
-int mbuf_avail(MBuf * mbuf);
-int mbuf_size(MBuf * mbuf);
-int mbuf_grab(MBuf * mbuf, int len, uint8 **data_p);
-int mbuf_steal_data(MBuf * mbuf, uint8 **data_p);
-int mbuf_append(MBuf * dst, const uint8 *buf, int cnt);
-int mbuf_rewind(MBuf * mbuf);
-int mbuf_free(MBuf * mbuf);
+int mbuf_tell(MBuf *mbuf);
+int mbuf_avail(MBuf *mbuf);
+int mbuf_size(MBuf *mbuf);
+int mbuf_grab(MBuf *mbuf, int len, uint8 **data_p);
+int mbuf_steal_data(MBuf *mbuf, uint8 **data_p);
+int mbuf_append(MBuf *dst, const uint8 *buf, int cnt);
+int mbuf_rewind(MBuf *mbuf);
+int mbuf_free(MBuf *mbuf);
/*
* Push filter
*/
-int pushf_create(PushFilter ** res, const PushFilterOps * ops, void *init_arg,
- PushFilter * next);
-int pushf_write(PushFilter * mp, const uint8 *data, int len);
-void pushf_free_all(PushFilter * mp);
-void pushf_free(PushFilter * mp);
-int pushf_flush(PushFilter * mp);
+int pushf_create(PushFilter **res, const PushFilterOps *ops, void *init_arg,
+ PushFilter *next);
+int pushf_write(PushFilter *mp, const uint8 *data, int len);
+void pushf_free_all(PushFilter *mp);
+void pushf_free(PushFilter *mp);
+int pushf_flush(PushFilter *mp);
-int pushf_create_mbuf_writer(PushFilter ** mp_p, MBuf * mbuf);
+int pushf_create_mbuf_writer(PushFilter **mp_p, MBuf *mbuf);
/*
* Pull filter
*/
-int pullf_create(PullFilter ** res, const PullFilterOps * ops,
- void *init_arg, PullFilter * src);
-int pullf_read(PullFilter * mp, int len, uint8 **data_p);
-int pullf_read_max(PullFilter * mp, int len,
+int pullf_create(PullFilter **res, const PullFilterOps *ops,
+ void *init_arg, PullFilter *src);
+int pullf_read(PullFilter *mp, int len, uint8 **data_p);
+int pullf_read_max(PullFilter *mp, int len,
uint8 **data_p, uint8 *tmpbuf);
-void pullf_free(PullFilter * mp);
-int pullf_read_fixed(PullFilter * src, int len, uint8 *dst);
+void pullf_free(PullFilter *mp);
+int pullf_read_fixed(PullFilter *src, int len, uint8 *dst);
-int pullf_create_mbuf_reader(PullFilter ** pf_p, MBuf * mbuf);
+int pullf_create_mbuf_reader(PullFilter **pf_p, MBuf *mbuf);
#define GETBYTE(pf, dst) \
do { \
static void md5_calc(uint8 *, md5_ctxt *);
void
-md5_init(md5_ctxt * ctxt)
+md5_init(md5_ctxt *ctxt)
{
ctxt->md5_n = 0;
ctxt->md5_i = 0;
}
void
-md5_loop(md5_ctxt * ctxt, const uint8 *input, unsigned len)
+md5_loop(md5_ctxt *ctxt, const uint8 *input, unsigned len)
{
unsigned int gap,
i;
}
void
-md5_pad(md5_ctxt * ctxt)
+md5_pad(md5_ctxt *ctxt)
{
unsigned int gap;
}
void
-md5_result(uint8 *digest, md5_ctxt * ctxt)
+md5_result(uint8 *digest, md5_ctxt *ctxt)
{
/* 4 byte words */
#ifndef WORDS_BIGENDIAN
#endif
static void
-md5_calc(uint8 *b64, md5_ctxt * ctxt)
+md5_calc(uint8 *b64, md5_ctxt *ctxt)
{
uint32 A = ctxt->md5_sta;
uint32 B = ctxt->md5_stb;
unsigned int md5_i;
uint8 md5_buf[MD5_BUFLEN];
-} md5_ctxt;
+} md5_ctxt;
extern void md5_init(md5_ctxt *);
extern void md5_loop(md5_ctxt *, const uint8 *, unsigned int);
#include "sha2.c"
#include "internal-sha2.c"
-typedef void (*init_f) (PX_MD * md);
+typedef void (*init_f) (PX_MD *md);
static int
-compat_find_digest(const char *name, PX_MD ** res)
+compat_find_digest(const char *name, PX_MD **res)
{
init_f init = NULL;
{
const EVP_MD *algo;
EVP_MD_CTX ctx;
-} OSSLDigest;
+} OSSLDigest;
static unsigned
-digest_result_size(PX_MD * h)
+digest_result_size(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static unsigned
-digest_block_size(PX_MD * h)
+digest_block_size(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_reset(PX_MD * h)
+digest_reset(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_update(PX_MD * h, const uint8 *data, unsigned dlen)
+digest_update(PX_MD *h, const uint8 *data, unsigned dlen)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_finish(PX_MD * h, uint8 *dst)
+digest_finish(PX_MD *h, uint8 *dst)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
}
static void
-digest_free(PX_MD * h)
+digest_free(PX_MD *h)
{
OSSLDigest *digest = (OSSLDigest *) h->p.ptr;
/* PUBLIC functions */
int
-px_find_digest(const char *name, PX_MD ** res)
+px_find_digest(const char *name, PX_MD **res)
{
const EVP_MD *md;
PX_MD *h;
struct ossl_cipher
{
- int (*init) (PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv);
- int (*encrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- int (*decrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*init) (PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv);
+ int (*encrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*decrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
int block_size;
int max_key_size;
unsigned klen;
unsigned init;
const struct ossl_cipher *ciph;
-} ossldata;
+} ossldata;
/* generic */
static unsigned
-gen_ossl_block_size(PX_Cipher * c)
+gen_ossl_block_size(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static unsigned
-gen_ossl_key_size(PX_Cipher * c)
+gen_ossl_key_size(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static unsigned
-gen_ossl_iv_size(PX_Cipher * c)
+gen_ossl_iv_size(PX_Cipher *c)
{
unsigned ivlen;
ossldata *od = (ossldata *) c->ptr;
}
static void
-gen_ossl_free(PX_Cipher * c)
+gen_ossl_free(PX_Cipher *c)
{
ossldata *od = (ossldata *) c->ptr;
}
static int
-bf_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+bf_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
static int bf_is_strong = -1;
}
static int
-bf_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
unsigned i;
}
static int
-bf_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c),
i;
}
static int
-bf_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cfb64_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cfb64_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-bf_cfb64_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+bf_cfb64_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
/* DES */
static int
-ossl_des_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_des_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
DES_cblock xkey;
}
static int
-ossl_des_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_des_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* DES3 */
static int
-ossl_des3_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_des3_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
DES_cblock xkey1,
}
static int
-ossl_des3_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des3_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_des3_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_des3_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_des3_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* CAST5 */
static int
-ossl_cast_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_cast_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_cast_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
}
static int
-ossl_cast_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
ossldata *od = c->ptr;
}
static int
-ossl_cast_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_cast_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
+ossl_cast_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
{
ossldata *od = c->ptr;
/* AES */
static int
-ossl_aes_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
+ossl_aes_init(PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
{
ossldata *od = c->ptr;
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_key_init(ossldata * od, int type)
+ossl_aes_key_init(ossldata *od, int type)
{
int err;
}
static int
-ossl_aes_ecb_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_ecb_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_ecb_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_ecb_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
unsigned bs = gen_ossl_block_size(c);
}
static int
-ossl_aes_cbc_encrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_cbc_encrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
}
static int
-ossl_aes_cbc_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen,
+ossl_aes_cbc_decrypt(PX_Cipher *c, const uint8 *data, unsigned dlen,
uint8 *res)
{
ossldata *od = c->ptr;
/* PUBLIC functions */
int
-px_find_cipher(const char *name, PX_Cipher ** res)
+px_find_cipher(const char *name, PX_Cipher **res)
{
const struct ossl_cipher_lookup *i;
PX_Cipher *c = NULL;
#include "px.h"
#include "pgp.h"
-typedef int (*mix_data_t) (PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
+typedef int (*mix_data_t) (PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
struct PGP_CFB
{
};
int
-pgp_cfb_create(PGP_CFB ** ctx_p, int algo, const uint8 *key, int key_len,
+pgp_cfb_create(PGP_CFB **ctx_p, int algo, const uint8 *key, int key_len,
int resync, uint8 *iv)
{
int res;
}
void
-pgp_cfb_free(PGP_CFB * ctx)
+pgp_cfb_free(PGP_CFB *ctx)
{
px_cipher_free(ctx->ciph);
memset(ctx, 0, sizeof(*ctx));
* Data processing for normal CFB. (PGP_PKT_SYMENCRYPTED_DATA_MDC)
*/
static int
-mix_encrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i;
}
static int
-mix_decrypt_normal(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i;
* thus its all concentrated here.
*/
static int
-mix_encrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_encrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i,
n;
}
static int
-mix_decrypt_resync(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+mix_decrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
int i,
n;
* common code for both encrypt and decrypt.
*/
static int
-cfb_process(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst,
+cfb_process(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst,
mix_data_t mix_data)
{
int n;
*/
int
-pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
mix_data_t mix = ctx->resync ? mix_encrypt_resync : mix_encrypt_normal;
}
int
-pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst)
+pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
mix_data_t mix = ctx->resync ? mix_decrypt_resync : mix_decrypt_normal;
}
static int
-compress_init(PushFilter * next, void *init_arg, void **priv_p)
+compress_init(PushFilter *next, void *init_arg, void **priv_p)
{
int res;
struct ZipStat *st;
/* cant handle zero-len incoming data, but shouldnt */
static int
-compress_process(PushFilter * next, void *priv, const uint8 *data, int len)
+compress_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res,
n_out;
}
static int
-compress_flush(PushFilter * next, void *priv)
+compress_flush(PushFilter *next, void *priv)
{
int res,
zres,
};
int
-pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
+pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
{
return pushf_create(res, &compress_filter, ctx, dst);
}
};
static int
-decompress_init(void **priv_p, void *arg, PullFilter * src)
+decompress_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
struct DecomprData *dec;
}
static int
-decompress_read(void *priv, PullFilter * src, int len,
+decompress_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
};
int
-pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
+pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
{
return pullf_create(res, &decompress_filter, ctx, src);
}
#else /* !HAVE_ZLIB */
int
-pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst)
+pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst)
{
return PXE_PGP_UNSUPPORTED_COMPR;
}
int
-pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src)
+pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src)
{
return PXE_PGP_UNSUPPORTED_COMPR;
}
#define MAX_CHUNK (16*1024*1024)
static int
-parse_new_len(PullFilter * src, int *len_p)
+parse_new_len(PullFilter *src, int *len_p)
{
uint8 b;
int len;
}
static int
-parse_old_len(PullFilter * src, int *len_p, int lentype)
+parse_old_len(PullFilter *src, int *len_p, int lentype)
{
uint8 b;
int len;
/* returns pkttype or 0 on eof */
int
-pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p, int allow_ctx)
+pgp_parse_pkt_hdr(PullFilter *src, uint8 *tag, int *len_p, int allow_ctx)
{
int lentype;
int res;
};
static int
-pktreader_pull(void *priv, PullFilter * src, int len,
+pktreader_pull(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
/* needs helper function to pass several parameters */
int
-pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
- int pkttype, PGP_Context * ctx)
+pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
+ int pkttype, PGP_Context *ctx)
{
int res;
struct PktData *pkt = px_alloc(sizeof(*pkt));
*/
static int
-prefix_init(void **priv_p, void *arg, PullFilter * src)
+prefix_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
int len;
*/
static int
-decrypt_init(void **priv_p, void *arg, PullFilter * src)
+decrypt_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_CFB *cfb = arg;
}
static int
-decrypt_read(void *priv, PullFilter * src, int len,
+decrypt_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
PGP_CFB *cfb = priv;
*/
static int
-mdc_init(void **priv_p, void *arg, PullFilter * src)
+mdc_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
}
static int
-mdc_finish(PGP_Context * ctx, PullFilter * src,
+mdc_finish(PGP_Context *ctx, PullFilter *src,
int len, uint8 **data_p)
{
int res;
}
static int
-mdc_read(void *priv, PullFilter * src, int len,
+mdc_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
int res;
};
static int
-mdcbuf_init(void **priv_p, void *arg, PullFilter * src)
+mdcbuf_init(void **priv_p, void *arg, PullFilter *src)
{
PGP_Context *ctx = arg;
struct MDCBufData *st;
}
static int
-mdcbuf_refill(struct MDCBufData * st, PullFilter * src)
+mdcbuf_refill(struct MDCBufData * st, PullFilter *src)
{
uint8 *data;
int res;
}
static int
-mdcbuf_read(void *priv, PullFilter * src, int len,
+mdcbuf_read(void *priv, PullFilter *src, int len,
uint8 **data_p, uint8 *buf, int buflen)
{
struct MDCBufData *st = priv;
* Decrypt separate session key
*/
static int
-decrypt_key(PGP_Context * ctx, const uint8 *src, int len)
+decrypt_key(PGP_Context *ctx, const uint8 *src, int len)
{
int res;
uint8 algo;
* Handle key packet
*/
static int
-parse_symenc_sesskey(PGP_Context * ctx, PullFilter * src)
+parse_symenc_sesskey(PGP_Context *ctx, PullFilter *src)
{
uint8 *p;
int res;
}
static int
-copy_crlf(MBuf * dst, uint8 *data, int len, int *got_cr)
+copy_crlf(MBuf *dst, uint8 *data, int len, int *got_cr)
{
uint8 *data_end = data + len;
uint8 tmpbuf[1024];
}
static int
-parse_literal_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
+parse_literal_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
{
int type;
int name_len;
}
/* process_data_packets and parse_compressed_data call each other */
-static int process_data_packets(PGP_Context * ctx, MBuf * dst,
- PullFilter * src, int allow_compr, int need_mdc);
+static int process_data_packets(PGP_Context *ctx, MBuf *dst,
+ PullFilter *src, int allow_compr, int need_mdc);
static int
-parse_compressed_data(PGP_Context * ctx, MBuf * dst, PullFilter * pkt)
+parse_compressed_data(PGP_Context *ctx, MBuf *dst, PullFilter *pkt)
{
int res;
uint8 type;
}
static int
-process_data_packets(PGP_Context * ctx, MBuf * dst, PullFilter * src,
+process_data_packets(PGP_Context *ctx, MBuf *dst, PullFilter *src,
int allow_compr, int need_mdc)
{
uint8 tag;
}
static int
-parse_symenc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
+parse_symenc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
{
int res;
PGP_CFB *cfb = NULL;
}
static int
-parse_symenc_mdc_data(PGP_Context * ctx, PullFilter * pkt, MBuf * dst)
+parse_symenc_mdc_data(PGP_Context *ctx, PullFilter *pkt, MBuf *dst)
{
int res;
PGP_CFB *cfb = NULL;
* skip over packet contents
*/
int
-pgp_skip_packet(PullFilter * pkt)
+pgp_skip_packet(PullFilter *pkt)
{
int res = 1;
uint8 *tmp;
* expect to be at packet end, any data is error
*/
int
-pgp_expect_packet_end(PullFilter * pkt)
+pgp_expect_packet_end(PullFilter *pkt)
{
int res = 1;
uint8 *tmp;
}
int
-pgp_decrypt(PGP_Context * ctx, MBuf * msrc, MBuf * mdst)
+pgp_decrypt(PGP_Context *ctx, MBuf *msrc, MBuf *mdst)
{
int res;
PullFilter *src = NULL;
}
static int
-write_tag_only(PushFilter * dst, int tag)
+write_tag_only(PushFilter *dst, int tag)
{
uint8 hdr = 0xC0 | tag;
}
static int
-write_normal_header(PushFilter * dst, int tag, int len)
+write_normal_header(PushFilter *dst, int tag, int len)
{
uint8 hdr[8];
uint8 *h = hdr;
*/
static int
-mdc_init(PushFilter * dst, void *init_arg, void **priv_p)
+mdc_init(PushFilter *dst, void *init_arg, void **priv_p)
{
int res;
PX_MD *md;
}
static int
-mdc_write(PushFilter * dst, void *priv, const uint8 *data, int len)
+mdc_write(PushFilter *dst, void *priv, const uint8 *data, int len)
{
PX_MD *md = priv;
}
static int
-mdc_flush(PushFilter * dst, void *priv)
+mdc_flush(PushFilter *dst, void *priv)
{
int res;
uint8 pkt[2 + MDC_DIGEST_LEN];
};
static int
-encrypt_init(PushFilter * next, void *init_arg, void **priv_p)
+encrypt_init(PushFilter *next, void *init_arg, void **priv_p)
{
struct EncStat *st;
PGP_Context *ctx = init_arg;
}
static int
-encrypt_process(PushFilter * next, void *priv, const uint8 *data, int len)
+encrypt_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res;
struct EncStat *st = priv;
};
static int
-pkt_stream_init(PushFilter * next, void *init_arg, void **priv_p)
+pkt_stream_init(PushFilter *next, void *init_arg, void **priv_p)
{
struct PktStreamStat *st;
}
static int
-pkt_stream_process(PushFilter * next, void *priv, const uint8 *data, int len)
+pkt_stream_process(PushFilter *next, void *priv, const uint8 *data, int len)
{
int res;
uint8 hdr[8];
}
static int
-pkt_stream_flush(PushFilter * next, void *priv)
+pkt_stream_flush(PushFilter *next, void *priv)
{
int res;
uint8 hdr[8];
};
int
-pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p)
+pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p)
{
int res;
*/
static int
-crlf_process(PushFilter * dst, void *priv, const uint8 *data, int len)
+crlf_process(PushFilter *dst, void *priv, const uint8 *data, int len)
{
const uint8 *data_end = data + len;
const uint8 *p2,
* Initialize literal data packet
*/
static int
-init_litdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_litdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
int hdrlen;
* Initialize compression filter
*/
static int
-init_compress(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_compress(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
uint8 type = ctx->compress_algo;
* Initialize encdata packet
*/
static int
-init_encdata_packet(PushFilter ** pf_res, PGP_Context * ctx, PushFilter * dst)
+init_encdata_packet(PushFilter **pf_res, PGP_Context *ctx, PushFilter *dst)
{
int res;
int tag;
* write prefix
*/
static int
-write_prefix(PGP_Context * ctx, PushFilter * dst)
+write_prefix(PGP_Context *ctx, PushFilter *dst)
{
uint8 prefix[PGP_MAX_BLOCK + 2];
int res,
*/
static int
-symencrypt_sesskey(PGP_Context * ctx, uint8 *dst)
+symencrypt_sesskey(PGP_Context *ctx, uint8 *dst)
{
int res;
PGP_CFB *cfb;
/* 5.3: Symmetric-Key Encrypted Session-Key */
static int
-write_symenc_sesskey(PGP_Context * ctx, PushFilter * dst)
+write_symenc_sesskey(PGP_Context *ctx, PushFilter *dst)
{
uint8 pkt[256];
int pktlen;
* key setup
*/
static int
-init_s2k_key(PGP_Context * ctx)
+init_s2k_key(PGP_Context *ctx)
{
int res;
}
static int
-init_sess_key(PGP_Context * ctx)
+init_sess_key(PGP_Context *ctx)
{
int res;
* combine
*/
int
-pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst)
+pgp_encrypt(PGP_Context *ctx, MBuf *src, MBuf *dst)
{
int res;
int len;
#include "pgp.h"
static int
-read_pubkey_keyid(PullFilter * pkt, uint8 *keyid_buf)
+read_pubkey_keyid(PullFilter *pkt, uint8 *keyid_buf)
{
int res;
PGP_PubKey *pk = NULL;
}
static int
-read_pubenc_keyid(PullFilter * pkt, uint8 *keyid_buf)
+read_pubenc_keyid(PullFilter *pkt, uint8 *keyid_buf)
{
uint8 ver;
int res;
* dst should have room for 17 bytes
*/
int
-pgp_get_keyid(MBuf * pgp_data, char *dst)
+pgp_get_keyid(MBuf *pgp_data, char *dst)
{
int res;
PullFilter *src;
}
static void
-mp_clear_free(mpz_t * a)
+mp_clear_free(mpz_t *a)
{
if (!a)
return;
static int
-mp_px_rand(uint32 bits, mpz_t * res)
+mp_px_rand(uint32 bits, mpz_t *res)
{
int err;
unsigned bytes = (bits + 7) / 8;
}
static void
-mp_modmul(mpz_t * a, mpz_t * b, mpz_t * p, mpz_t * res)
+mp_modmul(mpz_t *a, mpz_t *b, mpz_t *p, mpz_t *res)
{
mpz_t *tmp = mp_new();
}
static mpz_t *
-mpi_to_bn(PGP_MPI * n)
+mpi_to_bn(PGP_MPI *n)
{
mpz_t *bn = mp_new();
}
static PGP_MPI *
-bn_to_mpi(mpz_t * bn)
+bn_to_mpi(mpz_t *bn)
{
int res;
PGP_MPI *n;
}
int
-pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
- PGP_MPI ** c1_p, PGP_MPI ** c2_p)
+pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
+ PGP_MPI **c1_p, PGP_MPI **c2_p)
{
int res = PXE_PGP_MATH_FAILED;
int k_bits;
}
int
-pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
- PGP_MPI ** msg_p)
+pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
+ PGP_MPI **msg_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *c1 = mpi_to_bn(_c1);
}
int
-pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * _m, PGP_MPI ** c_p)
+pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *m = mpi_to_bn(_m);
}
int
-pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * _c, PGP_MPI ** m_p)
+pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
{
int res = PXE_PGP_MATH_FAILED;
mpz_t *c = mpi_to_bn(_c);
#include "pgp.h"
static BIGNUM *
-mpi_to_bn(PGP_MPI * n)
+mpi_to_bn(PGP_MPI *n)
{
BIGNUM *bn = BN_bin2bn(n->data, n->bytes, NULL);
}
int
-pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * _m,
- PGP_MPI ** c1_p, PGP_MPI ** c2_p)
+pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *_m,
+ PGP_MPI **c1_p, PGP_MPI **c2_p)
{
int res = PXE_PGP_MATH_FAILED;
int k_bits;
}
int
-pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * _c1, PGP_MPI * _c2,
- PGP_MPI ** msg_p)
+pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *_c1, PGP_MPI *_c2,
+ PGP_MPI **msg_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *c1 = mpi_to_bn(_c1);
}
int
-pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * _m, PGP_MPI ** c_p)
+pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *_m, PGP_MPI **c_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *m = mpi_to_bn(_m);
}
int
-pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * _c, PGP_MPI ** m_p)
+pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *_c, PGP_MPI **m_p)
{
int res = PXE_PGP_MATH_FAILED;
BIGNUM *c = mpi_to_bn(_c);
#include "pgp.h"
int
-pgp_mpi_alloc(int bits, PGP_MPI ** mpi)
+pgp_mpi_alloc(int bits, PGP_MPI **mpi)
{
PGP_MPI *n;
int len = (bits + 7) / 8;
}
int
-pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi)
+pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
{
int res;
PGP_MPI *n;
}
int
-pgp_mpi_free(PGP_MPI * mpi)
+pgp_mpi_free(PGP_MPI *mpi)
{
if (mpi == NULL)
return 0;
}
int
-pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi)
+pgp_mpi_read(PullFilter *src, PGP_MPI **mpi)
{
int res;
uint8 hdr[2];
}
int
-pgp_mpi_write(PushFilter * dst, PGP_MPI * n)
+pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
{
int res;
uint8 buf[2];
}
int
-pgp_mpi_hash(PX_MD * md, PGP_MPI * n)
+pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
{
uint8 buf[2];
}
unsigned
-pgp_mpi_cksum(unsigned cksum, PGP_MPI * n)
+pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
{
int i;
* Mix a block of data into RNG.
*/
static void
-add_block_entropy(PX_MD * md, text *data)
+add_block_entropy(PX_MD *md, text *data)
{
uint8 sha1[20];
} while (0)
static void
-check_expect(PGP_Context * ctx, struct debug_expect * ex)
+check_expect(PGP_Context *ctx, struct debug_expect * ex)
{
EX_CHECK(cipher_algo);
EX_CHECK(s2k_mode);
}
static int
-set_arg(PGP_Context * ctx, char *key, char *val,
+set_arg(PGP_Context *ctx, char *key, char *val,
struct debug_expect * ex)
{
int res = 0;
}
static int
-parse_args(PGP_Context * ctx, uint8 *args, int arg_len,
+parse_args(PGP_Context *ctx, uint8 *args, int arg_len,
struct debug_expect * ex)
{
char *str = downcase_convert(args, arg_len);
}
static void
-init_work(PGP_Context ** ctx_p, int is_text,
+init_work(PGP_Context **ctx_p, int is_text,
text *args, struct debug_expect * ex)
{
int err = pgp_init(ctx_p);
}
static int
-decrypt_elgamal(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
+decrypt_elgamal(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
{
int res;
PGP_MPI *c1 = NULL;
}
static int
-decrypt_rsa(PGP_PubKey * pk, PullFilter * pkt, PGP_MPI ** m_p)
+decrypt_rsa(PGP_PubKey *pk, PullFilter *pkt, PGP_MPI **m_p)
{
int res;
PGP_MPI *c;
any_key[] = {0, 0, 0, 0, 0, 0, 0, 0};
int
-pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt)
+pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt)
{
int ver;
int algo;
}
static int
-create_secmsg(PGP_Context * ctx, PGP_MPI ** msg_p, int full_bytes)
+create_secmsg(PGP_Context *ctx, PGP_MPI **msg_p, int full_bytes)
{
uint8 *secmsg;
int res,
}
static int
-encrypt_and_write_elgamal(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
+encrypt_and_write_elgamal(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
{
int res;
PGP_MPI *m = NULL,
}
static int
-encrypt_and_write_rsa(PGP_Context * ctx, PGP_PubKey * pk, PushFilter * pkt)
+encrypt_and_write_rsa(PGP_Context *ctx, PGP_PubKey *pk, PushFilter *pkt)
{
int res;
PGP_MPI *m = NULL,
}
int
-pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst)
+pgp_write_pubenc_sesskey(PGP_Context *ctx, PushFilter *dst)
{
int res;
PGP_PubKey *pk = ctx->pub_key;
#include "pgp.h"
int
-pgp_key_alloc(PGP_PubKey ** pk_p)
+pgp_key_alloc(PGP_PubKey **pk_p)
{
PGP_PubKey *pk;
}
void
-pgp_key_free(PGP_PubKey * pk)
+pgp_key_free(PGP_PubKey *pk)
{
if (pk == NULL)
return;
}
static int
-calc_key_id(PGP_PubKey * pk)
+calc_key_id(PGP_PubKey *pk)
{
int res;
PX_MD *md;
}
int
-_pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p)
+_pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p)
{
int res;
PGP_PubKey *pk;
#define HIDE_SHA1 254
static int
-check_key_sha1(PullFilter * src, PGP_PubKey * pk)
+check_key_sha1(PullFilter *src, PGP_PubKey *pk)
{
int res;
uint8 got_sha1[20];
}
static int
-check_key_cksum(PullFilter * src, PGP_PubKey * pk)
+check_key_cksum(PullFilter *src, PGP_PubKey *pk)
{
int res;
unsigned got_cksum,
}
static int
-process_secret_key(PullFilter * pkt, PGP_PubKey ** pk_p,
+process_secret_key(PullFilter *pkt, PGP_PubKey **pk_p,
const uint8 *key, int key_len)
{
int res;
}
static int
-internal_read_key(PullFilter * src, PGP_PubKey ** pk_p,
+internal_read_key(PullFilter *src, PGP_PubKey **pk_p,
const uint8 *psw, int psw_len, int pubtype)
{
PullFilter *pkt = NULL;
}
int
-pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
const uint8 *key, int key_len, int pubtype)
{
int res;
#include "pgp.h"
static int
-calc_s2k_simple(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
+calc_s2k_simple(PGP_S2K *s2k, PX_MD *md, const uint8 *key,
unsigned key_len)
{
unsigned md_bs,
}
static int
-calc_s2k_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key, unsigned key_len)
+calc_s2k_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key, unsigned key_len)
{
unsigned md_bs,
md_rlen;
}
static int
-calc_s2k_iter_salted(PGP_S2K * s2k, PX_MD * md, const uint8 *key,
+calc_s2k_iter_salted(PGP_S2K *s2k, PX_MD *md, const uint8 *key,
unsigned key_len)
{
unsigned md_bs,
}
int
-pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo)
+pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo)
{
int res = 0;
uint8 tmp;
}
int
-pgp_s2k_read(PullFilter * src, PGP_S2K * s2k)
+pgp_s2k_read(PullFilter *src, PGP_S2K *s2k)
{
int res = 0;
}
int
-pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int key_len)
+pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int key_len)
{
int res;
PX_MD *md;
}
int
-pgp_load_cipher(int code, PX_Cipher ** res)
+pgp_load_cipher(int code, PX_Cipher **res)
{
int err;
const struct cipher_info *i = get_cipher_info(code);
}
int
-pgp_load_digest(int code, PX_MD ** res)
+pgp_load_digest(int code, PX_MD **res)
{
int err;
const char *name = pgp_get_digest_name(code);
}
int
-pgp_init(PGP_Context ** ctx_p)
+pgp_init(PGP_Context **ctx_p)
{
PGP_Context *ctx;
}
int
-pgp_free(PGP_Context * ctx)
+pgp_free(PGP_Context *ctx)
{
if (ctx->pub_key)
pgp_key_free(ctx->pub_key);
}
int
-pgp_disable_mdc(PGP_Context * ctx, int disable)
+pgp_disable_mdc(PGP_Context *ctx, int disable)
{
ctx->disable_mdc = disable ? 1 : 0;
return 0;
}
int
-pgp_set_sess_key(PGP_Context * ctx, int use)
+pgp_set_sess_key(PGP_Context *ctx, int use)
{
ctx->use_sess_key = use ? 1 : 0;
return 0;
}
int
-pgp_set_convert_crlf(PGP_Context * ctx, int doit)
+pgp_set_convert_crlf(PGP_Context *ctx, int doit)
{
ctx->convert_crlf = doit ? 1 : 0;
return 0;
}
int
-pgp_set_s2k_mode(PGP_Context * ctx, int mode)
+pgp_set_s2k_mode(PGP_Context *ctx, int mode)
{
int err = PXE_OK;
}
int
-pgp_set_compress_algo(PGP_Context * ctx, int algo)
+pgp_set_compress_algo(PGP_Context *ctx, int algo)
{
switch (algo)
{
}
int
-pgp_set_compress_level(PGP_Context * ctx, int level)
+pgp_set_compress_level(PGP_Context *ctx, int level)
{
if (level >= 0 && level <= 9)
{
}
int
-pgp_set_text_mode(PGP_Context * ctx, int mode)
+pgp_set_text_mode(PGP_Context *ctx, int mode)
{
ctx->text_mode = mode;
return 0;
}
int
-pgp_set_cipher_algo(PGP_Context * ctx, const char *name)
+pgp_set_cipher_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_cipher_code(name);
}
int
-pgp_set_s2k_cipher_algo(PGP_Context * ctx, const char *name)
+pgp_set_s2k_cipher_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_cipher_code(name);
}
int
-pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name)
+pgp_set_s2k_digest_algo(PGP_Context *ctx, const char *name)
{
int code = pgp_get_digest_code(name);
}
int
-pgp_get_unicode_mode(PGP_Context * ctx)
+pgp_get_unicode_mode(PGP_Context *ctx)
{
return ctx->unicode_mode;
}
int
-pgp_set_unicode_mode(PGP_Context * ctx, int mode)
+pgp_set_unicode_mode(PGP_Context *ctx, int mode)
{
ctx->unicode_mode = mode ? 1 : 0;
return 0;
}
int
-pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int len)
+pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int len)
{
if (key == NULL || len < 1)
return PXE_ARGUMENT_ERROR;
int can_encrypt;
};
-int pgp_init(PGP_Context ** ctx);
-int pgp_encrypt(PGP_Context * ctx, MBuf * src, MBuf * dst);
-int pgp_decrypt(PGP_Context * ctx, MBuf * src, MBuf * dst);
-int pgp_free(PGP_Context * ctx);
+int pgp_init(PGP_Context **ctx);
+int pgp_encrypt(PGP_Context *ctx, MBuf *src, MBuf *dst);
+int pgp_decrypt(PGP_Context *ctx, MBuf *src, MBuf *dst);
+int pgp_free(PGP_Context *ctx);
int pgp_get_digest_code(const char *name);
int pgp_get_cipher_code(const char *name);
const char *pgp_get_digest_name(int code);
const char *pgp_get_cipher_name(int code);
-int pgp_set_cipher_algo(PGP_Context * ctx, const char *name);
-int pgp_set_s2k_mode(PGP_Context * ctx, int type);
-int pgp_set_s2k_cipher_algo(PGP_Context * ctx, const char *name);
-int pgp_set_s2k_digest_algo(PGP_Context * ctx, const char *name);
-int pgp_set_convert_crlf(PGP_Context * ctx, int doit);
-int pgp_disable_mdc(PGP_Context * ctx, int disable);
-int pgp_set_sess_key(PGP_Context * ctx, int use);
-int pgp_set_compress_algo(PGP_Context * ctx, int algo);
-int pgp_set_compress_level(PGP_Context * ctx, int level);
-int pgp_set_text_mode(PGP_Context * ctx, int mode);
-int pgp_set_unicode_mode(PGP_Context * ctx, int mode);
-int pgp_get_unicode_mode(PGP_Context * ctx);
-
-int pgp_set_symkey(PGP_Context * ctx, const uint8 *key, int klen);
-int pgp_set_pubkey(PGP_Context * ctx, MBuf * keypkt,
+int pgp_set_cipher_algo(PGP_Context *ctx, const char *name);
+int pgp_set_s2k_mode(PGP_Context *ctx, int type);
+int pgp_set_s2k_cipher_algo(PGP_Context *ctx, const char *name);
+int pgp_set_s2k_digest_algo(PGP_Context *ctx, const char *name);
+int pgp_set_convert_crlf(PGP_Context *ctx, int doit);
+int pgp_disable_mdc(PGP_Context *ctx, int disable);
+int pgp_set_sess_key(PGP_Context *ctx, int use);
+int pgp_set_compress_algo(PGP_Context *ctx, int algo);
+int pgp_set_compress_level(PGP_Context *ctx, int level);
+int pgp_set_text_mode(PGP_Context *ctx, int mode);
+int pgp_set_unicode_mode(PGP_Context *ctx, int mode);
+int pgp_get_unicode_mode(PGP_Context *ctx);
+
+int pgp_set_symkey(PGP_Context *ctx, const uint8 *key, int klen);
+int pgp_set_pubkey(PGP_Context *ctx, MBuf *keypkt,
const uint8 *key, int klen, int pubtype);
-int pgp_get_keyid(MBuf * pgp_data, char *dst);
+int pgp_get_keyid(MBuf *pgp_data, char *dst);
/* internal functions */
-int pgp_load_digest(int c, PX_MD ** res);
-int pgp_load_cipher(int c, PX_Cipher ** res);
+int pgp_load_digest(int c, PX_MD **res);
+int pgp_load_cipher(int c, PX_Cipher **res);
int pgp_get_cipher_key_size(int c);
int pgp_get_cipher_block_size(int c);
-int pgp_s2k_fill(PGP_S2K * s2k, int mode, int digest_algo);
-int pgp_s2k_read(PullFilter * src, PGP_S2K * s2k);
-int pgp_s2k_process(PGP_S2K * s2k, int cipher, const uint8 *key, int klen);
+int pgp_s2k_fill(PGP_S2K *s2k, int mode, int digest_algo);
+int pgp_s2k_read(PullFilter *src, PGP_S2K *s2k);
+int pgp_s2k_process(PGP_S2K *s2k, int cipher, const uint8 *key, int klen);
typedef struct PGP_CFB PGP_CFB;
int
-pgp_cfb_create(PGP_CFB ** ctx_p, int algo,
+pgp_cfb_create(PGP_CFB **ctx_p, int algo,
const uint8 *key, int key_len, int recync, uint8 *iv);
-void pgp_cfb_free(PGP_CFB * ctx);
-int pgp_cfb_encrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
-int pgp_cfb_decrypt(PGP_CFB * ctx, const uint8 *data, int len, uint8 *dst);
+void pgp_cfb_free(PGP_CFB *ctx);
+int pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
+int pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);
int pgp_armor_encode(const uint8 *src, unsigned len, uint8 *dst);
int pgp_armor_decode(const uint8 *src, unsigned len, uint8 *dst);
unsigned pgp_armor_enc_len(unsigned len);
unsigned pgp_armor_dec_len(unsigned len);
-int pgp_compress_filter(PushFilter ** res, PGP_Context * ctx, PushFilter * dst);
-int pgp_decompress_filter(PullFilter ** res, PGP_Context * ctx, PullFilter * src);
+int pgp_compress_filter(PushFilter **res, PGP_Context *ctx, PushFilter *dst);
+int pgp_decompress_filter(PullFilter **res, PGP_Context *ctx, PullFilter *src);
-int pgp_key_alloc(PGP_PubKey ** pk_p);
-void pgp_key_free(PGP_PubKey * pk);
-int _pgp_read_public_key(PullFilter * pkt, PGP_PubKey ** pk_p);
+int pgp_key_alloc(PGP_PubKey **pk_p);
+void pgp_key_free(PGP_PubKey *pk);
+int _pgp_read_public_key(PullFilter *pkt, PGP_PubKey **pk_p);
-int pgp_parse_pubenc_sesskey(PGP_Context * ctx, PullFilter * pkt);
-int pgp_create_pkt_reader(PullFilter ** pf_p, PullFilter * src, int len,
- int pkttype, PGP_Context * ctx);
-int pgp_parse_pkt_hdr(PullFilter * src, uint8 *tag, int *len_p,
+int pgp_parse_pubenc_sesskey(PGP_Context *ctx, PullFilter *pkt);
+int pgp_create_pkt_reader(PullFilter **pf_p, PullFilter *src, int len,
+ int pkttype, PGP_Context *ctx);
+int pgp_parse_pkt_hdr(PullFilter *src, uint8 *tag, int *len_p,
int allow_ctx);
-int pgp_skip_packet(PullFilter * pkt);
-int pgp_expect_packet_end(PullFilter * pkt);
-
-int pgp_write_pubenc_sesskey(PGP_Context * ctx, PushFilter * dst);
-int pgp_create_pkt_writer(PushFilter * dst, int tag, PushFilter ** res_p);
-
-int pgp_mpi_alloc(int bits, PGP_MPI ** mpi);
-int pgp_mpi_create(uint8 *data, int bits, PGP_MPI ** mpi);
-int pgp_mpi_free(PGP_MPI * mpi);
-int pgp_mpi_read(PullFilter * src, PGP_MPI ** mpi);
-int pgp_mpi_write(PushFilter * dst, PGP_MPI * n);
-int pgp_mpi_hash(PX_MD * md, PGP_MPI * n);
-unsigned pgp_mpi_cksum(unsigned cksum, PGP_MPI * n);
-
-int pgp_elgamal_encrypt(PGP_PubKey * pk, PGP_MPI * m,
- PGP_MPI ** c1, PGP_MPI ** c2);
-int pgp_elgamal_decrypt(PGP_PubKey * pk, PGP_MPI * c1, PGP_MPI * c2,
- PGP_MPI ** m);
-int pgp_rsa_encrypt(PGP_PubKey * pk, PGP_MPI * m, PGP_MPI ** c);
-int pgp_rsa_decrypt(PGP_PubKey * pk, PGP_MPI * c, PGP_MPI ** m);
+int pgp_skip_packet(PullFilter *pkt);
+int pgp_expect_packet_end(PullFilter *pkt);
+
+int pgp_write_pubenc_sesskey(PGP_Context *ctx, PushFilter *dst);
+int pgp_create_pkt_writer(PushFilter *dst, int tag, PushFilter **res_p);
+
+int pgp_mpi_alloc(int bits, PGP_MPI **mpi);
+int pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi);
+int pgp_mpi_free(PGP_MPI *mpi);
+int pgp_mpi_read(PullFilter *src, PGP_MPI **mpi);
+int pgp_mpi_write(PushFilter *dst, PGP_MPI *n);
+int pgp_mpi_hash(PX_MD *md, PGP_MPI *n);
+unsigned pgp_mpi_cksum(unsigned cksum, PGP_MPI *n);
+
+int pgp_elgamal_encrypt(PGP_PubKey *pk, PGP_MPI *m,
+ PGP_MPI **c1, PGP_MPI **c2);
+int pgp_elgamal_decrypt(PGP_PubKey *pk, PGP_MPI *c1, PGP_MPI *c2,
+ PGP_MPI **m);
+int pgp_rsa_encrypt(PGP_PubKey *pk, PGP_MPI *m, PGP_MPI **c);
+int pgp_rsa_decrypt(PGP_PubKey *pk, PGP_MPI *c, PGP_MPI **m);
extern struct PullFilterOps pgp_decrypt_filter;
#define HMAC_OPAD 0x5C
static unsigned
-hmac_result_size(PX_HMAC * h)
+hmac_result_size(PX_HMAC *h)
{
return px_md_result_size(h->md);
}
static unsigned
-hmac_block_size(PX_HMAC * h)
+hmac_block_size(PX_HMAC *h)
{
return px_md_block_size(h->md);
}
static void
-hmac_init(PX_HMAC * h, const uint8 *key, unsigned klen)
+hmac_init(PX_HMAC *h, const uint8 *key, unsigned klen)
{
unsigned bs,
hlen,
}
static void
-hmac_reset(PX_HMAC * h)
+hmac_reset(PX_HMAC *h)
{
PX_MD *md = h->md;
unsigned bs = px_md_block_size(md);
}
static void
-hmac_update(PX_HMAC * h, const uint8 *data, unsigned dlen)
+hmac_update(PX_HMAC *h, const uint8 *data, unsigned dlen)
{
px_md_update(h->md, data, dlen);
}
static void
-hmac_finish(PX_HMAC * h, uint8 *dst)
+hmac_finish(PX_HMAC *h, uint8 *dst)
{
PX_MD *md = h->md;
unsigned bs,
}
static void
-hmac_free(PX_HMAC * h)
+hmac_free(PX_HMAC *h)
{
unsigned bs;
/* PUBLIC FUNCTIONS */
int
-px_find_hmac(const char *name, PX_HMAC ** res)
+px_find_hmac(const char *name, PX_HMAC **res)
{
int err;
PX_MD *md;
const char *
-px_resolve_alias(const PX_Alias * list, const char *name)
+px_resolve_alias(const PX_Alias *list, const char *name)
{
while (list->name)
{
*/
static unsigned
-combo_encrypt_len(PX_Combo * cx, unsigned dlen)
+combo_encrypt_len(PX_Combo *cx, unsigned dlen)
{
return dlen + 512;
}
static unsigned
-combo_decrypt_len(PX_Combo * cx, unsigned dlen)
+combo_decrypt_len(PX_Combo *cx, unsigned dlen)
{
return dlen;
}
static int
-combo_init(PX_Combo * cx, const uint8 *key, unsigned klen,
+combo_init(PX_Combo *cx, const uint8 *key, unsigned klen,
const uint8 *iv, unsigned ivlen)
{
int err;
}
static int
-combo_encrypt(PX_Combo * cx, const uint8 *data, unsigned dlen,
+combo_encrypt(PX_Combo *cx, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen)
{
int err = 0;
}
static int
-combo_decrypt(PX_Combo * cx, const uint8 *data, unsigned dlen,
+combo_decrypt(PX_Combo *cx, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen)
{
unsigned bs,
}
static void
-combo_free(PX_Combo * cx)
+combo_free(PX_Combo *cx)
{
if (cx->cipher)
px_cipher_free(cx->cipher);
/* provider */
int
-px_find_combo(const char *name, PX_Combo ** res)
+px_find_combo(const char *name, PX_Combo **res)
{
int err;
char *buf,
struct px_digest
{
- unsigned (*result_size) (PX_MD * h);
- unsigned (*block_size) (PX_MD * h);
- void (*reset) (PX_MD * h);
- void (*update) (PX_MD * h, const uint8 *data, unsigned dlen);
- void (*finish) (PX_MD * h, uint8 *dst);
- void (*free) (PX_MD * h);
+ unsigned (*result_size) (PX_MD *h);
+ unsigned (*block_size) (PX_MD *h);
+ void (*reset) (PX_MD *h);
+ void (*update) (PX_MD *h, const uint8 *data, unsigned dlen);
+ void (*finish) (PX_MD *h, uint8 *dst);
+ void (*free) (PX_MD *h);
/* private */
union
{
struct px_hmac
{
- unsigned (*result_size) (PX_HMAC * h);
- unsigned (*block_size) (PX_HMAC * h);
- void (*reset) (PX_HMAC * h);
- void (*update) (PX_HMAC * h, const uint8 *data, unsigned dlen);
- void (*finish) (PX_HMAC * h, uint8 *dst);
- void (*free) (PX_HMAC * h);
- void (*init) (PX_HMAC * h, const uint8 *key, unsigned klen);
+ unsigned (*result_size) (PX_HMAC *h);
+ unsigned (*block_size) (PX_HMAC *h);
+ void (*reset) (PX_HMAC *h);
+ void (*update) (PX_HMAC *h, const uint8 *data, unsigned dlen);
+ void (*finish) (PX_HMAC *h, uint8 *dst);
+ void (*free) (PX_HMAC *h);
+ void (*init) (PX_HMAC *h, const uint8 *key, unsigned klen);
PX_MD *md;
/* private */
struct px_cipher
{
- unsigned (*block_size) (PX_Cipher * c);
- unsigned (*key_size) (PX_Cipher * c); /* max key len */
- unsigned (*iv_size) (PX_Cipher * c);
-
- int (*init) (PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv);
- int (*encrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- int (*decrypt) (PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res);
- void (*free) (PX_Cipher * c);
+ unsigned (*block_size) (PX_Cipher *c);
+ unsigned (*key_size) (PX_Cipher *c); /* max key len */
+ unsigned (*iv_size) (PX_Cipher *c);
+
+ int (*init) (PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv);
+ int (*encrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
+ int (*decrypt) (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res);
+ void (*free) (PX_Cipher *c);
/* private */
void *ptr;
int pstat; /* mcrypt uses it */
struct px_combo
{
- int (*init) (PX_Combo * cx, const uint8 *key, unsigned klen,
+ int (*init) (PX_Combo *cx, const uint8 *key, unsigned klen,
const uint8 *iv, unsigned ivlen);
- int (*encrypt) (PX_Combo * cx, const uint8 *data, unsigned dlen,
+ int (*encrypt) (PX_Combo *cx, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen);
- int (*decrypt) (PX_Combo * cx, const uint8 *data, unsigned dlen,
+ int (*decrypt) (PX_Combo *cx, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen);
- unsigned (*encrypt_len) (PX_Combo * cx, unsigned dlen);
- unsigned (*decrypt_len) (PX_Combo * cx, unsigned dlen);
- void (*free) (PX_Combo * cx);
+ unsigned (*encrypt_len) (PX_Combo *cx, unsigned dlen);
+ unsigned (*decrypt_len) (PX_Combo *cx, unsigned dlen);
+ void (*free) (PX_Combo *cx);
PX_Cipher *cipher;
unsigned padding;
};
-int px_find_digest(const char *name, PX_MD ** res);
-int px_find_hmac(const char *name, PX_HMAC ** res);
-int px_find_cipher(const char *name, PX_Cipher ** res);
-int px_find_combo(const char *name, PX_Combo ** res);
+int px_find_digest(const char *name, PX_MD **res);
+int px_find_hmac(const char *name, PX_HMAC **res);
+int px_find_cipher(const char *name, PX_Cipher **res);
+int px_find_combo(const char *name, PX_Combo **res);
int px_get_random_bytes(uint8 *dst, unsigned count);
int px_get_pseudo_random_bytes(uint8 *dst, unsigned count);
const char *px_strerror(int err);
-const char *px_resolve_alias(const PX_Alias * aliases, const char *name);
+const char *px_resolve_alias(const PX_Alias *aliases, const char *name);
void px_set_debug_handler(void (*handler) (const char *));
} while (0)
rijndael_ctx *
-rijndael_set_key(rijndael_ctx * ctx, const u4byte * in_key, const u4byte key_len,
+rijndael_set_key(rijndael_ctx *ctx, const u4byte *in_key, const u4byte key_len,
int encrypt)
{
u4byte i,
} while (0)
void
-rijndael_encrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
+rijndael_encrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
{
u4byte k_len = ctx->k_len;
u4byte *e_key = ctx->e_key;
} while (0)
void
-rijndael_decrypt(rijndael_ctx * ctx, const u4byte * in_blk, u4byte * out_blk)
+rijndael_decrypt(rijndael_ctx *ctx, const u4byte *in_blk, u4byte *out_blk)
{
u4byte b0[4],
b1[4],
*/
void
-aes_set_key(rijndael_ctx * ctx, const uint8 *key, unsigned keybits, int enc)
+aes_set_key(rijndael_ctx *ctx, const uint8 *key, unsigned keybits, int enc)
{
uint32 *k;
}
void
-aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
+aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
}
void
-aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len)
+aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len)
{
unsigned bs = 16;
uint32 *d;
}
void
-aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
+aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *iv = (uint32 *) iva;
uint32 *d = (uint32 *) data;
}
void
-aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len)
+aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len)
{
uint32 *d = (uint32 *) data;
unsigned bs = 16;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* $OpenBSD$ */
int decrypt;
u4byte e_key[64];
u4byte d_key[64];
-} rijndael_ctx;
+} rijndael_ctx;
/* 2. Standard interface for AES cryptographic routines */
/* conventional interface */
-void aes_set_key(rijndael_ctx * ctx, const uint8 *key, unsigned keybits, int enc);
-void aes_ecb_encrypt(rijndael_ctx * ctx, uint8 *data, unsigned len);
-void aes_ecb_decrypt(rijndael_ctx * ctx, uint8 *data, unsigned len);
-void aes_cbc_encrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
-void aes_cbc_decrypt(rijndael_ctx * ctx, uint8 *iva, uint8 *data, unsigned len);
+void aes_set_key(rijndael_ctx *ctx, const uint8 *key, unsigned keybits, int enc);
+void aes_ecb_encrypt(rijndael_ctx *ctx, uint8 *data, unsigned len);
+void aes_ecb_decrypt(rijndael_ctx *ctx, uint8 *data, unsigned len);
+void aes_cbc_encrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len);
+void aes_cbc_decrypt(rijndael_ctx *ctx, uint8 *iva, uint8 *data, unsigned len);
#endif /* _RIJNDAEL_H_ */
/*** SHA-256: *********************************************************/
void
-SHA256_Init(SHA256_CTX * context)
+SHA256_Init(SHA256_CTX *context)
{
if (context == NULL)
return;
} while(0)
static void
-SHA256_Transform(SHA256_CTX * context, const uint8 *data)
+SHA256_Transform(SHA256_CTX *context, const uint8 *data)
{
uint32 a,
b,
#else /* SHA2_UNROLL_TRANSFORM */
static void
-SHA256_Transform(SHA256_CTX * context, const uint8 *data)
+SHA256_Transform(SHA256_CTX *context, const uint8 *data)
{
uint32 a,
b,
#endif /* SHA2_UNROLL_TRANSFORM */
void
-SHA256_Update(SHA256_CTX * context, const uint8 *data, size_t len)
+SHA256_Update(SHA256_CTX *context, const uint8 *data, size_t len)
{
size_t freespace,
usedspace;
}
static void
-SHA256_Last(SHA256_CTX * context)
+SHA256_Last(SHA256_CTX *context)
{
unsigned int usedspace;
}
void
-SHA256_Final(uint8 digest[], SHA256_CTX * context)
+SHA256_Final(uint8 digest[], SHA256_CTX *context)
{
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL)
/*** SHA-512: *********************************************************/
void
-SHA512_Init(SHA512_CTX * context)
+SHA512_Init(SHA512_CTX *context)
{
if (context == NULL)
return;
} while(0)
static void
-SHA512_Transform(SHA512_CTX * context, const uint8 *data)
+SHA512_Transform(SHA512_CTX *context, const uint8 *data)
{
uint64 a,
b,
#else /* SHA2_UNROLL_TRANSFORM */
static void
-SHA512_Transform(SHA512_CTX * context, const uint8 *data)
+SHA512_Transform(SHA512_CTX *context, const uint8 *data)
{
uint64 a,
b,
#endif /* SHA2_UNROLL_TRANSFORM */
void
-SHA512_Update(SHA512_CTX * context, const uint8 *data, size_t len)
+SHA512_Update(SHA512_CTX *context, const uint8 *data, size_t len)
{
size_t freespace,
usedspace;
}
static void
-SHA512_Last(SHA512_CTX * context)
+SHA512_Last(SHA512_CTX *context)
{
unsigned int usedspace;
}
void
-SHA512_Final(uint8 digest[], SHA512_CTX * context)
+SHA512_Final(uint8 digest[], SHA512_CTX *context)
{
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL)
/*** SHA-384: *********************************************************/
void
-SHA384_Init(SHA384_CTX * context)
+SHA384_Init(SHA384_CTX *context)
{
if (context == NULL)
return;
}
void
-SHA384_Update(SHA384_CTX * context, const uint8 *data, size_t len)
+SHA384_Update(SHA384_CTX *context, const uint8 *data, size_t len)
{
SHA512_Update((SHA512_CTX *) context, data, len);
}
void
-SHA384_Final(uint8 digest[], SHA384_CTX * context)
+SHA384_Final(uint8 digest[], SHA384_CTX *context)
{
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL)
/*** SHA-224: *********************************************************/
void
-SHA224_Init(SHA224_CTX * context)
+SHA224_Init(SHA224_CTX *context)
{
if (context == NULL)
return;
}
void
-SHA224_Update(SHA224_CTX * context, const uint8 *data, size_t len)
+SHA224_Update(SHA224_CTX *context, const uint8 *data, size_t len)
{
SHA256_Update((SHA256_CTX *) context, data, len);
}
void
-SHA224_Final(uint8 digest[], SHA224_CTX * context)
+SHA224_Final(uint8 digest[], SHA224_CTX *context)
{
/* If no digest buffer is passed, we don't bother doing this: */
if (digest != NULL)
uint32 state[8];
uint64 bitcount;
uint8 buffer[SHA256_BLOCK_LENGTH];
-} SHA256_CTX;
+} SHA256_CTX;
typedef struct _SHA512_CTX
{
uint64 state[8];
uint64 bitcount[2];
uint8 buffer[SHA512_BLOCK_LENGTH];
-} SHA512_CTX;
+} SHA512_CTX;
typedef SHA256_CTX SHA224_CTX;
typedef SHA512_CTX SHA384_CTX;
Relation rel;
HeapScanDesc scan;
int ncolumns;
-} MyData;
+} MyData;
Datum
pgrowlocks(PG_FUNCTION_ARGS)
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* pgstatindex
uint64 free_space;
uint64 fragments;
-} BTIndexStat;
+} BTIndexStat;
/* ------------------------------------------------------
* pgstatindex()
Relation rel;
RangeVar *relrv;
Datum result;
- BlockNumber nblocks;
- BlockNumber blkno;
+ BlockNumber nblocks;
+ BlockNumber blkno;
BTIndexStat indexStat;
if (!superuser())
RelationGetRelationName(rel));
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
uint64 dead_tuple_count;
uint64 dead_tuple_len;
uint64 free_space; /* free/reusable space in bytes */
-} pgstattuple_type;
+} pgstattuple_type;
typedef void (*pgstat_page) (pgstattuple_type *, Relation, BlockNumber);
-static Datum build_pgstattuple_type(pgstattuple_type * stat,
+static Datum build_pgstattuple_type(pgstattuple_type *stat,
FunctionCallInfo fcinfo);
static Datum pgstat_relation(Relation rel, FunctionCallInfo fcinfo);
static Datum pgstat_heap(Relation rel, FunctionCallInfo fcinfo);
-static void pgstat_btree_page(pgstattuple_type * stat,
+static void pgstat_btree_page(pgstattuple_type *stat,
Relation rel, BlockNumber blkno);
-static void pgstat_hash_page(pgstattuple_type * stat,
+static void pgstat_hash_page(pgstattuple_type *stat,
Relation rel, BlockNumber blkno);
-static void pgstat_gist_page(pgstattuple_type * stat,
+static void pgstat_gist_page(pgstattuple_type *stat,
Relation rel, BlockNumber blkno);
static Datum pgstat_index(Relation rel, BlockNumber start,
pgstat_page pagefn, FunctionCallInfo fcinfo);
-static void pgstat_index_page(pgstattuple_type * stat, Page page,
+static void pgstat_index_page(pgstattuple_type *stat, Page page,
OffsetNumber minoff, OffsetNumber maxoff);
/*
* build_pgstattuple_type -- build a pgstattuple_type tuple
*/
static Datum
-build_pgstattuple_type(pgstattuple_type * stat, FunctionCallInfo fcinfo)
+build_pgstattuple_type(pgstattuple_type *stat, FunctionCallInfo fcinfo)
{
#define NCOLUMNS 9
#define NCHARS 32
const char *err;
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
* pgstat_btree_page -- check tuples in a btree page
*/
static void
-pgstat_btree_page(pgstattuple_type * stat, Relation rel, BlockNumber blkno)
+pgstat_btree_page(pgstattuple_type *stat, Relation rel, BlockNumber blkno)
{
Buffer buf;
Page page;
* pgstat_hash_page -- check tuples in a hash page
*/
static void
-pgstat_hash_page(pgstattuple_type * stat, Relation rel, BlockNumber blkno)
+pgstat_hash_page(pgstattuple_type *stat, Relation rel, BlockNumber blkno)
{
Buffer buf;
Page page;
* pgstat_gist_page -- check tuples in a gist page
*/
static void
-pgstat_gist_page(pgstattuple_type * stat, Relation rel, BlockNumber blkno)
+pgstat_gist_page(pgstattuple_type *stat, Relation rel, BlockNumber blkno)
{
Buffer buf;
Page page;
* pgstat_index_page -- for generic index page
*/
static void
-pgstat_index_page(pgstattuple_type * stat, Page page,
+pgstat_index_page(pgstattuple_type *stat, Page page,
OffsetNumber minoff, OffsetNumber maxoff)
{
OffsetNumber i;
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
******************************************************************************
This file contains routines that can be bound to a Postgres backend and
/*
** GiST support methods
*/
-bool gseg_consistent(GISTENTRY *entry,
- SEG * query,
- StrategyNumber strategy,
- Oid subtype,
- bool *recheck);
+bool gseg_consistent(GISTENTRY *entry,
+ SEG *query,
+ StrategyNumber strategy,
+ Oid subtype,
+ bool *recheck);
GISTENTRY *gseg_compress(GISTENTRY *entry);
GISTENTRY *gseg_decompress(GISTENTRY *entry);
float *gseg_penalty(GISTENTRY *origentry, GISTENTRY *newentry, float *result);
GIST_SPLITVEC *gseg_picksplit(GistEntryVector *entryvec, GIST_SPLITVEC *v);
-bool gseg_leaf_consistent(SEG * key, SEG * query, StrategyNumber strategy);
-bool gseg_internal_consistent(SEG * key, SEG * query, StrategyNumber strategy);
+bool gseg_leaf_consistent(SEG *key, SEG *query, StrategyNumber strategy);
+bool gseg_internal_consistent(SEG *key, SEG *query, StrategyNumber strategy);
SEG *gseg_union(GistEntryVector *entryvec, int *sizep);
-SEG *gseg_binary_union(SEG * r1, SEG * r2, int *sizep);
-bool *gseg_same(SEG * b1, SEG * b2, bool *result);
+SEG *gseg_binary_union(SEG *r1, SEG *r2, int *sizep);
+bool *gseg_same(SEG *b1, SEG *b2, bool *result);
/*
** R-tree support functions
*/
-bool seg_same(SEG * a, SEG * b);
-bool seg_contains_int(SEG * a, int *b);
-bool seg_contains_float4(SEG * a, float4 *b);
-bool seg_contains_float8(SEG * a, float8 *b);
-bool seg_contains(SEG * a, SEG * b);
-bool seg_contained(SEG * a, SEG * b);
-bool seg_overlap(SEG * a, SEG * b);
-bool seg_left(SEG * a, SEG * b);
-bool seg_over_left(SEG * a, SEG * b);
-bool seg_right(SEG * a, SEG * b);
-bool seg_over_right(SEG * a, SEG * b);
-SEG *seg_union(SEG * a, SEG * b);
-SEG *seg_inter(SEG * a, SEG * b);
-void rt_seg_size(SEG * a, float *sz);
+bool seg_same(SEG *a, SEG *b);
+bool seg_contains_int(SEG *a, int *b);
+bool seg_contains_float4(SEG *a, float4 *b);
+bool seg_contains_float8(SEG *a, float8 *b);
+bool seg_contains(SEG *a, SEG *b);
+bool seg_contained(SEG *a, SEG *b);
+bool seg_overlap(SEG *a, SEG *b);
+bool seg_left(SEG *a, SEG *b);
+bool seg_over_left(SEG *a, SEG *b);
+bool seg_right(SEG *a, SEG *b);
+bool seg_over_right(SEG *a, SEG *b);
+SEG *seg_union(SEG *a, SEG *b);
+SEG *seg_inter(SEG *a, SEG *b);
+void rt_seg_size(SEG *a, float *sz);
/*
** Various operators
*/
-int32 seg_cmp(SEG * a, SEG * b);
-bool seg_lt(SEG * a, SEG * b);
-bool seg_le(SEG * a, SEG * b);
-bool seg_gt(SEG * a, SEG * b);
-bool seg_ge(SEG * a, SEG * b);
-bool seg_different(SEG * a, SEG * b);
+int32 seg_cmp(SEG *a, SEG *b);
+bool seg_lt(SEG *a, SEG *b);
+bool seg_le(SEG *a, SEG *b);
+bool seg_gt(SEG *a, SEG *b);
+bool seg_ge(SEG *a, SEG *b);
+bool seg_different(SEG *a, SEG *b);
/*
** Auxiliary funxtions
Datum
seg_center(PG_FUNCTION_ARGS)
{
- SEG *seg = (SEG *) PG_GETARG_POINTER(0);
+ SEG *seg = (SEG *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4(((float) seg->lower + (float) seg->upper) / 2.0);
}
Datum
seg_lower(PG_FUNCTION_ARGS)
{
- SEG *seg = (SEG *) PG_GETARG_POINTER(0);
+ SEG *seg = (SEG *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4(seg->lower);
}
Datum
seg_upper(PG_FUNCTION_ARGS)
{
- SEG *seg = (SEG *) PG_GETARG_POINTER(0);
+ SEG *seg = (SEG *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4(seg->upper);
}
*/
bool
gseg_consistent(GISTENTRY *entry,
- SEG * query,
+ SEG *query,
StrategyNumber strategy,
Oid subtype,
bool *recheck)
** Equality methods
*/
bool *
-gseg_same(SEG * b1, SEG * b2, bool *result)
+gseg_same(SEG *b1, SEG *b2, bool *result)
{
if (seg_same(b1, b2))
*result = TRUE;
** SUPPORT ROUTINES
*/
bool
-gseg_leaf_consistent(SEG * key,
- SEG * query,
+gseg_leaf_consistent(SEG *key,
+ SEG *query,
StrategyNumber strategy)
{
bool retval;
}
bool
-gseg_internal_consistent(SEG * key,
- SEG * query,
+gseg_internal_consistent(SEG *key,
+ SEG *query,
StrategyNumber strategy)
{
bool retval;
}
SEG *
-gseg_binary_union(SEG * r1, SEG * r2, int *sizep)
+gseg_binary_union(SEG *r1, SEG *r2, int *sizep)
{
SEG *retval;
bool
-seg_contains(SEG * a, SEG * b)
+seg_contains(SEG *a, SEG *b)
{
return ((a->lower <= b->lower) && (a->upper >= b->upper));
}
bool
-seg_contained(SEG * a, SEG * b)
+seg_contained(SEG *a, SEG *b)
{
return (seg_contains(b, a));
}
*****************************************************************************/
bool
-seg_same(SEG * a, SEG * b)
+seg_same(SEG *a, SEG *b)
{
return seg_cmp(a, b) == 0;
}
/* seg_overlap -- does a overlap b?
*/
bool
-seg_overlap(SEG * a, SEG * b)
+seg_overlap(SEG *a, SEG *b)
{
return (
((a->upper >= b->upper) && (a->lower <= b->upper))
/* seg_overleft -- is the right edge of (a) located at or left of the right edge of (b)?
*/
bool
-seg_over_left(SEG * a, SEG * b)
+seg_over_left(SEG *a, SEG *b)
{
return (a->upper <= b->upper);
}
/* seg_left -- is (a) entirely on the left of (b)?
*/
bool
-seg_left(SEG * a, SEG * b)
+seg_left(SEG *a, SEG *b)
{
return (a->upper < b->lower);
}
/* seg_right -- is (a) entirely on the right of (b)?
*/
bool
-seg_right(SEG * a, SEG * b)
+seg_right(SEG *a, SEG *b)
{
return (a->lower > b->upper);
}
/* seg_overright -- is the left edge of (a) located at or right of the left edge of (b)?
*/
bool
-seg_over_right(SEG * a, SEG * b)
+seg_over_right(SEG *a, SEG *b)
{
return (a->lower >= b->lower);
}
SEG *
-seg_union(SEG * a, SEG * b)
+seg_union(SEG *a, SEG *b)
{
SEG *n;
SEG *
-seg_inter(SEG * a, SEG * b)
+seg_inter(SEG *a, SEG *b)
{
SEG *n;
}
void
-rt_seg_size(SEG * a, float *size)
+rt_seg_size(SEG *a, float *size)
{
if (a == (SEG *) NULL || a->upper <= a->lower)
*size = 0.0;
Datum
seg_size(PG_FUNCTION_ARGS)
{
- SEG *seg = (SEG *) PG_GETARG_POINTER(0);
+ SEG *seg = (SEG *) PG_GETARG_POINTER(0);
PG_RETURN_FLOAT4((float) Abs(seg->upper - seg->lower));
}
* Miscellaneous operators
*****************************************************************************/
int32
-seg_cmp(SEG * a, SEG * b)
+seg_cmp(SEG *a, SEG *b)
{
/*
* First compare on lower boundary position
}
bool
-seg_lt(SEG * a, SEG * b)
+seg_lt(SEG *a, SEG *b)
{
return seg_cmp(a, b) < 0;
}
bool
-seg_le(SEG * a, SEG * b)
+seg_le(SEG *a, SEG *b)
{
return seg_cmp(a, b) <= 0;
}
bool
-seg_gt(SEG * a, SEG * b)
+seg_gt(SEG *a, SEG *b)
{
return seg_cmp(a, b) > 0;
}
bool
-seg_ge(SEG * a, SEG * b)
+seg_ge(SEG *a, SEG *b)
{
return seg_cmp(a, b) >= 0;
}
bool
-seg_different(SEG * a, SEG * b)
+seg_different(SEG *a, SEG *b)
{
return seg_cmp(a, b) != 0;
}
*/
bool
-seg_contains_int(SEG * a, int *b)
+seg_contains_int(SEG *a, int *b)
{
return ((a->lower <= *b) && (a->upper >= *b));
}
bool
-seg_contains_float4(SEG * a, float4 *b)
+seg_contains_float4(SEG *a, float4 *b)
{
return ((a->lower <= *b) && (a->upper >= *b));
}
bool
-seg_contains_float8(SEG * a, float8 *b)
+seg_contains_float8(SEG *a, float8 *b)
{
return ((a->lower <= *b) && (a->upper >= *b));
}
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
typedef struct SEG
{
char u_sigd;
char l_ext;
char u_ext;
-} SEG;
+} SEG;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "postgres.h"
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* refint.c -- set of functions to define referential integrity
char *ident;
int nplans;
SPIPlanPtr *splan;
-} EPlan;
+} EPlan;
static EPlan *FPlans = NULL;
static int nFPlans = 0;
static EPlan *PPlans = NULL;
static int nPPlans = 0;
-static EPlan *find_plan(char *ident, EPlan ** eplan, int *nplans);
+static EPlan *find_plan(char *ident, EPlan **eplan, int *nplans);
/*
* check_primary_key () -- check that key in tuple being inserted/updated
}
static EPlan *
-find_plan(char *ident, EPlan ** eplan, int *nplans)
+find_plan(char *ident, EPlan **eplan, int *nplans)
{
EPlan *newp;
int i;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* timetravel.c -- function to get time travel feature
{
char *ident;
SPIPlanPtr splan;
-} EPlan;
+} EPlan;
static EPlan *Plans = NULL; /* for UPDATE/DELETE */
static int nPlans = 0;
{
struct _TTOffList *next;
char name[1];
-} TTOffList;
+} TTOffList;
static TTOffList TTOff = {NULL, {0}};
static int findTTStatus(char *name);
-static EPlan *find_plan(char *ident, EPlan ** eplan, int *nplans);
+static EPlan *find_plan(char *ident, EPlan **eplan, int *nplans);
/*
* timetravel () --
*/
static EPlan *
-find_plan(char *ident, EPlan ** eplan, int *nplans)
+find_plan(char *ident, EPlan **eplan, int *nplans)
{
EPlan *newp;
int i;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* tablefunc
float8 stddev; /* stddev of the distribution */
float8 carry_val; /* hold second generated value */
bool use_carry; /* use second generated value */
-} normal_rand_fctx;
+} normal_rand_fctx;
#define xpfree(var_) \
do { \
{
char *catname; /* full category name */
int attidx; /* zero based */
-} crosstab_cat_desc;
+} crosstab_cat_desc;
#define MAX_CATNAME_LEN NAMEDATALEN
#define INIT_CATS 64
{
char internal_catname[MAX_CATNAME_LEN];
crosstab_cat_desc *catdesc;
-} crosstab_HashEnt;
+} crosstab_HashEnt;
/*
* normal_rand - return requested number of random values
}
/*
- * Check that return tupdesc is compatible with the data we got from
- * SPI, at least based on number and type of attributes
+ * Check that return tupdesc is compatible with the data we got from SPI,
+ * at least based on number and type of attributes
*/
if (!compatCrosstabTupleDescs(tupdesc, spi_tupdesc))
ereport(ERROR,
MemoryContextSwitchTo(oldcontext);
/*
- * Generate attribute metadata needed later to produce tuples from raw
- * C strings
+ * Generate attribute metadata needed later to produce tuples from raw C
+ * strings
*/
attinmeta = TupleDescGetAttInMetadata(tupdesc);
values = (char **) palloc0((1 + num_categories) * sizeof(char *));
/*
- * now loop through the sql results and assign each value in
- * sequence to the next category
+ * now loop through the sql results and assign each value in sequence
+ * to the next category
*/
for (i = 0; i < num_categories; i++)
{
rowid = SPI_getvalue(spi_tuple, spi_tupdesc, 1);
/*
- * If this is the first pass through the values for this
- * rowid, set the first column to rowid
+ * If this is the first pass through the values for this rowid,
+ * set the first column to rowid
*/
if (i == 0)
{
xpstrdup(values[0], rowid);
/*
- * Check to see if the rowid is the same as that of the
- * last tuple sent -- if so, skip this tuple entirely
+ * Check to see if the rowid is the same as that of the last
+ * tuple sent -- if so, skip this tuple entirely
*/
if (!firstpass && xstreq(lastrowid, rowid))
{
if (xstreq(rowid, values[0]))
{
/*
- * Get the next category item value, which is always
- * attribute number three.
+ * Get the next category item value, which is always attribute
+ * number three.
*
- * Be careful to assign the value to the array index based
- * on which category we are presently processing.
+ * Be careful to assign the value to the array index based on
+ * which category we are presently processing.
*/
values[1 + i] = SPI_getvalue(spi_tuple, spi_tupdesc, 3);
/*
* increment the counter since we consume a row for each
- * category, but not for last pass because the outer loop
- * will do that for us
+ * category, but not for last pass because the outer loop will
+ * do that for us
*/
if (i < (num_categories - 1))
call_cntr++;
else
{
/*
- * We'll fill in NULLs for the missing values, but we need
- * to decrement the counter since this sql result row
- * doesn't belong to the current output tuple.
+ * We'll fill in NULLs for the missing values, but we need to
+ * decrement the counter since this sql result row doesn't
+ * belong to the current output tuple.
*/
call_cntr--;
xpfree(rowid);
crosstab_hash,
tupdesc,
per_query_ctx,
- rsinfo->allowedModes & SFRM_Materialize_Random);
+ rsinfo->allowedModes & SFRM_Materialize_Random);
/*
* SFRM_Materialize mode expects us to return a NULL Datum. The actual
show_branch,
show_serial,
per_query_ctx,
- rsinfo->allowedModes & SFRM_Materialize_Random,
+ rsinfo->allowedModes & SFRM_Materialize_Random,
attinmeta);
rsinfo->setDesc = tupdesc;
show_branch,
show_serial,
per_query_ctx,
- rsinfo->allowedModes & SFRM_Materialize_Random,
+ rsinfo->allowedModes & SFRM_Materialize_Random,
attinmeta);
rsinfo->setDesc = tupdesc;
rawstr_text = cstring_to_text(rawstr);
result_text = DatumGetTextP(DirectFunctionCall1(quote_literal,
- PointerGetDatum(rawstr_text)));
+ PointerGetDatum(rawstr_text)));
result = text_to_cstring(result_text);
return result;
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* tablefunc
char *buffer; /* text to parse */
int len; /* length of the text in buffer */
int pos; /* position of the parser */
-} ParserState;
+} ParserState;
/* copy-paste from wparser.h of tsearch2 */
typedef struct
{
TriggerData *trigdata;
Trigger *trigger;
- char **tgargs,
+ char **tgargs,
**tgargs_old;
int i;
Datum res;
static void
pguuid_complain(uuid_rc_t rc)
{
- char *err = uuid_error(rc);
+ char *err = uuid_error(rc);
if (err != NULL)
ereport(ERROR,
}
static char *
-uuid_to_string(const uuid_t * uuid)
+uuid_to_string(const uuid_t *uuid)
{
char *buf = palloc(UUID_LEN_STR + 1);
void *ptr = buf;
static void
-string_to_uuid(const char *str, uuid_t * uuid)
+string_to_uuid(const char *str, uuid_t *uuid)
{
uuid_rc_t rc;
static Datum
-uuid_generate_internal(int mode, const uuid_t * ns, const char *name)
+uuid_generate_internal(int mode, const uuid_t *ns, const char *name)
{
uuid_t *uuid;
char *str;
void pgxml_parser_init(void);
static xmlChar *pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
- xmlChar * toptagname, xmlChar * septagname,
- xmlChar * plainsep);
+ xmlChar *toptagname, xmlChar *septagname,
+ xmlChar *plainsep);
-text *pgxml_result_to_text(xmlXPathObjectPtr res, xmlChar * toptag,
- xmlChar * septag, xmlChar * plainsep);
+text *pgxml_result_to_text(xmlXPathObjectPtr res, xmlChar *toptag,
+ xmlChar *septag, xmlChar *plainsep);
xmlChar *pgxml_texttoxmlchar(text *textstring);
-static xmlXPathObjectPtr pgxml_xpath(text *document, xmlChar * xpath);
+static xmlXPathObjectPtr pgxml_xpath(text *document, xmlChar *xpath);
Datum xml_is_well_formed(PG_FUNCTION_ARGS);
}
static xmlChar
-*
+ *
pgxmlNodeSetToText(xmlNodeSetPtr nodeset,
- xmlChar * toptagname,
- xmlChar * septagname,
- xmlChar * plainsep)
+ xmlChar *toptagname,
+ xmlChar *septagname,
+ xmlChar *plainsep)
{
/* Function translates a nodeset into a text representation */
/* Core function to evaluate XPath query */
xmlXPathObjectPtr
-pgxml_xpath(text *document, xmlChar * xpath)
+pgxml_xpath(text *document, xmlChar *xpath)
{
xmlDocPtr doctree;
text
*
pgxml_result_to_text(xmlXPathObjectPtr res,
- xmlChar * toptag,
- xmlChar * septag,
- xmlChar * plainsep)
+ xmlChar *toptag,
+ xmlChar *septag,
+ xmlChar *plainsep)
{
xmlChar *xpresstr;
text *xpres;
/* Parse the document */
if (xmldoc)
doctree = xmlParseMemory(xmldoc, strlen(xmldoc));
- else /* treat NULL as not well-formed */
+ else /* treat NULL as not well-formed */
doctree = NULL;
if (doctree == NULL)
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
* XSLT processing functions (requiring libxslt)
*
* Now check to see if any preceding bits are null...
*/
{
- int byte = attnum >> 3;
+ int byte = attnum >> 3;
int finalbit = attnum & 0x07;
/* check for nulls "before" final bit of last byte */
{
if (tuple == NULL) /* internal error */
elog(ERROR, "cannot extract system attribute from virtual tuple");
- if (tuple == &(slot->tts_minhdr)) /* internal error */
+ if (tuple == &(slot->tts_minhdr)) /* internal error */
elog(ERROR, "cannot extract system attribute from minimal tuple");
return heap_getsysattr(tuple, attnum, tupleDesc, isnull);
}
{
if (tuple == NULL) /* internal error */
elog(ERROR, "cannot extract system attribute from virtual tuple");
- if (tuple == &(slot->tts_minhdr)) /* internal error */
+ if (tuple == &(slot->tts_minhdr)) /* internal error */
elog(ERROR, "cannot extract system attribute from minimal tuple");
return heap_attisnull(tuple, attnum);
}
* try to compress it in-line.
*/
if (!VARATT_IS_EXTENDED(DatumGetPointer(untoasted_values[i])) &&
- VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
+ VARSIZE(DatumGetPointer(untoasted_values[i])) > TOAST_INDEX_TARGET &&
(att->attstorage == 'x' || att->attstorage == 'm'))
{
Datum cvalue = toast_compress_datum(untoasted_values[i]);
* Now check to see if any preceding bits are null...
*/
{
- int byte = attnum >> 3;
+ int byte = attnum >> 3;
int finalbit = attnum & 0x07;
/* check for nulls "before" final bit of last byte */
{
DR_printtup *self = (DR_printtup *) palloc0(sizeof(DR_printtup));
- self->pub.receiveSlot = printtup; /* might get changed later */
+ self->pub.receiveSlot = printtup; /* might get changed later */
self->pub.rStartup = printtup_startup;
self->pub.rShutdown = printtup_shutdown;
self->pub.rDestroy = printtup_destroy;
true
},
/* list terminator */
- { { NULL } }
+ {{NULL}}
};
static relopt_int intRelOpts[] =
}, 150000000, 0, 2000000000
},
/* list terminator */
- { { NULL } }
+ {{NULL}}
};
static relopt_real realRelOpts[] =
0.1, 0.0, 100.0
},
/* list terminator */
- { { NULL } }
+ {{NULL}}
};
static relopt_string stringRelOpts[] =
{
/* list terminator */
- { { NULL } }
+ {{NULL}}
};
static relopt_gen **relOpts = NULL;
static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT;
-static int num_custom_options = 0;
+static int num_custom_options = 0;
static relopt_gen **custom_options = NULL;
-static bool need_initialization = true;
+static bool need_initialization = true;
static void initialize_reloptions(void);
static void parse_one_reloption(relopt_value *option, char *text_str,
/*
* initialize_reloptions
- * initialization routine, must be called before parsing
+ * initialization routine, must be called before parsing
*
* Initialize the relOpts array and fill each variable's type and name length.
*/
static void
initialize_reloptions(void)
{
- int i;
- int j = 0;
+ int i;
+ int j = 0;
for (i = 0; boolRelOpts[i].gen.name; i++)
j++;
/*
* add_reloption_kind
- * Create a new relopt_kind value, to be used in custom reloptions by
- * user-defined AMs.
+ * Create a new relopt_kind value, to be used in custom reloptions by
+ * user-defined AMs.
*/
relopt_kind
add_reloption_kind(void)
if (last_assigned_kind >= RELOPT_KIND_MAX)
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("user-defined relation parameter types limit exceeded")));
+ errmsg("user-defined relation parameter types limit exceeded")));
last_assigned_kind <<= 1;
return (relopt_kind) last_assigned_kind;
}
/*
* add_reloption
- * Add an already-created custom reloption to the list, and recompute the
- * main parser table.
+ * Add an already-created custom reloption to the list, and recompute the
+ * main parser table.
*/
static void
add_reloption(relopt_gen *newoption)
{
- static int max_custom_options = 0;
+ static int max_custom_options = 0;
if (num_custom_options >= max_custom_options)
{
- MemoryContext oldcxt;
+ MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
{
max_custom_options *= 2;
custom_options = repalloc(custom_options,
- max_custom_options * sizeof(relopt_gen *));
+ max_custom_options * sizeof(relopt_gen *));
}
MemoryContextSwitchTo(oldcxt);
}
/*
* allocate_reloption
- * Allocate a new reloption and initialize the type-agnostic fields
- * (for types other than string)
+ * Allocate a new reloption and initialize the type-agnostic fields
+ * (for types other than string)
*/
static relopt_gen *
allocate_reloption(bits32 kinds, int type, char *name, char *desc)
{
- MemoryContext oldcxt;
- size_t size;
- relopt_gen *newoption;
+ MemoryContext oldcxt;
+ size_t size;
+ relopt_gen *newoption;
Assert(type != RELOPT_TYPE_STRING);
break;
default:
elog(ERROR, "unsupported option type");
- return NULL; /* keep compiler quiet */
+ return NULL; /* keep compiler quiet */
}
newoption = palloc(size);
/*
* add_bool_reloption
- * Add a new boolean reloption
+ * Add a new boolean reloption
*/
void
add_bool_reloption(bits32 kinds, char *name, char *desc, bool default_val)
{
- relopt_bool *newoption;
+ relopt_bool *newoption;
newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL,
name, desc);
/*
* add_int_reloption
- * Add a new integer reloption
+ * Add a new integer reloption
*/
void
add_int_reloption(bits32 kinds, char *name, char *desc, int default_val,
int min_val, int max_val)
{
- relopt_int *newoption;
+ relopt_int *newoption;
newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT,
name, desc);
/*
* add_real_reloption
- * Add a new float reloption
+ * Add a new float reloption
*/
void
add_real_reloption(bits32 kinds, char *name, char *desc, double default_val,
- double min_val, double max_val)
+ double min_val, double max_val)
{
- relopt_real *newoption;
+ relopt_real *newoption;
newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL,
name, desc);
* Add a new string reloption
*
* "validator" is an optional function pointer that can be used to test the
- * validity of the values. It must elog(ERROR) when the argument string is
+ * validity of the values. It must elog(ERROR) when the argument string is
* not acceptable for the variable. Note that the default value must pass
* the validation.
*/
add_string_reloption(bits32 kinds, char *name, char *desc, char *default_val,
validate_string_relopt validator)
{
- MemoryContext oldcxt;
- relopt_string *newoption;
- int default_len = 0;
+ MemoryContext oldcxt;
+ relopt_string *newoption;
+ int default_len = 0;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
* Note that this is not responsible for determining whether the options
* are valid, but it does check that namespaces for all the options given are
* listed in validnsps. The NULL namespace is always valid and needs not be
- * explicitely listed. Passing a NULL pointer means that only the NULL
+ * explicitely listed. Passing a NULL pointer means that only the NULL
* namespace is valid.
*
* Both oldOptions and the result are text arrays (or NULL for "default"),
/* Search for a match in defList */
foreach(cell, defList)
{
- DefElem *def = (DefElem *) lfirst(cell);
+ DefElem *def = (DefElem *) lfirst(cell);
int kw_len;
/* ignore if not in the same namespace */
*/
foreach(cell, defList)
{
- DefElem *def = (DefElem *) lfirst(cell);
+ DefElem *def = (DefElem *) lfirst(cell);
if (isReset)
{
Size len;
/*
- * Error out if the namespace is not valid. A NULL namespace
- * is always valid.
+ * Error out if the namespace is not valid. A NULL namespace is
+ * always valid.
*/
if (def->defnamespace != NULL)
{
- bool valid = false;
- int i;
+ bool valid = false;
+ int i;
if (validnsps)
{
bytea *
extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, Oid amoptions)
{
- bytea *options;
- bool isnull;
- Datum datum;
- Form_pg_class classForm;
+ bytea *options;
+ bool isnull;
+ Datum datum;
+ Form_pg_class classForm;
datum = fastgetattr(tuple,
Anum_pg_class_reloptions,
* is returned.
*
* Note: values of type int, bool and real are allocated as part of the
- * returned array. Values of type string are allocated separately and must
+ * returned array. Values of type string are allocated separately and must
* be freed by the caller.
*/
relopt_value *
parsed = parse_bool(value, &option->values.bool_val);
if (validate && !parsed)
ereport(ERROR,
- (errmsg("invalid value for boolean option \"%s\": %s",
- option->gen->name, value)));
+ (errmsg("invalid value for boolean option \"%s\": %s",
+ option->gen->name, value)));
}
break;
case RELOPT_TYPE_INT:
{
- relopt_int *optint = (relopt_int *) option->gen;
+ relopt_int *optint = (relopt_int *) option->gen;
parsed = parse_int(value, &option->values.int_val, 0, NULL);
if (validate && !parsed)
ereport(ERROR,
- (errmsg("invalid value for integer option \"%s\": %s",
- option->gen->name, value)));
+ (errmsg("invalid value for integer option \"%s\": %s",
+ option->gen->name, value)));
if (validate && (option->values.int_val < optint->min ||
option->values.int_val > optint->max))
ereport(ERROR,
- (errmsg("value %s out of bounds for option \"%s\"",
- value, option->gen->name),
- errdetail("Valid values are between \"%d\" and \"%d\".",
- optint->min, optint->max)));
+ (errmsg("value %s out of bounds for option \"%s\"",
+ value, option->gen->name),
+ errdetail("Valid values are between \"%d\" and \"%d\".",
+ optint->min, optint->max)));
}
break;
case RELOPT_TYPE_REAL:
{
- relopt_real *optreal = (relopt_real *) option->gen;
+ relopt_real *optreal = (relopt_real *) option->gen;
parsed = parse_real(value, &option->values.real_val);
if (validate && !parsed)
if (validate && (option->values.real_val < optreal->min ||
option->values.real_val > optreal->max))
ereport(ERROR,
- (errmsg("value %s out of bounds for option \"%s\"",
- value, option->gen->name),
- errdetail("Valid values are between \"%f\" and \"%f\".",
- optreal->min, optreal->max)));
+ (errmsg("value %s out of bounds for option \"%s\"",
+ value, option->gen->name),
+ errdetail("Valid values are between \"%f\" and \"%f\".",
+ optreal->min, optreal->max)));
}
break;
case RELOPT_TYPE_STRING:
{
- relopt_string *optstring = (relopt_string *) option->gen;
+ relopt_string *optstring = (relopt_string *) option->gen;
option->values.string_val = value;
nofree = true;
break;
default:
elog(ERROR, "unsupported reloption type %d", option->gen->type);
- parsed = true; /* quiet compiler */
+ parsed = true; /* quiet compiler */
break;
}
void *
allocateReloptStruct(Size base, relopt_value *options, int numoptions)
{
- Size size = base;
- int i;
+ Size size = base;
+ int i;
for (i = 0; i < numoptions; i++)
if (options[i].gen->type == RELOPT_TYPE_STRING)
bool validate,
const relopt_parse_elt *elems, int numelems)
{
- int i;
- int offset = basesize;
+ int i;
+ int offset = basesize;
for (i = 0; i < numoptions; i++)
{
- int j;
- bool found = false;
+ int j;
+ bool found = false;
for (j = 0; j < numelems; j++)
{
if (pg_strcasecmp(options[i].gen->name, elems[j].optname) == 0)
{
relopt_string *optstring;
- char *itempos = ((char *) rdopts) + elems[j].offset;
- char *string_val;
+ char *itempos = ((char *) rdopts) + elems[j].offset;
+ char *string_val;
switch (options[i].gen->type)
{
bytea *
default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
{
- relopt_value *options;
- StdRdOptions *rdopts;
- int numoptions;
+ relopt_value *options;
+ StdRdOptions *rdopts;
+ int numoptions;
static const relopt_parse_elt tab[] = {
{"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)},
{"autovacuum_enabled", RELOPT_TYPE_BOOL,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, enabled)},
{"autovacuum_vacuum_threshold", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_threshold)},
{"autovacuum_analyze_threshold", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, analyze_threshold)},
{"autovacuum_vacuum_cost_delay", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_cost_delay)},
{"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_cost_limit)},
{"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_min_age)},
{"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_max_age)},
{"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, freeze_table_age)},
{"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)},
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, vacuum_scale_factor)},
{"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL,
- offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)}
+ offsetof(StdRdOptions, autovacuum) +offsetof(AutoVacOpts, analyze_scale_factor)}
};
options = parseRelOptions(reloptions, validate, kind, &numoptions);
* pointers.
*
* Note: Only the fixed part of pg_attribute rows is included in tuple
- * descriptors, so we only need ATTRIBUTE_FIXED_PART_SIZE space
- * per attr. That might need alignment padding, however.
+ * descriptors, so we only need ATTRIBUTE_FIXED_PART_SIZE space per attr.
+ * That might need alignment padding, however.
*/
attroffset = sizeof(struct tupleDesc) + natts * sizeof(Form_pg_attribute);
attroffset = MAXALIGN(attroffset);
bool *check = (bool *) PG_GETARG_POINTER(0);
StrategyNumber strategy = PG_GETARG_UINT16(1);
ArrayType *query = PG_GETARG_ARRAYTYPE_P(2);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
/* Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4); */
bool *recheck = (bool *) PG_GETARG_POINTER(5);
static Datum
getDatumCopy(BuildAccumulator *accum, OffsetNumber attnum, Datum value)
{
- Form_pg_attribute att = accum->ginstate->origTupdesc->attrs[ attnum - 1 ];
+ Form_pg_attribute att = accum->ginstate->origTupdesc->attrs[attnum - 1];
Datum res;
if (att->attbyval)
* then calls itself for each parts
*/
static void
-ginChooseElem(BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum,
- Datum *entries, uint32 nentry,
+ginChooseElem(BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum,
+ Datum *entries, uint32 nentry,
uint32 low, uint32 high, uint32 offset)
{
uint32 pos;
* next middle on left part and middle of right part.
*/
void
-ginInsertRecordBA(BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum,
- Datum *entries, int32 nentry)
+ginInsertRecordBA(BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum,
+ Datum *entries, int32 nentry)
{
uint32 i,
nbit = 0,
while (aptr - a < na && bptr - b < nb)
{
- int cmp = compareItemPointers(aptr, bptr);
+ int cmp = compareItemPointers(aptr, bptr);
if (cmp > 0)
*dptr++ = *bptr++;
* Attributes of an index tuple are different for single and multicolumn index.
* For single-column case, index tuple stores only value to be indexed.
* For multicolumn case, it stores two attributes: column number of value
- * and value.
+ * and value.
*/
IndexTuple
GinFormTuple(GinState *ginstate, OffsetNumber attnum, Datum key, ItemPointerData *ipd, uint32 nipd)
{
- bool isnull[2] = {FALSE,FALSE};
+ bool isnull[2] = {FALSE, FALSE};
IndexTuple itup;
- if ( ginstate->oneCol )
+ if (ginstate->oneCol)
itup = index_form_tuple(ginstate->origTupdesc, &key, isnull);
else
{
- Datum datums[2];
+ Datum datums[2];
datums[0] = UInt16GetDatum(attnum);
datums[1] = key;
- itup = index_form_tuple(ginstate->tupdesc[attnum-1], datums, isnull);
+ itup = index_form_tuple(ginstate->tupdesc[attnum - 1], datums, isnull);
}
GinSetOrigSizePosting(itup, IndexTupleSize(itup));
if (GinPageRightMost(page))
return FALSE;
- itup = getRightMostTuple(page);
+ itup = getRightMostTuple(page);
if (compareAttEntries(btree->ginstate,
- btree->entryAttnum, btree->entryValue,
- gintuple_get_attrnum(btree->ginstate, itup),
- gin_index_getattr(btree->ginstate, itup)) > 0)
+ btree->entryAttnum, btree->entryValue,
+ gintuple_get_attrnum(btree->ginstate, itup),
+ gin_index_getattr(btree->ginstate, itup)) > 0)
return TRUE;
return FALSE;
else
{
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, mid));
- result = compareAttEntries(btree->ginstate,
- btree->entryAttnum, btree->entryValue,
- gintuple_get_attrnum(btree->ginstate, itup),
- gin_index_getattr(btree->ginstate, itup));
+ result = compareAttEntries(btree->ginstate,
+ btree->entryAttnum, btree->entryValue,
+ gintuple_get_attrnum(btree->ginstate, itup),
+ gin_index_getattr(btree->ginstate, itup));
}
if (result == 0)
int result;
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, mid));
- result = compareAttEntries(btree->ginstate,
- btree->entryAttnum, btree->entryValue,
- gintuple_get_attrnum(btree->ginstate, itup),
- gin_index_getattr(btree->ginstate, itup));
+ result = compareAttEntries(btree->ginstate,
+ btree->entryAttnum, btree->entryValue,
+ gintuple_get_attrnum(btree->ginstate, itup),
+ gin_index_getattr(btree->ginstate, itup));
if (result == 0)
{
stack->off = mid;
typedef struct DatumArray
{
- Datum *values; /* expansible array */
- int32 nvalues; /* current number of valid entries */
- int32 maxvalues; /* allocated size of array */
+ Datum *values; /* expansible array */
+ int32 nvalues; /* current number of valid entries */
+ int32 maxvalues; /* allocated size of array */
} DatumArray;
writeListPage(Relation index, Buffer buffer,
IndexTuple *tuples, int32 ntuples, BlockNumber rightlink)
{
- Page page = BufferGetPage(buffer);
- int i, freesize, size=0;
- OffsetNumber l, off;
- char *workspace;
- char *ptr;
+ Page page = BufferGetPage(buffer);
+ int i,
+ freesize,
+ size = 0;
+ OffsetNumber l,
+ off;
+ char *workspace;
+ char *ptr;
/* workspace could be a local array; we use palloc for alignment */
workspace = palloc(BLCKSZ);
off = FirstOffsetNumber;
ptr = workspace;
- for(i=0; i<ntuples; i++)
+ for (i = 0; i < ntuples; i++)
{
- int this_size = IndexTupleSize(tuples[i]);
+ int this_size = IndexTupleSize(tuples[i]);
memcpy(ptr, tuples[i], this_size);
ptr += this_size;
size += this_size;
- l = PageAddItem(page, (Item)tuples[i], this_size, off, false, false);
+ l = PageAddItem(page, (Item) tuples[i], this_size, off, false, false);
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add item to index page in \"%s\"",
GinPageGetOpaque(page)->rightlink = rightlink;
/*
- * tail page may contain only the whole row(s) or final
- * part of row placed on previous pages
+ * tail page may contain only the whole row(s) or final part of row placed
+ * on previous pages
*/
- if ( rightlink == InvalidBlockNumber )
+ if (rightlink == InvalidBlockNumber)
{
GinPageSetFullRow(page);
GinPageGetOpaque(page)->maxoff = 1;
if (!index->rd_istemp)
{
- XLogRecData rdata[2];
- ginxlogInsertListPage data;
- XLogRecPtr recptr;
+ XLogRecData rdata[2];
+ ginxlogInsertListPage data;
+ XLogRecPtr recptr;
rdata[0].buffer = buffer;
rdata[0].buffer_std = true;
- rdata[0].data = (char*)&data;
+ rdata[0].data = (char *) &data;
rdata[0].len = sizeof(ginxlogInsertListPage);
- rdata[0].next = rdata+1;
+ rdata[0].next = rdata + 1;
rdata[1].buffer = InvalidBuffer;
rdata[1].data = workspace;
makeSublist(Relation index, IndexTuple *tuples, int32 ntuples,
GinMetaPageData *res)
{
- Buffer curBuffer = InvalidBuffer;
- Buffer prevBuffer = InvalidBuffer;
- int i, size = 0, tupsize;
- int startTuple = 0;
+ Buffer curBuffer = InvalidBuffer;
+ Buffer prevBuffer = InvalidBuffer;
+ int i,
+ size = 0,
+ tupsize;
+ int startTuple = 0;
Assert(ntuples > 0);
/*
* Split tuples into pages
*/
- for(i=0;i<ntuples;i++)
+ for (i = 0; i < ntuples; i++)
{
- if ( curBuffer == InvalidBuffer )
+ if (curBuffer == InvalidBuffer)
{
curBuffer = GinNewBuffer(index);
- if ( prevBuffer != InvalidBuffer )
+ if (prevBuffer != InvalidBuffer)
{
res->nPendingPages++;
writeListPage(index, prevBuffer,
- tuples+startTuple, i-startTuple,
+ tuples + startTuple, i - startTuple,
BufferGetBlockNumber(curBuffer));
}
else
tupsize = MAXALIGN(IndexTupleSize(tuples[i])) + sizeof(ItemIdData);
- if ( size + tupsize >= GinListPageSize )
+ if (size + tupsize >= GinListPageSize)
{
/* won't fit, force a new page and reprocess */
i--;
*/
res->tail = BufferGetBlockNumber(curBuffer);
res->tailFreeSize = writeListPage(index, curBuffer,
- tuples+startTuple, ntuples-startTuple,
+ tuples + startTuple, ntuples - startTuple,
InvalidBlockNumber);
res->nPendingPages++;
/* that was only one heap tuple */
ginHeapTupleFastInsert(Relation index, GinState *ginstate,
GinTupleCollector *collector)
{
- Buffer metabuffer;
- Page metapage;
- GinMetaPageData *metadata = NULL;
- XLogRecData rdata[2];
- Buffer buffer = InvalidBuffer;
- Page page = NULL;
- ginxlogUpdateMeta data;
- bool separateList = false;
- bool needCleanup = false;
-
- if ( collector->ntuples == 0 )
+ Buffer metabuffer;
+ Page metapage;
+ GinMetaPageData *metadata = NULL;
+ XLogRecData rdata[2];
+ Buffer buffer = InvalidBuffer;
+ Page page = NULL;
+ ginxlogUpdateMeta data;
+ bool separateList = false;
+ bool needCleanup = false;
+
+ if (collector->ntuples == 0)
return;
data.node = index->rd_node;
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
metapage = BufferGetPage(metabuffer);
- if ( collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GIN_PAGE_FREESIZE )
+ if (collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GIN_PAGE_FREESIZE)
{
/*
* Total size is greater than one page => make sublist
LockBuffer(metabuffer, GIN_EXCLUSIVE);
metadata = GinPageGetMeta(metapage);
- if ( metadata->head == InvalidBlockNumber ||
- collector->sumsize + collector->ntuples * sizeof(ItemIdData) > metadata->tailFreeSize )
+ if (metadata->head == InvalidBlockNumber ||
+ collector->sumsize + collector->ntuples * sizeof(ItemIdData) > metadata->tailFreeSize)
{
/*
* Pending list is empty or total size is greater than freespace
}
}
- if ( separateList )
+ if (separateList)
{
- GinMetaPageData sublist;
+ GinMetaPageData sublist;
/*
* We should make sublist separately and append it to the tail
*/
- memset( &sublist, 0, sizeof(GinMetaPageData) );
+ memset(&sublist, 0, sizeof(GinMetaPageData));
makeSublist(index, collector->tuples, collector->ntuples, &sublist);
LockBuffer(metabuffer, GIN_EXCLUSIVE);
metadata = GinPageGetMeta(metapage);
- if ( metadata->head == InvalidBlockNumber )
+ if (metadata->head == InvalidBlockNumber)
{
/*
* Sublist becomes main list
*/
START_CRIT_SECTION();
- memcpy(metadata, &sublist, sizeof(GinMetaPageData) );
- memcpy(&data.metadata, &sublist, sizeof(GinMetaPageData) );
+ memcpy(metadata, &sublist, sizeof(GinMetaPageData));
+ memcpy(&data.metadata, &sublist, sizeof(GinMetaPageData));
}
else
{
metadata->nPendingPages += sublist.nPendingPages;
metadata->nPendingHeapTuples += sublist.nPendingHeapTuples;
- memcpy(&data.metadata, metadata, sizeof(GinMetaPageData) );
+ memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
data.newRightlink = sublist.head;
MarkBufferDirty(buffer);
* Insert into tail page, metapage is already locked
*/
- OffsetNumber l, off;
- int i, tupsize;
- char *ptr;
+ OffsetNumber l,
+ off;
+ int i,
+ tupsize;
+ char *ptr;
buffer = ReadBuffer(index, metadata->tail);
LockBuffer(buffer, GIN_EXCLUSIVE);
page = BufferGetPage(buffer);
off = (PageIsEmpty(page)) ? FirstOffsetNumber :
- OffsetNumberNext(PageGetMaxOffsetNumber(page));
+ OffsetNumberNext(PageGetMaxOffsetNumber(page));
rdata[0].next = rdata + 1;
rdata[1].buffer = buffer;
rdata[1].buffer_std = true;
- ptr = rdata[1].data = (char *) palloc( collector->sumsize );
+ ptr = rdata[1].data = (char *) palloc(collector->sumsize);
rdata[1].len = collector->sumsize;
rdata[1].next = NULL;
/*
* Increase counter of heap tuples
*/
- Assert( GinPageGetOpaque(page)->maxoff <= metadata->nPendingHeapTuples );
+ Assert(GinPageGetOpaque(page)->maxoff <= metadata->nPendingHeapTuples);
GinPageGetOpaque(page)->maxoff++;
metadata->nPendingHeapTuples++;
- for(i=0; i<collector->ntuples; i++)
+ for (i = 0; i < collector->ntuples; i++)
{
tupsize = IndexTupleSize(collector->tuples[i]);
- l = PageAddItem(page, (Item)collector->tuples[i], tupsize, off, false, false);
+ l = PageAddItem(page, (Item) collector->tuples[i], tupsize, off, false, false);
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add item to index page in \"%s\"",
- RelationGetRelationName(index));
+ RelationGetRelationName(index));
memcpy(ptr, collector->tuples[i], tupsize);
- ptr+=tupsize;
+ ptr += tupsize;
off++;
}
metadata->tailFreeSize -= collector->sumsize + collector->ntuples * sizeof(ItemIdData);
- memcpy(&data.metadata, metadata, sizeof(GinMetaPageData) );
+ memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
MarkBufferDirty(buffer);
}
/*
- * Make real write
+ * Make real write
*/
MarkBufferDirty(metabuffer);
- if ( !index->rd_istemp )
+ if (!index->rd_istemp)
{
- XLogRecPtr recptr;
+ XLogRecPtr recptr;
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE, rdata);
PageSetLSN(metapage, recptr);
PageSetTLI(metapage, ThisTimeLineID);
- if ( buffer != InvalidBuffer )
+ if (buffer != InvalidBuffer)
{
PageSetLSN(page, recptr);
PageSetTLI(page, ThisTimeLineID);
UnlockReleaseBuffer(buffer);
/*
- * Force pending list cleanup when it becomes too long.
- * And, ginInsertCleanup could take significant amount of
- * time, so we prefer to call it when it can do all the work in a
- * single collection cycle. In non-vacuum mode, it shouldn't
- * require maintenance_work_mem, so fire it while pending list is
- * still small enough to fit into work_mem.
+ * Force pending list cleanup when it becomes too long. And,
+ * ginInsertCleanup could take significant amount of time, so we prefer to
+ * call it when it can do all the work in a single collection cycle. In
+ * non-vacuum mode, it shouldn't require maintenance_work_mem, so fire it
+ * while pending list is still small enough to fit into work_mem.
*
* ginInsertCleanup() should not be called inside our CRIT_SECTION.
*/
- if ( metadata->nPendingPages * GIN_PAGE_FREESIZE > work_mem * 1024L )
+ if (metadata->nPendingPages * GIN_PAGE_FREESIZE > work_mem * 1024L)
needCleanup = true;
UnlockReleaseBuffer(metabuffer);
END_CRIT_SECTION();
- if ( needCleanup )
+ if (needCleanup)
ginInsertCleanup(index, ginstate, false, NULL);
}
/*
* Allocate/reallocate memory for storing collected tuples
*/
- if ( collector->tuples == NULL )
+ if (collector->tuples == NULL)
{
collector->lentuples = nentries * index->rd_att->natts;
- collector->tuples = (IndexTuple*)palloc(sizeof(IndexTuple) * collector->lentuples);
+ collector->tuples = (IndexTuple *) palloc(sizeof(IndexTuple) * collector->lentuples);
}
- while ( collector->ntuples + nentries > collector->lentuples )
+ while (collector->ntuples + nentries > collector->lentuples)
{
collector->lentuples *= 2;
- collector->tuples = (IndexTuple*)repalloc( collector->tuples,
- sizeof(IndexTuple) * collector->lentuples);
+ collector->tuples = (IndexTuple *) repalloc(collector->tuples,
+ sizeof(IndexTuple) * collector->lentuples);
}
/*
*/
for (i = 0; i < nentries; i++)
{
- int32 tupsize;
+ int32 tupsize;
collector->tuples[collector->ntuples + i] = GinFormTuple(ginstate, attnum, entries[i], NULL, 0);
collector->tuples[collector->ntuples + i]->t_tid = *item;
tupsize = IndexTupleSize(collector->tuples[collector->ntuples + i]);
- if ( tupsize > TOAST_INDEX_TARGET || tupsize >= GinMaxItemSize)
+ if (tupsize > TOAST_INDEX_TARGET || tupsize >= GinMaxItemSize)
elog(ERROR, "huge tuple");
collector->sumsize += tupsize;
shiftList(Relation index, Buffer metabuffer, BlockNumber newHead,
IndexBulkDeleteResult *stats)
{
- Page metapage;
- GinMetaPageData *metadata;
- BlockNumber blknoToDelete;
+ Page metapage;
+ GinMetaPageData *metadata;
+ BlockNumber blknoToDelete;
metapage = BufferGetPage(metabuffer);
metadata = GinPageGetMeta(metapage);
do
{
- Page page;
- int i;
- int64 nDeletedHeapTuples = 0;
- ginxlogDeleteListPages data;
- XLogRecData rdata[1];
- Buffer buffers[GIN_NDELETE_AT_ONCE];
+ Page page;
+ int i;
+ int64 nDeletedHeapTuples = 0;
+ ginxlogDeleteListPages data;
+ XLogRecData rdata[1];
+ Buffer buffers[GIN_NDELETE_AT_ONCE];
data.node = index->rd_node;
data.ndeleted = 0;
while (data.ndeleted < GIN_NDELETE_AT_ONCE && blknoToDelete != newHead)
{
- data.toDelete[ data.ndeleted ] = blknoToDelete;
- buffers[ data.ndeleted ] = ReadBuffer(index, blknoToDelete);
- LockBuffer( buffers[ data.ndeleted ], GIN_EXCLUSIVE );
- page = BufferGetPage( buffers[ data.ndeleted ] );
+ data.toDelete[data.ndeleted] = blknoToDelete;
+ buffers[data.ndeleted] = ReadBuffer(index, blknoToDelete);
+ LockBuffer(buffers[data.ndeleted], GIN_EXCLUSIVE);
+ page = BufferGetPage(buffers[data.ndeleted]);
data.ndeleted++;
- if ( GinPageIsDeleted(page) )
+ if (GinPageIsDeleted(page))
{
/* concurrent cleanup process is detected */
- for(i=0;i<data.ndeleted;i++)
- UnlockReleaseBuffer( buffers[i] );
+ for (i = 0; i < data.ndeleted; i++)
+ UnlockReleaseBuffer(buffers[i]);
return true;
}
nDeletedHeapTuples += GinPageGetOpaque(page)->maxoff;
- blknoToDelete = GinPageGetOpaque( page )->rightlink;
+ blknoToDelete = GinPageGetOpaque(page)->rightlink;
}
if (stats)
metadata->head = blknoToDelete;
- Assert( metadata->nPendingPages >= data.ndeleted );
+ Assert(metadata->nPendingPages >= data.ndeleted);
metadata->nPendingPages -= data.ndeleted;
- Assert( metadata->nPendingHeapTuples >= nDeletedHeapTuples );
+ Assert(metadata->nPendingHeapTuples >= nDeletedHeapTuples);
metadata->nPendingHeapTuples -= nDeletedHeapTuples;
- if ( blknoToDelete == InvalidBlockNumber )
+ if (blknoToDelete == InvalidBlockNumber)
{
metadata->tail = InvalidBlockNumber;
metadata->tailFreeSize = 0;
metadata->nPendingPages = 0;
metadata->nPendingHeapTuples = 0;
}
- memcpy( &data.metadata, metadata, sizeof(GinMetaPageData));
+ memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
- MarkBufferDirty( metabuffer );
+ MarkBufferDirty(metabuffer);
- for(i=0; i<data.ndeleted; i++)
+ for (i = 0; i < data.ndeleted; i++)
{
- page = BufferGetPage( buffers[ i ] );
- GinPageGetOpaque( page )->flags = GIN_DELETED;
- MarkBufferDirty( buffers[ i ] );
+ page = BufferGetPage(buffers[i]);
+ GinPageGetOpaque(page)->flags = GIN_DELETED;
+ MarkBufferDirty(buffers[i]);
}
- if ( !index->rd_istemp )
+ if (!index->rd_istemp)
{
- XLogRecPtr recptr;
+ XLogRecPtr recptr;
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_LISTPAGE, rdata);
PageSetLSN(metapage, recptr);
PageSetTLI(metapage, ThisTimeLineID);
- for(i=0; i<data.ndeleted; i++)
+ for (i = 0; i < data.ndeleted; i++)
{
- page = BufferGetPage( buffers[ i ] );
+ page = BufferGetPage(buffers[i]);
PageSetLSN(page, recptr);
PageSetTLI(page, ThisTimeLineID);
}
}
- for(i=0; i<data.ndeleted; i++)
- UnlockReleaseBuffer( buffers[ i ] );
+ for (i = 0; i < data.ndeleted; i++)
+ UnlockReleaseBuffer(buffers[i]);
END_CRIT_SECTION();
- } while( blknoToDelete != newHead );
+ } while (blknoToDelete != newHead);
return false;
}
static void
addDatum(DatumArray *datums, Datum datum)
{
- if ( datums->nvalues >= datums->maxvalues)
+ if (datums->nvalues >= datums->maxvalues)
{
datums->maxvalues *= 2;
- datums->values = (Datum*)repalloc(datums->values,
- sizeof(Datum)*datums->maxvalues);
+ datums->values = (Datum *) repalloc(datums->values,
+ sizeof(Datum) * datums->maxvalues);
}
- datums->values[ datums->nvalues++ ] = datum;
+ datums->values[datums->nvalues++] = datum;
}
/*
processPendingPage(BuildAccumulator *accum, DatumArray *da,
Page page, OffsetNumber startoff)
{
- ItemPointerData heapptr;
- OffsetNumber i,maxoff;
- OffsetNumber attrnum, curattnum;
+ ItemPointerData heapptr;
+ OffsetNumber i,
+ maxoff;
+ OffsetNumber attrnum,
+ curattnum;
/* reset *da to empty */
da->nvalues = 0;
maxoff = PageGetMaxOffsetNumber(page);
- Assert( maxoff >= FirstOffsetNumber );
+ Assert(maxoff >= FirstOffsetNumber);
ItemPointerSetInvalid(&heapptr);
attrnum = 0;
for (i = startoff; i <= maxoff; i = OffsetNumberNext(i))
{
- IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, i));
+ IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, i));
curattnum = gintuple_get_attrnum(accum->ginstate, itup);
- if ( !ItemPointerIsValid(&heapptr) )
+ if (!ItemPointerIsValid(&heapptr))
{
heapptr = itup->t_tid;
attrnum = curattnum;
}
- else if ( !(ItemPointerEquals(&heapptr, &itup->t_tid) &&
- curattnum == attrnum) )
+ else if (!(ItemPointerEquals(&heapptr, &itup->t_tid) &&
+ curattnum == attrnum))
{
/*
* We can insert several datums per call, but only for one heap
*
* This can be called concurrently by multiple backends, so it must cope.
* On first glance it looks completely not concurrent-safe and not crash-safe
- * either. The reason it's okay is that multiple insertion of the same entry
+ * either. The reason it's okay is that multiple insertion of the same entry
* is detected and treated as a no-op by gininsert.c. If we crash after
* posting entries to the main index and before removing them from the
* pending list, it's okay because when we redo the posting later on, nothing
ginInsertCleanup(Relation index, GinState *ginstate,
bool vac_delay, IndexBulkDeleteResult *stats)
{
- Buffer metabuffer, buffer;
- Page metapage, page;
- GinMetaPageData *metadata;
- MemoryContext opCtx, oldCtx;
- BuildAccumulator accum;
- DatumArray datums;
- BlockNumber blkno;
+ Buffer metabuffer,
+ buffer;
+ Page metapage,
+ page;
+ GinMetaPageData *metadata;
+ MemoryContext opCtx,
+ oldCtx;
+ BuildAccumulator accum;
+ DatumArray datums;
+ BlockNumber blkno;
metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
LockBuffer(metabuffer, GIN_SHARE);
metapage = BufferGetPage(metabuffer);
metadata = GinPageGetMeta(metapage);
- if ( metadata->head == InvalidBlockNumber )
+ if (metadata->head == InvalidBlockNumber)
{
/* Nothing to do */
UnlockReleaseBuffer(metabuffer);
LockBuffer(metabuffer, GIN_UNLOCK);
/*
- * Initialize. All temporary space will be in opCtx
+ * Initialize. All temporary space will be in opCtx
*/
opCtx = AllocSetContextCreate(CurrentMemoryContext,
"GIN insert cleanup temporary context",
oldCtx = MemoryContextSwitchTo(opCtx);
- datums.maxvalues=128;
+ datums.maxvalues = 128;
datums.nvalues = 0;
- datums.values = (Datum*)palloc(sizeof(Datum)*datums.maxvalues);
+ datums.values = (Datum *) palloc(sizeof(Datum) * datums.maxvalues);
ginInitBA(&accum);
accum.ginstate = ginstate;
/*
- * At the top of this loop, we have pin and lock on the current page
- * of the pending list. However, we'll release that before exiting
- * the loop. Note we also have pin but not lock on the metapage.
+ * At the top of this loop, we have pin and lock on the current page of
+ * the pending list. However, we'll release that before exiting the loop.
+ * Note we also have pin but not lock on the metapage.
*/
- for(;;)
+ for (;;)
{
- if ( GinPageIsDeleted(page) )
+ if (GinPageIsDeleted(page))
{
/* another cleanup process is running concurrently */
- UnlockReleaseBuffer( buffer );
+ UnlockReleaseBuffer(buffer);
break;
}
vacuum_delay_point();
/*
- * Is it time to flush memory to disk? Flush if we are at the end
- * of the pending list, or if we have a full row and memory is
- * getting full.
+ * Is it time to flush memory to disk? Flush if we are at the end of
+ * the pending list, or if we have a full row and memory is getting
+ * full.
*
* XXX using up maintenance_work_mem here is probably unreasonably
* much, since vacuum might already be using that much.
(accum.allocatedMemory >= maintenance_work_mem * 1024L ||
accum.maxdepth > GIN_MAX_TREE_DEPTH)))
{
- ItemPointerData *list;
- uint32 nlist;
- Datum entry;
- OffsetNumber maxoff, attnum;
+ ItemPointerData *list;
+ uint32 nlist;
+ Datum entry;
+ OffsetNumber maxoff,
+ attnum;
/*
- * Unlock current page to increase performance.
- * Changes of page will be checked later by comparing
- * maxoff after completion of memory flush.
+ * Unlock current page to increase performance. Changes of page
+ * will be checked later by comparing maxoff after completion of
+ * memory flush.
*/
maxoff = PageGetMaxOffsetNumber(page);
LockBuffer(buffer, GIN_UNLOCK);
LockBuffer(metabuffer, GIN_EXCLUSIVE);
LockBuffer(buffer, GIN_SHARE);
- if ( GinPageIsDeleted(page) )
+ if (GinPageIsDeleted(page))
{
/* another cleanup process is running concurrently */
UnlockReleaseBuffer(buffer);
/*
* While we left the page unlocked, more stuff might have gotten
- * added to it. If so, process those entries immediately. There
+ * added to it. If so, process those entries immediately. There
* shouldn't be very many, so we don't worry about the fact that
* we're doing this with exclusive lock. Insertion algorithm
* gurantees that inserted row(s) will not continue on next page.
* NOTE: intentionally no vacuum_delay_point in this loop.
*/
- if ( PageGetMaxOffsetNumber(page) != maxoff )
+ if (PageGetMaxOffsetNumber(page) != maxoff)
{
ginInitBA(&accum);
- processPendingPage(&accum, &datums, page, maxoff+1);
+ processPendingPage(&accum, &datums, page, maxoff + 1);
while ((list = ginGetEntry(&accum, &attnum, &entry, &nlist)) != NULL)
ginEntryInsert(index, ginstate, attnum, entry, list, nlist, FALSE);
* Remember next page - it will become the new list head
*/
blkno = GinPageGetOpaque(page)->rightlink;
- UnlockReleaseBuffer(buffer); /* shiftList will do exclusive locking */
+ UnlockReleaseBuffer(buffer); /* shiftList will do exclusive
+ * locking */
/*
* remove readed pages from pending list, at this point all
* content of readed pages is in regular structure
*/
- if ( shiftList(index, metabuffer, blkno, stats) )
+ if (shiftList(index, metabuffer, blkno, stats))
{
/* another cleanup process is running concurrently */
LockBuffer(metabuffer, GIN_UNLOCK);
break;
}
- Assert( blkno == metadata->head );
+ Assert(blkno == metadata->head);
LockBuffer(metabuffer, GIN_UNLOCK);
/*
* if we removed the whole pending list just exit
*/
- if ( blkno == InvalidBlockNumber )
+ if (blkno == InvalidBlockNumber)
break;
/*
MemoryContextReset(opCtx);
ginInitBA(&accum);
datums.nvalues = 0;
- datums.values = (Datum*)palloc(sizeof(Datum)*datums.maxvalues);
+ datums.values = (Datum *) palloc(sizeof(Datum) * datums.maxvalues);
}
else
{
typedef struct pendingPosition
{
- Buffer pendingBuffer;
- OffsetNumber firstOffset;
- OffsetNumber lastOffset;
- ItemPointerData item;
+ Buffer pendingBuffer;
+ OffsetNumber firstOffset;
+ OffsetNumber lastOffset;
+ ItemPointerData item;
} pendingPosition;
* Goes to the next page if current offset is outside of bounds
*/
static bool
-moveRightIfItNeeded( GinBtreeData *btree, GinBtreeStack *stack )
+moveRightIfItNeeded(GinBtreeData *btree, GinBtreeStack *stack)
{
- Page page = BufferGetPage(stack->buffer);
+ Page page = BufferGetPage(stack->buffer);
- if ( stack->off > PageGetMaxOffsetNumber(page) )
+ if (stack->off > PageGetMaxOffsetNumber(page))
{
/*
* We scanned the whole page, so we should take right page
*/
stack->blkno = GinPageGetOpaque(page)->rightlink;
- if ( GinPageRightMost(page) )
- return false; /* no more pages */
+ if (GinPageRightMost(page))
+ return false; /* no more pages */
LockBuffer(stack->buffer, GIN_UNLOCK);
stack->buffer = ReleaseAndReadBuffer(stack->buffer, btree->index, stack->blkno);
* in scanEntry->partialMatch TIDBitmap
*/
static void
-scanForItems( Relation index, GinScanEntry scanEntry, BlockNumber rootPostingTree )
+scanForItems(Relation index, GinScanEntry scanEntry, BlockNumber rootPostingTree)
{
GinPostingTreeScan *gdi;
- Buffer buffer;
- Page page;
- BlockNumber blkno;
+ Buffer buffer;
+ Page page;
+ BlockNumber blkno;
gdi = prepareScanPostingTree(index, rootPostingTree, TRUE);
/*
* Goes through all leaves
*/
- for(;;)
+ for (;;)
{
page = BufferGetPage(buffer);
- if ((GinPageGetOpaque(page)->flags & GIN_DELETED) == 0 && GinPageGetOpaque(page)->maxoff >= FirstOffsetNumber )
+ if ((GinPageGetOpaque(page)->flags & GIN_DELETED) == 0 && GinPageGetOpaque(page)->maxoff >= FirstOffsetNumber)
{
- tbm_add_tuples( scanEntry->partialMatch,
- (ItemPointer)GinDataPageGetItem(page, FirstOffsetNumber),
- GinPageGetOpaque(page)->maxoff, false);
+ tbm_add_tuples(scanEntry->partialMatch,
+ (ItemPointer) GinDataPageGetItem(page, FirstOffsetNumber),
+ GinPageGetOpaque(page)->maxoff, false);
scanEntry->predictNumberResult += GinPageGetOpaque(page)->maxoff;
}
blkno = GinPageGetOpaque(page)->rightlink;
- if ( GinPageRightMost(page) )
+ if (GinPageRightMost(page))
{
UnlockReleaseBuffer(buffer);
- return; /* no more pages */
+ return; /* no more pages */
}
LockBuffer(buffer, GIN_UNLOCK);
* Returns true if done, false if it's needed to restart scan from scratch
*/
static bool
-computePartialMatchList( GinBtreeData *btree, GinBtreeStack *stack, GinScanEntry scanEntry )
+computePartialMatchList(GinBtreeData *btree, GinBtreeStack *stack, GinScanEntry scanEntry)
{
- Page page;
- IndexTuple itup;
+ Page page;
+ IndexTuple itup;
Datum idatum;
int32 cmp;
- scanEntry->partialMatch = tbm_create( work_mem * 1024L );
+ scanEntry->partialMatch = tbm_create(work_mem * 1024L);
- for(;;)
+ for (;;)
{
/*
* stack->off points to the interested entry, buffer is already locked
*/
- if ( moveRightIfItNeeded(btree, stack) == false )
+ if (moveRightIfItNeeded(btree, stack) == false)
return true;
page = BufferGetPage(stack->buffer);
/*
* If tuple stores another attribute then stop scan
*/
- if ( gintuple_get_attrnum( btree->ginstate, itup ) != scanEntry->attnum )
+ if (gintuple_get_attrnum(btree->ginstate, itup) != scanEntry->attnum)
return true;
- idatum = gin_index_getattr( btree->ginstate, itup );
+ idatum = gin_index_getattr(btree->ginstate, itup);
/*----------
* case cmp < 0 => not match and continue scan
*----------
*/
- cmp = DatumGetInt32(FunctionCall4(&btree->ginstate->comparePartialFn[scanEntry->attnum-1],
+ cmp = DatumGetInt32(FunctionCall4(&btree->ginstate->comparePartialFn[scanEntry->attnum - 1],
scanEntry->entry,
idatum,
UInt16GetDatum(scanEntry->strategy),
- PointerGetDatum(scanEntry->extra_data)));
+ PointerGetDatum(scanEntry->extra_data)));
- if ( cmp > 0 )
+ if (cmp > 0)
return true;
- else if ( cmp < 0 )
+ else if (cmp < 0)
{
stack->off++;
continue;
}
- if ( GinIsPostingTree(itup) )
+ if (GinIsPostingTree(itup))
{
BlockNumber rootPostingTree = GinGetPostingTree(itup);
Datum newDatum,
- savedDatum = datumCopy (
- idatum,
- btree->ginstate->origTupdesc->attrs[scanEntry->attnum-1]->attbyval,
- btree->ginstate->origTupdesc->attrs[scanEntry->attnum-1]->attlen
- );
+ savedDatum = datumCopy(
+ idatum,
+ btree->ginstate->origTupdesc->attrs[scanEntry->attnum - 1]->attbyval,
+ btree->ginstate->origTupdesc->attrs[scanEntry->attnum - 1]->attlen
+ );
+
/*
- * We should unlock current page (but not unpin) during
- * tree scan to prevent deadlock with vacuum processes.
+ * We should unlock current page (but not unpin) during tree scan
+ * to prevent deadlock with vacuum processes.
*
* We save current entry value (savedDatum) to be able to refind
* our tuple after re-locking
*/
LockBuffer(stack->buffer, GIN_UNLOCK);
- scanForItems( btree->index, scanEntry, rootPostingTree );
+ scanForItems(btree->index, scanEntry, rootPostingTree);
/*
- * We lock again the entry page and while it was unlocked
- * insert might occured, so we need to refind our position
+ * We lock again the entry page and while it was unlocked insert
+ * might occured, so we need to refind our position
*/
LockBuffer(stack->buffer, GIN_SHARE);
page = BufferGetPage(stack->buffer);
- if ( !GinPageIsLeaf(page) )
+ if (!GinPageIsLeaf(page))
{
/*
- * Root page becomes non-leaf while we unlock it. We
- * will start again, this situation doesn't cause
- * often - root can became a non-leaf only one per
- * life of index.
+ * Root page becomes non-leaf while we unlock it. We will
+ * start again, this situation doesn't cause often - root can
+ * became a non-leaf only one per life of index.
*/
return false;
}
- for(;;)
+ for (;;)
{
- if ( moveRightIfItNeeded(btree, stack) == false )
- elog(ERROR, "lost saved point in index"); /* must not happen !!! */
+ if (moveRightIfItNeeded(btree, stack) == false)
+ elog(ERROR, "lost saved point in index"); /* must not happen !!! */
page = BufferGetPage(stack->buffer);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
- newDatum = gin_index_getattr( btree->ginstate, itup );
+ newDatum = gin_index_getattr(btree->ginstate, itup);
- if ( gintuple_get_attrnum( btree->ginstate, itup ) != scanEntry->attnum )
- elog(ERROR, "lost saved point in index"); /* must not happen !!! */
+ if (gintuple_get_attrnum(btree->ginstate, itup) != scanEntry->attnum)
+ elog(ERROR, "lost saved point in index"); /* must not happen !!! */
- if ( compareEntries(btree->ginstate, scanEntry->attnum, newDatum, savedDatum) == 0 )
+ if (compareEntries(btree->ginstate, scanEntry->attnum, newDatum, savedDatum) == 0)
{
/* Found! */
- if ( btree->ginstate->origTupdesc->attrs[scanEntry->attnum-1]->attbyval == false )
- pfree( DatumGetPointer(savedDatum) );
+ if (btree->ginstate->origTupdesc->attrs[scanEntry->attnum - 1]->attbyval == false)
+ pfree(DatumGetPointer(savedDatum));
break;
}
}
else
{
- tbm_add_tuples( scanEntry->partialMatch, GinGetPosting(itup), GinGetNPosting(itup), false);
- scanEntry->predictNumberResult += GinGetNPosting(itup);
+ tbm_add_tuples(scanEntry->partialMatch, GinGetPosting(itup), GinGetNPosting(itup), false);
+ scanEntry->predictNumberResult += GinGetNPosting(itup);
}
/*
static void
startScanEntry(Relation index, GinState *ginstate, GinScanEntry entry)
{
- GinBtreeData btreeEntry;
- GinBtreeStack *stackEntry;
- Page page;
- bool needUnlock = TRUE;
+ GinBtreeData btreeEntry;
+ GinBtreeStack *stackEntry;
+ Page page;
+ bool needUnlock = TRUE;
entry->buffer = InvalidBuffer;
entry->offset = InvalidOffsetNumber;
}
/*
- * we should find entry, and begin scan of posting tree
- * or just store posting list in memory
+ * we should find entry, and begin scan of posting tree or just store
+ * posting list in memory
*/
prepareEntryScan(&btreeEntry, index, entry->attnum, entry->entry, ginstate);
entry->isFinished = TRUE;
- if ( entry->isPartialMatch )
+ if (entry->isPartialMatch)
{
/*
- * btreeEntry.findItem points to the first equal or greater value
- * than needed. So we will scan further and collect all
- * ItemPointers
+ * btreeEntry.findItem points to the first equal or greater value than
+ * needed. So we will scan further and collect all ItemPointers
*/
btreeEntry.findItem(&btreeEntry, stackEntry);
- if ( computePartialMatchList( &btreeEntry, stackEntry, entry ) == false )
+ if (computePartialMatchList(&btreeEntry, stackEntry, entry) == false)
{
/*
- * GIN tree was seriously restructured, so we will
- * cleanup all found data and rescan. See comments near
- * 'return false' in computePartialMatchList()
+ * GIN tree was seriously restructured, so we will cleanup all
+ * found data and rescan. See comments near 'return false' in
+ * computePartialMatchList()
*/
- if ( entry->partialMatch )
+ if (entry->partialMatch)
{
if (entry->partialMatchIterator)
tbm_end_iterate(entry->partialMatchIterator);
entry->partialMatchIterator = NULL;
- tbm_free( entry->partialMatch );
+ tbm_free(entry->partialMatch);
entry->partialMatch = NULL;
}
LockBuffer(stackEntry->buffer, GIN_UNLOCK);
return;
}
- if ( entry->partialMatch && !tbm_is_empty(entry->partialMatch) )
+ if (entry->partialMatch && !tbm_is_empty(entry->partialMatch))
{
entry->partialMatchIterator = tbm_begin_iterate(entry->partialMatch);
entry->isFinished = FALSE;
Page page;
/*
- * We should unlock entry page before make deal with
- * posting tree to prevent deadlocks with vacuum processes.
- * Because entry is never deleted from page and posting tree is
- * never reduced to the posting list, we can unlock page after
- * getting BlockNumber of root of posting tree.
+ * We should unlock entry page before make deal with posting tree
+ * to prevent deadlocks with vacuum processes. Because entry is
+ * never deleted from page and posting tree is never reduced to
+ * the posting list, we can unlock page after getting BlockNumber
+ * of root of posting tree.
*/
LockBuffer(stackEntry->buffer, GIN_UNLOCK);
needUnlock = FALSE;
gdi = prepareScanPostingTree(index, rootPostingTree, TRUE);
entry->buffer = scanBeginPostingTree(gdi);
+
/*
* We keep buffer pinned because we need to prevent deletion of
- * page during scan. See GIN's vacuum implementation. RefCount
- * is increased to keep buffer pinned after freeGinBtreeStack()
- * call.
+ * page during scan. See GIN's vacuum implementation. RefCount is
+ * increased to keep buffer pinned after freeGinBtreeStack() call.
*/
IncrBufferRefCount(entry->buffer);
/*
* Keep page content in memory to prevent durable page locking
*/
- entry->list = (ItemPointerData *) palloc( BLCKSZ );
+ entry->list = (ItemPointerData *) palloc(BLCKSZ);
entry->nlist = GinPageGetOpaque(page)->maxoff;
- memcpy( entry->list, GinDataPageGetItem(page, FirstOffsetNumber),
- GinPageGetOpaque(page)->maxoff * sizeof(ItemPointerData) );
+ memcpy(entry->list, GinDataPageGetItem(page, FirstOffsetNumber),
+ GinPageGetOpaque(page)->maxoff * sizeof(ItemPointerData));
LockBuffer(entry->buffer, GIN_UNLOCK);
freeGinBtreeStack(gdi->stack);
}
if (needUnlock)
- LockBuffer(stackEntry->buffer, GIN_UNLOCK);
+ LockBuffer(stackEntry->buffer, GIN_UNLOCK);
freeGinBtreeStack(stackEntry);
}
if (GinFuzzySearchLimit > 0)
{
/*
- * If all of keys more than threshold we will try to reduce
- * result, we hope (and only hope, for intersection operation of
- * array our supposition isn't true), that total result will not
- * more than minimal predictNumberResult.
+ * If all of keys more than threshold we will try to reduce result, we
+ * hope (and only hope, for intersection operation of array our
+ * supposition isn't true), that total result will not more than
+ * minimal predictNumberResult.
*/
for (i = 0; i < key->nentries; i++)
Page page;
BlockNumber blkno;
- for(;;)
+ for (;;)
{
entry->offset++;
LockBuffer(entry->buffer, GIN_SHARE);
page = BufferGetPage(entry->buffer);
- for(;;)
+ for (;;)
{
/*
* It's needed to go by right link. During that we should refind
* Found position equal to or greater than stored
*/
entry->nlist = GinPageGetOpaque(page)->maxoff;
- memcpy( entry->list, GinDataPageGetItem(page, FirstOffsetNumber),
- GinPageGetOpaque(page)->maxoff * sizeof(ItemPointerData) );
+ memcpy(entry->list, GinDataPageGetItem(page, FirstOffsetNumber),
+ GinPageGetOpaque(page)->maxoff * sizeof(ItemPointerData));
LockBuffer(entry->buffer, GIN_UNLOCK);
- if ( !ItemPointerIsValid(&entry->curItem) ||
- compareItemPointers( &entry->curItem, entry->list + entry->offset - 1 ) == 0 )
+ if (!ItemPointerIsValid(&entry->curItem) ||
+ compareItemPointers(&entry->curItem, entry->list + entry->offset - 1) == 0)
{
/*
- * First pages are deleted or empty, or we found exact position,
- * so break inner loop and continue outer one.
+ * First pages are deleted or empty, or we found exact
+ * position, so break inner loop and continue outer one.
*/
- break;
+ break;
}
/*
entry->isFinished = entry->master->isFinished;
entry->curItem = entry->master->curItem;
}
- else if ( entry->partialMatch )
+ else if (entry->partialMatch)
{
do
{
{
entry->partialMatchResult = tbm_iterate(entry->partialMatchIterator);
- if ( entry->partialMatchResult == NULL )
+ if (entry->partialMatchResult == NULL)
{
ItemPointerSet(&entry->curItem, InvalidBlockNumber, InvalidOffsetNumber);
tbm_end_iterate(entry->partialMatchIterator);
}
/*
- * reset counter to the beginning of entry->partialMatchResult.
- * Note: entry->offset is still greater than
- * partialMatchResult->ntuples if partialMatchResult is
- * lossy. So, on next call we will get next result from
- * TIDBitmap.
+ * reset counter to the beginning of
+ * entry->partialMatchResult. Note: entry->offset is still
+ * greater than partialMatchResult->ntuples if
+ * partialMatchResult is lossy. So, on next call we will get
+ * next result from TIDBitmap.
*/
entry->offset = 0;
}
- if ( entry->partialMatchResult->ntuples < 0 )
+ if (entry->partialMatchResult->ntuples < 0)
{
/*
* lossy result, so we need to check the whole page
*/
ItemPointerSetLossyPage(&entry->curItem,
entry->partialMatchResult->blockno);
+
/*
* We might as well fall out of the loop; we could not
* estimate number of results on this page to support correct
* Sets key->curItem to new found heap item pointer for one scan key
* Returns isFinished, ie TRUE means we did NOT get a new item pointer!
* Also, *keyrecheck is set true if recheck is needed for this scan key.
- * Note: lossy page could be returned after items from the same page.
+ * Note: lossy page could be returned after items from the same page.
*/
static bool
keyGetItem(Relation index, GinState *ginstate, MemoryContext tempCtx,
{
/*
* move forward from previously value and set new curItem, which is
- * minimal from entries->curItems. Lossy page is encoded by ItemPointer
- * with max value for offset (0xffff), so if there is an non-lossy entries
- * on lossy page they will returned too and after that the whole page.
- * That's not a problem for resulting tidbitmap.
+ * minimal from entries->curItems. Lossy page is encoded by
+ * ItemPointer with max value for offset (0xffff), so if there is an
+ * non-lossy entries on lossy page they will returned too and after
+ * that the whole page. That's not a problem for resulting tidbitmap.
*/
ItemPointerSetMax(&key->curItem);
for (i = 0; i < key->nentries; i++)
if (key->entryRes[i])
{
/*
- * Move forward only entries which was the least
- * on previous call, key->entryRes[i] points that
- * current entry was a result of loop/call.
+ * Move forward only entries which was the least on previous
+ * call, key->entryRes[i] points that current entry was a
+ * result of loop/call.
*/
if (entry->isFinished == FALSE && entryGetItem(index, entry) == FALSE)
{
/*----------
* entryRes array is used for:
* - as an argument for consistentFn
- * - entry->curItem with corresponding key->entryRes[i] == false are
- * greater than key->curItem, so next loop/call they should be
- * renewed by entryGetItem(). So, we need to set up an array before
- * checking of lossy page.
+ * - entry->curItem with corresponding key->entryRes[i] == false are
+ * greater than key->curItem, so next loop/call they should be
+ * renewed by entryGetItem(). So, we need to set up an array before
+ * checking of lossy page.
*----------
*/
for (i = 0; i < key->nentries; i++)
return FALSE;
oldCtx = MemoryContextSwitchTo(tempCtx);
- res = DatumGetBool(FunctionCall6(&ginstate->consistentFn[key->attnum-1],
+ res = DatumGetBool(FunctionCall6(&ginstate->consistentFn[key->attnum - 1],
PointerGetDatum(key->entryRes),
UInt16GetDatum(key->strategy),
key->query,
static bool
scanGetCandidate(IndexScanDesc scan, pendingPosition *pos)
{
- OffsetNumber maxoff;
- Page page;
- IndexTuple itup;
+ OffsetNumber maxoff;
+ Page page;
+ IndexTuple itup;
- ItemPointerSetInvalid( &pos->item );
- for(;;)
+ ItemPointerSetInvalid(&pos->item);
+ for (;;)
{
page = BufferGetPage(pos->pendingBuffer);
maxoff = PageGetMaxOffsetNumber(page);
- if ( pos->firstOffset > maxoff )
+ if (pos->firstOffset > maxoff)
{
BlockNumber blkno = GinPageGetOpaque(page)->rightlink;
- if ( blkno == InvalidBlockNumber )
+
+ if (blkno == InvalidBlockNumber)
{
UnlockReleaseBuffer(pos->pendingBuffer);
- pos->pendingBuffer=InvalidBuffer;
+ pos->pendingBuffer = InvalidBuffer;
return false;
}
else
{
/*
- * Here we must prevent deletion of next page by
- * insertcleanup process, which may be trying to obtain
- * exclusive lock on current page. So, we lock next
- * page before releasing the current one
+ * Here we must prevent deletion of next page by insertcleanup
+ * process, which may be trying to obtain exclusive lock on
+ * current page. So, we lock next page before releasing the
+ * current one
*/
- Buffer tmpbuf = ReadBuffer(scan->indexRelation, blkno);
+ Buffer tmpbuf = ReadBuffer(scan->indexRelation, blkno);
LockBuffer(tmpbuf, GIN_SHARE);
UnlockReleaseBuffer(pos->pendingBuffer);
{
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, pos->firstOffset));
pos->item = itup->t_tid;
- if ( GinPageHasFullRow(page) )
+ if (GinPageHasFullRow(page))
{
/*
* find itempointer to the next row
*/
- for(pos->lastOffset = pos->firstOffset+1; pos->lastOffset<=maxoff; pos->lastOffset++)
+ for (pos->lastOffset = pos->firstOffset + 1; pos->lastOffset <= maxoff; pos->lastOffset++)
{
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, pos->lastOffset));
if (!ItemPointerEquals(&pos->item, &itup->t_tid))
}
/*
- * Now pos->firstOffset points to the first tuple of current heap row,
- * pos->lastOffset points to the first tuple of second heap row (or
- * to the end of page)
+ * Now pos->firstOffset points to the first tuple of current heap
+ * row, pos->lastOffset points to the first tuple of second heap
+ * row (or to the end of page)
*/
break;
matchPartialInPendingList(GinState *ginstate, Page page,
OffsetNumber off, OffsetNumber maxoff,
Datum value, OffsetNumber attrnum,
- Datum *datum, bool *datumExtracted,
+ Datum *datum, bool *datumExtracted,
StrategyNumber strategy,
Pointer extra_data)
{
- IndexTuple itup;
- int32 cmp;
+ IndexTuple itup;
+ int32 cmp;
- while ( off < maxoff )
+ while (off < maxoff)
{
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, off));
- if ( attrnum != gintuple_get_attrnum(ginstate, itup) )
+ if (attrnum != gintuple_get_attrnum(ginstate, itup))
return false;
- if (datumExtracted[ off-1 ] == false)
+ if (datumExtracted[off - 1] == false)
{
- datum[ off-1 ] = gin_index_getattr(ginstate, itup);
- datumExtracted[ off-1 ] = true;
+ datum[off - 1] = gin_index_getattr(ginstate, itup);
+ datumExtracted[off - 1] = true;
}
/*----------
* case cmp < 0 => not match and continue scan
*----------
*/
- cmp = DatumGetInt32(FunctionCall4(&ginstate->comparePartialFn[attrnum-1],
+ cmp = DatumGetInt32(FunctionCall4(&ginstate->comparePartialFn[attrnum - 1],
value,
- datum[off-1],
+ datum[off - 1],
UInt16GetDatum(strategy),
PointerGetDatum(extra_data)));
if (cmp == 0)
static bool
collectDatumForItem(IndexScanDesc scan, pendingPosition *pos)
{
- GinScanOpaque so = (GinScanOpaque) scan->opaque;
- OffsetNumber attrnum;
- Page page;
- IndexTuple itup;
- int i, j;
- bool hasMatch = false;
+ GinScanOpaque so = (GinScanOpaque) scan->opaque;
+ OffsetNumber attrnum;
+ Page page;
+ IndexTuple itup;
+ int i,
+ j;
+ bool hasMatch = false;
/*
* Resets entryRes
for (i = 0; i < so->nkeys; i++)
{
GinScanKey key = so->keys + i;
- memset( key->entryRes, FALSE, key->nentries );
+
+ memset(key->entryRes, FALSE, key->nentries);
}
- for(;;)
+ for (;;)
{
- Datum datum[ BLCKSZ/sizeof(IndexTupleData) ];
- bool datumExtracted[ BLCKSZ/sizeof(IndexTupleData) ];
+ Datum datum[BLCKSZ / sizeof(IndexTupleData)];
+ bool datumExtracted[BLCKSZ / sizeof(IndexTupleData)];
- Assert( pos->lastOffset > pos->firstOffset );
- memset(datumExtracted + pos->firstOffset - 1, 0, sizeof(bool) * (pos->lastOffset - pos->firstOffset ));
+ Assert(pos->lastOffset > pos->firstOffset);
+ memset(datumExtracted + pos->firstOffset - 1, 0, sizeof(bool) * (pos->lastOffset - pos->firstOffset));
page = BufferGetPage(pos->pendingBuffer);
- for(i = 0; i < so->nkeys; i++)
+ for (i = 0; i < so->nkeys; i++)
{
- GinScanKey key = so->keys + i;
+ GinScanKey key = so->keys + i;
- for(j=0; j<key->nentries; j++)
+ for (j = 0; j < key->nentries; j++)
{
- OffsetNumber StopLow = pos->firstOffset,
- StopHigh = pos->lastOffset,
- StopMiddle;
- GinScanEntry entry = key->scanEntry + j;
+ OffsetNumber StopLow = pos->firstOffset,
+ StopHigh = pos->lastOffset,
+ StopMiddle;
+ GinScanEntry entry = key->scanEntry + j;
/* already true - do not extra work */
- if ( key->entryRes[j] )
+ if (key->entryRes[j])
continue;
/*
- * Interested tuples are from pos->firstOffset to pos->lastOffset
- * and they are ordered by (attnum, Datum) as it's done in entry tree
- * So we could use binary search to prevent linear scanning
+ * Interested tuples are from pos->firstOffset to
+ * pos->lastOffset and they are ordered by (attnum, Datum) as
+ * it's done in entry tree So we could use binary search to
+ * prevent linear scanning
*/
while (StopLow < StopHigh)
{
StopLow = StopMiddle + 1;
else
{
- int res;
+ int res;
- if (datumExtracted[ StopMiddle-1 ] == false)
+ if (datumExtracted[StopMiddle - 1] == false)
{
- datum[ StopMiddle-1 ] = gin_index_getattr(&so->ginstate, itup);
- datumExtracted[ StopMiddle-1 ] = true;
+ datum[StopMiddle - 1] = gin_index_getattr(&so->ginstate, itup);
+ datumExtracted[StopMiddle - 1] = true;
}
- res = compareEntries(&so->ginstate,
- entry->attnum,
- entry->entry,
- datum[ StopMiddle-1 ]);
+ res = compareEntries(&so->ginstate,
+ entry->attnum,
+ entry->entry,
+ datum[StopMiddle - 1]);
- if ( res == 0 )
+ if (res == 0)
{
/*
- * The exact match causes, so we just scan from
- * current position to find a partial match.
- * See comment above about tuple's ordering.
+ * The exact match causes, so we just scan from
+ * current position to find a partial match. See
+ * comment above about tuple's ordering.
*/
- if ( entry->isPartialMatch )
+ if (entry->isPartialMatch)
key->entryRes[j] =
matchPartialInPendingList(&so->ginstate,
- page, StopMiddle,
+ page, StopMiddle,
pos->lastOffset,
entry->entry,
entry->attnum,
datum,
datumExtracted,
entry->strategy,
- entry->extra_data);
+ entry->extra_data);
else
key->entryRes[j] = true;
break;
}
- else if ( res < 0 )
+ else if (res < 0)
StopHigh = StopMiddle;
else
StopLow = StopMiddle + 1;
}
}
- if ( StopLow>=StopHigh && entry->isPartialMatch )
+ if (StopLow >= StopHigh && entry->isPartialMatch)
{
- /*
- * The exact match wasn't found, so we need to start
- * scan from first tuple greater then current entry
- * See comment above about tuple's ordering.
+ /*
+ * The exact match wasn't found, so we need to start scan
+ * from first tuple greater then current entry See comment
+ * above about tuple's ordering.
*/
key->entryRes[j] =
matchPartialInPendingList(&so->ginstate,
pos->firstOffset = pos->lastOffset;
- if ( GinPageHasFullRow(page) )
+ if (GinPageHasFullRow(page))
{
/*
* We scan all values from one tuple, go to next one
ItemPointerData item = pos->item;
/*
- * need to get next portion of tuples of row containing
- * on several pages
+ * need to get next portion of tuples of row containing on several
+ * pages
*/
- if ( scanGetCandidate(scan, pos) == false || !ItemPointerEquals(&pos->item, &item) )
- elog(ERROR,"Could not process tuple"); /* XXX should not be here ! */
+ if (scanGetCandidate(scan, pos) == false || !ItemPointerEquals(&pos->item, &item))
+ elog(ERROR, "Could not process tuple"); /* XXX should not be
+ * here ! */
}
}
scanPendingInsert(IndexScanDesc scan, TIDBitmap *tbm, int64 *ntids)
{
GinScanOpaque so = (GinScanOpaque) scan->opaque;
- MemoryContext oldCtx;
- bool recheck, keyrecheck, match;
- int i;
- pendingPosition pos;
- Buffer metabuffer = ReadBuffer(scan->indexRelation, GIN_METAPAGE_BLKNO);
- BlockNumber blkno;
+ MemoryContext oldCtx;
+ bool recheck,
+ keyrecheck,
+ match;
+ int i;
+ pendingPosition pos;
+ Buffer metabuffer = ReadBuffer(scan->indexRelation, GIN_METAPAGE_BLKNO);
+ BlockNumber blkno;
*ntids = 0;
blkno = GinPageGetMeta(BufferGetPage(metabuffer))->head;
/*
- * fetch head of list before unlocking metapage.
- * head page must be pinned to prevent deletion by vacuum process
+ * fetch head of list before unlocking metapage. head page must be pinned
+ * to prevent deletion by vacuum process
*/
- if ( blkno == InvalidBlockNumber )
+ if (blkno == InvalidBlockNumber)
{
/* No pending list, so proceed with normal scan */
- UnlockReleaseBuffer( metabuffer );
+ UnlockReleaseBuffer(metabuffer);
return;
}
pos.pendingBuffer = ReadBuffer(scan->indexRelation, blkno);
LockBuffer(pos.pendingBuffer, GIN_SHARE);
pos.firstOffset = FirstOffsetNumber;
- UnlockReleaseBuffer( metabuffer );
+ UnlockReleaseBuffer(metabuffer);
/*
- * loop for each heap row. scanGetCandidate returns full row
- * or row's tuples from first page.
+ * loop for each heap row. scanGetCandidate returns full row or row's
+ * tuples from first page.
*/
- while( scanGetCandidate(scan, &pos) )
+ while (scanGetCandidate(scan, &pos))
{
-
/*
- * Check entries in tuple and setup entryRes array
- * If tuples of heap's row are placed on several pages
- * collectDatumForItem will read all of that pages.
+ * Check entries in tuple and setup entryRes array If tuples of heap's
+ * row are placed on several pages collectDatumForItem will read all
+ * of that pages.
*/
if (!collectDatumForItem(scan, &pos))
continue;
/*
- * Matching of entries of one row is finished,
- * so check row by consistent function.
+ * Matching of entries of one row is finished, so check row by
+ * consistent function.
*/
oldCtx = MemoryContextSwitchTo(so->tempCtx);
recheck = false;
for (i = 0; i < so->nkeys; i++)
{
- GinScanKey key = so->keys + i;
+ GinScanKey key = so->keys + i;
keyrecheck = true;
- if (!DatumGetBool(FunctionCall6(&so->ginstate.consistentFn[key->attnum-1],
+ if (!DatumGetBool(FunctionCall6(&so->ginstate.consistentFn[key->attnum - 1],
PointerGetDatum(key->entryRes),
UInt16GetDatum(key->strategy),
key->query,
MemoryContextSwitchTo(oldCtx);
MemoryContextReset(so->tempCtx);
- if ( match )
+ if (match)
{
tbm_add_tuples(tbm, &pos.item, 1, recheck);
(*ntids)++;
* We return recheck = true if any of the keyGetItem calls return
* keyrecheck = true. Note that because the second loop might advance
* some keys, this could theoretically be too conservative. In practice
- * though, we expect that a consistentFn's recheck result will depend
- * only on the operator and the query, so for any one key it should
- * stay the same regardless of advancing to new items. So it's not
- * worth working harder.
+ * though, we expect that a consistentFn's recheck result will depend only
+ * on the operator and the query, so for any one key it should stay the
+ * same regardless of advancing to new items. So it's not worth working
+ * harder.
*/
*recheck = false;
{
int cmp = compareItemPointers(item, &key->curItem);
- if ( cmp != 0 && (ItemPointerIsLossyPage(item) || ItemPointerIsLossyPage(&key->curItem)) )
+ if (cmp != 0 && (ItemPointerIsLossyPage(item) || ItemPointerIsLossyPage(&key->curItem)))
{
/*
* if one of ItemPointers points to the whole page then
* compare only page's number
*/
- if ( ItemPointerGetBlockNumber(item) == ItemPointerGetBlockNumber(&key->curItem) )
+ if (ItemPointerGetBlockNumber(item) == ItemPointerGetBlockNumber(&key->curItem))
cmp = 0;
else
cmp = (ItemPointerGetBlockNumber(item) > ItemPointerGetBlockNumber(&key->curItem)) ? 1 : -1;
gingetbitmap(PG_FUNCTION_ARGS)
{
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
- TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
+ TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
int64 ntids;
if (GinIsNewKey(scan))
ntids = 0;
/*
- * First, scan the pending list and collect any matching entries into
- * the bitmap. After we scan a pending item, some other backend could
- * post it into the main index, and so we might visit it a second time
- * during the main scan. This is okay because we'll just re-set the
- * same bit in the bitmap. (The possibility of duplicate visits is a
- * major reason why GIN can't support the amgettuple API, however.)
- * Note that it would not do to scan the main index before the pending
- * list, since concurrent cleanup could then make us miss entries
- * entirely.
+ * First, scan the pending list and collect any matching entries into the
+ * bitmap. After we scan a pending item, some other backend could post it
+ * into the main index, and so we might visit it a second time during the
+ * main scan. This is okay because we'll just re-set the same bit in the
+ * bitmap. (The possibility of duplicate visits is a major reason why GIN
+ * can't support the amgettuple API, however.) Note that it would not do
+ * to scan the main index before the pending list, since concurrent
+ * cleanup could then make us miss entries entirely.
*/
scanPendingInsert(scan, tbm, &ntids);
if (!scanGetItem(scan, &iptr, &recheck))
break;
- if ( ItemPointerIsLossyPage(&iptr) )
+ if (ItemPointerIsLossyPage(&iptr))
tbm_add_page(tbm, ItemPointerGetBlockNumber(&iptr));
else
tbm_add_tuples(tbm, &iptr, 1, recheck);
addItemPointersToTuple(Relation index, GinState *ginstate, GinBtreeStack *stack,
IndexTuple old, ItemPointerData *items, uint32 nitem, bool isBuild)
{
- Datum key = gin_index_getattr(ginstate, old);
- OffsetNumber attnum = gintuple_get_attrnum(ginstate, old);
- IndexTuple res = GinFormTuple(ginstate, attnum, key,
- NULL, nitem + GinGetNPosting(old));
+ Datum key = gin_index_getattr(ginstate, old);
+ OffsetNumber attnum = gintuple_get_attrnum(ginstate, old);
+ IndexTuple res = GinFormTuple(ginstate, attnum, key,
+ NULL, nitem + GinGetNPosting(old));
if (res)
{
/* good, small enough */
- uint32 newnitem;
+ uint32 newnitem;
newnitem = MergeItemPointers(GinGetPosting(res),
GinGetPosting(old), GinGetNPosting(old),
{
GinBuildState *buildstate = (GinBuildState *) state;
MemoryContext oldCtx;
- int i;
+ int i;
oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
- for(i=0; i<buildstate->ginstate.origTupdesc->natts;i++)
- if ( !isnull[i] )
- buildstate->indtuples += ginHeapTupleBulkInsert(buildstate,
- (OffsetNumber)(i+1), values[i],
- &htup->t_self);
+ for (i = 0; i < buildstate->ginstate.origTupdesc->natts; i++)
+ if (!isnull[i])
+ buildstate->indtuples += ginHeapTupleBulkInsert(buildstate,
+ (OffsetNumber) (i + 1), values[i],
+ &htup->t_self);
/* If we've maxed out our available memory, dump everything to the index */
/* Also dump if the tree seems to be getting too unbalanced */
ItemPointerData *list;
Datum entry;
uint32 nlist;
- OffsetNumber attnum;
+ OffsetNumber attnum;
while ((list = ginGetEntry(&buildstate->accum, &attnum, &entry, &nlist)) != NULL)
{
IndexBuildResult *result;
double reltuples;
GinBuildState buildstate;
- Buffer RootBuffer, MetaBuffer;
+ Buffer RootBuffer,
+ MetaBuffer;
ItemPointerData *list;
Datum entry;
uint32 nlist;
rdata.next = NULL;
recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_CREATE_INDEX, &rdata);
-
+
page = BufferGetPage(RootBuffer);
PageSetLSN(page, recptr);
PageSetTLI(page, ThisTimeLineID);
MemoryContext oldCtx;
MemoryContext insertCtx;
uint32 res = 0;
- int i;
+ int i;
insertCtx = AllocSetContextCreate(CurrentMemoryContext,
"Gin insert temporary context",
initGinState(&ginstate, index);
- if ( GinGetUseFastUpdate(index) )
+ if (GinGetUseFastUpdate(index))
{
- GinTupleCollector collector;
+ GinTupleCollector collector;
memset(&collector, 0, sizeof(GinTupleCollector));
- for(i=0; i<ginstate.origTupdesc->natts;i++)
- if ( !isnull[i] )
+ for (i = 0; i < ginstate.origTupdesc->natts; i++)
+ if (!isnull[i])
res += ginHeapTupleFastCollect(index, &ginstate, &collector,
- (OffsetNumber)(i+1), values[i], ht_ctid);
+ (OffsetNumber) (i + 1), values[i], ht_ctid);
ginHeapTupleFastInsert(index, &ginstate, &collector);
}
else
{
- for(i=0; i<ginstate.origTupdesc->natts;i++)
- if ( !isnull[i] )
- res += ginHeapTupleInsert(index, &ginstate,
- (OffsetNumber)(i+1), values[i], ht_ctid);
+ for (i = 0; i < ginstate.origTupdesc->natts; i++)
+ if (!isnull[i])
+ res += ginHeapTupleInsert(index, &ginstate,
+ (OffsetNumber) (i + 1), values[i], ht_ctid);
}
static void
fillScanKey(GinState *ginstate, GinScanKey key, OffsetNumber attnum, Datum query,
- Datum *entryValues, bool *partial_matches, uint32 nEntryValues,
+ Datum *entryValues, bool *partial_matches, uint32 nEntryValues,
StrategyNumber strategy, Pointer *extra_data)
{
uint32 i,
key->scanEntry[i].strategy = strategy;
key->scanEntry[i].list = NULL;
key->scanEntry[i].nlist = 0;
- key->scanEntry[i].isPartialMatch = ( ginstate->canPartialMatch[attnum - 1] && partial_matches )
- ? partial_matches[i] : false;
+ key->scanEntry[i].isPartialMatch = (ginstate->canPartialMatch[attnum - 1] && partial_matches)
+ ? partial_matches[i] : false;
/* link to the equals entry in current scan key */
key->scanEntry[i].master = NULL;
ScanKey skey = &scankey[i];
Datum *entryValues;
int32 nEntryValues = 0;
- bool *partial_matches = NULL;
- Pointer *extra_data = NULL;
+ bool *partial_matches = NULL;
+ Pointer *extra_data = NULL;
/*
- * Assume, that GIN-indexable operators are strict, so
- * nothing could be found
+ * Assume, that GIN-indexable operators are strict, so nothing could
+ * be found
*/
if (skey->sk_flags & SK_ISNULL)
{
if (nEntryValues < 0)
{
/*
- * extractQueryFn signals that nothing can match, so we can
- * just set isVoidRes flag. No need to examine any more keys.
+ * extractQueryFn signals that nothing can match, so we can just
+ * set isVoidRes flag. No need to examine any more keys.
*/
so->isVoidRes = true;
break;
if (entryValues == NULL || nEntryValues == 0)
{
/*
- * extractQueryFn signals that everything matches. This would
- * require a full scan, which we can't do, but perhaps there
- * is another scankey that provides a restriction to use. So
- * we keep going and check only at the end.
+ * extractQueryFn signals that everything matches. This would
+ * require a full scan, which we can't do, but perhaps there is
+ * another scankey that provides a restriction to use. So we keep
+ * going and check only at the end.
*/
continue;
}
#include "access/genam.h"
#include "access/gin.h"
#include "access/reloptions.h"
-#include "catalog/pg_type.h"
+#include "catalog/pg_type.h"
#include "storage/bufmgr.h"
#include "storage/freespace.h"
#include "storage/indexfsm.h"
void
initGinState(GinState *state, Relation index)
{
- int i;
+ int i;
state->origTupdesc = index->rd_att;
state->oneCol = (index->rd_att->natts == 1) ? true : false;
- for(i=0;i<index->rd_att->natts;i++)
+ for (i = 0; i < index->rd_att->natts; i++)
{
- state->tupdesc[i] = CreateTemplateTupleDesc(2,false);
+ state->tupdesc[i] = CreateTemplateTupleDesc(2, false);
- TupleDescInitEntry( state->tupdesc[i], (AttrNumber) 1, NULL,
- INT2OID, -1, 0);
- TupleDescInitEntry( state->tupdesc[i], (AttrNumber) 2, NULL,
- index->rd_att->attrs[i]->atttypid,
- index->rd_att->attrs[i]->atttypmod,
- index->rd_att->attrs[i]->attndims
- );
+ TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 1, NULL,
+ INT2OID, -1, 0);
+ TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 2, NULL,
+ index->rd_att->attrs[i]->atttypid,
+ index->rd_att->attrs[i]->atttypmod,
+ index->rd_att->attrs[i]->attndims
+ );
fmgr_info_copy(&(state->compareFn[i]),
- index_getprocinfo(index, i+1, GIN_COMPARE_PROC),
- CurrentMemoryContext);
+ index_getprocinfo(index, i + 1, GIN_COMPARE_PROC),
+ CurrentMemoryContext);
fmgr_info_copy(&(state->extractValueFn[i]),
- index_getprocinfo(index, i+1, GIN_EXTRACTVALUE_PROC),
- CurrentMemoryContext);
+ index_getprocinfo(index, i + 1, GIN_EXTRACTVALUE_PROC),
+ CurrentMemoryContext);
fmgr_info_copy(&(state->extractQueryFn[i]),
- index_getprocinfo(index, i+1, GIN_EXTRACTQUERY_PROC),
- CurrentMemoryContext);
+ index_getprocinfo(index, i + 1, GIN_EXTRACTQUERY_PROC),
+ CurrentMemoryContext);
fmgr_info_copy(&(state->consistentFn[i]),
- index_getprocinfo(index, i+1, GIN_CONSISTENT_PROC),
- CurrentMemoryContext);
+ index_getprocinfo(index, i + 1, GIN_CONSISTENT_PROC),
+ CurrentMemoryContext);
/*
* Check opclass capability to do partial match.
*/
- if ( index_getprocid(index, i+1, GIN_COMPARE_PARTIAL_PROC) != InvalidOid )
+ if (index_getprocid(index, i + 1, GIN_COMPARE_PARTIAL_PROC) != InvalidOid)
{
fmgr_info_copy(&(state->comparePartialFn[i]),
- index_getprocinfo(index, i+1, GIN_COMPARE_PARTIAL_PROC),
+ index_getprocinfo(index, i + 1, GIN_COMPARE_PARTIAL_PROC),
CurrentMemoryContext);
state->canPartialMatch[i] = true;
{
OffsetNumber colN = FirstOffsetNumber;
- if ( !ginstate->oneCol )
+ if (!ginstate->oneCol)
{
- Datum res;
- bool isnull;
+ Datum res;
+ bool isnull;
/*
- * First attribute is always int16, so we can safely use any
- * tuple descriptor to obtain first attribute of tuple
+ * First attribute is always int16, so we can safely use any tuple
+ * descriptor to obtain first attribute of tuple
*/
res = index_getattr(tuple, FirstOffsetNumber, ginstate->tupdesc[0],
&isnull);
Assert(!isnull);
colN = DatumGetUInt16(res);
- Assert( colN >= FirstOffsetNumber && colN <= ginstate->origTupdesc->natts );
+ Assert(colN >= FirstOffsetNumber && colN <= ginstate->origTupdesc->natts);
}
return colN;
Datum
gin_index_getattr(GinState *ginstate, IndexTuple tuple)
{
- bool isnull;
- Datum res;
+ bool isnull;
+ Datum res;
- if ( ginstate->oneCol )
+ if (ginstate->oneCol)
{
/*
* Single column index doesn't store attribute numbers in tuples
else
{
/*
- * Since the datum type depends on which index column it's from,
- * we must be careful to use the right tuple descriptor here.
+ * Since the datum type depends on which index column it's from, we
+ * must be careful to use the right tuple descriptor here.
*/
OffsetNumber colN = gintuple_get_attrnum(ginstate, tuple);
void
GinInitMetabuffer(Buffer b)
{
- GinMetaPageData *metadata;
- Page page = BufferGetPage(b);
+ GinMetaPageData *metadata;
+ Page page = BufferGetPage(b);
GinInitPage(page, GIN_META, BufferGetPageSize(b));
{
return DatumGetInt32(
FunctionCall2(
- &ginstate->compareFn[attnum-1],
+ &ginstate->compareFn[attnum - 1],
a, b
)
);
int
compareAttEntries(GinState *ginstate, OffsetNumber attnum_a, Datum a,
- OffsetNumber attnum_b, Datum b)
+ OffsetNumber attnum_b, Datum b)
{
- if ( attnum_a == attnum_b )
- return compareEntries( ginstate, attnum_a, a, b);
+ if (attnum_a == attnum_b)
+ return compareEntries(ginstate, attnum_a, a, b);
- return ( attnum_a < attnum_b ) ? -1 : 1;
+ return (attnum_a < attnum_b) ? -1 : 1;
}
typedef struct
Datum *entries;
entries = (Datum *) DatumGetPointer(FunctionCall2(
- &ginstate->extractValueFn[attnum-1],
+ &ginstate->extractValueFn[attnum - 1],
value,
PointerGetDatum(nentries)
));
{
cmpEntriesData arg;
- arg.cmpDatumFunc = &ginstate->compareFn[attnum-1];
+ arg.cmpDatumFunc = &ginstate->compareFn[attnum - 1];
arg.needUnique = needUnique;
qsort_arg(entries, *nentries, sizeof(Datum),
(qsort_arg_comparator) cmpEntries, (void *) &arg);
rdopts = allocateReloptStruct(sizeof(GinOptions), options, numoptions);
fillRelOptions((void *) rdopts, sizeof(GinOptions), options, numoptions,
- validate, tab, lengthof(tab));
+ validate, tab, lengthof(tab));
pfree(options);
if (GinGetNPosting(itup) != newN)
{
- Datum value;
- OffsetNumber attnum;
+ Datum value;
+ OffsetNumber attnum;
/*
* Some ItemPointers was deleted, so we should remake our
PG_RETURN_POINTER(stats);
}
- /*
- * Set up all-zero stats and cleanup pending inserts
- * if ginbulkdelete wasn't called
+ /*
+ * Set up all-zero stats and cleanup pending inserts if ginbulkdelete
+ * wasn't called
*/
if (stats == NULL)
{
if (needLock)
UnlockRelationForExtension(index, ExclusiveLock);
- totFreePages = 0;
+ totFreePages = 0;
for (blkno = GIN_ROOT_BLKNO + 1; blkno < npages; blkno++)
{
ginRedoCreateIndex(XLogRecPtr lsn, XLogRecord *record)
{
RelFileNode *node = (RelFileNode *) XLogRecGetData(record);
- Buffer RootBuffer, MetaBuffer;
+ Buffer RootBuffer,
+ MetaBuffer;
Page page;
MetaBuffer = XLogReadBuffer(*node, GIN_METAPAGE_BLKNO, true);
static void
ginRedoUpdateMetapage(XLogRecPtr lsn, XLogRecord *record)
{
- ginxlogUpdateMeta *data = (ginxlogUpdateMeta*) XLogRecGetData(record);
+ ginxlogUpdateMeta *data = (ginxlogUpdateMeta *) XLogRecGetData(record);
Buffer metabuffer;
Page metapage;
if (!XLByteLE(lsn, PageGetLSN(metapage)))
{
- memcpy( GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));
+ memcpy(GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));
PageSetLSN(metapage, lsn);
PageSetTLI(metapage, ThisTimeLineID);
MarkBufferDirty(metabuffer);
}
- if ( data->ntuples > 0 )
+ if (data->ntuples > 0)
{
/*
* insert into tail page
*/
if (!(record->xl_info & XLR_BKP_BLOCK_1))
{
- Buffer buffer = XLogReadBuffer(data->node, data->metadata.tail, false);
- Page page = BufferGetPage(buffer);
+ Buffer buffer = XLogReadBuffer(data->node, data->metadata.tail, false);
+ Page page = BufferGetPage(buffer);
- if ( !XLByteLE(lsn, PageGetLSN(page)))
+ if (!XLByteLE(lsn, PageGetLSN(page)))
{
- OffsetNumber l, off = (PageIsEmpty(page)) ? FirstOffsetNumber :
- OffsetNumberNext(PageGetMaxOffsetNumber(page));
- int i, tupsize;
- IndexTuple tuples = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogUpdateMeta));
-
- for(i=0; i<data->ntuples; i++)
+ OffsetNumber l,
+ off = (PageIsEmpty(page)) ? FirstOffsetNumber :
+ OffsetNumberNext(PageGetMaxOffsetNumber(page));
+ int i,
+ tupsize;
+ IndexTuple tuples = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogUpdateMeta));
+
+ for (i = 0; i < data->ntuples; i++)
{
tupsize = IndexTupleSize(tuples);
- l = PageAddItem(page, (Item)tuples, tupsize, off, false, false);
+ l = PageAddItem(page, (Item) tuples, tupsize, off, false, false);
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add item to index page");
- tuples = (IndexTuple)( ((char*)tuples) + tupsize );
+ tuples = (IndexTuple) (((char *) tuples) + tupsize);
}
/*
UnlockReleaseBuffer(buffer);
}
}
- else if ( data->prevTail != InvalidBlockNumber )
+ else if (data->prevTail != InvalidBlockNumber)
{
/*
* New tail
*/
- Buffer buffer = XLogReadBuffer(data->node, data->prevTail, false);
- Page page = BufferGetPage(buffer);
+ Buffer buffer = XLogReadBuffer(data->node, data->prevTail, false);
+ Page page = BufferGetPage(buffer);
- if ( !XLByteLE(lsn, PageGetLSN(page)))
+ if (!XLByteLE(lsn, PageGetLSN(page)))
{
GinPageGetOpaque(page)->rightlink = data->newRightlink;
static void
ginRedoInsertListPage(XLogRecPtr lsn, XLogRecord *record)
{
- ginxlogInsertListPage *data = (ginxlogInsertListPage*) XLogRecGetData(record);
- Buffer buffer;
- Page page;
- OffsetNumber l, off = FirstOffsetNumber;
- int i, tupsize;
- IndexTuple tuples = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogInsertListPage));
+ ginxlogInsertListPage *data = (ginxlogInsertListPage *) XLogRecGetData(record);
+ Buffer buffer;
+ Page page;
+ OffsetNumber l,
+ off = FirstOffsetNumber;
+ int i,
+ tupsize;
+ IndexTuple tuples = (IndexTuple) (XLogRecGetData(record) + sizeof(ginxlogInsertListPage));
if (record->xl_info & XLR_BKP_BLOCK_1)
return;
GinInitBuffer(buffer, GIN_LIST);
GinPageGetOpaque(page)->rightlink = data->rightlink;
- if ( data->rightlink == InvalidBlockNumber )
+ if (data->rightlink == InvalidBlockNumber)
{
/* tail of sublist */
GinPageSetFullRow(page);
GinPageGetOpaque(page)->maxoff = 0;
}
- for(i=0; i<data->ntuples; i++)
+ for (i = 0; i < data->ntuples; i++)
{
tupsize = IndexTupleSize(tuples);
- l = PageAddItem(page, (Item)tuples, tupsize, off, false, false);
+ l = PageAddItem(page, (Item) tuples, tupsize, off, false, false);
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add item to index page");
- tuples = (IndexTuple)( ((char*)tuples) + tupsize );
+ tuples = (IndexTuple) (((char *) tuples) + tupsize);
}
PageSetLSN(page, lsn);
static void
ginRedoDeleteListPages(XLogRecPtr lsn, XLogRecord *record)
{
- ginxlogDeleteListPages *data = (ginxlogDeleteListPages*) XLogRecGetData(record);
+ ginxlogDeleteListPages *data = (ginxlogDeleteListPages *) XLogRecGetData(record);
Buffer metabuffer;
Page metapage;
- int i;
+ int i;
metabuffer = XLogReadBuffer(data->node, GIN_METAPAGE_BLKNO, false);
metapage = BufferGetPage(metabuffer);
if (!XLByteLE(lsn, PageGetLSN(metapage)))
{
- memcpy( GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));
+ memcpy(GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));
PageSetLSN(metapage, lsn);
PageSetTLI(metapage, ThisTimeLineID);
MarkBufferDirty(metabuffer);
}
- for(i=0; i<data->ndeleted; i++)
+ for (i = 0; i < data->ndeleted; i++)
{
- Buffer buffer = XLogReadBuffer(data->node,data->toDelete[i],false);
- Page page = BufferGetPage(buffer);
+ Buffer buffer = XLogReadBuffer(data->node, data->toDelete[i], false);
+ Page page = BufferGetPage(buffer);
- if ( !XLByteLE(lsn, PageGetLSN(page)))
+ if (!XLByteLE(lsn, PageGetLSN(page)))
{
GinPageGetOpaque(page)->flags = GIN_DELETED;
case XLOG_GIN_INSERT_LISTPAGE:
ginRedoInsertListPage(lsn, record);
break;
- case XLOG_GIN_DELETE_LISTPAGE:
+ case XLOG_GIN_DELETE_LISTPAGE:
ginRedoDeleteListPages(lsn, record);
break;
default:
break;
case XLOG_GIN_UPDATE_META_PAGE:
appendStringInfo(buf, "Update metapage, ");
- desc_node(buf, ((ginxlogUpdateMeta *) rec)->node, ((ginxlogUpdateMeta *) rec)->metadata.tail);
+ desc_node(buf, ((ginxlogUpdateMeta *) rec)->node, ((ginxlogUpdateMeta *) rec)->metadata.tail);
break;
case XLOG_GIN_INSERT_LISTPAGE:
appendStringInfo(buf, "Insert new list page, ");
- desc_node(buf, ((ginxlogInsertListPage *) rec)->node, ((ginxlogInsertListPage *) rec)->blkno);
+ desc_node(buf, ((ginxlogInsertListPage *) rec)->node, ((ginxlogInsertListPage *) rec)->blkno);
break;
case XLOG_GIN_DELETE_LISTPAGE:
appendStringInfo(buf, "Delete list pages (%d), ", ((ginxlogDeleteListPages *) rec)->ndeleted);
- desc_node(buf, ((ginxlogDeleteListPages *) rec)->node, ((ginxlogDeleteListPages *) rec)->metadata.head);
+ desc_node(buf, ((ginxlogDeleteListPages *) rec)->node, ((ginxlogDeleteListPages *) rec)->metadata.head);
break;
default:
elog(PANIC, "gin_desc: unknown op code %u", info);
so = (GISTScanOpaque) scan->opaque;
- if (dir != ForwardScanDirection)
+ if (dir != ForwardScanDirection)
elog(ERROR, "GiST doesn't support other scan directions than forward");
/*
gistgetbitmap(PG_FUNCTION_ARGS)
{
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
- TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
- int64 ntids;
+ TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
+ int64 ntids;
ntids = gistnext(scan, tbm);
so = (GISTScanOpaque) scan->opaque;
- if ( so->qual_ok == false )
+ if (so->qual_ok == false)
return 0;
- if ( so->curbuf == InvalidBuffer )
+ if (so->curbuf == InvalidBuffer)
{
if (ItemPointerIsValid(&so->curpos) == false)
{
stk->block = GIST_ROOT_BLKNO;
pgstat_count_index_scan(scan->indexRelation);
- }
+ }
else
{
/* scan is finished */
}
/*
- * check stored pointers from last visit
+ * check stored pointers from last visit
*/
- if ( so->nPageData > 0 )
+ if (so->nPageData > 0)
{
/*
* gistgetmulti never should go here
*/
- Assert( tbm == NULL );
+ Assert(tbm == NULL);
- if ( so->curPageData < so->nPageData )
+ if (so->curPageData < so->nPageData)
{
- scan->xs_ctup.t_self = so->pageData[ so->curPageData ].heapPtr;
- scan->xs_recheck = so->pageData[ so->curPageData ].recheck;
+ scan->xs_ctup.t_self = so->pageData[so->curPageData].heapPtr;
+ scan->xs_recheck = so->pageData[so->curPageData].recheck;
ItemPointerSet(&so->curpos,
- BufferGetBlockNumber(so->curbuf),
- so->pageData[ so->curPageData ].pageOffset);
+ BufferGetBlockNumber(so->curbuf),
+ so->pageData[so->curPageData].pageOffset);
- so->curPageData ++;
+ so->curPageData++;
return 1;
}
if (!XLogRecPtrIsInvalid(so->stack->parentlsn) &&
XLByteLT(so->stack->parentlsn, opaque->nsn) &&
opaque->rightlink != InvalidBlockNumber /* sanity check */ &&
- (so->stack->next == NULL || so->stack->next->block != opaque->rightlink) /* check if already
+ (so->stack->next == NULL || so->stack->next->block != opaque->rightlink) /* check if already
added */ )
{
/* detect page split, follow right link to add pages */
if (!OffsetNumberIsValid(n))
{
/*
- * If we was called from gistgettuple and current buffer contains
- * something matched then make a recursive call - it will return
- * ItemPointer from so->pageData. But we save buffer pinned to
- * support tuple's killing
+ * If we was called from gistgettuple and current buffer
+ * contains something matched then make a recursive call - it
+ * will return ItemPointer from so->pageData. But we save
+ * buffer pinned to support tuple's killing
*/
- if ( !tbm && so->nPageData > 0 )
+ if (!tbm && so->nPageData > 0)
{
LockBuffer(so->curbuf, GIST_UNLOCK);
return gistnext(scan, NULL);
ntids++;
if (tbm != NULL)
tbm_add_tuples(tbm, &it->t_tid, 1, scan->xs_recheck);
- else
+ else
{
- so->pageData[ so->nPageData ].heapPtr = it->t_tid;
- so->pageData[ so->nPageData ].pageOffset = n;
- so->pageData[ so->nPageData ].recheck = scan->xs_recheck;
- so->nPageData ++;
+ so->pageData[so->nPageData].heapPtr = it->t_tid;
+ so->pageData[so->nPageData].pageOffset = n;
+ so->pageData[so->nPageData].recheck = scan->xs_recheck;
+ so->nPageData++;
}
}
}
/*
* Call the Consistent function to evaluate the test. The
* arguments are the index datum (as a GISTENTRY*), the comparison
- * datum, the comparison operator's strategy number and
- * subtype from pg_amop, and the recheck flag.
+ * datum, the comparison operator's strategy number and subtype
+ * from pg_amop, and the recheck flag.
*
* (Presently there's no need to pass the subtype since it'll
* always be zero, but might as well pass it for possible future
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
BOX *query = PG_GETARG_BOX_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
static void
fallbackSplit(GistEntryVector *entryvec, GIST_SPLITVEC *v)
{
- OffsetNumber i,
- maxoff;
- BOX *unionL = NULL,
- *unionR = NULL;
- int nbytes;
+ OffsetNumber i,
+ maxoff;
+ BOX *unionL = NULL,
+ *unionR = NULL;
+ int nbytes;
maxoff = entryvec->n - 1;
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
- BOX * cur = DatumGetBoxP(entryvec->vector[i].key);
+ BOX *cur = DatumGetBoxP(entryvec->vector[i].key);
if (i <= (maxoff - FirstOffsetNumber + 1) / 2)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
POLYGON *query = PG_GETARG_POLYGON_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
bool result;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
CIRCLE *query = PG_GETARG_CIRCLE_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
BOX bbox;
* Next, if any of keys is a NULL and that key is not marked with
* SK_SEARCHNULL then nothing can be found.
*/
- for (i = 0; i < scan->numberOfKeys; i++) {
+ for (i = 0; i < scan->numberOfKeys; i++)
+ {
scan->keyData[i].sk_func = so->giststate->consistentFn[scan->keyData[i].sk_attno - 1];
- if ( scan->keyData[i].sk_flags & SK_ISNULL ) {
- if ( (scan->keyData[i].sk_flags & SK_SEARCHNULL) == 0 )
+ if (scan->keyData[i].sk_flags & SK_ISNULL)
+ {
+ if ((scan->keyData[i].sk_flags & SK_SEARCHNULL) == 0)
so->qual_ok = false;
}
}
}
/*
- * Trivial picksplit implementaion. Function called only
+ * Trivial picksplit implementaion. Function called only
* if user-defined picksplit puts all keys to the one page.
* That is a bug of user-defined picksplit but we'd like
* to "fix" that.
static void
genericPickSplit(GISTSTATE *giststate, GistEntryVector *entryvec, GIST_SPLITVEC *v, int attno)
{
- OffsetNumber i,
- maxoff;
- int nbytes;
- GistEntryVector *evec;
+ OffsetNumber i,
+ maxoff;
+ int nbytes;
+ GistEntryVector *evec;
maxoff = entryvec->n - 1;
* Form unions of each page
*/
- evec = palloc( sizeof(GISTENTRY) * entryvec->n + GEVHDRSZ );
+ evec = palloc(sizeof(GISTENTRY) * entryvec->n + GEVHDRSZ);
evec->n = v->spl_nleft;
- memcpy(evec->vector, entryvec->vector + FirstOffsetNumber,
- sizeof(GISTENTRY) * evec->n);
- v->spl_ldatum = FunctionCall2(&giststate->unionFn[attno],
- PointerGetDatum(evec),
- PointerGetDatum(&nbytes));
+ memcpy(evec->vector, entryvec->vector + FirstOffsetNumber,
+ sizeof(GISTENTRY) * evec->n);
+ v->spl_ldatum = FunctionCall2(&giststate->unionFn[attno],
+ PointerGetDatum(evec),
+ PointerGetDatum(&nbytes));
evec->n = v->spl_nright;
- memcpy(evec->vector, entryvec->vector + FirstOffsetNumber + v->spl_nleft,
- sizeof(GISTENTRY) * evec->n);
- v->spl_rdatum = FunctionCall2(&giststate->unionFn[attno],
- PointerGetDatum(evec),
- PointerGetDatum(&nbytes));
+ memcpy(evec->vector, entryvec->vector + FirstOffsetNumber + v->spl_nleft,
+ sizeof(GISTENTRY) * evec->n);
+ v->spl_rdatum = FunctionCall2(&giststate->unionFn[attno],
+ PointerGetDatum(evec),
+ PointerGetDatum(&nbytes));
}
/*
PointerGetDatum(entryvec),
PointerGetDatum(sv));
- if ( sv->spl_nleft == 0 || sv->spl_nright == 0 )
+ if (sv->spl_nleft == 0 || sv->spl_nright == 0)
{
ereport(DEBUG1,
(errcode(ERRCODE_INTERNAL_ERROR),
- errmsg("picksplit method for %d column of index \"%s\" failed",
- attno+1, RelationGetRelationName(r)),
+ errmsg("picksplit method for %d column of index \"%s\" failed",
+ attno + 1, RelationGetRelationName(r)),
errhint("The index is not optimal. To optimize it, contact a developer, or try to use the column as the second one in the CREATE INDEX command.")));
/*
- * Reinit GIST_SPLITVEC. Although that fields are not used
- * by genericPickSplit(), let us set up it for further processing
+ * Reinit GIST_SPLITVEC. Although that fields are not used by
+ * genericPickSplit(), let us set up it for further processing
*/
sv->spl_ldatum_exists = (v->spl_lisnull[attno]) ? false : true;
sv->spl_rdatum_exists = (v->spl_risnull[attno]) ? false : true;
for (i = 0; i < len; i++)
{
- Size sz = IndexTupleSize(itup[i]);
+ Size sz = IndexTupleSize(itup[i]);
+
l = PageAddItem(page, (Item) itup[i], sz, off, false, false);
if (l == InvalidOffsetNumber)
elog(ERROR, "failed to add item to GiST index page, item %d out of %d, size %d bytes",
Relation rel = info->index;
BlockNumber npages,
blkno;
- BlockNumber totFreePages;
+ BlockNumber totFreePages;
BlockNumber lastBlock = GIST_ROOT_BLKNO,
lastFilledBlock = GIST_ROOT_BLKNO;
bool needLock;
Relation index = (Relation) PG_GETARG_POINTER(1);
IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
IndexBuildResult *result;
- BlockNumber relpages;
+ BlockNumber relpages;
double reltuples;
uint32 num_buckets;
HashBuildState buildstate;
* (assuming their hash codes are pretty random) there will be no locality
* of access to the index, and if the index is bigger than available RAM
* then we'll thrash horribly. To prevent that scenario, we can sort the
- * tuples by (expected) bucket number. However, such a sort is useless
+ * tuples by (expected) bucket number. However, such a sort is useless
* overhead when the index does fit in RAM. We choose to sort if the
* initial index size exceeds NBuffers.
*
- * NOTE: this test will need adjustment if a bucket is ever different
- * from one page.
+ * NOTE: this test will need adjustment if a bucket is ever different from
+ * one page.
*/
if (num_buckets >= (uint32) NBuffers)
buildstate.spool = _h_spoolinit(index, num_buckets);
hashgetbitmap(PG_FUNCTION_ARGS)
{
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
- TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
+ TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
HashScanOpaque so = (HashScanOpaque) scan->opaque;
bool res;
int64 ntids = 0;
while (res)
{
- bool add_tuple;
+ bool add_tuple;
/*
* Skip killed tuples if asked to.
add_tuple = true;
/* Save tuple ID, and continue scanning */
- if (add_tuple)
+ if (add_tuple)
{
/* Note we mark the tuple ID as requiring recheck */
tbm_add_tuples(tbm, &scan->xs_ctup.t_self, 1, true);
* each bucket.
*/
metabuf = _hash_getbuf(rel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
- metap = HashPageGetMeta(BufferGetPage(metabuf));
+ metap = HashPageGetMeta(BufferGetPage(metabuf));
orig_maxbucket = metap->hashm_maxbucket;
orig_ntuples = metap->hashm_ntuples;
memcpy(&local_metapage, metap, sizeof(local_metapage));
* are sometimes the same for one pair and different for another pair.
* This was tested for:
* * pairs that differed by one bit, by two bits, in any combination
- * of top bits of (a,b,c), or in any combination of bottom bits of
- * (a,b,c).
+ * of top bits of (a,b,c), or in any combination of bottom bits of
+ * (a,b,c).
* * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- * is commonly produced by subtraction) look like a single 1-bit
- * difference.
+ * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ * is commonly produced by subtraction) look like a single 1-bit
+ * difference.
* * the base values were pseudorandom, all zero but one bit set, or
- * all zero plus a counter that starts at zero.
- *
+ * all zero plus a counter that starts at zero.
+ *
* This does not achieve avalanche. There are input bits of (a,b,c)
* that fail to affect some output bits of (a,b,c), especially of a. The
* most thoroughly mixed value is c, but it doesn't really even achieve
- * avalanche in c.
- *
+ * avalanche in c.
+ *
* This allows some parallelism. Read-after-writes are good at doubling
* the number of bits affected, so the goal of mixing pulls in the opposite
- * direction from the goal of parallelism. I did what I could. Rotates
+ * direction from the goal of parallelism. I did what I could. Rotates
* seem to cost as much as shifts on every machine I could lay my hands on,
* and rotates are much kinder to the top and bottom bits, so I used rotates.
*----------
*/
#define mix(a,b,c) \
{ \
- a -= c; a ^= rot(c, 4); c += b; \
- b -= a; b ^= rot(a, 6); a += c; \
- c -= b; c ^= rot(b, 8); b += a; \
- a -= c; a ^= rot(c,16); c += b; \
- b -= a; b ^= rot(a,19); a += c; \
- c -= b; c ^= rot(b, 4); b += a; \
+ a -= c; a ^= rot(c, 4); c += b; \
+ b -= a; b ^= rot(a, 6); a += c; \
+ c -= b; c ^= rot(b, 8); b += a; \
+ a -= c; a ^= rot(c,16); c += b; \
+ b -= a; b ^= rot(a,19); a += c; \
+ c -= b; c ^= rot(b, 4); b += a; \
}
/*----------
* Pairs of (a,b,c) values differing in only a few bits will usually
* produce values of c that look totally different. This was tested for
* * pairs that differed by one bit, by two bits, in any combination
- * of top bits of (a,b,c), or in any combination of bottom bits of
- * (a,b,c).
+ * of top bits of (a,b,c), or in any combination of bottom bits of
+ * (a,b,c).
* * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- * is commonly produced by subtraction) look like a single 1-bit
- * difference.
+ * the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
+ * is commonly produced by subtraction) look like a single 1-bit
+ * difference.
* * the base values were pseudorandom, all zero but one bit set, or
- * all zero plus a counter that starts at zero.
- *
+ * all zero plus a counter that starts at zero.
+ *
* The use of separate functions for mix() and final() allow for a
* substantial performance increase since final() does not need to
* do well in reverse, but is does need to affect all output bits.
* mix(), on the other hand, does not need to affect all output
- * bits (affecting 32 bits is enough). The original hash function had
+ * bits (affecting 32 bits is enough). The original hash function had
* a single mixing operation that had to satisfy both sets of requirements
* and was slower as a result.
*----------
/* fall through */
case 1:
a += ((uint32) k[0] << 24);
- /* case 0: nothing left to add */
+ /* case 0: nothing left to add */
}
-#else /* !WORDS_BIGENDIAN */
+#else /* !WORDS_BIGENDIAN */
switch (len)
{
case 11:
/* fall through */
case 1:
a += k[0];
- /* case 0: nothing left to add */
+ /* case 0: nothing left to add */
}
-#endif /* WORDS_BIGENDIAN */
+#endif /* WORDS_BIGENDIAN */
}
else
{
a += (k[3] + ((uint32) k[2] << 8) + ((uint32) k[1] << 16) + ((uint32) k[0] << 24));
b += (k[7] + ((uint32) k[6] << 8) + ((uint32) k[5] << 16) + ((uint32) k[4] << 24));
c += (k[11] + ((uint32) k[10] << 8) + ((uint32) k[9] << 16) + ((uint32) k[8] << 24));
-#else /* !WORDS_BIGENDIAN */
+#else /* !WORDS_BIGENDIAN */
a += (k[0] + ((uint32) k[1] << 8) + ((uint32) k[2] << 16) + ((uint32) k[3] << 24));
b += (k[4] + ((uint32) k[5] << 8) + ((uint32) k[6] << 16) + ((uint32) k[7] << 24));
c += (k[8] + ((uint32) k[9] << 8) + ((uint32) k[10] << 16) + ((uint32) k[11] << 24));
-#endif /* WORDS_BIGENDIAN */
+#endif /* WORDS_BIGENDIAN */
mix(a, b, c);
k += 12;
len -= 12;
a += ((uint32) k[1] << 16);
case 1:
a += ((uint32) k[0] << 24);
- /* case 0: nothing left to add */
+ /* case 0: nothing left to add */
}
-#else /* !WORDS_BIGENDIAN */
+#else /* !WORDS_BIGENDIAN */
switch (len) /* all the case statements fall through */
{
case 11:
a += ((uint32) k[1] << 8);
case 1:
a += k[0];
- /* case 0: nothing left to add */
+ /* case 0: nothing left to add */
}
-#endif /* WORDS_BIGENDIAN */
+#endif /* WORDS_BIGENDIAN */
}
final(a, b, c);
/*
* Choose the number of initial bucket pages to match the fill factor
* given the estimated number of tuples. We round up the result to the
- * next power of 2, however, and always force at least 2 bucket pages.
- * The upper limit is determined by considerations explained in
+ * next power of 2, however, and always force at least 2 bucket pages. The
+ * upper limit is determined by considerations explained in
* _hash_expandtable().
*/
dnumbuckets = num_tuples / ffactor;
/*
* We initialize the index with N buckets, 0 .. N-1, occupying physical
- * blocks 1 to N. The first freespace bitmap page is in block N+1.
- * Since N is a power of 2, we can set the masks this way:
+ * blocks 1 to N. The first freespace bitmap page is in block N+1. Since
+ * N is a power of 2, we can set the masks this way:
*/
metap->hashm_maxbucket = metap->hashm_lowmask = num_buckets - 1;
metap->hashm_highmask = (num_buckets << 1) - 1;
/*
* Release buffer lock on the metapage while we initialize buckets.
* Otherwise, we'll be in interrupt holdoff and the CHECK_FOR_INTERRUPTS
- * won't accomplish anything. It's a bad idea to hold buffer locks
- * for long intervals in any case, since that can block the bgwriter.
+ * won't accomplish anything. It's a bad idea to hold buffer locks for
+ * long intervals in any case, since that can block the bgwriter.
*/
_hash_chgbufaccess(rel, metabuf, HASH_WRITE, HASH_NOLOCK);
* _hash_alloc_buckets() would fail, but if we supported buckets smaller
* than a disk block then this would be an independent constraint.
*
- * If you change this, see also the maximum initial number of buckets
- * in _hash_metapinit().
+ * If you change this, see also the maximum initial number of buckets in
+ * _hash_metapinit().
*/
if (metap->hashm_maxbucket >= (uint32) 0x7FFFFFFE)
goto fail;
}
/*
- * Fetch the item's hash key (conveniently stored in the item)
- * and determine which bucket it now belongs in.
+ * Fetch the item's hash key (conveniently stored in the item) and
+ * determine which bucket it now belongs in.
*/
itup = (IndexTuple) PageGetItem(opage, PageGetItemId(opage, ooffnum));
bucket = _hash_hashkey2bucket(_hash_get_indextuple_hashkey(itup),
/*
* Release all HashScanList items belonging to the current ResourceOwner.
* Note that we do not release the underlying IndexScanDesc; that's in
- * executor memory and will go away on its own (in fact quite possibly
- * has gone away already, so we mustn't try to touch it here).
+ * executor memory and will go away on its own (in fact quite possibly has
+ * gone away already, so we mustn't try to touch it here).
*
* Note: this should be a no-op during normal query shutdown. However, in
* an abort situation ExecutorEnd is not called and so there may be open
for (;;)
{
/*
- * check if we're still in the range of items with
- * the target hash key
+ * check if we're still in the range of items with the
+ * target hash key
*/
if (offnum <= maxoff)
{
Assert(offnum >= FirstOffsetNumber);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
if (so->hashso_sk_hash == _hash_get_indextuple_hashkey(itup))
- break; /* yes, so exit for-loop */
+ break; /* yes, so exit for-loop */
}
/*
for (;;)
{
/*
- * check if we're still in the range of items with
- * the target hash key
+ * check if we're still in the range of items with the
+ * target hash key
*/
if (offnum >= FirstOffsetNumber)
{
Assert(offnum <= maxoff);
itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
if (so->hashso_sk_hash == _hash_get_indextuple_hashkey(itup))
- break; /* yes, so exit for-loop */
+ break; /* yes, so exit for-loop */
}
/*
* thrashing. We use tuplesort.c to sort the given index tuples into order.
*
* Note: if the number of rows in the table has been underestimated,
- * bucket splits may occur during the index build. In that case we'd
+ * bucket splits may occur during the index build. In that case we'd
* be inserting into two or more buckets for each possible masked-off
* hash code value. That's no big problem though, since we'll still have
* plenty of locality of access.
hspool->index = index;
/*
- * Determine the bitmask for hash code values. Since there are currently
+ * Determine the bitmask for hash code values. Since there are currently
* num_buckets buckets in the index, the appropriate mask can be computed
* as follows.
*
- * Note: at present, the passed-in num_buckets is always a power of 2,
- * so we could just compute num_buckets - 1. We prefer not to assume
- * that here, though.
+ * Note: at present, the passed-in num_buckets is always a power of 2, so
+ * we could just compute num_buckets - 1. We prefer not to assume that
+ * here, though.
*/
hash_mask = (((uint32) 1) << _hash_log2(num_buckets)) - 1;
_hash_checkqual(IndexScanDesc scan, IndexTuple itup)
{
/*
- * Currently, we can't check any of the scan conditions since we do
- * not have the original index entry value to supply to the sk_func.
- * Always return true; we expect that hashgettuple already set the
- * recheck flag to make the main indexscan code do it.
+ * Currently, we can't check any of the scan conditions since we do not
+ * have the original index entry value to supply to the sk_func. Always
+ * return true; we expect that hashgettuple already set the recheck flag
+ * to make the main indexscan code do it.
*/
#ifdef NOT_USED
TupleDesc tupdesc = RelationGetDescr(scan->indexRelation);
char *attp;
/*
- * We assume the hash key is the first attribute and can't be null,
- * so this can be done crudely but very very cheaply ...
+ * We assume the hash key is the first attribute and can't be null, so
+ * this can be done crudely but very very cheaply ...
*/
attp = (char *) itup + IndexInfoFindDataOffset(itup->t_info);
return *((uint32 *) attp);
IndexTuple
_hash_form_tuple(Relation index, Datum *values, bool *isnull)
{
- IndexTuple itup;
- uint32 hashkey;
- Datum hashkeydatum;
- TupleDesc hashdesc;
+ IndexTuple itup;
+ uint32 hashkey;
+ Datum hashkeydatum;
+ TupleDesc hashdesc;
if (isnull[0])
hashkeydatum = (Datum) 0;
*
* Returns the offset of the first index entry having hashkey >= hash_value,
* or the page's max offset plus one if hash_value is greater than all
- * existing hash keys in the page. This is the appropriate place to start
+ * existing hash keys in the page. This is the appropriate place to start
* a search, or to insert a new item.
*/
OffsetNumber
_hash_binsearch(Page page, uint32 hash_value)
{
- OffsetNumber upper;
- OffsetNumber lower;
+ OffsetNumber upper;
+ OffsetNumber lower;
/* Loop invariant: lower <= desired place <= upper */
upper = PageGetMaxOffsetNumber(page) + 1;
while (upper > lower)
{
- OffsetNumber off;
- IndexTuple itup;
- uint32 hashkey;
+ OffsetNumber off;
+ IndexTuple itup;
+ uint32 hashkey;
off = (upper + lower) / 2;
Assert(OffsetNumberIsValid(off));
OffsetNumber
_hash_binsearch_last(Page page, uint32 hash_value)
{
- OffsetNumber upper;
- OffsetNumber lower;
+ OffsetNumber upper;
+ OffsetNumber lower;
/* Loop invariant: lower <= desired place <= upper */
upper = PageGetMaxOffsetNumber(page);
while (upper > lower)
{
- IndexTuple itup;
- OffsetNumber off;
- uint32 hashkey;
+ IndexTuple itup;
+ OffsetNumber off;
+ uint32 hashkey;
off = (upper + lower + 1) / 2;
Assert(OffsetNumberIsValid(off));
/* GUC variable */
-bool synchronize_seqscans = true;
+bool synchronize_seqscans = true;
static HeapScanDesc heap_beginscan_internal(Relation relation,
* strategy and enable synchronized scanning (see syncscan.c). Although
* the thresholds for these features could be different, we make them the
* same so that there are only two behaviors to tune rather than four.
- * (However, some callers need to be able to disable one or both of
- * these behaviors, independently of the size of the table; also there
- * is a GUC variable that can disable synchronized scanning.)
+ * (However, some callers need to be able to disable one or both of these
+ * behaviors, independently of the size of the table; also there is a GUC
+ * variable that can disable synchronized scanning.)
*
* During a rescan, don't make a new strategy object if we don't have to.
*/
if (is_rescan)
{
/*
- * If rescan, keep the previous startblock setting so that rewinding
- * a cursor doesn't generate surprising results. Reset the syncscan
+ * If rescan, keep the previous startblock setting so that rewinding a
+ * cursor doesn't generate surprising results. Reset the syncscan
* setting, though.
*/
scan->rs_syncscan = (allow_sync && synchronize_seqscans);
FreeBulkInsertState(BulkInsertState bistate)
{
if (bistate->current_buf != InvalidBuffer)
- ReleaseBuffer(bistate->current_buf);
+ ReleaseBuffer(bistate->current_buf);
FreeAccessStrategy(bistate->strategy);
pfree(bistate);
}
/* Clear the bit in the visibility map if necessary */
if (all_visible_cleared)
- visibilitymap_clear(relation,
+ visibilitymap_clear(relation,
ItemPointerGetBlockNumber(&(heaptup->t_self)));
/*
LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
/*
- * Don't update the visibility map here. Locking a tuple doesn't
- * change visibility info.
+ * Don't update the visibility map here. Locking a tuple doesn't change
+ * visibility info.
*/
/*
nowunused, nunused,
clean_move);
- freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
+ freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
/*
- * Note: we don't worry about updating the page's prunability hints.
- * At worst this will cause an extra prune cycle to occur soon.
+ * Note: we don't worry about updating the page's prunability hints. At
+ * worst this will cause an extra prune cycle to occur soon.
*/
PageSetLSN(page, lsn);
OffsetNumber offnum;
ItemId lp = NULL;
HeapTupleHeader htup;
- BlockNumber blkno;
+ BlockNumber blkno;
blkno = ItemPointerGetBlockNumber(&(xlrec->target.tid));
/*
- * The visibility map always needs to be updated, even if the heap page
- * is already up-to-date.
+ * The visibility map always needs to be updated, even if the heap page is
+ * already up-to-date.
*/
if (xlrec->all_visible_cleared)
{
- Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+ Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+
visibilitymap_clear(reln, blkno);
FreeFakeRelcacheEntry(reln);
}
xl_heap_header xlhdr;
uint32 newlen;
Size freespace;
- BlockNumber blkno;
+ BlockNumber blkno;
blkno = ItemPointerGetBlockNumber(&(xlrec->target.tid));
/*
- * The visibility map always needs to be updated, even if the heap page
- * is already up-to-date.
+ * The visibility map always needs to be updated, even if the heap page is
+ * already up-to-date.
*/
if (xlrec->all_visible_cleared)
{
- Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+ Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+
visibilitymap_clear(reln, blkno);
FreeFakeRelcacheEntry(reln);
}
if (offnum == InvalidOffsetNumber)
elog(PANIC, "heap_insert_redo: failed to add tuple");
- freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
+ freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
PageSetLSN(page, lsn);
PageSetTLI(page, ThisTimeLineID);
/*
* If the page is running low on free space, update the FSM as well.
- * Arbitrarily, our definition of "low" is less than 20%. We can't do
- * much better than that without knowing the fill-factor for the table.
+ * Arbitrarily, our definition of "low" is less than 20%. We can't do much
+ * better than that without knowing the fill-factor for the table.
*
* XXX: We don't get here if the page was restored from full page image.
* We don't bother to update the FSM in that case, it doesn't need to be
Size freespace;
/*
- * The visibility map always needs to be updated, even if the heap page
- * is already up-to-date.
+ * The visibility map always needs to be updated, even if the heap page is
+ * already up-to-date.
*/
if (xlrec->all_visible_cleared)
{
- Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+ Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+
visibilitymap_clear(reln,
ItemPointerGetBlockNumber(&xlrec->target.tid));
FreeFakeRelcacheEntry(reln);
newt:;
/*
- * The visibility map always needs to be updated, even if the heap page
- * is already up-to-date.
+ * The visibility map always needs to be updated, even if the heap page is
+ * already up-to-date.
*/
if (xlrec->new_all_visible_cleared)
{
- Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+ Relation reln = CreateFakeRelcacheEntry(xlrec->target.node);
+
visibilitymap_clear(reln, ItemPointerGetBlockNumber(&xlrec->newtid));
FreeFakeRelcacheEntry(reln);
}
if (xlrec->new_all_visible_cleared)
PageClearAllVisible(page);
- freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
+ freespace = PageGetHeapFreeSpace(page); /* needed to update FSM below */
PageSetLSN(page, lsn);
PageSetTLI(page, ThisTimeLineID);
/*
* If the page is running low on free space, update the FSM as well.
- * Arbitrarily, our definition of "low" is less than 20%. We can't do
- * much better than that without knowing the fill-factor for the table.
+ * Arbitrarily, our definition of "low" is less than 20%. We can't do much
+ * better than that without knowing the fill-factor for the table.
*
* However, don't update the FSM on HOT updates, because after crash
* recovery, either the old or the new tuple will certainly be dead and
*/
if (!hot_update && freespace < BLCKSZ / 5)
XLogRecordPageWithFreeSpace(xlrec->target.node,
- ItemPointerGetBlockNumber(&(xlrec->newtid)), freespace);
+ ItemPointerGetBlockNumber(&(xlrec->newtid)), freespace);
}
static void
ReadBufferBI(Relation relation, BlockNumber targetBlock,
BulkInsertState bistate)
{
- Buffer buffer;
+ Buffer buffer;
/* If not bulk-insert, exactly like ReadBuffer */
if (!bistate)
* happen if space is freed in that page after heap_update finds there's not
* enough there). In that case, the page will be pinned and locked only once.
*
- * We normally use FSM to help us find free space. However,
+ * We normally use FSM to help us find free space. However,
* if HEAP_INSERT_SKIP_FSM is specified, we just append a new empty page to
* the end of the relation if the tuple won't fit on the current target page.
* This can save some cycles when we know the relation is new and doesn't
* for additional constraints needed for safe usage of this behavior.)
*
* The caller can also provide a BulkInsertState object to optimize many
- * insertions into the same relation. This keeps a pin on the current
+ * insertions into the same relation. This keeps a pin on the current
* insertion target page (to save pin/unpin cycles) and also passes a
* BULKWRITE buffer selection strategy object to the buffer manager.
* Passing NULL for bistate selects the default behavior.
/*
* We first try to put the tuple on the same page we last inserted a tuple
- * on, as cached in the BulkInsertState or relcache entry. If that
+ * on, as cached in the BulkInsertState or relcache entry. If that
* doesn't work, we ask the Free Space Map to locate a suitable page.
* Since the FSM's info might be out of date, we have to be prepared to
* loop around and retry multiple times. (To insure this isn't an infinite
typedef struct
{
TransactionId new_prune_xid; /* new prune hint value for page */
- int nredirected; /* numbers of entries in arrays below */
+ int nredirected; /* numbers of entries in arrays below */
int ndead;
int nunused;
/* arrays that accumulate indexes of items to be changed */
/*
* Our strategy is to scan the page and make lists of items to change,
- * then apply the changes within a critical section. This keeps as
- * much logic as possible out of the critical section, and also ensures
- * that WAL replay will work the same as the normal case.
+ * then apply the changes within a critical section. This keeps as much
+ * logic as possible out of the critical section, and also ensures that
+ * WAL replay will work the same as the normal case.
*
- * First, inform inval.c that upcoming CacheInvalidateHeapTuple calls
- * are nontransactional.
+ * First, inform inval.c that upcoming CacheInvalidateHeapTuple calls are
+ * nontransactional.
*/
if (redirect_move)
BeginNonTransactionalInvalidation();
/*
- * Initialize the new pd_prune_xid value to zero (indicating no
- * prunable tuples). If we find any tuples which may soon become
- * prunable, we will save the lowest relevant XID in new_prune_xid.
- * Also initialize the rest of our working state.
+ * Initialize the new pd_prune_xid value to zero (indicating no prunable
+ * tuples). If we find any tuples which may soon become prunable, we will
+ * save the lowest relevant XID in new_prune_xid. Also initialize the rest
+ * of our working state.
*/
prstate.new_prune_xid = InvalidTransactionId;
prstate.nredirected = prstate.ndead = prstate.nunused = 0;
}
/*
- * Send invalidation messages for any tuples we are about to move.
- * It is safe to do this now, even though we could theoretically still
- * fail before making the actual page update, because a useless cache
+ * Send invalidation messages for any tuples we are about to move. It is
+ * safe to do this now, even though we could theoretically still fail
+ * before making the actual page update, because a useless cache
* invalidation doesn't hurt anything. Also, no one else can reload the
* tuples while we have exclusive buffer lock, so it's not too early to
* send the invals. This avoids sending the invals while inside the
if (prstate.nredirected > 0 || prstate.ndead > 0 || prstate.nunused > 0)
{
/*
- * Apply the planned item changes, then repair page fragmentation,
- * and update the page's hint bit about whether it has free line
- * pointers.
+ * Apply the planned item changes, then repair page fragmentation, and
+ * update the page's hint bit about whether it has free line pointers.
*/
heap_page_prune_execute(buffer,
prstate.redirected, prstate.nredirected,
{
/*
* If we didn't prune anything, but have found a new value for the
- * pd_prune_xid field, update it and mark the buffer dirty.
- * This is treated as a non-WAL-logged hint.
+ * pd_prune_xid field, update it and mark the buffer dirty. This is
+ * treated as a non-WAL-logged hint.
*
* Also clear the "page is full" flag if it is set, since there's no
* point in repeating the prune/defrag process until something else
* OldestXmin is the cutoff XID used to identify dead tuples.
*
* We don't actually change the page here, except perhaps for hint-bit updates
- * caused by HeapTupleSatisfiesVacuum. We just add entries to the arrays in
- * prstate showing the changes to be made. Items to be redirected are added
+ * caused by HeapTupleSatisfiesVacuum. We just add entries to the arrays in
+ * prstate showing the changes to be made. Items to be redirected are added
* to the redirected[] array (two entries per redirection); items to be set to
* LP_DEAD state are added to nowdead[]; and items to be set to LP_UNUSED
* state are added to nowunused[].
else if (redirect_move && ItemIdIsRedirected(rootlp))
{
/*
- * If we desire to eliminate LP_REDIRECT items by moving tuples,
- * make a redirection entry for each redirected root item; this
- * will cause heap_page_prune_execute to actually do the move.
- * (We get here only when there are no DEAD tuples in the chain;
- * otherwise the redirection entry was made above.)
+ * If we desire to eliminate LP_REDIRECT items by moving tuples, make
+ * a redirection entry for each redirected root item; this will cause
+ * heap_page_prune_execute to actually do the move. (We get here only
+ * when there are no DEAD tuples in the chain; otherwise the
+ * redirection entry was made above.)
*/
heap_prune_record_redirect(prstate, rootoffnum, chainitems[1]);
redirect_target = chainitems[1];
}
/*
- * If we are going to implement a redirect by moving tuples, we have
- * to issue a cache invalidation against the redirection target tuple,
+ * If we are going to implement a redirect by moving tuples, we have to
+ * issue a cache invalidation against the redirection target tuple,
* because its CTID will be effectively changed by the move. Note that
* CacheInvalidateHeapTuple only queues the request, it doesn't send it;
* if we fail before reaching EndNonTransactionalInvalidation, nothing
* buffer, and is inside a critical section.
*
* This is split out because it is also used by heap_xlog_clean()
- * to replay the WAL record when needed after a crash. Note that the
+ * to replay the WAL record when needed after a crash. Note that the
* arguments are identical to those of log_heap_clean().
*/
void
heaptup = toast_insert_or_update(state->rs_new_rel, tup, NULL,
HEAP_INSERT_SKIP_FSM |
(state->rs_use_wal ?
- 0 : HEAP_INSERT_SKIP_WAL));
+ 0 : HEAP_INSERT_SKIP_WAL));
else
heaptup = tup;
Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
/*
- * No point in wasting a palloc cycle if value size is out of the
- * allowed range for compression
+ * No point in wasting a palloc cycle if value size is out of the allowed
+ * range for compression
*/
if (valsize < PGLZ_strategy_default->min_input_size ||
valsize > PGLZ_strategy_default->max_input_size)
* because it might be satisfied with having saved as little as one byte
* in the compressed data --- which could turn into a net loss once you
* consider header and alignment padding. Worst case, the compressed
- * format might require three padding bytes (plus header, which is included
- * in VARSIZE(tmp)), whereas the uncompressed format would take only one
- * header byte and no padding if the value is short enough. So we insist
- * on a savings of more than 2 bytes to ensure we have a gain.
+ * format might require three padding bytes (plus header, which is
+ * included in VARSIZE(tmp)), whereas the uncompressed format would take
+ * only one header byte and no padding if the value is short enough. So
+ * we insist on a savings of more than 2 bytes to ensure we have a gain.
*/
if (pglz_compress(VARDATA_ANY(DatumGetPointer(value)), valsize,
(PGLZ_Header *) tmp, PGLZ_strategy_default) &&
struct
{
struct varlena hdr;
- char data[TOAST_MAX_CHUNK_SIZE]; /* make struct big enough */
+ char data[TOAST_MAX_CHUNK_SIZE]; /* make struct big enough */
int32 align_it; /* ensure struct is aligned well enough */
} chunk_data;
int32 chunk_size;
/*
* Find all the chunks. (We don't actually care whether we see them in
- * sequence or not, but since we've already locked the index we might
- * as well use systable_beginscan_ordered.)
+ * sequence or not, but since we've already locked the index we might as
+ * well use systable_beginscan_ordered.)
*/
toastscan = systable_beginscan_ordered(toastrel, toastidx,
SnapshotToast, 1, &toastkey);
*/
nextidx = startchunk;
toastscan = systable_beginscan_ordered(toastrel, toastidx,
- SnapshotToast, nscankeys, toastkey);
+ SnapshotToast, nscankeys, toastkey);
while ((ttup = systable_getnext_ordered(toastscan, ForwardScanDirection)) != NULL)
{
/*
* $PostgreSQL$
*
* INTERFACE ROUTINES
- * visibilitymap_clear - clear a bit in the visibility map
+ * visibilitymap_clear - clear a bit in the visibility map
* visibilitymap_pin - pin a map page for setting a bit
* visibilitymap_set - set a bit in a previously pinned page
* visibilitymap_test - test if a bit is set
mapBuffer = vm_readbuf(rel, mapBlock, false);
if (!BufferIsValid(mapBuffer))
- return; /* nothing to do */
+ return; /* nothing to do */
LockBuffer(mapBuffer, BUFFER_LOCK_EXCLUSIVE);
map = PageGetContents(BufferGetPage(mapBuffer));
visibilitymap_truncate(Relation rel, BlockNumber nheapblocks)
{
BlockNumber newnblocks;
+
/* last remaining block, byte, and bit */
BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
- uint32 truncByte = HEAPBLK_TO_MAPBYTE(nheapblocks);
- uint8 truncBit = HEAPBLK_TO_MAPBIT(nheapblocks);
+ uint32 truncByte = HEAPBLK_TO_MAPBYTE(nheapblocks);
+ uint8 truncBit = HEAPBLK_TO_MAPBIT(nheapblocks);
#ifdef TRACE_VISIBILITYMAP
elog(DEBUG1, "vm_truncate %s %d", RelationGetRelationName(rel), nheapblocks);
* Unless the new size is exactly at a visibility map page boundary, the
* tail bits in the last remaining map page, representing truncated heap
* blocks, need to be cleared. This is not only tidy, but also necessary
- * because we don't get a chance to clear the bits if the heap is
- * extended again.
+ * because we don't get a chance to clear the bits if the heap is extended
+ * again.
*/
if (truncByte != 0 || truncBit != 0)
{
- Buffer mapBuffer;
- Page page;
- char *map;
+ Buffer mapBuffer;
+ Page page;
+ char *map;
newnblocks = truncBlock + 1;
/*
* Mask out the unwanted bits of the last remaining byte.
*
- * ((1 << 0) - 1) = 00000000
- * ((1 << 1) - 1) = 00000001
- * ...
- * ((1 << 6) - 1) = 00111111
- * ((1 << 7) - 1) = 01111111
+ * ((1 << 0) - 1) = 00000000 ((1 << 1) - 1) = 00000001 ... ((1 << 6) -
+ * 1) = 00111111 ((1 << 7) - 1) = 01111111
*/
map[truncByte] &= (1 << truncBit) - 1;
rel->rd_istemp);
/*
- * Need to invalidate the relcache entry, because rd_vm_nblocks
- * seen by other backends is no longer valid.
+ * Need to invalidate the relcache entry, because rd_vm_nblocks seen by
+ * other backends is no longer valid.
*/
if (!InRecovery)
CacheInvalidateRelcache(rel);
static Buffer
vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
{
- Buffer buf;
+ Buffer buf;
RelationOpenSmgr(rel);
vm_extend(Relation rel, BlockNumber vm_nblocks)
{
BlockNumber vm_nblocks_now;
- Page pg;
+ Page pg;
pg = (Page) palloc(BLCKSZ);
PageInit(pg, BLCKSZ, 0);
/*
- * We use the relation extension lock to lock out other backends trying
- * to extend the visibility map at the same time. It also locks out
- * extension of the main fork, unnecessarily, but extending the
- * visibility map happens seldom enough that it doesn't seem worthwhile to
- * have a separate lock tag type for it.
+ * We use the relation extension lock to lock out other backends trying to
+ * extend the visibility map at the same time. It also locks out extension
+ * of the main fork, unnecessarily, but extending the visibility map
+ * happens seldom enough that it doesn't seem worthwhile to have a
+ * separate lock tag type for it.
*
- * Note that another backend might have extended or created the
- * relation before we get the lock.
+ * Note that another backend might have extended or created the relation
+ * before we get the lock.
*/
LockRelationForExtension(rel, ExclusiveLock);
/* Change attribute numbers to be index column numbers. */
for (i = 0; i < nkeys; i++)
{
- int j;
+ int j;
for (j = 0; j < irel->rd_index->indnatts; j++)
{
if (sysscan->irel)
{
htup = index_getnext(sysscan->iscan, ForwardScanDirection);
+
/*
- * We currently don't need to support lossy index operators for
- * any system catalog scan. It could be done here, using the
- * scan keys to drive the operator calls, if we arranged to save
- * the heap attnums during systable_beginscan(); this is practical
- * because we still wouldn't need to support indexes on expressions.
+ * We currently don't need to support lossy index operators for any
+ * system catalog scan. It could be done here, using the scan keys to
+ * drive the operator calls, if we arranged to save the heap attnums
+ * during systable_beginscan(); this is practical because we still
+ * wouldn't need to support indexes on expressions.
*/
if (htup && sysscan->iscan->xs_recheck)
elog(ERROR, "system catalog scans with lossy index conditions are not implemented");
* index order. Also, for largely historical reasons, the index to use
* is opened and locked by the caller, not here.
*
- * Currently we do not support non-index-based scans here. (In principle
+ * Currently we do not support non-index-based scans here. (In principle
* we could do a heapscan and sort, but the uses are in places that
* probably don't need to still work with corrupted catalog indexes.)
* For the moment, therefore, these functions are merely the thinnest of
/* Change attribute numbers to be index column numbers. */
for (i = 0; i < nkeys; i++)
{
- int j;
+ int j;
for (j = 0; j < indexRelation->rd_index->indnatts; j++)
{
* index_markpos - mark a scan position
* index_restrpos - restore a scan position
* index_getnext - get the next tuple from a scan
- * index_getbitmap - get all tuples from a scan
+ * index_getbitmap - get all tuples from a scan
* index_bulk_delete - bulk deletion of index tuples
* index_vacuum_cleanup - post-deletion cleanup of an index
* index_getprocid - get a support procedure OID
/*
* The AM's gettuple proc finds the next index entry matching the
- * scan keys, and puts the TID in xs_ctup.t_self (ie, *tid).
- * It should also set scan->xs_recheck, though we pay no
- * attention to that here.
+ * scan keys, and puts the TID in xs_ctup.t_self (ie, *tid). It
+ * should also set scan->xs_recheck, though we pay no attention to
+ * that here.
*/
found = DatumGetBool(FunctionCall2(procedure,
PointerGetDatum(scan),
* removing any LP_DEAD tuples.
*
* On entry, *buf and *offsetptr point to the first legal position
- * where the new tuple could be inserted. The caller should hold an
+ * where the new tuple could be inserted. The caller should hold an
* exclusive lock on *buf. *offsetptr can also be set to
* InvalidOffsetNumber, in which case the function will search for the
* right location within the page if needed. On exit, they point to the
sopaque = (BTPageOpaque) PageGetSpecialPointer(spage);
if (sopaque->btpo_prev != ropaque->btpo_prev)
elog(PANIC, "right sibling's left-link doesn't match: "
- "block %u links to %u instead of expected %u in index \"%s\"",
+ "block %u links to %u instead of expected %u in index \"%s\"",
ropaque->btpo_next, sopaque->btpo_prev, ropaque->btpo_prev,
RelationGetRelationName(rel));
btgetbitmap(PG_FUNCTION_ARGS)
{
IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0);
- TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
+ TIDBitmap *tbm = (TIDBitmap *) PG_GETARG_POINTER(1);
BTScanOpaque so = (BTScanOpaque) scan->opaque;
int64 ntids = 0;
ItemPointer heapTid;
/*
* During a non-FULL vacuum it's quite possible for us to be fooled by
* concurrent page splits into double-counting some index tuples, so
- * disbelieve any total that exceeds the underlying heap's count ...
- * if we know that accurately. Otherwise this might just make matters
- * worse.
+ * disbelieve any total that exceeds the underlying heap's count ... if we
+ * know that accurately. Otherwise this might just make matters worse.
*/
if (!info->vacuum_full && !info->estimated_count)
{
_bt_restore_page(rpage, datapos, datalen);
/*
- * On leaf level, the high key of the left page is equal to the
- * first key on the right page.
+ * On leaf level, the high key of the left page is equal to the first key
+ * on the right page.
*/
if (xlrec->level == 0)
{
buf = XLogReadBuffer(action->node, action->delblk, false);
if (BufferIsValid(buf))
{
- Relation reln;
+ Relation reln;
reln = CreateFakeRelcacheEntry(action->node);
if (_bt_pagedel(reln, buf, NULL, true) == 0)
static void WriteZeroPageXlogRec(int pageno);
static void WriteTruncateXlogRec(int pageno);
static void TransactionIdSetPageStatus(TransactionId xid, int nsubxids,
- TransactionId *subxids, XidStatus status,
+ TransactionId *subxids, XidStatus status,
XLogRecPtr lsn, int pageno);
static void TransactionIdSetStatusBit(TransactionId xid, XidStatus status,
XLogRecPtr lsn, int slotno);
* the same CLOG page as xid. If they all are, then the lock will be grabbed
* only once, and the status will be set to committed directly. Otherwise
* we must
- * 1. set sub-committed all subxids that are not on the same page as the
- * main xid
- * 2. atomically set committed the main xid and the subxids on the same page
- * 3. go over the first bunch again and set them committed
+ * 1. set sub-committed all subxids that are not on the same page as the
+ * main xid
+ * 2. atomically set committed the main xid and the subxids on the same page
+ * 3. go over the first bunch again and set them committed
* Note that as far as concurrent checkers are concerned, main transaction
* commit as a whole is still atomic.
*
* page2: set t2,t3 as sub-committed
* page3: set t4 as sub-committed
* 2. update page1:
- * set t1 as sub-committed,
+ * set t1 as sub-committed,
* then set t as committed,
then set t1 as committed
* 3. update pages2-3:
* page2: set t2,t3 as committed
* page3: set t4 as committed
- *
+ *
* NB: this is a low-level routine and is NOT the preferred entry point
* for most uses; functions in transam.c are the intended callers.
*
*/
void
TransactionIdSetTreeStatus(TransactionId xid, int nsubxids,
- TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
+ TransactionId *subxids, XidStatus status, XLogRecPtr lsn)
{
- int pageno = TransactionIdToPage(xid); /* get page of parent */
- int i;
+ int pageno = TransactionIdToPage(xid); /* get page of parent */
+ int i;
Assert(status == TRANSACTION_STATUS_COMMITTED ||
status == TRANSACTION_STATUS_ABORTED);
/*
- * See how many subxids, if any, are on the same page as the parent, if any.
+ * See how many subxids, if any, are on the same page as the parent, if
+ * any.
*/
for (i = 0; i < nsubxids; i++)
{
}
else
{
- int nsubxids_on_first_page = i;
+ int nsubxids_on_first_page = i;
/*
* If this is a commit then we care about doing this correctly (i.e.
- * using the subcommitted intermediate status). By here, we know we're
- * updating more than one page of clog, so we must mark entries that
- * are *not* on the first page so that they show as subcommitted before
- * we then return to update the status to fully committed.
+ * using the subcommitted intermediate status). By here, we know
+ * we're updating more than one page of clog, so we must mark entries
+ * that are *not* on the first page so that they show as subcommitted
+ * before we then return to update the status to fully committed.
*
* To avoid touching the first page twice, skip marking subcommitted
* for the subxids on that first page.
set_status_by_pages(int nsubxids, TransactionId *subxids,
XidStatus status, XLogRecPtr lsn)
{
- int pageno = TransactionIdToPage(subxids[0]);
- int offset = 0;
- int i = 0;
+ int pageno = TransactionIdToPage(subxids[0]);
+ int offset = 0;
+ int i = 0;
while (i < nsubxids)
{
- int num_on_page = 0;
+ int num_on_page = 0;
while (TransactionIdToPage(subxids[i]) == pageno && i < nsubxids)
{
XLogRecPtr lsn, int pageno)
{
int slotno;
- int i;
+ int i;
Assert(status == TRANSACTION_STATUS_COMMITTED ||
status == TRANSACTION_STATUS_ABORTED ||
*
* If we update more than one xid on this page while it is being written
* out, we might find that some of the bits go to disk and others don't.
- * If we are updating commits on the page with the top-level xid that could
- * break atomicity, so we subcommit the subxids first before we mark the
- * top-level commit.
+ * If we are updating commits on the page with the top-level xid that
+ * could break atomicity, so we subcommit the subxids first before we mark
+ * the top-level commit.
*/
if (TransactionIdIsValid(xid))
{
curval == TRANSACTION_STATUS_COMMITTED)
return;
- /*
+ /*
* Current state change should be from 0 or subcommitted to target state
* or we should already be there when replaying changes during recovery.
*/
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("prepared transactions are disabled"),
- errhint("Set max_prepared_transactions to a nonzero value.")));
+ errhint("Set max_prepared_transactions to a nonzero value.")));
LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
*
* "used" must be TRUE if the caller intends to use the command ID to mark
* inserted/updated/deleted tuples. FALSE means the ID is being fetched
- * for read-only purposes (ie, as a snapshot validity cutoff). See
+ * for read-only purposes (ie, as a snapshot validity cutoff). See
* CommandCounterIncrement() for discussion.
*/
CommandId
*/
for (s = CurrentTransactionState; s != NULL; s = s->parent)
{
- int low, high;
+ int low,
+ high;
if (s->state == TRANS_ABORT)
continue;
high = s->nChildXids - 1;
while (low <= high)
{
- int middle;
- TransactionId probe;
+ int middle;
+ TransactionId probe;
middle = low + (high - low) / 2;
probe = s->childXids[middle];
CommandCounterIncrement(void)
{
/*
- * If the current value of the command counter hasn't been "used" to
- * mark tuples, we need not increment it, since there's no need to
- * distinguish a read-only command from others. This helps postpone
- * command counter overflow, and keeps no-op CommandCounterIncrement
- * operations cheap.
+ * If the current value of the command counter hasn't been "used" to mark
+ * tuples, we need not increment it, since there's no need to distinguish
+ * a read-only command from others. This helps postpone command counter
+ * overflow, and keeps no-op CommandCounterIncrement operations cheap.
*/
if (currentCommandIdUsed)
{
currentCommandId += 1;
- if (currentCommandId == FirstCommandId) /* check for overflow */
+ if (currentCommandId == FirstCommandId) /* check for overflow */
{
currentCommandId -= 1;
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("cannot have more than 2^32-1 commands in a transaction")));
+ errmsg("cannot have more than 2^32-1 commands in a transaction")));
}
currentCommandIdUsed = false;
/* Propagate new command ID into static snapshots */
SnapshotSetCommandId(currentCommandId);
-
+
/*
- * Make any catalog changes done by the just-completed command
- * visible in the local syscache. We obviously don't need to do
- * this after a read-only command. (But see hacks in inval.c
- * to make real sure we don't think a command that queued inval
- * messages was read-only.)
+ * Make any catalog changes done by the just-completed command visible
+ * in the local syscache. We obviously don't need to do this after a
+ * read-only command. (But see hacks in inval.c to make real sure we
+ * don't think a command that queued inval messages was read-only.)
*/
AtCommit_LocalCache();
}
/*
* Make any other backends' catalog changes visible to me.
*
- * XXX this is probably in the wrong place: CommandCounterIncrement
- * should be purely a local operation, most likely. However fooling
- * with this will affect asynchronous cross-backend interactions,
- * which doesn't seem like a wise thing to do in late beta, so save
- * improving this for another day - tgl 2007-11-30
+ * XXX this is probably in the wrong place: CommandCounterIncrement should
+ * be purely a local operation, most likely. However fooling with this
+ * will affect asynchronous cross-backend interactions, which doesn't seem
+ * like a wise thing to do in late beta, so save improving this for
+ * another day - tgl 2007-11-30
*/
AtStart_Cache();
}
/* Allocate or enlarge the parent array if necessary */
if (s->parent->maxChildXids < new_nChildXids)
{
- int new_maxChildXids;
- TransactionId *new_childXids;
+ int new_maxChildXids;
+ TransactionId *new_childXids;
/*
* Make it 2x what's needed right now, to avoid having to enlarge it
- * repeatedly. But we can't go above MaxAllocSize. (The latter
- * limit is what ensures that we don't need to worry about integer
- * overflow here or in the calculation of new_nChildXids.)
+ * repeatedly. But we can't go above MaxAllocSize. (The latter limit
+ * is what ensures that we don't need to worry about integer overflow
+ * here or in the calculation of new_nChildXids.)
*/
new_maxChildXids = Min(new_nChildXids * 2,
(int) (MaxAllocSize / sizeof(TransactionId)));
*/
if (s->parent->childXids == NULL)
new_childXids =
- MemoryContextAlloc(TopTransactionContext,
+ MemoryContextAlloc(TopTransactionContext,
new_maxChildXids * sizeof(TransactionId));
else
- new_childXids = repalloc(s->parent->childXids,
- new_maxChildXids * sizeof(TransactionId));
+ new_childXids = repalloc(s->parent->childXids,
+ new_maxChildXids * sizeof(TransactionId));
- s->parent->childXids = new_childXids;
+ s->parent->childXids = new_childXids;
s->parent->maxChildXids = new_maxChildXids;
}
*
* Note: We rely on the fact that the XID of a child always follows that
* of its parent. By copying the XID of this subtransaction before the
- * XIDs of its children, we ensure that the array stays ordered. Likewise,
- * all XIDs already in the array belong to subtransactions started and
- * subcommitted before us, so their XIDs must precede ours.
+ * XIDs of its children, we ensure that the array stays ordered.
+ * Likewise, all XIDs already in the array belong to subtransactions
+ * started and subcommitted before us, so their XIDs must precede ours.
*/
s->parent->childXids[s->parent->nChildXids] = s->transactionId;
/* NOTIFY and flatfiles will be handled below */
/*
- * Don't allow PREPARE TRANSACTION if we've accessed a temporary table
- * in this transaction. Having the prepared xact hold locks on another
+ * Don't allow PREPARE TRANSACTION if we've accessed a temporary table in
+ * this transaction. Having the prepared xact hold locks on another
* backend's temp table seems a bad idea --- for instance it would prevent
- * the backend from exiting. There are other problems too, such as how
- * to clean up the source backend's local buffers and ON COMMIT state
- * if the prepared xact includes a DROP of a temp table.
+ * the backend from exiting. There are other problems too, such as how to
+ * clean up the source backend's local buffers and ON COMMIT state if the
+ * prepared xact includes a DROP of a temp table.
*
- * We must check this after executing any ON COMMIT actions, because
- * they might still access a temp relation.
+ * We must check this after executing any ON COMMIT actions, because they
+ * might still access a temp relation.
*
* XXX In principle this could be relaxed to allow some useful special
* cases, such as a temp table created and dropped all within the
/*
* Reset user ID which might have been changed transiently. We need this
* to clean up in case control escaped out of a SECURITY DEFINER function
- * or other local change of CurrentUserId; therefore, the prior value
- * of SecurityDefinerContext also needs to be restored.
+ * or other local change of CurrentUserId; therefore, the prior value of
+ * SecurityDefinerContext also needs to be restored.
*
* (Note: it is not necessary to restore session authorization or role
* settings here because those can only be changed via GUC, and GUC will
/* Must CCI to ensure commands of subtransaction are seen as done */
CommandCounterIncrement();
- /*
- * Prior to 8.4 we marked subcommit in clog at this point. We now only
+ /*
+ * Prior to 8.4 we marked subcommit in clog at this point. We now only
* perform that step, if required, as part of the atomic update of the
* whole transaction tree at top level commit or abort.
*/
s->state = TRANS_ABORT;
/*
- * Reset user ID which might have been changed transiently. (See notes
- * in AbortTransaction.)
+ * Reset user ID which might have been changed transiently. (See notes in
+ * AbortTransaction.)
*/
SetUserIdAndContext(s->prevUser, s->prevSecDefCxt);
if (s->nChildXids > 0)
{
- int i;
+ int i;
appendStringInfo(&buf, "%u", s->childXids[0]);
for (i = 1; i < s->nChildXids; i++)
for (i = 0; i < xlrec->nrels; i++)
{
SMgrRelation srel = smgropen(xlrec->xnodes[i]);
- ForkNumber fork;
+ ForkNumber fork;
for (fork = 0; fork <= MAX_FORKNUM; fork++)
{
for (i = 0; i < xlrec->nrels; i++)
{
SMgrRelation srel = smgropen(xlrec->xnodes[i]);
- ForkNumber fork;
+ ForkNumber fork;
for (fork = 0; fork <= MAX_FORKNUM; fork++)
{
appendStringInfo(buf, "; rels:");
for (i = 0; i < xlrec->nrels; i++)
{
- char *path = relpath(xlrec->xnodes[i], MAIN_FORKNUM);
+ char *path = relpath(xlrec->xnodes[i], MAIN_FORKNUM);
+
appendStringInfo(buf, " %s", path);
pfree(path);
}
appendStringInfo(buf, "; rels:");
for (i = 0; i < xlrec->nrels; i++)
{
- char *path = relpath(xlrec->xnodes[i], MAIN_FORKNUM);
+ char *path = relpath(xlrec->xnodes[i], MAIN_FORKNUM);
+
appendStringInfo(buf, " %s", path);
pfree(path);
}
char *XLogArchiveCommand = NULL;
bool fullPageWrites = true;
bool log_checkpoints = false;
-int sync_method = DEFAULT_SYNC_METHOD;
+int sync_method = DEFAULT_SYNC_METHOD;
#ifdef WAL_DEBUG
bool XLOG_DEBUG = false;
TimeLineID ThisTimeLineID = 0;
/*
- * Are we doing recovery from XLOG?
+ * Are we doing recovery from XLOG?
*
* This is only ever true in the startup process, even if the system is still
* in recovery. Prior to 8.4, all activity during recovery were carried out
bool SharedRecoveryInProgress;
/*
- * During recovery, we keep a copy of the latest checkpoint record
- * here. Used by the background writer when it wants to create
- * a restartpoint.
+ * During recovery, we keep a copy of the latest checkpoint record here.
+ * Used by the background writer when it wants to create a restartpoint.
*
* Protected by info_lck.
*/
static XLogRecPtr EndRecPtr; /* end+1 of last record read */
static XLogRecord *nextRecord = NULL;
static TimeLineID lastPageTLI = 0;
-static XLogRecPtr minRecoveryPoint; /* local copy of ControlFile->minRecoveryPoint */
-static bool updateMinRecoveryPoint = true;
+static XLogRecPtr minRecoveryPoint; /* local copy of
+ * ControlFile->minRecoveryPoint */
+static bool updateMinRecoveryPoint = true;
static bool InRedo = false;
*/
static volatile sig_atomic_t got_SIGHUP = false;
static volatile sig_atomic_t shutdown_requested = false;
+
/*
* Flag set when executing a restore command, to tell SIGTERM signal handler
* that it's safe to just proc_exit.
static void WriteControlFile(void);
static void ReadControlFile(void);
static char *str_time(pg_time_t tnow);
+
#ifdef WAL_DEBUG
static void xlog_outrec(StringInfo buf, XLogRecord *record);
#endif
static bool read_backup_label(XLogRecPtr *checkPointLoc,
XLogRecPtr *minRecoveryLoc);
static void rm_redo_error_callback(void *arg);
-static int get_sync_bit(int method);
+static int get_sync_bit(int method);
/*
return false;
/*
- * Check to see if the WAL file has been removed by checkpoint,
- * which implies it has already been archived, and explains why we
- * can't see a status file for it.
+ * Check to see if the WAL file has been removed by checkpoint, which
+ * implies it has already been archived, and explains why we can't see a
+ * status file for it.
*/
snprintf(archiveStatusPath, MAXPGPATH, XLOGDIR "/%s", xlog);
if (stat(archiveStatusPath, &stat_buf) != 0 &&
* Advance minRecoveryPoint in control file.
*
* If we crash during recovery, we must reach this point again before the
- * database is consistent.
- *
+ * database is consistent.
+ *
* If 'force' is true, 'lsn' argument is ignored. Otherwise, minRecoveryPoint
* is is only updated if it's not already greater than or equal to 'lsn'.
*/
{
/* use volatile pointer to prevent code rearrangement */
volatile XLogCtlData *xlogctl = XLogCtl;
- XLogRecPtr newMinRecoveryPoint;
+ XLogRecPtr newMinRecoveryPoint;
/*
* To avoid having to update the control file too often, we update it
/*
* WAL segment files will not be re-read in normal operation, so we advise
- * the OS to release any cached pages. But do not do so if WAL archiving
+ * the OS to release any cached pages. But do not do so if WAL archiving
* is active, because archiver process could use the cache to read the WAL
* segment. Also, don't bother with it if we are using O_DIRECT, since
* the kernel is presumably not caching in that case.
/*
* Calculate the archive file cutoff point for use during log shipping
- * replication. All files earlier than this point can be deleted
- * from the archive, though there is no requirement to do so.
+ * replication. All files earlier than this point can be deleted from the
+ * archive, though there is no requirement to do so.
*
* We initialise this with the filename of an InvalidXLogRecPtr, which
- * will prevent the deletion of any WAL files from the archive
- * because of the alphabetic sorting property of WAL filenames.
+ * will prevent the deletion of any WAL files from the archive because of
+ * the alphabetic sorting property of WAL filenames.
*
* Once we have successfully located the redo pointer of the checkpoint
* from which we start recovery we never request a file prior to the redo
- * pointer of the last restartpoint. When redo begins we know that we
- * have successfully located it, so there is no need for additional
- * status flags to signify the point when we can begin deleting WAL files
- * from the archive.
+ * pointer of the last restartpoint. When redo begins we know that we have
+ * successfully located it, so there is no need for additional status
+ * flags to signify the point when we can begin deleting WAL files from
+ * the archive.
*/
if (InRedo)
{
* On SIGTERM, assume we have received a fast shutdown request, and exit
* cleanly. It's pure chance whether we receive the SIGTERM first, or the
* child process. If we receive it first, the signal handler will call
- * proc_exit, otherwise we do it here. If we or the child process
- * received SIGTERM for any other reason than a fast shutdown request,
- * postmaster will perform an immediate shutdown when it sees us exiting
+ * proc_exit, otherwise we do it here. If we or the child process received
+ * SIGTERM for any other reason than a fast shutdown request, postmaster
+ * will perform an immediate shutdown when it sees us exiting
* unexpectedly.
*
* Per the Single Unix Spec, shells report exit status > 128 when a called
/*
* Calculate the archive file cutoff point for use during log shipping
- * replication. All files earlier than this point can be deleted
- * from the archive, though there is no requirement to do so.
+ * replication. All files earlier than this point can be deleted from the
+ * archive, though there is no requirement to do so.
*
* We initialise this with the filename of an InvalidXLogRecPtr, which
- * will prevent the deletion of any WAL files from the archive
- * because of the alphabetic sorting property of WAL filenames.
+ * will prevent the deletion of any WAL files from the archive because of
+ * the alphabetic sorting property of WAL filenames.
*
* Once we have successfully located the redo pointer of the checkpoint
* from which we start recovery we never request a file prior to the redo
- * pointer of the last restartpoint. When redo begins we know that we
- * have successfully located it, so there is no need for additional
- * status flags to signify the point when we can begin deleting WAL files
- * from the archive.
+ * pointer of the last restartpoint. When redo begins we know that we have
+ * successfully located it, so there is no need for additional status
+ * flags to signify the point when we can begin deleting WAL files from
+ * the archive.
*/
if (InRedo)
{
{
/*
* If the failure was due to any sort of signal, it's best to punt and
- * abort recovery. See also detailed comments on signals in
+ * abort recovery. See also detailed comments on signals in
* RestoreArchivedFile().
*/
signaled = WIFSIGNALED(rc) || WEXITSTATUS(rc) > 125;
ereport(signaled ? FATAL : WARNING,
(errmsg("recovery_end_command \"%s\": return code %d",
- xlogRecoveryEndCmd, rc)));
+ xlogRecoveryEndCmd, rc)));
}
}
ValidateXLOGDirectoryStructure(void)
{
char path[MAXPGPATH];
- struct stat stat_buf;
+ struct stat stat_buf;
/* Check for pg_xlog; if it doesn't exist, error out */
if (stat(XLOGDIR, &stat_buf) != 0 ||
!S_ISDIR(stat_buf.st_mode))
- ereport(FATAL,
+ ereport(FATAL,
(errmsg("required WAL directory \"%s\" does not exist",
XLOGDIR)));
{
/* Check for weird cases where it exists but isn't a directory */
if (!S_ISDIR(stat_buf.st_mode))
- ereport(FATAL,
+ ereport(FATAL,
(errmsg("required WAL directory \"%s\" does not exist",
path)));
}
ereport(LOG,
(errmsg("creating missing WAL directory \"%s\"", path)));
if (mkdir(path, 0700) < 0)
- ereport(FATAL,
+ ereport(FATAL,
(errmsg("could not create missing directory \"%s\": %m",
path)));
}
* ignoring them as already applied, but that's not a huge drawback.
*
* If 'cleanup' is true, a cleanup lock is used when restoring blocks.
- * Otherwise, a normal exclusive lock is used. At the moment, that's just
+ * Otherwise, a normal exclusive lock is used. At the moment, that's just
* pro forma, because there can't be any regular backends in the system
* during recovery. The 'cleanup' argument applies to all backup blocks
* in the WAL record, that suffices for now.
ereport(FATAL,
(errmsg("database files are incompatible with server"),
errdetail("The database cluster was initialized with PG_CONTROL_VERSION %d (0x%08x),"
- " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
- ControlFile->pg_control_version, ControlFile->pg_control_version,
+ " but the server was compiled with PG_CONTROL_VERSION %d (0x%08x).",
+ ControlFile->pg_control_version, ControlFile->pg_control_version,
PG_CONTROL_VERSION, PG_CONTROL_VERSION),
errhint("This could be a problem of mismatched byte ordering. It looks like you need to initdb.")));
/*
* Do compatibility checking immediately. If the database isn't
- * compatible with the backend executable, we want to abort before we
- * can possibly do any damage.
+ * compatible with the backend executable, we want to abort before we can
+ * possibly do any damage.
*/
if (ControlFile->catalog_version_no != CATALOG_VERSION_NO)
ereport(FATAL,
ereport(FATAL,
(errmsg("database files are incompatible with server"),
errdetail("The database cluster was initialized without USE_FLOAT4_BYVAL"
- " but the server was compiled with USE_FLOAT4_BYVAL."),
+ " but the server was compiled with USE_FLOAT4_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#else
if (ControlFile->float4ByVal != false)
ereport(FATAL,
(errmsg("database files are incompatible with server"),
- errdetail("The database cluster was initialized with USE_FLOAT4_BYVAL"
- " but the server was compiled without USE_FLOAT4_BYVAL."),
+ errdetail("The database cluster was initialized with USE_FLOAT4_BYVAL"
+ " but the server was compiled without USE_FLOAT4_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#endif
ereport(FATAL,
(errmsg("database files are incompatible with server"),
errdetail("The database cluster was initialized without USE_FLOAT8_BYVAL"
- " but the server was compiled with USE_FLOAT8_BYVAL."),
+ " but the server was compiled with USE_FLOAT8_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#else
if (ControlFile->float8ByVal != false)
ereport(FATAL,
(errmsg("database files are incompatible with server"),
- errdetail("The database cluster was initialized with USE_FLOAT8_BYVAL"
- " but the server was compiled without USE_FLOAT8_BYVAL."),
+ errdetail("The database cluster was initialized with USE_FLOAT8_BYVAL"
+ " but the server was compiled without USE_FLOAT8_BYVAL."),
errhint("It looks like you need to recompile or initdb.")));
#endif
}
* does nothing if a recovery_target is not also set
*/
if (!parse_bool(tok2, &recoveryTargetInclusive))
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("parameter \"recovery_target_inclusive\" requires a Boolean value")));
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("parameter \"recovery_target_inclusive\" requires a Boolean value")));
ereport(LOG,
(errmsg("recovery_target_inclusive = %s", tok2)));
}
/*
* Verify that pg_xlog and pg_xlog/archive_status exist. In cases where
- * someone has performed a copy for PITR, these directories may have
- * been excluded and need to be re-created.
+ * someone has performed a copy for PITR, these directories may have been
+ * excluded and need to be re-created.
*/
ValidateXLOGDirectoryStructure();
bool recoveryApply = true;
bool reachedMinRecoveryPoint = false;
ErrorContextCallback errcontext;
+
/* use volatile pointer to prevent code rearrangement */
volatile XLogCtlData *xlogctl = XLogCtl;
else
ereport(LOG,
(errmsg("redo starts at %X/%X, consistency will be reached at %X/%X",
- ReadRecPtr.xlogid, ReadRecPtr.xrecoff,
+ ReadRecPtr.xlogid, ReadRecPtr.xrecoff,
minRecoveryPoint.xlogid, minRecoveryPoint.xrecoff)));
/*
proc_exit(1);
/*
- * Have we reached our safe starting point? If so, we can
- * tell postmaster that the database is consistent now.
+ * Have we reached our safe starting point? If so, we can tell
+ * postmaster that the database is consistent now.
*/
- if (!reachedMinRecoveryPoint &&
- XLByteLE(minRecoveryPoint, EndRecPtr))
+ if (!reachedMinRecoveryPoint &&
+ XLByteLE(minRecoveryPoint, EndRecPtr))
{
reachedMinRecoveryPoint = true;
if (InArchiveRecovery)
{
ereport(LOG,
- (errmsg("consistent recovery state reached")));
+ (errmsg("consistent recovery state reached")));
if (IsUnderPostmaster)
SendPostmasterSignal(PMSIGNAL_RECOVERY_CONSISTENT);
}
}
/*
- * Update shared replayEndRecPtr before replaying this
- * record, so that XLogFlush will update minRecoveryPoint
- * correctly.
+ * Update shared replayEndRecPtr before replaying this record,
+ * so that XLogFlush will update minRecoveryPoint correctly.
*/
SpinLockAcquire(&xlogctl->info_lck);
xlogctl->replayEndRecPtr = EndRecPtr;
RecoveryInProgress(void)
{
/*
- * We check shared state each time only until we leave recovery mode.
- * We can't re-enter recovery, so we rely on the local state variable
- * after that.
+ * We check shared state each time only until we leave recovery mode. We
+ * can't re-enter recovery, so we rely on the local state variable after
+ * that.
*/
if (!LocalRecoveryInProgress)
return false;
static void
LogCheckpointStart(int flags, bool restartpoint)
{
- char *msg;
+ char *msg;
/*
- * XXX: This is hopelessly untranslatable. We could call gettext_noop
- * for the main message, but what about all the flags?
+ * XXX: This is hopelessly untranslatable. We could call gettext_noop for
+ * the main message, but what about all the flags?
*/
if (restartpoint)
msg = "restartpoint starting:%s%s%s%s%s%s";
/*
* This is used during WAL recovery to establish a point from which recovery
- * can roll forward without replaying the entire recovery log. This function
+ * can roll forward without replaying the entire recovery log. This function
* is called each time a checkpoint record is read from XLOG. It is stored
* in shared memory, so that it can be used as a restartpoint later on.
*/
RecoveryRestartPoint(const CheckPoint *checkPoint)
{
int rmid;
+
/* use volatile pointer to prevent code rearrangement */
volatile XLogCtlData *xlogctl = XLogCtl;
}
/*
- * Copy the checkpoint record to shared memory, so that bgwriter can
- * use it the next time it wants to perform a restartpoint.
+ * Copy the checkpoint record to shared memory, so that bgwriter can use
+ * it the next time it wants to perform a restartpoint.
*/
SpinLockAcquire(&xlogctl->info_lck);
XLogCtl->lastCheckPointRecPtr = ReadRecPtr;
bool
CreateRestartPoint(int flags)
{
- XLogRecPtr lastCheckPointRecPtr;
- CheckPoint lastCheckPoint;
+ XLogRecPtr lastCheckPointRecPtr;
+ CheckPoint lastCheckPoint;
+
/* use volatile pointer to prevent code rearrangement */
volatile XLogCtlData *xlogctl = XLogCtl;
memcpy(&lastCheckPoint, &XLogCtl->lastCheckPoint, sizeof(CheckPoint));
SpinLockRelease(&xlogctl->info_lck);
- /*
+ /*
* Check that we're still in recovery mode. It's ok if we exit recovery
* mode after this check, the restart point is valid anyway.
*/
if (!RecoveryInProgress())
{
ereport(DEBUG2,
- (errmsg("skipping restartpoint, recovery has already ended")));
+ (errmsg("skipping restartpoint, recovery has already ended")));
LWLockRelease(CheckpointLock);
return false;
}
* possible in case of immediate shutdown, though.
*
* We don't explicitly advance minRecoveryPoint when we do create a
- * restartpoint. It's assumed that flushing the buffers will do that
- * as a side-effect.
+ * restartpoint. It's assumed that flushing the buffers will do that as a
+ * side-effect.
*/
if (XLogRecPtrIsInvalid(lastCheckPointRecPtr) ||
XLByteLE(lastCheckPoint.redo, ControlFile->checkPointCopy.redo))
{
- XLogRecPtr InvalidXLogRecPtr = {0, 0};
+ XLogRecPtr InvalidXLogRecPtr = {0, 0};
+
ereport(DEBUG2,
(errmsg("skipping restartpoint, already performed at %X/%X",
- lastCheckPoint.redo.xlogid, lastCheckPoint.redo.xrecoff)));
+ lastCheckPoint.redo.xlogid, lastCheckPoint.redo.xrecoff)));
UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
LWLockRelease(CheckpointLock);
LWLockRelease(ControlFileLock);
/*
- * Currently, there is no need to truncate pg_subtrans during recovery.
- * If we did do that, we will need to have called StartupSUBTRANS()
- * already and then TruncateSUBTRANS() would go here.
+ * Currently, there is no need to truncate pg_subtrans during recovery. If
+ * we did do that, we will need to have called StartupSUBTRANS() already
+ * and then TruncateSUBTRANS() would go here.
*/
/* All real work is done, but log before releasing lock. */
ereport((log_checkpoints ? LOG : DEBUG2),
(errmsg("recovery restart point at %X/%X",
- lastCheckPoint.redo.xlogid, lastCheckPoint.redo.xrecoff)));
+ lastCheckPoint.redo.xlogid, lastCheckPoint.redo.xrecoff)));
if (recoveryLastXTime)
ereport((log_checkpoints ? LOG : DEBUG2),
- (errmsg("last completed transaction was at log time %s",
- timestamptz_to_str(recoveryLastXTime))));
+ (errmsg("last completed transaction was at log time %s",
+ timestamptz_to_str(recoveryLastXTime))));
LWLockRelease(CheckpointLock);
return true;
(int) checkPoint.ThisTimeLineID))
ereport(PANIC,
(errmsg("unexpected timeline ID %u (after %u) in checkpoint record",
- checkPoint.ThisTimeLineID, ThisTimeLineID)));
- /* Following WAL records should be run with new TLI */
- ThisTimeLineID = checkPoint.ThisTimeLineID;
+ checkPoint.ThisTimeLineID, ThisTimeLineID)));
+ /* Following WAL records should be run with new TLI */
+ ThisTimeLineID = checkPoint.ThisTimeLineID;
}
RecoveryRestartPoint(&checkPoint);
switch (method)
{
- /*
- * enum values for all sync options are defined even if they are not
- * supported on the current platform. But if not, they are not
- * included in the enum option array, and therefore will never be seen
- * here.
- */
+ /*
+ * enum values for all sync options are defined even if they are
+ * not supported on the current platform. But if not, they are
+ * not included in the enum option array, and therefore will never
+ * be seen here.
+ */
case SYNC_METHOD_FSYNC:
case SYNC_METHOD_FSYNC_WRITETHROUGH:
case SYNC_METHOD_FDATASYNC:
default:
/* can't happen (unless we are out of sync with option array) */
elog(ERROR, "unrecognized wal_sync_method: %d", method);
- return 0; /* silence warning */
+ return 0; /* silence warning */
}
}
* have different checkpoint positions and hence different history
* file names, even if nothing happened in between.
*
- * We use CHECKPOINT_IMMEDIATE only if requested by user (via
- * passing fast = true). Otherwise this can take awhile.
+ * We use CHECKPOINT_IMMEDIATE only if requested by user (via passing
+ * fast = true). Otherwise this can take awhile.
*/
RequestCheckpoint(CHECKPOINT_FORCE | CHECKPOINT_WAIT |
(fast ? CHECKPOINT_IMMEDIATE : 0));
* property of the WAL files ensures any earlier WAL files are safely
* archived as well.
*
- * We wait forever, since archive_command is supposed to work and
- * we assume the admin wanted his backup to work completely. If you
- * don't wish to wait, you can set statement_timeout.
+ * We wait forever, since archive_command is supposed to work and we
+ * assume the admin wanted his backup to work completely. If you don't
+ * wish to wait, you can set statement_timeout.
*/
XLByteToPrevSeg(stoppoint, _logId, _logSeg);
XLogFileName(lastxlogfilename, ThisTimeLineID, _logId, _logSeg);
if (++waits >= seconds_before_warning)
{
- seconds_before_warning *= 2; /* This wraps in >10 years... */
+ seconds_before_warning *= 2; /* This wraps in >10 years... */
ereport(WARNING,
(errmsg("pg_stop_backup still waiting for archive to complete (%d seconds elapsed)",
waits)));
ereport(LOG,
(errmsg("online backup mode cancelled"),
errdetail("\"%s\" was renamed to \"%s\".",
- BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
+ BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
}
else
{
(errcode_for_file_access(),
errmsg("online backup mode was not cancelled"),
errdetail("Could not rename \"%s\" to \"%s\": %m.",
- BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
+ BACKUP_LABEL_FILE, BACKUP_LABEL_OLD)));
}
}
/* ------------------------------------------------------
- * Startup Process main entry point and signal handlers
+ * Startup Process main entry point and signal handlers
* ------------------------------------------------------
*/
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
- * should ensure the postmaster sees this as a crash, too, but no harm
- * in being doubly sure.)
+ * should ensure the postmaster sees this as a crash, too, but no harm in
+ * being doubly sure.)
*/
exit(2);
}
/*
* Properly accept or ignore signals the postmaster might send us
*/
- pqsignal(SIGHUP, StartupProcSigHupHandler); /* reload config file */
- pqsignal(SIGINT, SIG_IGN); /* ignore query cancel */
- pqsignal(SIGTERM, StartupProcShutdownHandler); /* request shutdown */
- pqsignal(SIGQUIT, startupproc_quickdie); /* hard crash time */
+ pqsignal(SIGHUP, StartupProcSigHupHandler); /* reload config file */
+ pqsignal(SIGINT, SIG_IGN); /* ignore query cancel */
+ pqsignal(SIGTERM, StartupProcShutdownHandler); /* request shutdown */
+ pqsignal(SIGQUIT, startupproc_quickdie); /* hard crash time */
pqsignal(SIGALRM, SIG_IGN);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, SIG_IGN);
*/
PG_SETMASK(&UnBlockSig);
- StartupXLOG();
+ StartupXLOG();
BuildFlatFiles(false);
/*
- * Exit normally. Exit code 0 tells postmaster that we completed
- * recovery successfully.
+ * Exit normally. Exit code 0 tells postmaster that we completed recovery
+ * successfully.
*/
proc_exit(0);
}
*/
if (log_min_messages <= DEBUG1 || client_min_messages <= DEBUG1)
{
- char *path = relpath(node, forkno);
+ char *path = relpath(node, forkno);
+
if (present)
elog(DEBUG1, "page %u of relation %s is uninitialized",
blkno, path);
{
if (log_min_messages <= DEBUG2 || client_min_messages <= DEBUG2)
{
- char *path = relpath(hentry->key.node, forkno);
+ char *path = relpath(hentry->key.node, forkno);
+
elog(DEBUG2, "page %u of relation %s has been dropped",
hentry->key.blkno, path);
pfree(path);
{
if (log_min_messages <= DEBUG2 || client_min_messages <= DEBUG2)
{
- char *path = relpath(hentry->key.node, hentry->key.forkno);
+ char *path = relpath(hentry->key.node, hentry->key.forkno);
+
elog(DEBUG2, "page %u of relation %s has been dropped",
hentry->key.blkno, path);
pfree(path);
*/
while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
{
- char *path = relpath(hentry->key.node, hentry->key.forkno);
+ char *path = relpath(hentry->key.node, hentry->key.forkno);
+
if (hentry->present)
elog(WARNING, "page %u of relation %s was uninitialized",
hentry->key.blkno, path);
Buffer
XLogReadBuffer(RelFileNode rnode, BlockNumber blkno, bool init)
{
- Buffer buf;
+ Buffer buf;
+
buf = XLogReadBufferExtended(rnode, MAIN_FORKNUM, blkno,
init ? RBM_ZERO : RBM_NORMAL);
if (BufferIsValid(buf))
*/
typedef struct
{
- RelationData reldata; /* Note: this must be first */
- FormData_pg_class pgc;
+ RelationData reldata; /* Note: this must be first */
+ FormData_pg_class pgc;
} FakeRelCacheEntryData;
typedef FakeRelCacheEntryData *FakeRelCacheEntry;
* Create a fake relation cache entry for a physical relation
*
* It's often convenient to use the same functions in XLOG replay as in the
- * main codepath, but those functions typically work with a relcache entry.
- * We don't have a working relation cache during XLOG replay, but this
- * function can be used to create a fake relcache entry instead. Only the
- * fields related to physical storage, like rd_rel, are initialized, so the
+ * main codepath, but those functions typically work with a relcache entry.
+ * We don't have a working relation cache during XLOG replay, but this
+ * function can be used to create a fake relcache entry instead. Only the
+ * fields related to physical storage, like rd_rel, are initialized, so the
* fake entry is only usable in low-level operations like ReadBuffer().
*
* Caller must free the returned entry with FreeFakeRelcacheEntry().
CreateFakeRelcacheEntry(RelFileNode rnode)
{
FakeRelCacheEntry fakeentry;
- Relation rel;
+ Relation rel;
/* Allocate the Relation struct and all related space in one block. */
fakeentry = palloc0(sizeof(FakeRelCacheEntryData));
/*
* We set up the lockRelId in case anything tries to lock the dummy
* relation. Note that this is fairly bogus since relNode may be
- * different from the relation's OID. It shouldn't really matter
- * though, since we are presumably running by ourselves and can't have
- * any lock conflicts ...
+ * different from the relation's OID. It shouldn't really matter though,
+ * since we are presumably running by ourselves and can't have any lock
+ * conflicts ...
*/
rel->rd_lockInfo.lockRelId.dbId = rnode.dbNode;
rel->rd_lockInfo.lockRelId.relId = rnode.relNode;
{
/*
* This is unnecessarily heavy-handed, as it will close SMgrRelation
- * objects for other databases as well. DROP DATABASE occurs seldom
- * enough that it's not worth introducing a variant of smgrclose for
- * just this purpose. XXX: Or should we rather leave the smgr entries
- * dangling?
+ * objects for other databases as well. DROP DATABASE occurs seldom enough
+ * that it's not worth introducing a variant of smgrclose for just this
+ * purpose. XXX: Or should we rather leave the smgr entries dangling?
*/
smgrcloseall();
static List *objectNamesToOids(GrantObjectType objtype, List *objnames);
static void expand_col_privileges(List *colnames, Oid table_oid,
- AclMode this_privileges,
- AclMode *col_privileges,
- int num_col_privileges);
+ AclMode this_privileges,
+ AclMode *col_privileges,
+ int num_col_privileges);
static void expand_all_col_privileges(Oid table_oid, Form_pg_class classForm,
- AclMode this_privileges,
- AclMode *col_privileges,
- int num_col_privileges);
+ AclMode this_privileges,
+ AclMode *col_privileges,
+ int num_col_privileges);
static AclMode string_to_privilege(const char *privname);
static const char *privilege_to_string(AclMode privilege);
static AclMode restrict_and_check_grant(bool is_grant, AclMode avail_goptions,
AclObjectKind objkind, const char *objname,
AttrNumber att_number, const char *colname);
static AclMode pg_aclmask(AclObjectKind objkind, Oid table_oid, AttrNumber attnum,
- Oid roleid, AclMode mask, AclMaskHow how);
+ Oid roleid, AclMode mask, AclMaskHow how);
#ifdef ACLDEBUG
AclItem aclitem;
Acl *newer_acl;
- aclitem.ai_grantee = lfirst_oid(j);
+ aclitem. ai_grantee = lfirst_oid(j);
/*
* Grant options can only be granted to individual roles, not PUBLIC.
(errcode(ERRCODE_INVALID_GRANT_OPERATION),
errmsg("grant options can only be granted to roles")));
- aclitem.ai_grantor = grantorId;
+ aclitem. ai_grantor = grantorId;
/*
* The asymmetry in the conditions here comes from the spec. In
}
/*
- * Convert stmt->privileges, a list of AccessPriv nodes, into an
- * AclMode bitmask. Note: objtype can't be ACL_OBJECT_COLUMN.
+ * Convert stmt->privileges, a list of AccessPriv nodes, into an AclMode
+ * bitmask. Note: objtype can't be ACL_OBJECT_COLUMN.
*/
switch (stmt->objtype)
{
AclMode priv;
/*
- * If it's a column-level specification, we just set it aside
- * in col_privs for the moment; but insist it's for a relation.
+ * If it's a column-level specification, we just set it aside in
+ * col_privs for the moment; but insist it's for a relation.
*/
if (privnode->cols)
{
continue;
}
- if (privnode->priv_name == NULL) /* parser mistake? */
+ if (privnode->priv_name == NULL) /* parser mistake? */
elog(ERROR, "AccessPriv node must specify privilege or columns");
priv = string_to_privilege(privnode->priv_name);
/*
* ExecGrantStmt_oids
*
- * "Internal" entrypoint for granting and revoking privileges. This is
+ * "Internal" entrypoint for granting and revoking privileges. This is
* exported for pg_shdepend.c to use in revoking privileges when dropping
* a role.
*/
case ACL_OBJECT_FDW:
foreach(cell, objnames)
{
- char *fdwname = strVal(lfirst(cell));
- Oid fdwid = GetForeignDataWrapperOidByName(fdwname, false);
+ char *fdwname = strVal(lfirst(cell));
+ Oid fdwid = GetForeignDataWrapperOidByName(fdwname, false);
objects = lappend_oid(objects, fdwid);
}
case ACL_OBJECT_FOREIGN_SERVER:
foreach(cell, objnames)
{
- char *srvname = strVal(lfirst(cell));
- Oid srvid = GetForeignServerOidByName(srvname, false);
+ char *srvname = strVal(lfirst(cell));
+ Oid srvid = GetForeignServerOidByName(srvname, false);
objects = lappend_oid(objects, srvid);
}
colname, get_rel_name(table_oid))));
attnum -= FirstLowInvalidHeapAttributeNumber;
if (attnum <= 0 || attnum >= num_col_privileges)
- elog(ERROR, "column number out of range"); /* safety check */
+ elog(ERROR, "column number out of range"); /* safety check */
col_privileges[attnum] |= this_privileges;
}
}
AttrNumber attnum, Oid ownerId, AclMode col_privileges,
Relation attRelation, const Acl *old_rel_acl)
{
- HeapTuple attr_tuple;
- Form_pg_attribute pg_attribute_tuple;
- Acl *old_acl;
- Acl *new_acl;
- Acl *merged_acl;
- Datum aclDatum;
- bool isNull;
- Oid grantorId;
- AclMode avail_goptions;
- bool need_update;
- HeapTuple newtuple;
- Datum values[Natts_pg_attribute];
- bool nulls[Natts_pg_attribute];
- bool replaces[Natts_pg_attribute];
- int noldmembers;
- int nnewmembers;
- Oid *oldmembers;
- Oid *newmembers;
+ HeapTuple attr_tuple;
+ Form_pg_attribute pg_attribute_tuple;
+ Acl *old_acl;
+ Acl *new_acl;
+ Acl *merged_acl;
+ Datum aclDatum;
+ bool isNull;
+ Oid grantorId;
+ AclMode avail_goptions;
+ bool need_update;
+ HeapTuple newtuple;
+ Datum values[Natts_pg_attribute];
+ bool nulls[Natts_pg_attribute];
+ bool replaces[Natts_pg_attribute];
+ int noldmembers;
+ int nnewmembers;
+ Oid *oldmembers;
+ Oid *newmembers;
attr_tuple = SearchSysCache(ATTNUM,
ObjectIdGetDatum(relOid),
pg_attribute_tuple = (Form_pg_attribute) GETSTRUCT(attr_tuple);
/*
- * Get working copy of existing ACL. If there's no ACL,
- * substitute the proper default.
+ * Get working copy of existing ACL. If there's no ACL, substitute the
+ * proper default.
*/
aclDatum = SysCacheGetAttr(ATTNUM, attr_tuple, Anum_pg_attribute_attacl,
&isNull);
/*
* In select_best_grantor we should consider existing table-level ACL bits
* as well as the per-column ACL. Build a new ACL that is their
- * concatenation. (This is a bit cheap and dirty compared to merging
- * them properly with no duplications, but it's all we need here.)
+ * concatenation. (This is a bit cheap and dirty compared to merging them
+ * properly with no duplications, but it's all we need here.)
*/
merged_acl = aclconcat(old_rel_acl, old_acl);
pfree(merged_acl);
/*
- * Restrict the privileges to what we can actually grant, and emit
- * the standards-mandated warning and error messages. Note: we don't
- * track whether the user actually used the ALL PRIVILEGES(columns)
- * syntax for each column; we just approximate it by whether all the
- * possible privileges are specified now. Since the all_privs flag only
- * determines whether a warning is issued, this seems close enough.
+ * Restrict the privileges to what we can actually grant, and emit the
+ * standards-mandated warning and error messages. Note: we don't track
+ * whether the user actually used the ALL PRIVILEGES(columns) syntax for
+ * each column; we just approximate it by whether all the possible
+ * privileges are specified now. Since the all_privs flag only determines
+ * whether a warning is issued, this seems close enough.
*/
col_privileges =
restrict_and_check_grant(istmt->is_grant, avail_goptions,
/*
* Generate new ACL.
*
- * We need the members of both old and new ACLs so we can correct
- * the shared dependency information.
+ * We need the members of both old and new ACLs so we can correct the
+ * shared dependency information.
*/
noldmembers = aclmembers(old_acl, &oldmembers);
MemSet(replaces, false, sizeof(replaces));
/*
- * If the updated ACL is empty, we can set attacl to null, and maybe
- * even avoid an update of the pg_attribute row. This is worth testing
- * because we'll come through here multiple times for any relation-level
- * REVOKE, even if there were never any column GRANTs. Note we are
- * assuming that the "default" ACL state for columns is empty.
+ * If the updated ACL is empty, we can set attacl to null, and maybe even
+ * avoid an update of the pg_attribute row. This is worth testing because
+ * we'll come through here multiple times for any relation-level REVOKE,
+ * even if there were never any column GRANTs. Note we are assuming that
+ * the "default" ACL state for columns is empty.
*/
if (ACL_NUM(new_acl) > 0)
{
Form_pg_class pg_class_tuple;
bool isNull;
AclMode this_privileges;
- AclMode *col_privileges;
+ AclMode *col_privileges;
int num_col_privileges;
bool have_col_privileges;
Acl *old_acl;
/*
* Set up array in which we'll accumulate any column privilege bits
- * that need modification. The array is indexed such that entry [0]
+ * that need modification. The array is indexed such that entry [0]
* corresponds to FirstLowInvalidHeapAttributeNumber.
*/
num_col_privileges = pg_class_tuple->relnatts - FirstLowInvalidHeapAttributeNumber + 1;
restrict_and_check_grant(istmt->is_grant, avail_goptions,
istmt->all_privs, this_privileges,
relOid, grantorId,
- pg_class_tuple->relkind == RELKIND_SEQUENCE
+ pg_class_tuple->relkind == RELKIND_SEQUENCE
? ACL_KIND_SEQUENCE : ACL_KIND_CLASS,
NameStr(pg_class_tuple->relname),
0, NULL);
*/
foreach(cell_colprivs, istmt->col_privs)
{
- AccessPriv *col_privs = (AccessPriv *) lfirst(cell_colprivs);
+ AccessPriv *col_privs = (AccessPriv *) lfirst(cell_colprivs);
if (col_privs->priv_name == NULL)
this_privileges = ACL_ALL_RIGHTS_COLUMN;
{
/*
* The only column privilege allowed on sequences is SELECT.
- * This is a warning not error because we do it that way
- * for relation-level privileges.
+ * This is a warning not error because we do it that way for
+ * relation-level privileges.
*/
ereport(WARNING,
(errcode(ERRCODE_INVALID_GRANT_OPERATION),
if (have_col_privileges)
{
- AttrNumber i;
+ AttrNumber i;
for (i = 0; i < num_col_privileges; i++)
{
heap_close(relation, RowExclusiveLock);
}
-static void ExecGrant_ForeignServer(InternalGrant *istmt)
+static void
+ExecGrant_ForeignServer(InternalGrant *istmt)
{
Relation relation;
ListCell *cell;
this_privileges =
restrict_and_check_grant(istmt->is_grant, avail_goptions,
istmt->all_privs, istmt->privileges,
- srvid, grantorId, ACL_KIND_FOREIGN_SERVER,
+ srvid, grantorId, ACL_KIND_FOREIGN_SERVER,
NameStr(pg_server_tuple->srvname),
0, NULL);
*
* Note: this considers only privileges granted specifically on the column.
* It is caller's responsibility to take relation-level privileges into account
- * as appropriate. (For the same reason, we have no special case for
+ * as appropriate. (For the same reason, we have no special case for
* superuser-ness here.)
*/
AclMode
&isNull);
/*
- * Here we hard-wire knowledge that the default ACL for a column
- * grants no privileges, so that we can fall out quickly in the
- * very common case where attacl is null.
+ * Here we hard-wire knowledge that the default ACL for a column grants no
+ * privileges, so that we can fall out quickly in the very common case
+ * where attacl is null.
*/
if (isNull)
{
/*
* Must get the relation's ownerId from pg_class. Since we already found
- * a pg_attribute entry, the only likely reason for this to fail is that
- * a concurrent DROP of the relation committed since then (which could
- * only happen if we don't have lock on the relation). We prefer to
- * report "no privileges" rather than failing in such a case, so as to
- * avoid unwanted failures in has_column_privilege() tests.
+ * a pg_attribute entry, the only likely reason for this to fail is that a
+ * concurrent DROP of the relation committed since then (which could only
+ * happen if we don't have lock on the relation). We prefer to report "no
+ * privileges" rather than failing in such a case, so as to avoid unwanted
+ * failures in has_column_privilege() tests.
*/
classTuple = SearchSysCache(RELOID,
ObjectIdGetDatum(table_oid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
ereport(ERROR,
- (errmsg("foreign-data wrapper with OID %u does not exist",
+ (errmsg("foreign-data wrapper with OID %u does not exist",
fdw_oid)));
fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tuple);
*/
AclMode
pg_foreign_server_aclmask(Oid srv_oid, Oid roleid,
- AclMode mask, AclMaskHow how)
+ AclMode mask, AclMaskHow how)
{
AclMode result;
HeapTuple tuple;
0, 0, 0);
if (!HeapTupleIsValid(tuple))
ereport(ERROR,
- (errmsg("foreign server with OID %u does not exist",
+ (errmsg("foreign server with OID %u does not exist",
srv_oid)));
srvForm = (Form_pg_foreign_server) GETSTRUCT(tuple);
pg_attribute_aclcheck_all(Oid table_oid, Oid roleid, AclMode mode,
AclMaskHow how)
{
- AclResult result;
- HeapTuple classTuple;
- Form_pg_class classForm;
- AttrNumber nattrs;
- AttrNumber curr_att;
+ AclResult result;
+ HeapTuple classTuple;
+ Form_pg_class classForm;
+ AttrNumber nattrs;
+ AttrNumber curr_att;
/*
* Must fetch pg_class row to check number of attributes. As in
- * pg_attribute_aclmask, we prefer to return "no privileges" instead
- * of throwing an error if we get any unexpected lookup errors.
+ * pg_attribute_aclmask, we prefer to return "no privileges" instead of
+ * throwing an error if we get any unexpected lookup errors.
*/
classTuple = SearchSysCache(RELOID,
ObjectIdGetDatum(table_oid),
ReleaseSysCache(classTuple);
/*
- * Initialize result in case there are no non-dropped columns. We want
- * to report failure in such cases for either value of 'how'.
+ * Initialize result in case there are no non-dropped columns. We want to
+ * report failure in such cases for either value of 'how'.
*/
result = ACLCHECK_NO_PRIV;
/*
* Here we hard-wire knowledge that the default ACL for a column
- * grants no privileges, so that we can fall out quickly in the
- * very common case where attacl is null.
+ * grants no privileges, so that we can fall out quickly in the very
+ * common case where attacl is null.
*/
if (heap_attisnull(attTuple, Anum_pg_attribute_attacl))
attmask = 0;
if (!HeapTupleIsValid(tuple))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("foreign server with OID %u does not exist",
- srv_oid)));
+ errmsg("foreign server with OID %u does not exist",
+ srv_oid)));
ownerId = ((Form_pg_foreign_server) GETSTRUCT(tuple))->srvowner;
#include "utils/tqual.h"
-#define OIDCHARS 10 /* max chars printed by %u */
-#define FORKNAMECHARS 4 /* max chars for a fork name */
+#define OIDCHARS 10 /* max chars printed by %u */
+#define FORKNAMECHARS 4 /* max chars for a fork name */
/*
* Lookup table of fork name by fork number.
* up-to-date.
*/
const char *forkNames[] = {
- "main", /* MAIN_FORKNUM */
- "fsm", /* FSM_FORKNUM */
- "vm" /* VISIBILITYMAP_FORKNUM */
+ "main", /* MAIN_FORKNUM */
+ "fsm", /* FSM_FORKNUM */
+ "vm" /* VISIBILITYMAP_FORKNUM */
};
/*
ForkNumber
forkname_to_number(char *forkName)
{
- ForkNumber forkNum;
+ ForkNumber forkNum;
for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
if (strcmp(forkNames[forkNum], forkName) == 0)
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid fork name"),
errhint("Valid fork names are \"main\", \"fsm\", and \"vm\".")));
- return InvalidForkNumber; /* keep compiler quiet */
+ return InvalidForkNumber; /* keep compiler quiet */
}
/*
{
Oid newOid;
SnapshotData SnapshotDirty;
- SysScanDesc scan;
+ SysScanDesc scan;
ScanKeyData key;
bool collides;
struct ObjectAddresses
{
ObjectAddress *refs; /* => palloc'd array */
- ObjectAddressExtra *extras; /* => palloc'd array, or NULL if not used */
+ ObjectAddressExtra *extras; /* => palloc'd array, or NULL if not used */
int numrefs; /* current number of references */
int maxrefs; /* current size of palloc'd array(s) */
};
/* threaded list of ObjectAddresses, for recursion detection */
typedef struct ObjectAddressStack
{
- const ObjectAddress *object; /* object being visited */
+ const ObjectAddress *object; /* object being visited */
int flags; /* its current flag bits */
- struct ObjectAddressStack *next; /* next outer stack level */
+ struct ObjectAddressStack *next; /* next outer stack level */
} ObjectAddressStack;
/* for find_expr_references_walker */
const ObjectAddressExtra *extra,
ObjectAddresses *addrs);
static bool object_address_present_add_flags(const ObjectAddress *object,
- int flags,
- ObjectAddresses *addrs);
+ int flags,
+ ObjectAddresses *addrs);
static void getRelationDescription(StringInfo buffer, Oid relid);
static void getOpFamilyDescription(StringInfo buffer, Oid opfid);
depRel = heap_open(DependRelationId, RowExclusiveLock);
/*
- * Acquire deletion lock on the target object. (Ideally the caller has
+ * Acquire deletion lock on the target object. (Ideally the caller has
* done this already, but many places are sloppy about it.)
*/
AcquireDeletionLock(object);
/*
* Construct a list of objects to delete (ie, the given objects plus
* everything directly or indirectly dependent on them). Note that
- * because we pass the whole objects list as pendingObjects context,
- * we won't get a failure from trying to delete an object that is
- * internally dependent on another one in the list; we'll just skip
- * that object and delete it when we reach its owner.
+ * because we pass the whole objects list as pendingObjects context, we
+ * won't get a failure from trying to delete an object that is internally
+ * dependent on another one in the list; we'll just skip that object and
+ * delete it when we reach its owner.
*/
targetObjects = new_object_addresses();
findDependentObjects(thisobj,
DEPFLAG_ORIGINAL,
- NULL, /* empty stack */
+ NULL, /* empty stack */
targetObjects,
objects,
depRel);
/*
* Check if deletion is allowed, and report about cascaded deletes.
*
- * If there's exactly one object being deleted, report it the same
- * way as in performDeletion(), else we have to be vaguer.
+ * If there's exactly one object being deleted, report it the same way as
+ * in performDeletion(), else we have to be vaguer.
*/
reportDependentObjects(targetObjects,
behavior,
depRel = heap_open(DependRelationId, RowExclusiveLock);
/*
- * Acquire deletion lock on the target object. (Ideally the caller has
+ * Acquire deletion lock on the target object. (Ideally the caller has
* done this already, but many places are sloppy about it.)
*/
AcquireDeletionLock(object);
*
* For every object that depends on the starting object, acquire a deletion
* lock on the object, add it to targetObjects (if not already there),
- * and recursively find objects that depend on it. An object's dependencies
+ * and recursively find objects that depend on it. An object's dependencies
* will be placed into targetObjects before the object itself; this means
* that the finished list's order represents a safe deletion order.
*
/*
* If the target object is already being visited in an outer recursion
- * level, just report the current flags back to that level and exit.
- * This is needed to avoid infinite recursion in the face of circular
+ * level, just report the current flags back to that level and exit. This
+ * is needed to avoid infinite recursion in the face of circular
* dependencies.
*
* The stack check alone would result in dependency loops being broken at
* will not break a loop at an internal dependency: if we enter the loop
* at an "owned" object we will switch and start at the "owning" object
* instead. We could probably hack something up to avoid breaking at an
- * auto dependency, too, if we had to. However there are no known cases
+ * auto dependency, too, if we had to. However there are no known cases
* where that would be necessary.
*/
for (stackptr = stack; stackptr; stackptr = stackptr->next)
stackptr->flags |= flags;
return;
}
+
/*
* Could visit column with whole table already on stack; this is
* the same case noted in object_address_present_add_flags().
* specified flags to its entry and return.
*
* (Note: in these early-exit cases we could release the caller-taken
- * lock, since the object is presumably now locked multiple times;
- * but it seems not worth the cycles.)
+ * lock, since the object is presumably now locked multiple times; but it
+ * seems not worth the cycles.)
*/
if (object_address_present_add_flags(object, flags, targetObjects))
return;
* object, we have to transform this deletion request into a deletion
* request of the owning object. (We'll eventually recurse back to this
* object, but the owning object has to be visited first so it will be
- * deleted after.) The way to find out about this is to scan the
+ * deleted after.) The way to find out about this is to scan the
* pg_depend entries that show what this object depends on.
*/
ScanKeyInit(&key[0],
*
* 1. At the outermost recursion level, disallow the DROP. (We
* just ereport here, rather than proceeding, since no other
- * dependencies are likely to be interesting.) However, if
+ * dependencies are likely to be interesting.) However, if
* the other object is listed in pendingObjects, just release
- * the caller's lock and return; we'll eventually complete
- * the DROP when we reach that entry in the pending list.
+ * the caller's lock and return; we'll eventually complete the
+ * DROP when we reach that entry in the pending list.
*/
if (stack == NULL)
{
AcquireDeletionLock(&otherObject);
/*
- * The other object might have been deleted while we waited
- * to lock it; if so, neither it nor the current object are
+ * The other object might have been deleted while we waited to
+ * lock it; if so, neither it nor the current object are
* interesting anymore. We test this by checking the
* pg_depend entry (see notes below).
*/
}
/*
- * Okay, recurse to the other object instead of proceeding.
- * We treat this exactly as if the original reference had
- * linked to that object instead of this one; hence, pass
- * through the same flags and stack.
+ * Okay, recurse to the other object instead of proceeding. We
+ * treat this exactly as if the original reference had linked
+ * to that object instead of this one; hence, pass through the
+ * same flags and stack.
*/
findDependentObjects(&otherObject,
flags,
systable_endscan(scan);
/*
- * Now recurse to any dependent objects. We must visit them first
- * since they have to be deleted before the current object.
+ * Now recurse to any dependent objects. We must visit them first since
+ * they have to be deleted before the current object.
*/
mystack.object = object; /* set up a new stack level */
mystack.flags = flags;
while (HeapTupleIsValid(tup = systable_getnext(scan)))
{
Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
- int subflags;
+ int subflags;
otherObject.classId = foundDep->classid;
otherObject.objectId = foundDep->objid;
AcquireDeletionLock(&otherObject);
/*
- * The dependent object might have been deleted while we waited
- * to lock it; if so, we don't need to do anything more with it.
- * We can test this cheaply and independently of the object's type
- * by seeing if the pg_depend tuple we are looking at is still live.
- * (If the object got deleted, the tuple would have been deleted too.)
+ * The dependent object might have been deleted while we waited to
+ * lock it; if so, we don't need to do anything more with it. We can
+ * test this cheaply and independently of the object's type by seeing
+ * if the pg_depend tuple we are looking at is still live. (If the
+ * object got deleted, the tuple would have been deleted too.)
*/
if (!systable_recheck_tuple(scan, tup))
{
systable_endscan(scan);
/*
- * Finally, we can add the target object to targetObjects. Be careful
- * to include any flags that were passed back down to us from inner
- * recursion levels.
+ * Finally, we can add the target object to targetObjects. Be careful to
+ * include any flags that were passed back down to us from inner recursion
+ * levels.
*/
extra.flags = mystack.flags;
if (stack)
int i;
/*
- * If no error is to be thrown, and the msglevel is too low to be shown
- * to either client or server log, there's no need to do any of the work.
+ * If no error is to be thrown, and the msglevel is too low to be shown to
+ * either client or server log, there's no need to do any of the work.
*
* Note: this code doesn't know all there is to be known about elog
* levels, but it works for NOTICE and DEBUG2, which are the only values
objDesc = getObjectDescription(obj);
/*
- * If, at any stage of the recursive search, we reached the object
- * via an AUTO or INTERNAL dependency, then it's okay to delete it
- * even in RESTRICT mode.
+ * If, at any stage of the recursive search, we reached the object via
+ * an AUTO or INTERNAL dependency, then it's okay to delete it even in
+ * RESTRICT mode.
*/
if (extra->flags & (DEPFLAG_AUTO | DEPFLAG_INTERNAL))
{
/*
- * auto-cascades are reported at DEBUG2, not msglevel. We
- * don't try to combine them with the regular message because
- * the results are too confusing when client_min_messages and
+ * auto-cascades are reported at DEBUG2, not msglevel. We don't
+ * try to combine them with the regular message because the
+ * results are too confusing when client_min_messages and
* log_min_messages are different.
*/
ereport(DEBUG2,
}
else if (behavior == DROP_RESTRICT)
{
- char *otherDesc = getObjectDescription(&extra->dependee);
+ char *otherDesc = getObjectDescription(&extra->dependee);
if (numReportedClient < MAX_REPORTED_DEPS)
{
if (origObject)
ereport(ERROR,
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
- errmsg("cannot drop %s because other objects depend on it",
- getObjectDescription(origObject)),
+ errmsg("cannot drop %s because other objects depend on it",
+ getObjectDescription(origObject)),
errdetail("%s", clientdetail.data),
errdetail_log("%s", logdetail.data),
errhint("Use DROP ... CASCADE to drop the dependent objects too.")));
else if (numReportedClient > 1)
{
ereport(msglevel,
- /* translator: %d always has a value larger than 1 */
+ /* translator: %d always has a value larger than 1 */
(errmsg_plural("drop cascades to %d other object",
"drop cascades to %d other objects",
numReportedClient + numNotReportedClient,
/*
* First remove any pg_depend records that link from this object to
- * others. (Any records linking to this object should be gone already.)
+ * others. (Any records linking to this object should be gone already.)
*
* When dropping a whole object (subId = 0), remove all pg_depend records
* for its sub-objects too.
systable_endscan(scan);
/*
- * Delete shared dependency references related to this object. Again,
- * if subId = 0, remove records for sub-objects too.
+ * Delete shared dependency references related to this object. Again, if
+ * subId = 0, remove records for sub-objects too.
*/
deleteSharedDependencyRecordsFor(object->classId, object->objectId,
object->objectSubId);
newrefs;
/*
- * We can't sort if the array has "extra" data, because there's no way
- * to keep it in sync. Fortunately that combination of features is
- * not needed.
+ * We can't sort if the array has "extra" data, because there's no way to
+ * keep it in sync. Fortunately that combination of features is not
+ * needed.
*/
Assert(!addrs->extras);
addrs->refs = (ObjectAddress *)
repalloc(addrs->refs, addrs->maxrefs * sizeof(ObjectAddress));
addrs->extras = (ObjectAddressExtra *)
- repalloc(addrs->extras, addrs->maxrefs * sizeof(ObjectAddressExtra));
+ repalloc(addrs->extras, addrs->maxrefs * sizeof(ObjectAddressExtra));
}
/* record this item */
item = addrs->refs + addrs->numrefs;
{
/*
* We get here if we find a need to delete a column after
- * having already decided to drop its whole table. Obviously
+ * having already decided to drop its whole table. Obviously
* we no longer need to drop the column. But don't plaster
* its flags on the table.
*/
if (OidIsValid(con->conrelid))
{
- StringInfoData rel;
+ StringInfoData rel;
initStringInfo(&rel);
getRelationDescription(&rel, con->conrelid);
initStringInfo(&opfam);
getOpFamilyDescription(&opfam, amopForm->amopfamily);
+
/*
* translator: %d is the operator strategy (a number), the
- * first %s is the textual form of the operator, and the second
- * %s is the description of the operator family.
+ * first %s is the textual form of the operator, and the
+ * second %s is the description of the operator family.
*/
appendStringInfo(&buffer, _("operator %d %s of %s"),
amopForm->amopstrategy,
initStringInfo(&opfam);
getOpFamilyDescription(&opfam, amprocForm->amprocfamily);
+
/*
* translator: %d is the function number, the first %s is the
* textual form of the function with arguments, and the second
case OCLASS_USER_MAPPING:
{
- HeapTuple tup;
- Oid useid;
- char *usename;
+ HeapTuple tup;
+ Oid useid;
+ char *usename;
tup = SearchSysCache(USERMAPPINGOID,
ObjectIdGetDatum(object->objectId),
Oid new_array_type);
static void RelationRemoveInheritance(Oid relid);
static void StoreRelCheck(Relation rel, char *ccname, Node *expr,
- bool is_local, int inhcount);
+ bool is_local, int inhcount);
static void StoreConstraints(Relation rel, List *cooked_constraints);
static bool MergeWithExistingConstraint(Relation rel, char *ccname, Node *expr,
- bool allow_merge, bool is_local);
+ bool allow_merge, bool is_local);
static void SetRelationNumChecks(Relation rel, int numchecks);
static Node *cookConstraint(ParseState *pstate,
Node *raw_constraint,
static FormData_pg_attribute a1 = {
0, {"ctid"}, TIDOID, 0, sizeof(ItemPointerData),
SelfItemPointerAttributeNumber, 0, -1, -1,
- false, 'p', 's', true, false, false, true, 0, { 0 }
+ false, 'p', 's', true, false, false, true, 0, {0}
};
static FormData_pg_attribute a2 = {
0, {"oid"}, OIDOID, 0, sizeof(Oid),
ObjectIdAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
static FormData_pg_attribute a3 = {
0, {"xmin"}, XIDOID, 0, sizeof(TransactionId),
MinTransactionIdAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
static FormData_pg_attribute a4 = {
0, {"cmin"}, CIDOID, 0, sizeof(CommandId),
MinCommandIdAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
static FormData_pg_attribute a5 = {
0, {"xmax"}, XIDOID, 0, sizeof(TransactionId),
MaxTransactionIdAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
static FormData_pg_attribute a6 = {
0, {"cmax"}, CIDOID, 0, sizeof(CommandId),
MaxCommandIdAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
/*
static FormData_pg_attribute a7 = {
0, {"tableoid"}, OIDOID, 0, sizeof(Oid),
TableOidAttributeNumber, 0, -1, -1,
- true, 'p', 'i', true, false, false, true, 0, { 0 }
+ true, 'p', 'i', true, false, false, true, 0, {0}
};
static const Form_pg_attribute SysAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6, &a7};
* Caller has already opened and locked pg_attribute. new_attribute is the
* attribute to insert (but we ignore its attacl, if indeed it has one).
*
- * indstate is the index state for CatalogIndexInsert. It can be passed as
+ * indstate is the index state for CatalogIndexInsert. It can be passed as
* NULL, in which case we'll fetch the necessary info. (Don't do this when
* inserting multiple attributes, because it's a tad more expensive.)
*
heap_freetuple(tup);
}
+
/* --------------------------------
* AddNewAttributeTuples
*
ownerid, /* owner's ID */
-1, /* internal size (varlena) */
TYPTYPE_COMPOSITE, /* type-type (composite) */
- TYPCATEGORY_COMPOSITE, /* type-category (ditto) */
+ TYPCATEGORY_COMPOSITE, /* type-category (ditto) */
false, /* composite types are never preferred */
DEFAULT_TYPDELIM, /* default array delimiter */
F_RECORD_IN, /* input procedure */
ownerid, /* owner's ID */
-1, /* Internal size (varlena) */
TYPTYPE_BASE, /* Not composite - typelem is */
- TYPCATEGORY_ARRAY, /* type-category (array) */
+ TYPCATEGORY_ARRAY, /* type-category (array) */
false, /* array types are never preferred */
DEFAULT_TYPDELIM, /* default array delimiter */
F_ARRAY_IN, /* array input proc */
expr, /* Tree form check constraint */
ccbin, /* Binary form check constraint */
ccsrc, /* Source form check constraint */
- is_local, /* conislocal */
- inhcount); /* coninhcount */
+ is_local, /* conislocal */
+ inhcount); /* coninhcount */
pfree(ccbin);
pfree(ccsrc);
checknames = lappend(checknames, ccname);
/*
- * Check against pre-existing constraints. If we are allowed
- * to merge with an existing constraint, there's no more to
- * do here. (We omit the duplicate constraint from the result,
- * which is what ATAddCheckConstraint wants.)
+ * Check against pre-existing constraints. If we are allowed to
+ * merge with an existing constraint, there's no more to do here.
+ * (We omit the duplicate constraint from the result, which is
+ * what ATAddCheckConstraint wants.)
*/
if (MergeWithExistingConstraint(rel, ccname, expr,
allow_merge, is_local))
/* Found it. Conflicts if not identical check constraint */
if (con->contype == CONSTRAINT_CHECK)
{
- Datum val;
- bool isnull;
+ Datum val;
+ bool isnull;
val = fastgetattr(tup,
Anum_pg_constraint_conbin,
ccname, RelationGetRelationName(rel))));
/* OK to update the tuple */
ereport(NOTICE,
- (errmsg("merging constraint \"%s\" with inherited definition",
- ccname)));
+ (errmsg("merging constraint \"%s\" with inherited definition",
+ ccname)));
tup = heap_copytuple(tup);
con = (Form_pg_constraint) GETSTRUCT(tup);
if (is_local)
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot use window function in default expression")));
+ errmsg("cannot use window function in default expression")));
/*
* Coerce the expression to the correct type and typmod, if given. This
if (list_length(pstate->p_rtable) != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
- errmsg("only table \"%s\" can be referenced in check constraint",
- relname)));
+ errmsg("only table \"%s\" can be referenced in check constraint",
+ relname)));
/*
* No subplans or aggregates, either...
if (pstate->p_hasAggs)
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
- errmsg("cannot use aggregate function in check constraint")));
+ errmsg("cannot use aggregate function in check constraint")));
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
NULL, /* no check constraint */
NULL,
NULL,
- true, /* islocal */
- 0); /* inhcount */
+ true, /* islocal */
+ 0); /* inhcount */
referenced.classId = ConstraintRelationId;
referenced.objectId = conOid;
Assert(RegProcedureIsValid(procedure));
/*
- * Switch to the table owner's userid, so that any index functions are
- * run as that user.
+ * Switch to the table owner's userid, so that any index functions are run
+ * as that user.
*/
GetUserIdAndContext(&save_userid, &save_secdefcxt);
SetUserIdAndContext(heapRelation->rd_rel->relowner, true);
scan = heap_beginscan_strat(heapRelation, /* relation */
snapshot, /* snapshot */
- 0, /* number of keys */
- NULL, /* scan key */
- true, /* buffer access strategy OK */
+ 0, /* number of keys */
+ NULL, /* scan key */
+ true, /* buffer access strategy OK */
allow_sync); /* syncscan OK? */
reltuples = 0;
indexInfo->ii_Concurrent = true;
/*
- * Switch to the table owner's userid, so that any index functions are
- * run as that user.
+ * Switch to the table owner's userid, so that any index functions are run
+ * as that user.
*/
GetUserIdAndContext(&save_userid, &save_secdefcxt);
SetUserIdAndContext(heapRelation->rd_rel->relowner, true);
*/
scan = heap_beginscan_strat(heapRelation, /* relation */
snapshot, /* snapshot */
- 0, /* number of keys */
- NULL, /* scan key */
- true, /* buffer access strategy OK */
- false); /* syncscan not OK */
+ 0, /* number of keys */
+ NULL, /* scan key */
+ true, /* buffer access strategy OK */
+ false); /* syncscan not OK */
/*
* Scan all tuples matching the snapshot.
if (RELATION_IS_OTHER_TEMP(iRel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot reindex temporary tables of other sessions")));
+ errmsg("cannot reindex temporary tables of other sessions")));
/*
- * Also check for active uses of the index in the current transaction;
- * we don't want to reindex underneath an open indexscan.
+ * Also check for active uses of the index in the current transaction; we
+ * don't want to reindex underneath an open indexscan.
*/
CheckTableNotInUse(iRel, "REINDEX INDEX");
* and the returned nvargs will always be zero.
*
* If expand_defaults is true, functions that could match after insertion of
- * default argument values will also be retrieved. In this case the returned
+ * default argument values will also be retrieved. In this case the returned
* structs could have nargs > passed-in nargs, and ndargs is set to the number
* of additional args (which can be retrieved from the function's
* proargdefaults entry).
pronargs * sizeof(Oid));
if (variadic)
{
- int i;
+ int i;
newResult->nvargs = effective_nargs - pronargs + 1;
/* Expand variadic argument into N copies of element type */
}
else
{
- int cmp_nargs = newResult->nargs - newResult->ndargs;
+ int cmp_nargs = newResult->nargs - newResult->ndargs;
for (prevResult = resultList;
prevResult;
if (prevResult)
{
/*
- * We have a match with a previous result. Decide which one
+ * We have a match with a previous result. Decide which one
* to keep, or mark it ambiguous if we can't decide. The
* logic here is preference > 0 means prefer the old result,
* preference < 0 means prefer the new, preference = 0 means
* ambiguous.
*/
- int preference;
+ int preference;
if (pathpos != prevResult->pathpos)
{
{
/*
* With variadic functions we could have, for example,
- * both foo(numeric) and foo(variadic numeric[]) in
- * the same namespace; if so we prefer the
- * non-variadic match on efficiency grounds.
+ * both foo(numeric) and foo(variadic numeric[]) in the
+ * same namespace; if so we prefer the non-variadic match
+ * on efficiency grounds.
*/
preference = 1;
}
break;
}
}
- Assert(prevPrevResult); /* assert we found it */
+ Assert(prevPrevResult); /* assert we found it */
}
pfree(prevResult);
/* fall through to add newResult to list */
}
/*
- * If the corresponding toast-table namespace doesn't exist yet, create it.
- * (We assume there is no need to clean it out if it does exist, since
+ * If the corresponding toast-table namespace doesn't exist yet, create
+ * it. (We assume there is no need to clean it out if it does exist, since
* dropping a parent table should make its toast table go away.)
*/
snprintf(namespaceName, sizeof(namespaceName), "pg_toast_temp_%d",
/*
* Fetch the active search path into a caller-allocated array of OIDs.
- * Returns the number of path entries. (If this is more than sarray_len,
+ * Returns the number of path entries. (If this is more than sarray_len,
* then the data didn't fit and is not all stored.)
*
* The returned list always includes the implicitly-prepended namespaces,
/*
* Also, the return type can't be INTERNAL unless there's at least one
- * INTERNAL argument. This is the same type-safety restriction we
- * enforce for regular functions, but at the level of aggregates. We
- * must test this explicitly because we allow INTERNAL as the transtype.
+ * INTERNAL argument. This is the same type-safety restriction we enforce
+ * for regular functions, but at the level of aggregates. We must test
+ * this explicitly because we allow INTERNAL as the transtype.
*/
if (finaltype == INTERNALOID && !hasInternalArg)
ereport(ERROR,
PointerGetDatum(NULL), /* allParamTypes */
PointerGetDatum(NULL), /* parameterModes */
PointerGetDatum(NULL), /* parameterNames */
- NIL, /* parameterDefaults */
+ NIL, /* parameterDefaults */
PointerGetDatum(NULL), /* proconfig */
1, /* procost */
0); /* prorows */
con = (Form_pg_constraint) GETSTRUCT(tuple);
/*
- * We need to check whether the name is already in use --- note that
- * there currently is not a unique index that would catch this.
+ * We need to check whether the name is already in use --- note that there
+ * currently is not a unique index that would catch this.
*/
if (OidIsValid(con->conrelid) &&
ConstraintNameIsUsed(CONSTRAINT_RELATION,
newname))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
- errmsg("constraint \"%s\" for relation \"%s\" already exists",
- newname, get_rel_name(con->conrelid))));
+ errmsg("constraint \"%s\" for relation \"%s\" already exists",
+ newname, get_rel_name(con->conrelid))));
if (OidIsValid(con->contypid) &&
ConstraintNameIsUsed(CONSTRAINT_DOMAIN,
con->contypid,
{
List *result = NIL;
Relation depRel;
- ScanKeyData key[2];
- SysScanDesc scan;
+ ScanKeyData key[2];
+ SysScanDesc scan;
HeapTuple tup;
depRel = heap_open(DependRelationId, AccessShareLock);
Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
/*
- * We assume any internal dependency on a constraint
- * must be what we are looking for.
+ * We assume any internal dependency on a constraint must be what we
+ * are looking for.
*/
if (deprec->refclassid == ConstraintRelationId &&
deprec->refobjsubid == 0 &&
/*
* Now that we have the lock, double-check to see if the relation
- * really exists or not. If not, assume it was dropped while
- * we waited to acquire lock, and ignore it.
+ * really exists or not. If not, assume it was dropped while we
+ * waited to acquire lock, and ignore it.
*/
if (!SearchSysCacheExists(RELOID,
ObjectIdGetDatum(inhrelid),
HeapTuple inhtup;
/*
- * If we've seen this relid already, skip it. This avoids extra
- * work in multiple-inheritance scenarios, and also protects us
- * from an infinite loop in case there is a cycle in pg_inherits
- * (though theoretically that shouldn't happen).
+ * If we've seen this relid already, skip it. This avoids extra work
+ * in multiple-inheritance scenarios, and also protects us from an
+ * infinite loop in case there is a cycle in pg_inherits (though
+ * theoretically that shouldn't happen).
*/
if (list_member_oid(visited, this_relid))
continue;
if (OidIsValid(restrictionId))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("only boolean operators can have restriction selectivity")));
+ errmsg("only boolean operators can have restriction selectivity")));
if (OidIsValid(joinId))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("only boolean operators can have join selectivity")));
+ errmsg("only boolean operators can have join selectivity")));
if (canMerge)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
/*
* At this point, if operatorObjectId is not InvalidOid then we are
- * filling in a previously-created shell. Insist that the user own
- * any such shell.
+ * filling in a previously-created shell. Insist that the user own any
+ * such shell.
*/
if (OidIsValid(operatorObjectId) &&
!pg_oper_ownercheck(operatorObjectId, GetUserId()))
values[i++] = ObjectIdGetDatum(rightTypeId); /* oprright */
values[i++] = ObjectIdGetDatum(operResultType); /* oprresult */
values[i++] = ObjectIdGetDatum(commutatorId); /* oprcom */
- values[i++] = ObjectIdGetDatum(negatorId); /* oprnegate */
- values[i++] = ObjectIdGetDatum(procedureId); /* oprcode */
- values[i++] = ObjectIdGetDatum(restrictionId); /* oprrest */
- values[i++] = ObjectIdGetDatum(joinId); /* oprjoin */
+ values[i++] = ObjectIdGetDatum(negatorId); /* oprnegate */
+ values[i++] = ObjectIdGetDatum(procedureId); /* oprcode */
+ values[i++] = ObjectIdGetDatum(restrictionId); /* oprrest */
+ values[i++] = ObjectIdGetDatum(joinId); /* oprjoin */
pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
operatorObjectId);
tup = heap_modify_tuple(tup,
- RelationGetDescr(pg_operator_desc),
- values,
- nulls,
- replaces);
+ RelationGetDescr(pg_operator_desc),
+ values,
+ nulls,
+ replaces);
simple_heap_update(pg_operator_desc, &tup->t_self, tup);
}
}
tup = heap_modify_tuple(tup,
- RelationGetDescr(pg_operator_desc),
- values,
- nulls,
- replaces);
+ RelationGetDescr(pg_operator_desc),
+ values,
+ nulls,
+ replaces);
simple_heap_update(pg_operator_desc, &tup->t_self, tup);
replaces[Anum_pg_operator_oprcom - 1] = true;
tup = heap_modify_tuple(tup,
- RelationGetDescr(pg_operator_desc),
- values,
- nulls,
- replaces);
+ RelationGetDescr(pg_operator_desc),
+ values,
+ nulls,
+ replaces);
simple_heap_update(pg_operator_desc, &tup->t_self, tup);
replaces[Anum_pg_operator_oprnegate - 1] = true;
tup = heap_modify_tuple(tup,
- RelationGetDescr(pg_operator_desc),
- values,
- nulls,
- replaces);
+ RelationGetDescr(pg_operator_desc),
+ values,
+ nulls,
+ replaces);
simple_heap_update(pg_operator_desc, &tup->t_self, tup);
ARR_ELEMTYPE(modesArray) != CHAROID)
elog(ERROR, "parameterModes is not a 1-D char array");
modes = (char *) ARR_DATA_PTR(modesArray);
+
/*
- * Only the last input parameter can be variadic; if it is, save
- * its element type. Errors here are just elog since caller should
- * have checked this already.
+ * Only the last input parameter can be variadic; if it is, save its
+ * element type. Errors here are just elog since caller should have
+ * checked this already.
*/
for (i = 0; i < allParamCount; i++)
{
/*
* If there are existing defaults, check compatibility: redefinition
- * must not remove any defaults nor change their types. (Removing
- * a default might cause a function to fail to satisfy an existing
- * call. Changing type would only be possible if the associated
- * parameter is polymorphic, and in such cases a change of default
- * type might alter the resolved output type of existing calls.)
+ * must not remove any defaults nor change their types. (Removing a
+ * default might cause a function to fail to satisfy an existing call.
+ * Changing type would only be possible if the associated parameter is
+ * polymorphic, and in such cases a change of default type might alter
+ * the resolved output type of existing calls.)
*/
if (oldproc->pronargdefaults != 0)
{
foreach(oldlc, oldDefaults)
{
- Node *oldDef = (Node *) lfirst(oldlc);
- Node *newDef = (Node *) lfirst(newlc);
+ Node *oldDef = (Node *) lfirst(oldlc);
+ Node *newDef = (Node *) lfirst(newlc);
if (exprType(oldDef) != exprType(newDef))
ereport(ERROR,
else
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("function \"%s\" is not an aggregate function",
- procedureName)));
+ errmsg("function \"%s\" is not an aggregate function",
+ procedureName)));
}
if (oldproc->proiswindow != isWindowFunc)
{
static Oid classIdGetDbId(Oid classId);
static void shdepLockAndCheckObject(Oid classId, Oid objectId);
static void shdepChangeDep(Relation sdepRel,
- Oid classid, Oid objid, int32 objsubid,
- Oid refclassid, Oid refobjid,
- SharedDependencyType deptype);
+ Oid classid, Oid objid, int32 objsubid,
+ Oid refclassid, Oid refobjid,
+ SharedDependencyType deptype);
static void shdepAddDependency(Relation sdepRel,
- Oid classId, Oid objectId, int32 objsubId,
- Oid refclassId, Oid refobjId,
- SharedDependencyType deptype);
+ Oid classId, Oid objectId, int32 objsubId,
+ Oid refclassId, Oid refobjId,
+ SharedDependencyType deptype);
static void shdepDropDependency(Relation sdepRel,
- Oid classId, Oid objectId, int32 objsubId,
- bool drop_subobjects,
- Oid refclassId, Oid refobjId,
- SharedDependencyType deptype);
+ Oid classId, Oid objectId, int32 objsubId,
+ bool drop_subobjects,
+ Oid refclassId, Oid refobjId,
+ SharedDependencyType deptype);
static void storeObjectDescription(StringInfo descs, objectType type,
ObjectAddress *object,
SharedDependencyType deptype,
/* Caller screwed up if multiple matches */
if (oldtup)
elog(ERROR,
- "multiple pg_shdepend entries for object %u/%u/%d deptype %c",
+ "multiple pg_shdepend entries for object %u/%u/%d deptype %c",
classid, objid, objsubid, deptype);
oldtup = heap_copytuple(scantup);
}
SHARED_DEPENDENCY_ACL);
else
shdepDropDependency(sdepRel, classId, objectId, objsubId,
- false, /* exact match on objsubId */
+ false, /* exact match on objsubId */
AuthIdRelationId, roleid,
SHARED_DEPENDENCY_ACL);
}
if (numNotReportedDbs > 0)
appendStringInfo(&descs, ngettext("\nand objects in %d other database "
"(see server log for list)",
- "\nand objects in %d other databases "
+ "\nand objects in %d other databases "
"(see server log for list)",
numNotReportedDbs),
numNotReportedDbs);
if (internalSize == -1 && !(alignment == 'i' || alignment == 'd'))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("alignment \"%c\" is invalid for variable-length type",
- alignment)));
+ errmsg("alignment \"%c\" is invalid for variable-length type",
+ alignment)));
/* cstring must have char alignment */
if (internalSize == -2 && !(alignment == 'c'))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("alignment \"%c\" is invalid for variable-length type",
- alignment)));
+ errmsg("alignment \"%c\" is invalid for variable-length type",
+ alignment)));
}
/* Only varlena types can be toasted */
* Okay to update existing shell type tuple
*/
tup = heap_modify_tuple(tup,
- RelationGetDescr(pg_type_desc),
- values,
- nulls,
- replaces);
+ RelationGetDescr(pg_type_desc),
+ values,
+ nulls,
+ replaces);
simple_heap_update(pg_type_desc, &tup->t_self, tup);
else
{
tup = heap_form_tuple(RelationGetDescr(pg_type_desc),
- values,
- nulls);
+ values,
+ nulls);
/* Force the OID if requested by caller, else heap_insert does it */
if (OidIsValid(newTypeOid))
if (!istemp)
{
/*
- * Make an XLOG entry showing the file creation. If we abort, the file
- * will be dropped at abort time.
+ * Make an XLOG entry showing the file creation. If we abort, the
+ * file will be dropped at abort time.
*/
xlrec.rnode = rnode;
void
RelationTruncate(Relation rel, BlockNumber nblocks)
{
- bool fsm;
- bool vm;
+ bool fsm;
+ bool vm;
/* Open it at the smgr level if not already done */
RelationOpenSmgr(rel);
visibilitymap_truncate(rel, nblocks);
/*
- * We WAL-log the truncation before actually truncating, which
- * means trouble if the truncation fails. If we then crash, the WAL
- * replay likely isn't going to succeed in the truncation either, and
- * cause a PANIC. It's tempting to put a critical section here, but
- * that cure would be worse than the disease. It would turn a usually
- * harmless failure to truncate, that could spell trouble at WAL replay,
- * into a certain PANIC.
+ * We WAL-log the truncation before actually truncating, which means
+ * trouble if the truncation fails. If we then crash, the WAL replay
+ * likely isn't going to succeed in the truncation either, and cause a
+ * PANIC. It's tempting to put a critical section here, but that cure
+ * would be worse than the disease. It would turn a usually harmless
+ * failure to truncate, that could spell trouble at WAL replay, into a
+ * certain PANIC.
*/
if (!rel->rd_istemp)
{
lsn = XLogInsert(RM_SMGR_ID, XLOG_SMGR_TRUNCATE, &rdata);
/*
- * Flush, because otherwise the truncation of the main relation
- * might hit the disk before the WAL record, and the truncation of
- * the FSM or visibility map. If we crashed during that window, we'd
- * be left with a truncated heap, but the FSM or visibility map would
- * still contain entries for the non-existent heap pages.
+ * Flush, because otherwise the truncation of the main relation might
+ * hit the disk before the WAL record, and the truncation of the FSM
+ * or visibility map. If we crashed during that window, we'd be left
+ * with a truncated heap, but the FSM or visibility map would still
+ * contain entries for the non-existent heap pages.
*/
if (fsm || vm)
XLogFlush(lsn);
/* do deletion if called for */
if (pending->atCommit == isCommit)
{
- int i;
+ int i;
/* schedule unlinking old files */
SMgrRelation srel;
/* Also tell xlogutils.c about it */
XLogTruncateRelation(xlrec->rnode, MAIN_FORKNUM, xlrec->blkno);
-
+
/* Truncate FSM too */
if (smgrexists(reln, FSM_FORKNUM))
{
- Relation rel = CreateFakeRelcacheEntry(xlrec->rnode);
+ Relation rel = CreateFakeRelcacheEntry(xlrec->rnode);
+
FreeSpaceMapTruncateRel(rel, xlrec->blkno);
FreeFakeRelcacheEntry(rel);
}
if (info == XLOG_SMGR_CREATE)
{
xl_smgr_create *xlrec = (xl_smgr_create *) rec;
- char *path = relpath(xlrec->rnode, MAIN_FORKNUM);
+ char *path = relpath(xlrec->rnode, MAIN_FORKNUM);
appendStringInfo(buf, "file create: %s", path);
pfree(path);
else if (info == XLOG_SMGR_TRUNCATE)
{
xl_smgr_truncate *xlrec = (xl_smgr_truncate *) rec;
- char *path = relpath(xlrec->rnode, MAIN_FORKNUM);
+ char *path = relpath(xlrec->rnode, MAIN_FORKNUM);
appendStringInfo(buf, "file truncate: %s to %u blocks", path,
xlrec->blkno);
/*
* Check to see whether the table actually needs a TOAST table.
*
- * Caller can optionally override this check. (Note: at present
- * no callers in core Postgres do so, but this option is needed by
+ * Caller can optionally override this check. (Note: at present no
+ * callers in core Postgres do so, but this option is needed by
* pg_migrator.)
*/
if (!force && !needs_toast_table(rel))
*
* transtype can't be a pseudo-type, since we need to be able to store
* values of the transtype. However, we can allow polymorphic transtype
- * in some cases (AggregateCreate will check). Also, we allow "internal"
+ * in some cases (AggregateCreate will check). Also, we allow "internal"
* for functions that want to pass pointers to private data structures;
- * but allow that only to superusers, since you could crash the system
- * (or worse) by connecting up incompatible internal-using functions
- * in an aggregate.
+ * but allow that only to superusers, since you could crash the system (or
+ * worse) by connecting up incompatible internal-using functions in an
+ * aggregate.
*/
transTypeId = typenameTypeId(NULL, transType, NULL);
if (get_typtype(transTypeId) == TYPTYPE_PSEUDO &&
!IsPolymorphicType(transTypeId))
{
if (transTypeId == INTERNALOID && superuser())
- /* okay */ ;
+ /* okay */ ;
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
{
if (onerel->rd_rel->relisshared)
ereport(WARNING,
- (errmsg("skipping \"%s\" --- only superuser can analyze it",
- RelationGetRelationName(onerel))));
+ (errmsg("skipping \"%s\" --- only superuser can analyze it",
+ RelationGetRelationName(onerel))));
else if (onerel->rd_rel->relnamespace == PG_CATALOG_NAMESPACE)
ereport(WARNING,
(errmsg("skipping \"%s\" --- only superuser or database owner can analyze it",
RelationGetRelationName(onerel))));
/*
- * Switch to the table owner's userid, so that any index functions are
- * run as that user.
+ * Switch to the table owner's userid, so that any index functions are run
+ * as that user.
*/
GetUserIdAndContext(&save_userid, &save_secdefcxt);
SetUserIdAndContext(onerel->rd_rel->relowner, true);
/*
* Same for indexes. Vacuum always scans all indexes, so if we're part of
- * VACUUM ANALYZE, don't overwrite the accurate count already inserted by
+ * VACUUM ANALYZE, don't overwrite the accurate count already inserted by
* VACUUM.
*/
if (!vacstmt->vacuum)
return NULL;
/*
- * Create the VacAttrStats struct. Note that we only have a copy of
- * the fixed fields of the pg_attribute tuple.
+ * Create the VacAttrStats struct. Note that we only have a copy of the
+ * fixed fields of the pg_attribute tuple.
*/
stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));
stats->attr = (Form_pg_attribute) palloc(ATTRIBUTE_FIXED_PART_SIZE);
stats->tupattnum = attnum;
/*
- * The fields describing the stats->stavalues[n] element types default
- * to the type of the field being analyzed, but the type-specific
- * typanalyze function can change them if it wants to store something
- * else.
+ * The fields describing the stats->stavalues[n] element types default to
+ * the type of the field being analyzed, but the type-specific typanalyze
+ * function can change them if it wants to store something else.
*/
for (i = 0; i < STATISTIC_NUM_SLOTS; i++)
{
double *totalrows, double *totaldeadrows)
{
int numrows = 0; /* # rows now in reservoir */
- double samplerows = 0; /* total # rows collected */
+ double samplerows = 0; /* total # rows collected */
double liverows = 0; /* # live rows seen */
double deadrows = 0; /* # dead rows seen */
double rowstoskip = -1; /* -1 means not set yet */
* the maxoffset value stays good (else concurrent VACUUM might delete
* tuples out from under us). Hence, pin the page until we are done
* looking at it. We also choose to hold sharelock on the buffer
- * throughout --- we could release and re-acquire sharelock for
- * each tuple, but since we aren't doing much work per tuple, the
- * extra lock traffic is probably better avoided.
+ * throughout --- we could release and re-acquire sharelock for each
+ * tuple, but since we aren't doing much work per tuple, the extra
+ * lock traffic is probably better avoided.
*/
targbuffer = ReadBufferExtended(onerel, MAIN_FORKNUM, targblock,
RBM_NORMAL, vac_strategy);
/*
* We ignore unused and redirect line pointers. DEAD line
- * pointers should be counted as dead, because we need vacuum
- * to run to get rid of them. Note that this rule agrees with
- * the way that heap_page_prune() counts things.
+ * pointers should be counted as dead, because we need vacuum to
+ * run to get rid of them. Note that this rule agrees with the
+ * way that heap_page_prune() counts things.
*/
if (!ItemIdIsNormal(itemid))
{
break;
case HEAPTUPLE_INSERT_IN_PROGRESS:
+
/*
* Insert-in-progress rows are not counted. We assume
* that when the inserting transaction commits or aborts,
* count. This works right only if that transaction ends
* after we finish analyzing the table; if things happen
* in the other order, its stats update will be
- * overwritten by ours. However, the error will be
- * large only if the other transaction runs long enough
- * to insert many tuples, so assuming it will finish
- * after us is the safer option.
+ * overwritten by ours. However, the error will be large
+ * only if the other transaction runs long enough to
+ * insert many tuples, so assuming it will finish after us
+ * is the safer option.
*
* A special case is that the inserting transaction might
- * be our own. In this case we should count and sample
+ * be our own. In this case we should count and sample
* the row, to accommodate users who load a table and
* analyze it in one transaction. (pgstat_report_analyze
- * has to adjust the numbers we send to the stats collector
- * to make this come out right.)
+ * has to adjust the numbers we send to the stats
+ * collector to make this come out right.)
*/
if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple.t_data)))
{
break;
case HEAPTUPLE_DELETE_IN_PROGRESS:
+
/*
* We count delete-in-progress rows as still live, using
* the same reasoning given above; but we don't bother to
* If the delete was done by our own transaction, however,
* we must count the row as dead to make
* pgstat_report_analyze's stats adjustments come out
- * right. (Note: this works out properly when the row
- * was both inserted and deleted in our xact.)
+ * right. (Note: this works out properly when the row was
+ * both inserted and deleted in our xact.)
*/
if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmax(targtuple.t_data)))
deadrows += 1;
/*
* t in Vitter's paper is the number of records already
* processed. If we need to compute a new S value, we
- * must use the not-yet-incremented value of samplerows
- * as t.
+ * must use the not-yet-incremented value of samplerows as
+ * t.
*/
if (rowstoskip < 0)
rowstoskip = get_next_S(samplerows, targrows, &rstate);
{
/* Yes, replace it */
stup = heap_modify_tuple(oldtup,
- RelationGetDescr(sd),
- values,
- nulls,
- replaces);
+ RelationGetDescr(sd),
+ values,
+ nulls,
+ replaces);
ReleaseSysCache(oldtup);
simple_heap_update(sd, &stup->t_self, stup);
}
stats->numnumbers[0] = num_mcv;
stats->stavalues[0] = mcv_values;
stats->numvalues[0] = num_mcv;
+
/*
- * Accept the defaults for stats->statypid and others.
- * They have been set before we were called (see vacuum.h)
+ * Accept the defaults for stats->statypid and others. They have
+ * been set before we were called (see vacuum.h)
*/
}
}
stats->numnumbers[slot_idx] = num_mcv;
stats->stavalues[slot_idx] = mcv_values;
stats->numvalues[slot_idx] = num_mcv;
+
/*
- * Accept the defaults for stats->statypid and others.
- * They have been set before we were called (see vacuum.h)
+ * Accept the defaults for stats->statypid and others. They have
+ * been set before we were called (see vacuum.h)
*/
slot_idx++;
}
/*
* The object of this loop is to copy the first and last values[]
- * entries along with evenly-spaced values in between. So the
+ * entries along with evenly-spaced values in between. So the
* i'th value is values[(i * (nvals - 1)) / (num_hist - 1)]. But
* computing that subscript directly risks integer overflow when
* the stats target is more than a couple thousand. Instead we
stats->staop[slot_idx] = mystats->ltopr;
stats->stavalues[slot_idx] = hist_values;
stats->numvalues[slot_idx] = num_hist;
+
/*
- * Accept the defaults for stats->statypid and others.
- * They have been set before we were called (see vacuum.h)
+ * Accept the defaults for stats->statypid and others. They have
+ * been set before we were called (see vacuum.h)
*/
slot_idx++;
}
* transaction.
*
* Like NOTIFY, LISTEN and UNLISTEN just add the desired action to a list
- * of pending actions. If we reach transaction commit, the changes are
+ * of pending actions. If we reach transaction commit, the changes are
* applied to pg_listener just before executing any pending NOTIFYs. This
* method is necessary because to avoid race conditions, we must hold lock
* on pg_listener from when we insert a new listener tuple until we commit.
typedef struct
{
ListenActionKind action;
- char condname[1]; /* actually, as long as needed */
+ char condname[1]; /* actually, as long as needed */
} ListenAction;
-static List *pendingActions = NIL; /* list of ListenAction */
+static List *pendingActions = NIL; /* list of ListenAction */
-static List *upperPendingActions = NIL; /* list of upper-xact lists */
+static List *upperPendingActions = NIL; /* list of upper-xact lists */
/*
* State for outbound notifies consists of a list of all relnames NOTIFYed
* condition name, it will get a self-notify at commit. This is a bit odd
* but is consistent with our historical behavior.
*/
-static List *pendingNotifies = NIL; /* list of C strings */
+static List *pendingNotifies = NIL; /* list of C strings */
static List *upperPendingNotifies = NIL; /* list of upper-xact lists */
oldcontext = MemoryContextSwitchTo(CurTransactionContext);
/*
- * Ordering of the list isn't important. We choose to put new
- * entries on the front, as this might make duplicate-elimination
- * a tad faster when the same condition is signaled many times in
- * a row.
+ * Ordering of the list isn't important. We choose to put new entries
+ * on the front, as this might make duplicate-elimination a tad faster
+ * when the same condition is signaled many times in a row.
*/
pendingNotifies = lcons(pstrdup(relname), pendingNotifies);
ListenAction *actrec;
/*
- * Unlike Async_Notify, we don't try to collapse out duplicates.
- * It would be too complicated to ensure we get the right interactions
- * of conflicting LISTEN/UNLISTEN/UNLISTEN_ALL, and it's unlikely that
- * there would be any performance benefit anyway in sane applications.
+ * Unlike Async_Notify, we don't try to collapse out duplicates. It would
+ * be too complicated to ensure we get the right interactions of
+ * conflicting LISTEN/UNLISTEN/UNLISTEN_ALL, and it's unlikely that there
+ * would be any performance benefit anyway in sane applications.
*/
oldcontext = MemoryContextSwitchTo(CurTransactionContext);
namestrcpy(&condname, relname);
values[Anum_pg_listener_relname - 1] = NameGetDatum(&condname);
values[Anum_pg_listener_pid - 1] = Int32GetDatum(MyProcPid);
- values[Anum_pg_listener_notify - 1] = Int32GetDatum(0); /* no notifies pending */
+ values[Anum_pg_listener_notify - 1] = Int32GetDatum(0); /* no notifies pending */
tuple = heap_form_tuple(RelationGetDescr(lRel), values, nulls);
int my_level = GetCurrentTransactionNestLevel();
/*
- * All we have to do is pop the stack --- the actions/notifies made in this
- * subxact are no longer interesting, and the space will be freed when
- * CurTransactionContext is recycled.
+ * All we have to do is pop the stack --- the actions/notifies made in
+ * this subxact are no longer interesting, and the space will be freed
+ * when CurTransactionContext is recycled.
*
* This routine could be called more than once at a given nesting level if
* there is trouble during subxact abort. Avoid dumping core by using
/*
* At this point, everything is kosher except that the toast table's name
- * corresponds to the temporary table. The name is irrelevant to
- * the backend because it's referenced by OID, but users looking at the
- * catalogs could be confused. Rename it to prevent this problem.
+ * corresponds to the temporary table. The name is irrelevant to the
+ * backend because it's referenced by OID, but users looking at the
+ * catalogs could be confused. Rename it to prevent this problem.
*
* Note no lock required on the relation, because we already hold an
* exclusive lock on it.
/*
* Need to make a copy of the tuple descriptor, since
- * heap_create_with_catalog modifies it. Note that the NewHeap will
- * not receive any of the defaults or constraints associated with the
- * OldHeap; we don't need 'em, and there's no reason to spend cycles
- * inserting them into the catalogs only to delete them.
+ * heap_create_with_catalog modifies it. Note that the NewHeap will not
+ * receive any of the defaults or constraints associated with the OldHeap;
+ * we don't need 'em, and there's no reason to spend cycles inserting them
+ * into the catalogs only to delete them.
*/
tupdesc = CreateTupleDescCopy(OldHeapDesc);
&OldestXmin, &FreezeXid, NULL);
/*
- * FreezeXid will become the table's new relfrozenxid, and that mustn't
- * go backwards, so take the max.
+ * FreezeXid will become the table's new relfrozenxid, and that mustn't go
+ * backwards, so take the max.
*/
if (TransactionIdPrecedes(FreezeXid, OldHeap->rd_rel->relfrozenxid))
FreezeXid = OldHeap->rd_rel->relfrozenxid;
else
{
newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(description), values,
- nulls, replaces);
+ nulls, replaces);
simple_heap_update(description, &oldtuple->t_self, newtuple);
}
if (newtuple == NULL && comment != NULL)
{
newtuple = heap_form_tuple(RelationGetDescr(description),
- values, nulls);
+ values, nulls);
simple_heap_insert(description, newtuple);
}
else
{
newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(shdescription),
- values, nulls, replaces);
+ values, nulls, replaces);
simple_heap_update(shdescription, &oldtuple->t_self, newtuple);
}
if (newtuple == NULL && comment != NULL)
{
newtuple = heap_form_tuple(RelationGetDescr(shdescription),
- values, nulls);
+ values, nulls);
simple_heap_insert(shdescription, newtuple);
}
if (get_func_rettype(funcoid) != VOIDOID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("encoding conversion function %s must return type \"void\"",
- NameListToString(func_name))));
+ errmsg("encoding conversion function %s must return type \"void\"",
+ NameListToString(func_name))));
/* Check we have EXECUTE rights for the function */
aclresult = pg_proc_aclcheck(funcoid, GetUserId(), ACL_EXECUTE);
NameListToString(func_name));
/*
- * Check that the conversion function is suitable for the requested
- * source and target encodings. We do that by calling the function with
- * an empty string; the conversion function should throw an error if it
- * can't perform the requested conversion.
+ * Check that the conversion function is suitable for the requested source
+ * and target encodings. We do that by calling the function with an empty
+ * string; the conversion function should throw an error if it can't
+ * perform the requested conversion.
*/
OidFunctionCall5(funcoid,
Int32GetDatum(from_encoding),
DropConversionsCommand(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
/*
* First we identify all the conversions, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the conversions depends on another.
- * (Not that that is very likely, but we may as well do this consistently.)
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the conversions depends on another. (Not that
+ * that is very likely, but we may as well do this consistently.)
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *name = (List *) lfirst(cell);
+ List *name = (List *) lfirst(cell);
Oid conversionOid;
HeapTuple tuple;
Form_pg_conversion con;
* function call overhead in tight COPY loops.
*
* We must use "if (1)" because the usual "do {...} while(0)" wrapper would
- * prevent the continue/break processing from working. We end the "if (1)"
+ * prevent the continue/break processing from working. We end the "if (1)"
* with "else ((void) 0)" to ensure the "if" does not unintentionally match
* any "else" in the calling code, and to avoid any compiler warnings about
* empty statements. See http://www.cit.gu.edu.au/~anthony/info/C/C.macros.
if (strlen(cstate->delim) != 1)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("COPY delimiter must be a single one-byte character")));
+ errmsg("COPY delimiter must be a single one-byte character")));
/* Disallow end-of-line characters */
if (strchr(cstate->delim, '\r') != NULL ||
* backslash because it would be ambiguous. We can't allow the other
* cases because data characters matching the delimiter must be
* backslashed, and certain backslash combinations are interpreted
- * non-literally by COPY IN. Disallowing all lower case ASCII letters
- * is more than strictly necessary, but seems best for consistency and
+ * non-literally by COPY IN. Disallowing all lower case ASCII letters is
+ * more than strictly necessary, but seems best for consistency and
* future-proofing. Likewise we disallow all digits though only octal
* digits are actually dangerous.
*/
MemoryContext oldcontext = CurrentMemoryContext;
ErrorContextCallback errcontext;
CommandId mycid = GetCurrentCommandId(true);
- int hi_options = 0; /* start with default heap_insert options */
+ int hi_options = 0; /* start with default heap_insert options */
BulkInsertState bistate;
Assert(cstate->rel);
ereport(ERROR,
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
!cstate->csv_mode ?
- errmsg("literal carriage return found in data") :
- errmsg("unquoted carriage return found in data"),
+ errmsg("literal carriage return found in data") :
+ errmsg("unquoted carriage return found in data"),
!cstate->csv_mode ?
- errhint("Use \"\\r\" to represent carriage return.") :
+ errhint("Use \"\\r\" to represent carriage return.") :
errhint("Use quoted CSV field to represent carriage return.")));
/*
errmsg("literal carriage return found in data") :
errmsg("unquoted carriage return found in data"),
!cstate->csv_mode ?
- errhint("Use \"\\r\" to represent carriage return.") :
+ errhint("Use \"\\r\" to represent carriage return.") :
errhint("Use quoted CSV field to represent carriage return.")));
/* If reach here, we have found the line terminator */
break;
errmsg("unquoted newline found in data"),
!cstate->csv_mode ?
errhint("Use \"\\n\" to represent newline.") :
- errhint("Use quoted CSV field to represent newline.")));
+ errhint("Use quoted CSV field to represent newline.")));
cstate->eol_type = EOL_NL; /* in case not set yet */
/* If reach here, we have found the line terminator */
break;
*output_ptr++ = '\0';
/*
- * If we de-escaped a non-7-bit-ASCII char, make sure we still
- * have valid data for the db encoding. Avoid calling strlen here for
- * the sake of efficiency.
+ * If we de-escaped a non-7-bit-ASCII char, make sure we still have
+ * valid data for the db encoding. Avoid calling strlen here for the
+ * sake of efficiency.
*/
if (saw_non_ascii)
{
start_ptr = cur_ptr;
fieldvals[fieldno] = output_ptr;
- /* Scan data for field,
+ /*
+ * Scan data for field,
*
- * The loop starts in "not quote" mode and then toggles between
- * that and "in quote" mode.
- * The loop exits normally if it is in "not quote" mode and a
- * delimiter or line end is seen.
+ * The loop starts in "not quote" mode and then toggles between that
+ * and "in quote" mode. The loop exits normally if it is in "not
+ * quote" mode and a delimiter or line end is seen.
*/
for (;;)
{
if (c == escapec)
{
/*
- * peek at the next char if available, and escape it if it is
- * an escape char or a quote char
+ * peek at the next char if available, and escape it if it
+ * is an escape char or a quote char
*/
if (cur_ptr < line_end_ptr)
{
}
}
}
+
/*
- * end of quoted field. Must do this test after testing for escape
- * in case quote char and escape char are the same (which is the
- * common case).
+ * end of quoted field. Must do this test after testing for
+ * escape in case quote char and escape char are the same
+ * (which is the common case).
*/
if (c == quotec)
break;
*output_ptr++ = c;
}
}
- endfield:
+endfield:
/* Terminate attribute value in output area */
*output_ptr++ = '\0';
if ((unsigned char) c < (unsigned char) 0x20)
{
/*
- * \r and \n must be escaped, the others are traditional.
- * We prefer to dump these using the C-like notation, rather
- * than a backslash and the literal character, because it
- * makes the dump file a bit more proof against Microsoftish
- * data mangling.
+ * \r and \n must be escaped, the others are traditional. We
+ * prefer to dump these using the C-like notation, rather than
+ * a backslash and the literal character, because it makes the
+ * dump file a bit more proof against Microsoftish data
+ * mangling.
*/
switch (c)
{
DUMPSOFAR();
CopySendChar(cstate, '\\');
CopySendChar(cstate, c);
- start = ++ptr; /* do not include char in next run */
+ start = ++ptr; /* do not include char in next run */
}
else if (c == '\\' || c == delimc)
{
if ((unsigned char) c < (unsigned char) 0x20)
{
/*
- * \r and \n must be escaped, the others are traditional.
- * We prefer to dump these using the C-like notation, rather
- * than a backslash and the literal character, because it
- * makes the dump file a bit more proof against Microsoftish
- * data mangling.
+ * \r and \n must be escaped, the others are traditional. We
+ * prefer to dump these using the C-like notation, rather than
+ * a backslash and the literal character, because it makes the
+ * dump file a bit more proof against Microsoftish data
+ * mangling.
*/
switch (c)
{
DUMPSOFAR();
CopySendChar(cstate, '\\');
CopySendChar(cstate, c);
- start = ++ptr; /* do not include char in next run */
+ start = ++ptr; /* do not include char in next run */
}
else if (c == '\\' || c == delimc)
{
/*
* Check whether chosen encoding matches chosen locale settings. This
* restriction is necessary because libc's locale-specific code usually
- * fails when presented with data in an encoding it's not expecting.
- * We allow mismatch in three cases:
+ * fails when presented with data in an encoding it's not expecting. We
+ * allow mismatch in three cases:
*
* 1. locale encoding = SQL_ASCII, which means either that the locale is
* C/POSIX which works with any encoding, or that we couldn't determine
errmsg("encoding %s does not match locale %s",
pg_encoding_to_char(encoding),
dbctype),
- errdetail("The chosen LC_CTYPE setting requires encoding %s.",
- pg_encoding_to_char(ctype_encoding))));
+ errdetail("The chosen LC_CTYPE setting requires encoding %s.",
+ pg_encoding_to_char(ctype_encoding))));
if (!(collate_encoding == encoding ||
collate_encoding == PG_SQL_ASCII ||
new_record_nulls[Anum_pg_database_datacl - 1] = true;
tuple = heap_form_tuple(RelationGetDescr(pg_database_rel),
- new_record, new_record_nulls);
+ new_record, new_record_nulls);
HeapTupleSetOid(tuple, dboid);
createdb_failure_params *fparms = (createdb_failure_params *) DatumGetPointer(arg);
/*
- * Release lock on source database before doing recursive remove.
- * This is not essential but it seems desirable to release the lock
- * as soon as possible.
+ * Release lock on source database before doing recursive remove. This is
+ * not essential but it seems desirable to release the lock as soon as
+ * possible.
*/
UnlockSharedObject(DatabaseRelationId, fparms->src_dboid, 0, ShareLock);
/*
* Tell bgwriter to forget any pending fsync and unlink requests for files
- * in the database; else the fsyncs will fail at next checkpoint, or worse,
- * it will delete files that belong to a newly created database with the
- * same OID.
+ * in the database; else the fsyncs will fail at next checkpoint, or
+ * worse, it will delete files that belong to a newly created database
+ * with the same OID.
*/
ForgetDatabaseFsyncRequests(db_id);
static void
movedb(const char *dbname, const char *tblspcname)
{
- Oid db_id;
- Relation pgdbrel;
- int notherbackends;
- int npreparedxacts;
- HeapTuple oldtuple, newtuple;
- Oid src_tblspcoid, dst_tblspcoid;
- Datum new_record[Natts_pg_database];
- bool new_record_nulls[Natts_pg_database];
- bool new_record_repl[Natts_pg_database];
- ScanKeyData scankey;
- SysScanDesc sysscan;
- AclResult aclresult;
- char *src_dbpath;
- char *dst_dbpath;
- DIR *dstdir;
+ Oid db_id;
+ Relation pgdbrel;
+ int notherbackends;
+ int npreparedxacts;
+ HeapTuple oldtuple,
+ newtuple;
+ Oid src_tblspcoid,
+ dst_tblspcoid;
+ Datum new_record[Natts_pg_database];
+ bool new_record_nulls[Natts_pg_database];
+ bool new_record_repl[Natts_pg_database];
+ ScanKeyData scankey;
+ SysScanDesc sysscan;
+ AclResult aclresult;
+ char *src_dbpath;
+ char *dst_dbpath;
+ DIR *dstdir;
struct dirent *xlde;
movedb_failure_params fparms;
/*
* Force a checkpoint before proceeding. This will force dirty buffers out
- * to disk, to ensure source database is up-to-date on disk for the
- * copy. FlushDatabaseBuffers() would suffice for that, but we also want
- * to process any pending unlink requests. Otherwise, the check for
- * existing files in the target directory might fail unnecessarily, not to
- * mention that the copy might fail due to source files getting deleted
- * under it. On Windows, this also ensures that the bgwriter doesn't hold
- * any open files, which would cause rmdir() to fail.
+ * to disk, to ensure source database is up-to-date on disk for the copy.
+ * FlushDatabaseBuffers() would suffice for that, but we also want to
+ * process any pending unlink requests. Otherwise, the check for existing
+ * files in the target directory might fail unnecessarily, not to mention
+ * that the copy might fail due to source files getting deleted under it.
+ * On Windows, this also ensures that the bgwriter doesn't hold any open
+ * files, which would cause rmdir() to fail.
*/
RequestCheckpoint(CHECKPOINT_IMMEDIATE | CHECKPOINT_FORCE | CHECKPOINT_WAIT);
FreeDir(dstdir);
/*
- * The directory exists but is empty.
- * We must remove it before using the copydir function.
+ * The directory exists but is empty. We must remove it before using
+ * the copydir function.
*/
if (rmdir(dst_dbpath) != 0)
elog(ERROR, "could not remove directory \"%s\": %m",
/*
* Use an ENSURE block to make sure we remove the debris if the copy fails
- * (eg, due to out-of-disk-space). This is not a 100% solution, because
+ * (eg, due to out-of-disk-space). This is not a 100% solution, because
* of the possibility of failure during transaction commit, but it should
* handle most scenarios.
*/
sysscan = systable_beginscan(pgdbrel, DatabaseNameIndexId, true,
SnapshotNow, 1, &scankey);
oldtuple = systable_getnext(sysscan);
- if (!HeapTupleIsValid(oldtuple)) /* shouldn't happen... */
+ if (!HeapTupleIsValid(oldtuple)) /* shouldn't happen... */
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exist", dbname)));
PointerGetDatum(&fparms));
/*
- * Commit the transaction so that the pg_database update is committed.
- * If we crash while removing files, the database won't be corrupt,
- * we'll just leave some orphaned files in the old directory.
+ * Commit the transaction so that the pg_database update is committed. If
+ * we crash while removing files, the database won't be corrupt, we'll
+ * just leave some orphaned files in the old directory.
*
* (This is OK because we know we aren't inside a transaction block.)
*
- * XXX would it be safe/better to do this inside the ensure block? Not
+ * XXX would it be safe/better to do this inside the ensure block? Not
* convinced it's a good idea; consider elog just after the transaction
* really commits.
*/
}
newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), new_record,
- new_record_nulls, new_record_repl);
+ new_record_nulls, new_record_repl);
simple_heap_update(rel, &tuple->t_self, newtuple);
/* Update indexes */
}
newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &tuple->t_self, newtuple);
/* Update indexes */
/* default tablespace for this database */
if (dbTablespace)
*dbTablespace = dbform->dattablespace;
- /* default locale settings for this database */
- if (dbCollate)
- *dbCollate = pstrdup(NameStr(dbform->datcollate));
- if (dbCtype)
- *dbCtype = pstrdup(NameStr(dbform->datctype));
+ /* default locale settings for this database */
+ if (dbCollate)
+ *dbCollate = pstrdup(NameStr(dbform->datcollate));
+ if (dbCtype)
+ *dbCtype = pstrdup(NameStr(dbform->datctype));
ReleaseSysCache(tuple);
result = true;
break;
Plan *outer_plan,
int indent, ExplainState *es);
static void show_plan_tlist(Plan *plan,
- StringInfo str, int indent, ExplainState *es);
+ StringInfo str, int indent, ExplainState *es);
static void show_scan_qual(List *qual, const char *qlabel,
int scanrelid, Plan *scan_plan, Plan *outer_plan,
StringInfo str, int indent, ExplainState *es);
ExplainPrintPlan(StringInfo str, QueryDesc *queryDesc,
bool analyze, bool verbose)
{
- ExplainState es;
+ ExplainState es;
Assert(queryDesc->plannedstmt != NULL);
static Datum
optionListToArray(List *options)
{
- ArrayBuildState *astate = NULL;
- ListCell *cell;
+ ArrayBuildState *astate = NULL;
+ ListCell *cell;
foreach(cell, options)
{
/*
- * Transform a list of DefElem into text array format. This is substantially
+ * Transform a list of DefElem into text array format. This is substantially
* the same thing as optionListToArray(), except we recognize SET/ADD/DROP
* actions for modifying an existing list of options, which is passed in
* Datum form as oldOptions. Also, if fdwvalidator isn't InvalidOid
List *options,
Oid fdwvalidator)
{
- List *resultOptions = untransformRelOptions(oldOptions);
- ListCell *optcell;
- Datum result;
+ List *resultOptions = untransformRelOptions(oldOptions);
+ ListCell *optcell;
+ Datum result;
foreach(optcell, options)
{
- DefElem *od = lfirst(optcell);
+ DefElem *od = lfirst(optcell);
ListCell *cell;
ListCell *prev = NULL;
/*
- * Find the element in resultOptions. We need this for
- * validation in all cases. Also identify the previous element.
+ * Find the element in resultOptions. We need this for validation in
+ * all cases. Also identify the previous element.
*/
- foreach (cell, resultOptions)
+ foreach(cell, resultOptions)
{
- DefElem *def = lfirst(cell);
+ DefElem *def = lfirst(cell);
if (strcmp(def->defname, od->defname) == 0)
break;
}
/*
- * It is possible to perform multiple SET/DROP actions on the
- * same option. The standard permits this, as long as the
- * options to be added are unique. Note that an unspecified
- * action is taken to be ADD.
+ * It is possible to perform multiple SET/DROP actions on the same
+ * option. The standard permits this, as long as the options to be
+ * added are unique. Note that an unspecified action is taken to be
+ * ADD.
*/
switch (od->defaction)
{
static Oid
GetUserOidFromMapping(const char *username, bool missing_ok)
{
- if (!username)
- /* PUBLIC user mapping */
- return InvalidOid;
+ if (!username)
+ /* PUBLIC user mapping */
+ return InvalidOid;
- if (strcmp(username, "current_user") == 0)
- /* map to the owner */
- return GetUserId();
+ if (strcmp(username, "current_user") == 0)
+ /* map to the owner */
+ return GetUserId();
- /* map to provided user */
- return missing_ok ? get_roleid(username) : get_roleid_checked(username);
+ /* map to provided user */
+ return missing_ok ? get_roleid(username) : get_roleid_checked(username);
}
Oid fdwId;
Form_pg_foreign_data_wrapper form;
- /* Must be a superuser to change a FDW owner */
+ /* Must be a superuser to change a FDW owner */
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
name),
errhint("Must be superuser to change owner of a foreign-data wrapper.")));
- /* New owner must also be a superuser */
+ /* New owner must also be a superuser */
if (!superuser_arg(newOwnerId))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",
name),
- errhint("The owner of a foreign-data wrapper must be a superuser.")));
+ errhint("The owner of a foreign-data wrapper must be a superuser.")));
rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
if (!HeapTupleIsValid(tup))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("foreign-data wrapper \"%s\" does not exist", name)));
+ errmsg("foreign-data wrapper \"%s\" does not exist", name)));
fdwId = HeapTupleGetOid(tup);
form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);
0, 0, 0);
if (!HeapTupleIsValid(tup))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("server \"%s\" does not exist", name)));
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist", name)));
srvId = HeapTupleGetOid(tup);
form = (Form_pg_foreign_server) GETSTRUCT(tup);
void
CreateForeignDataWrapper(CreateFdwStmt *stmt)
{
- Relation rel;
- Datum values[Natts_pg_foreign_data_wrapper];
- bool nulls[Natts_pg_foreign_data_wrapper];
- HeapTuple tuple;
- Oid fdwId;
- Oid fdwvalidator;
- Datum fdwoptions;
- Oid ownerId;
+ Relation rel;
+ Datum values[Natts_pg_foreign_data_wrapper];
+ bool nulls[Natts_pg_foreign_data_wrapper];
+ HeapTuple tuple;
+ Oid fdwId;
+ Oid fdwvalidator;
+ Datum fdwoptions;
+ Oid ownerId;
/* Must be super user */
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("permission denied to create foreign-data wrapper \"%s\"",
- stmt->fdwname),
- errhint("Must be superuser to create a foreign-data wrapper.")));
+ errmsg("permission denied to create foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to create a foreign-data wrapper.")));
/* For now the owner cannot be specified on create. Use effective user ID. */
ownerId = GetUserId();
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("permission denied to alter foreign-data wrapper \"%s\"",
- stmt->fdwname),
- errhint("Must be superuser to alter a foreign-data wrapper.")));
+ errmsg("permission denied to alter foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to alter a foreign-data wrapper.")));
tp = SearchSysCacheCopy(FOREIGNDATAWRAPPERNAME,
CStringGetDatum(stmt->fdwname),
if (!HeapTupleIsValid(tp))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
+ errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
fdwId = HeapTupleGetOid(tp);
/*
* It could be that the options for the FDW, SERVER and USER MAPPING
- * are no longer valid with the new validator. Warn about this.
+ * are no longer valid with the new validator. Warn about this.
*/
if (stmt->validator)
ereport(WARNING,
- (errmsg("changing the foreign-data wrapper validator can cause "
- "the options for dependent objects to become invalid")));
+ (errmsg("changing the foreign-data wrapper validator can cause "
+ "the options for dependent objects to become invalid")));
}
else
{
/*
- * Validator is not changed, but we need it for validating
- * options.
+ * Validator is not changed, but we need it for validating options.
*/
datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
tp,
rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
tp = heap_modify_tuple(tp, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &tp->t_self, tp);
CatalogUpdateIndexes(rel, tp);
void
RemoveForeignDataWrapper(DropFdwStmt *stmt)
{
- Oid fdwId;
- ObjectAddress object;
+ Oid fdwId;
+ ObjectAddress object;
fdwId = GetForeignDataWrapperOidByName(stmt->fdwname, true);
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("permission denied to drop foreign-data wrapper \"%s\"",
- stmt->fdwname),
- errhint("Must be superuser to drop a foreign-data wrapper.")));
+ errmsg("permission denied to drop foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to drop a foreign-data wrapper.")));
if (!OidIsValid(fdwId))
{
if (!stmt->missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("foreign-data wrapper \"%s\" does not exist",
- stmt->fdwname)));
+ errmsg("foreign-data wrapper \"%s\" does not exist",
+ stmt->fdwname)));
/* IF EXISTS specified, just note it */
ereport(NOTICE,
- (errmsg("foreign-data wrapper \"%s\" does not exist, skipping",
- stmt->fdwname)));
+ (errmsg("foreign-data wrapper \"%s\" does not exist, skipping",
+ stmt->fdwname)));
return;
}
void
CreateForeignServer(CreateForeignServerStmt *stmt)
{
- Relation rel;
- Datum srvoptions;
- Datum values[Natts_pg_foreign_server];
- bool nulls[Natts_pg_foreign_server];
- HeapTuple tuple;
- Oid srvId;
- Oid ownerId;
- AclResult aclresult;
- ObjectAddress myself;
- ObjectAddress referenced;
+ Relation rel;
+ Datum srvoptions;
+ Datum values[Natts_pg_foreign_server];
+ bool nulls[Natts_pg_foreign_server];
+ HeapTuple tuple;
+ Oid srvId;
+ Oid ownerId;
+ AclResult aclresult;
+ ObjectAddress myself;
+ ObjectAddress referenced;
ForeignDataWrapper *fdw;
/* For now the owner cannot be specified on create. Use effective user ID. */
stmt->servername)));
/*
- * Check that the FDW exists and that we have USAGE on it.
- * Also get the actual FDW for option validation etc.
+ * Check that the FDW exists and that we have USAGE on it. Also get the
+ * actual FDW for option validation etc.
*/
fdw = GetForeignDataWrapperByName(stmt->fdwname, false);
bool repl_null[Natts_pg_foreign_server];
bool repl_repl[Natts_pg_foreign_server];
Oid srvId;
- Form_pg_foreign_server srvForm;
+ Form_pg_foreign_server srvForm;
tp = SearchSysCacheCopy(FOREIGNSERVERNAME,
CStringGetDatum(stmt->servername),
if (!HeapTupleIsValid(tp))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("server \"%s\" does not exist", stmt->servername)));
+ errmsg("server \"%s\" does not exist", stmt->servername)));
srvId = HeapTupleGetOid(tp);
srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
if (stmt->options)
{
ForeignDataWrapper *fdw = GetForeignDataWrapper(srvForm->srvfdw);
- Datum datum;
- bool isnull;
+ Datum datum;
+ bool isnull;
/* Extract the current srvoptions */
datum = SysCacheGetAttr(FOREIGNSERVEROID,
rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
tp = heap_modify_tuple(tp, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &tp->t_self, tp);
CatalogUpdateIndexes(rel, tp);
void
RemoveForeignServer(DropForeignServerStmt *stmt)
{
- Oid srvId;
- ObjectAddress object;
+ Oid srvId;
+ ObjectAddress object;
srvId = GetForeignServerOidByName(stmt->servername, true);
if (!stmt->missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("server \"%s\" does not exist", stmt->servername)));
+ errmsg("server \"%s\" does not exist", stmt->servername)));
/* IF EXISTS specified, just note it */
ereport(NOTICE,
{
if (umuserid == curuserid)
{
- AclResult aclresult;
+ AclResult aclresult;
aclresult = pg_foreign_server_aclcheck(serverid, curuserid, ACL_USAGE);
if (aclresult != ACLCHECK_OK)
void
CreateUserMapping(CreateUserMappingStmt *stmt)
{
- Relation rel;
- Datum useoptions;
- Datum values[Natts_pg_user_mapping];
- bool nulls[Natts_pg_user_mapping];
- HeapTuple tuple;
- Oid useId;
- Oid umId;
- ObjectAddress myself;
- ObjectAddress referenced;
- ForeignServer *srv;
+ Relation rel;
+ Datum useoptions;
+ Datum values[Natts_pg_user_mapping];
+ bool nulls[Natts_pg_user_mapping];
+ HeapTuple tuple;
+ Oid useId;
+ Oid umId;
+ ObjectAddress myself;
+ ObjectAddress referenced;
+ ForeignServer *srv;
ForeignDataWrapper *fdw;
useId = GetUserOidFromMapping(stmt->username, false);
* Check that the user mapping is unique within server.
*/
umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
- ObjectIdGetDatum(useId),
- ObjectIdGetDatum(srv->serverid),
- 0, 0);
+ ObjectIdGetDatum(useId),
+ ObjectIdGetDatum(srv->serverid),
+ 0, 0);
if (OidIsValid(umId))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
bool repl_repl[Natts_pg_user_mapping];
Oid useId;
Oid umId;
- ForeignServer *srv;
+ ForeignServer *srv;
useId = GetUserOidFromMapping(stmt->username, false);
srv = GetForeignServerByName(stmt->servername, false);
if (!OidIsValid(umId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("user mapping \"%s\" does not exist for the server",
- MappingUserName(useId))));
+ errmsg("user mapping \"%s\" does not exist for the server",
+ MappingUserName(useId))));
user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);
if (stmt->options)
{
- ForeignDataWrapper *fdw;
- Datum datum;
- bool isnull;
+ ForeignDataWrapper *fdw;
+ Datum datum;
+ bool isnull;
/*
* Process the options.
rel = heap_open(UserMappingRelationId, RowExclusiveLock);
tp = heap_modify_tuple(tp, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &tp->t_self, tp);
CatalogUpdateIndexes(rel, tp);
void
RemoveUserMapping(DropUserMappingStmt *stmt)
{
- ObjectAddress object;
- Oid useId;
- Oid umId;
- ForeignServer *srv;
+ ObjectAddress object;
+ Oid useId;
+ Oid umId;
+ ForeignServer *srv;
useId = GetUserOidFromMapping(stmt->username, stmt->missing_ok);
srv = GetForeignServerByName(stmt->servername, true);
if (stmt->username && !OidIsValid(useId))
{
/*
- * IF EXISTS specified, role not found and not public.
- * Notice this and leave.
+ * IF EXISTS specified, role not found and not public. Notice this and
+ * leave.
*/
elog(NOTICE, "role \"%s\" does not exist, skipping", stmt->username);
return;
if (!stmt->missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("server \"%s\" does not exist",
- stmt->servername)));
+ errmsg("server \"%s\" does not exist",
+ stmt->servername)));
/* IF EXISTS, just note it */
ereport(NOTICE, (errmsg("server does not exist, skipping")));
return;
if (!stmt->missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("user mapping \"%s\" does not exist for the server",
- MappingUserName(useId))));
+ errmsg("user mapping \"%s\" does not exist for the server",
+ MappingUserName(useId))));
/* IF EXISTS specified, just note it */
ereport(NOTICE,
- (errmsg("user mapping \"%s\" does not exist for the server, skipping",
- MappingUserName(useId))));
+ (errmsg("user mapping \"%s\" does not exist for the server, skipping",
+ MappingUserName(useId))));
return;
}
if (!OidIsValid(get_element_type(toid)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("VARIADIC parameter must be an array")));
+ errmsg("VARIADIC parameter must be an array")));
break;
}
}
if (fp->defexpr)
{
- Node *def;
+ Node *def;
if (!isinput)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
- errmsg("only input parameters can have default values")));
+ errmsg("only input parameters can have default values")));
def = transformExpr(pstate, fp->defexpr);
def = coerce_to_specific_type(pstate, def, toid, "DEFAULT");
if (pstate->p_hasSubLinks)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot use subquery in parameter default value")));
+ errmsg("cannot use subquery in parameter default value")));
if (pstate->p_hasAggs)
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
{
/*
* For "C" language, store the file name in probin and, when given,
- * the link symbol name in prosrc. If link symbol is omitted,
+ * the link symbol name in prosrc. If link symbol is omitted,
* substitute procedure name. We also allow link symbol to be
* specified as "-", since that was the habit in PG versions before
* 8.4, and there might be dump files out there that don't translate
}
newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val,
- repl_null, repl_repl);
+ repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple);
}
tup = heap_modify_tuple(tup, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
}
/* Do the update */
/* Detemine the cast method */
if (stmt->func != NULL)
castmethod = COERCION_METHOD_FUNCTION;
- else if(stmt->inout)
+ else if (stmt->inout)
castmethod = COERCION_METHOD_INOUT;
else
castmethod = COERCION_METHOD_BINARY;
if (!IsBinaryCoercible(sourcetypeid, procstruct->proargtypes.values[0]))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("argument of cast function must match or be binary-coercible from source data type")));
+ errmsg("argument of cast function must match or be binary-coercible from source data type")));
if (nargs > 1 && procstruct->proargtypes.values[1] != INT4OID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
if (procstruct->proiswindow)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("cast function must not be a window function")));
+ errmsg("cast function must not be a window function")));
if (procstruct->proretset)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
/*
* We know that composite, enum and array types are never binary-
- * compatible with each other. They all have OIDs embedded in them.
+ * compatible with each other. They all have OIDs embedded in them.
*
* Theoretically you could build a user-defined base type that is
* binary-compatible with a composite, enum, or array type. But we
targettyptype == TYPTYPE_COMPOSITE)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("composite data types are not binary-compatible")));
+ errmsg("composite data types are not binary-compatible")));
if (sourcetyptype == TYPTYPE_ENUM ||
targettyptype == TYPTYPE_ENUM)
* We can exclude any running transactions that have xmin > the xmin of
* our reference snapshot; their oldest snapshot must be newer than ours.
* We can also exclude any transactions that have xmin = zero, since they
- * evidently have no live snapshot at all (and any one they might be
- * in process of taking is certainly newer than ours). Transactions in
- * other DBs can be ignored too, since they'll never even be able to see
- * this index.
+ * evidently have no live snapshot at all (and any one they might be in
+ * process of taking is certainly newer than ours). Transactions in other
+ * DBs can be ignored too, since they'll never even be able to see this
+ * index.
*
* We can also exclude autovacuum processes and processes running manual
* lazy VACUUMs, because they won't be fazed by missing index entries
- * either. (Manual ANALYZEs, however, can't be excluded because they
+ * either. (Manual ANALYZEs, however, can't be excluded because they
* might be within transactions that are going to do arbitrary operations
* later.)
*
* Also, GetCurrentVirtualXIDs never reports our own vxid, so we need not
* check for that.
*
- * If a process goes idle-in-transaction with xmin zero, we do not need
- * to wait for it anymore, per the above argument. We do not have the
- * infrastructure right now to stop waiting if that happens, but we can
- * at least avoid the folly of waiting when it is idle at the time we
- * would begin to wait. We do this by repeatedly rechecking the output of
+ * If a process goes idle-in-transaction with xmin zero, we do not need to
+ * wait for it anymore, per the above argument. We do not have the
+ * infrastructure right now to stop waiting if that happens, but we can at
+ * least avoid the folly of waiting when it is idle at the time we would
+ * begin to wait. We do this by repeatedly rechecking the output of
* GetCurrentVirtualXIDs. If, during any iteration, a particular vxid
* doesn't show up in the output, we know we can forget about it.
*/
newer_snapshots = GetCurrentVirtualXIDs(snapshot->xmin,
true, false,
- PROC_IS_AUTOVACUUM | PROC_IN_VACUUM,
+ PROC_IS_AUTOVACUUM | PROC_IN_VACUUM,
&n_newer_snapshots);
for (j = i; j < n_old_snapshots; j++)
{
if (!VirtualTransactionIdIsValid(old_snapshots[j]))
- continue; /* found uninteresting in previous cycle */
+ continue; /* found uninteresting in previous cycle */
for (k = 0; k < n_newer_snapshots; k++)
{
if (VirtualTransactionIdEquals(old_snapshots[j],
ScanKeyData skey[1];
SysScanDesc scan;
HeapTuple tup;
- TYPCATEGORY tcategory;
+ TYPCATEGORY tcategory;
/* If it's a domain, look at the base type instead */
type_id = getBaseType(type_id);
#include "utils/lsyscache.h"
static void LockTableRecurse(Oid reloid, RangeVar *rv,
- LOCKMODE lockmode, bool nowait, bool recurse);
+ LOCKMODE lockmode, bool nowait, bool recurse);
/*
AclResult aclresult;
/*
- * Acquire the lock. We must do this first to protect against
- * concurrent drops. Note that a lock against an already-dropped
- * relation's OID won't fail.
+ * Acquire the lock. We must do this first to protect against concurrent
+ * drops. Note that a lock against an already-dropped relation's OID
+ * won't fail.
*/
if (nowait)
{
*/
if (recurse)
{
- List *children = find_inheritance_children(reloid, NoLock);
- ListCell *lc;
+ List *children = find_inheritance_children(reloid, NoLock);
+ ListCell *lc;
foreach(lc, children)
{
functionOid = LookupFuncName(functionName, nargs, typeId, false);
/*
- * We require EXECUTE rights for the function. This isn't strictly
- * necessary, since EXECUTE will be checked at any attempted use of
- * the operator, but it seems like a good idea anyway.
+ * We require EXECUTE rights for the function. This isn't strictly
+ * necessary, since EXECUTE will be checked at any attempted use of the
+ * operator, but it seems like a good idea anyway.
*/
aclresult = pg_proc_aclcheck(functionOid, GetUserId(), ACL_EXECUTE);
if (aclresult != ACLCHECK_OK)
typeId[4] = INTERNALOID; /* SpecialJoinInfo */
/*
- * As of Postgres 8.4, the preferred signature for join estimators
- * has 5 arguments, but we still allow the old 4-argument form.
- * Try the preferred form first.
+ * As of Postgres 8.4, the preferred signature for join estimators has
+ * 5 arguments, but we still allow the old 4-argument form. Try the
+ * preferred form first.
*/
joinOid = LookupFuncName(joinName, 5, typeId, true);
if (!OidIsValid(joinOid))
if (get_func_rettype(joinOid) != FLOAT8OID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("join estimator function %s must return type \"float8\"",
- NameListToString(joinName))));
+ errmsg("join estimator function %s must return type \"float8\"",
+ NameListToString(joinName))));
/* Require EXECUTE rights for the estimator */
aclresult = pg_proc_aclcheck(joinOid, GetUserId(), ACL_EXECUTE);
oprNamespace, /* namespace */
typeId1, /* left type id */
typeId2, /* right type id */
- functionOid, /* function for operator */
+ functionOid, /* function for operator */
commutatorName, /* optional commutator operator name */
negatorName, /* optional negator operator name */
restrictionOid, /* optional restrict. sel. procedure */
ExecutorRewind(queryDesc);
/*
- * Change the destination to output to the tuplestore. Note we
- * tell the tuplestore receiver to detoast all data passed through it.
+ * Change the destination to output to the tuplestore. Note we tell
+ * the tuplestore receiver to detoast all data passed through it.
*/
queryDesc->dest = CreateDestReceiver(DestTuplestore);
SetTuplestoreDestReceiverParams(queryDesc->dest,
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot use window function in EXECUTE parameter")));
+ errmsg("cannot use window function in EXECUTE parameter")));
given_type_id = exprType(expr);
pltemplate->tmplhandler,
pltemplate->tmpllibrary,
false, /* isAgg */
- false, /* isWindowFunc */
+ false, /* isWindowFunc */
false, /* security_definer */
false, /* isStrict */
PROVOLATILE_VOLATILE,
pltemplate->tmplvalidator,
pltemplate->tmpllibrary,
false, /* isAgg */
- false, /* isWindowFunc */
+ false, /* isWindowFunc */
false, /* security_definer */
false, /* isStrict */
PROVOLATILE_VOLATILE,
}
newtuple = heap_modify_tuple(tup, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple);
* temporarily set the current user so that the object(s) will be created
* with the correct ownership.
*
- * (The setting will be restored at the end of this routine, or in case
- * of error, transaction abort will clean things up.)
+ * (The setting will be restored at the end of this routine, or in case of
+ * error, transaction abort will clean things up.)
*/
if (saved_uid != owner_uid)
SetUserIdAndContext(owner_uid, true);
RemoveSchemas(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
/*
* First we identify all the schemas, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the schemas depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the schemas depends on another.
*/
objects = new_object_addresses();
snprintf(bufm, sizeof(bufm), INT64_FORMAT, new->min_value);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("RESTART value (%s) cannot be less than MINVALUE (%s)",
- bufs, bufm)));
+ errmsg("RESTART value (%s) cannot be less than MINVALUE (%s)",
+ bufs, bufm)));
}
if (new->last_value > new->max_value)
{
snprintf(bufm, sizeof(bufm), INT64_FORMAT, new->max_value);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("RESTART value (%s) cannot be greater than MAXVALUE (%s)",
- bufs, bufm)));
+ errmsg("RESTART value (%s) cannot be greater than MAXVALUE (%s)",
+ bufs, bufm)));
}
/* CACHE */
List *constraints; /* List of NewConstraint */
List *newvals; /* List of NewColumnValue */
bool new_notnull; /* T if we added new NOT NULL constraints */
- bool new_changeoids; /* T if we added/dropped the OID column */
+ bool new_changeoids; /* T if we added/dropped the OID column */
Oid newTableSpace; /* new tablespace; 0 means no change */
/* Objects to rebuild after completing ALTER TYPE operations */
List *changedConstraintOids; /* OIDs of constraints to rebuild */
static const struct dropmsgstrings dropmsgstringarray[] = {
{RELKIND_RELATION,
- ERRCODE_UNDEFINED_TABLE,
- gettext_noop("table \"%s\" does not exist"),
- gettext_noop("table \"%s\" does not exist, skipping"),
- gettext_noop("\"%s\" is not a table"),
- gettext_noop("Use DROP TABLE to remove a table.")},
+ ERRCODE_UNDEFINED_TABLE,
+ gettext_noop("table \"%s\" does not exist"),
+ gettext_noop("table \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not a table"),
+ gettext_noop("Use DROP TABLE to remove a table.")},
{RELKIND_SEQUENCE,
- ERRCODE_UNDEFINED_TABLE,
- gettext_noop("sequence \"%s\" does not exist"),
- gettext_noop("sequence \"%s\" does not exist, skipping"),
- gettext_noop("\"%s\" is not a sequence"),
- gettext_noop("Use DROP SEQUENCE to remove a sequence.")},
+ ERRCODE_UNDEFINED_TABLE,
+ gettext_noop("sequence \"%s\" does not exist"),
+ gettext_noop("sequence \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not a sequence"),
+ gettext_noop("Use DROP SEQUENCE to remove a sequence.")},
{RELKIND_VIEW,
- ERRCODE_UNDEFINED_TABLE,
- gettext_noop("view \"%s\" does not exist"),
- gettext_noop("view \"%s\" does not exist, skipping"),
- gettext_noop("\"%s\" is not a view"),
- gettext_noop("Use DROP VIEW to remove a view.")},
+ ERRCODE_UNDEFINED_TABLE,
+ gettext_noop("view \"%s\" does not exist"),
+ gettext_noop("view \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not a view"),
+ gettext_noop("Use DROP VIEW to remove a view.")},
{RELKIND_INDEX,
- ERRCODE_UNDEFINED_OBJECT,
- gettext_noop("index \"%s\" does not exist"),
- gettext_noop("index \"%s\" does not exist, skipping"),
- gettext_noop("\"%s\" is not an index"),
- gettext_noop("Use DROP INDEX to remove an index.")},
+ ERRCODE_UNDEFINED_OBJECT,
+ gettext_noop("index \"%s\" does not exist"),
+ gettext_noop("index \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not an index"),
+ gettext_noop("Use DROP INDEX to remove an index.")},
{RELKIND_COMPOSITE_TYPE,
- ERRCODE_UNDEFINED_OBJECT,
- gettext_noop("type \"%s\" does not exist"),
- gettext_noop("type \"%s\" does not exist, skipping"),
- gettext_noop("\"%s\" is not a type"),
- gettext_noop("Use DROP TYPE to remove a type.")},
+ ERRCODE_UNDEFINED_OBJECT,
+ gettext_noop("type \"%s\" does not exist"),
+ gettext_noop("type \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not a type"),
+ gettext_noop("Use DROP TYPE to remove a type.")},
{'\0', 0, NULL, NULL, NULL, NULL}
};
bool recurse, bool recursing);
static void ATRewriteCatalogs(List **wqueue);
static void ATExecCmd(List **wqueue, AlteredTableInfo *tab, Relation rel,
- AlterTableCmd *cmd);
+ AlterTableCmd *cmd);
static void ATRewriteTables(List **wqueue);
static void ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap);
static AlteredTableInfo *ATGetQueueEntry(List **wqueue, Relation rel);
ColumnDef *colDef, bool isOid);
static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid);
static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
- AlterTableCmd *cmd);
+ AlterTableCmd *cmd);
static void ATExecDropNotNull(Relation rel, const char *colName);
static void ATExecSetNotNull(AlteredTableInfo *tab, Relation rel,
const char *colName);
static void ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
IndexStmt *stmt, bool is_rebuild);
static void ATExecAddConstraint(List **wqueue,
- AlteredTableInfo *tab, Relation rel,
- Node *newConstraint, bool recurse);
+ AlteredTableInfo *tab, Relation rel,
+ Node *newConstraint, bool recurse);
static void ATAddCheckConstraint(List **wqueue,
- AlteredTableInfo *tab, Relation rel,
- Constraint *constr,
- bool recurse, bool recursing);
+ AlteredTableInfo *tab, Relation rel,
+ Constraint *constr,
+ bool recurse, bool recursing);
static void ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
FkConstraint *fkconstraint);
static void ATExecDropConstraint(Relation rel, const char *constrName,
- DropBehavior behavior,
- bool recurse, bool recursing);
+ DropBehavior behavior,
+ bool recurse, bool recursing);
static void ATPrepAlterColumnType(List **wqueue,
AlteredTableInfo *tab, Relation rel,
bool recurse, bool recursing,
static void ATExecAddInherit(Relation rel, RangeVar *parent);
static void ATExecDropInherit(Relation rel, RangeVar *parent);
static void copy_relation_data(SMgrRelation rel, SMgrRelation dst,
- ForkNumber forkNum, bool istemp);
+ ForkNumber forkNum, bool istemp);
/* ----------------------------------------------------------------
Datum reloptions;
ListCell *listptr;
AttrNumber attnum;
- static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
+ static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
/*
* Truncate relname to appropriate length (probably a waste of time, as
&inheritOids, &old_constraints, &parentOidCount);
/*
- * Create a tuple descriptor from the relation schema. Note that this
+ * Create a tuple descriptor from the relation schema. Note that this
* deals with column names, types, and NOT NULL constraints, but not
* default values or CHECK constraints; we handle those below.
*/
* Find columns with default values and prepare for insertion of the
* defaults. Pre-cooked (that is, inherited) defaults go into a list of
* CookedConstraint structs that we'll pass to heap_create_with_catalog,
- * while raw defaults go into a list of RawColumnDefault structs that
- * will be processed by AddRelationNewConstraints. (We can't deal with
- * raw expressions until we can do transformExpr.)
+ * while raw defaults go into a list of RawColumnDefault structs that will
+ * be processed by AddRelationNewConstraints. (We can't deal with raw
+ * expressions until we can do transformExpr.)
*
* We can set the atthasdef flags now in the tuple descriptor; this just
* saves StoreAttrDefault from having to do an immediate update of the
}
/*
- * Create the relation. Inherited defaults and constraints are passed
- * in for immediate handling --- since they don't need parsing, they
- * can be stored immediately.
+ * Create the relation. Inherited defaults and constraints are passed in
+ * for immediate handling --- since they don't need parsing, they can be
+ * stored immediately.
*/
relationId = heap_create_with_catalog(relname,
namespaceId,
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg(rentry->nota_msg, relname),
- (wentry->kind != '\0') ? errhint("%s", _(wentry->drophint_msg)) : 0));
+ (wentry->kind != '\0') ? errhint("%s", _(wentry->drophint_msg)) : 0));
}
/*
/*
* First we identify all the relations, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the relations depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the relations depends on another.
*/
/* Determine required relkind */
default:
elog(ERROR, "unrecognized drop object type: %d",
(int) drop->removeType);
- relkind = 0; /* keep compiler quiet */
+ relkind = 0; /* keep compiler quiet */
break;
}
#endif
/*
- * If we are asked to restart sequences, find all the sequences,
- * lock them (we only need AccessShareLock because that's all that
- * ALTER SEQUENCE takes), and check permissions. We want to do this
- * early since it's pointless to do all the truncation work only to fail
- * on sequence permissions.
+ * If we are asked to restart sequences, find all the sequences, lock them
+ * (we only need AccessShareLock because that's all that ALTER SEQUENCE
+ * takes), and check permissions. We want to do this early since it's
+ * pointless to do all the truncation work only to fail on sequence
+ * permissions.
*/
if (stmt->restart_seqs)
{
foreach(seqcell, seqlist)
{
- Oid seq_relid = lfirst_oid(seqcell);
- Relation seq_rel;
+ Oid seq_relid = lfirst_oid(seqcell);
+ Relation seq_rel;
seq_rel = relation_open(seq_relid, AccessShareLock);
AfterTriggerBeginQuery();
/*
- * To fire triggers, we'll need an EState as well as a ResultRelInfo
- * for each relation.
+ * To fire triggers, we'll need an EState as well as a ResultRelInfo for
+ * each relation.
*/
estate = CreateExecutorState();
resultRelInfos = (ResultRelInfo *)
InitResultRelInfo(resultRelInfo,
rel,
- 0, /* dummy rangetable index */
+ 0, /* dummy rangetable index */
CMD_DELETE, /* don't need any index info */
false);
resultRelInfo++;
/*
* Process all BEFORE STATEMENT TRUNCATE triggers before we begin
- * truncating (this is because one of them might throw an error).
- * Also, if we were to allow them to prevent statement execution,
- * that would need to be handled here.
+ * truncating (this is because one of them might throw an error). Also, if
+ * we were to allow them to prevent statement execution, that would need
+ * to be handled here.
*/
resultRelInfo = resultRelInfos;
foreach(cell, rels)
/*
* Lastly, restart any owned sequences if we were asked to. This is done
- * last because it's nontransactional: restarts will not roll back if
- * we abort later. Hence it's important to postpone them as long as
+ * last because it's nontransactional: restarts will not roll back if we
+ * abort later. Hence it's important to postpone them as long as
* possible. (This is also a big reason why we locked and
* permission-checked the sequences beforehand.)
*/
if (stmt->restart_seqs)
{
- List *options = list_make1(makeDefElem("restart", NULL));
+ List *options = list_make1(makeDefElem("restart", NULL));
foreach(cell, seq_relids)
{
- Oid seq_relid = lfirst_oid(cell);
+ Oid seq_relid = lfirst_oid(cell);
AlterSequenceInternal(seq_relid, options);
}
/*
* Now copy the CHECK constraints of this parent, adjusting attnos
- * using the completed newattno[] map. Identically named constraints
+ * using the completed newattno[] map. Identically named constraints
* are merged if possible, else we throw error.
*/
if (constr && constr->num_check > 0)
cooked = (CookedConstraint *) palloc(sizeof(CookedConstraint));
cooked->contype = CONSTR_CHECK;
cooked->name = pstrdup(name);
- cooked->attnum = 0; /* not used for constraints */
+ cooked->attnum = 0; /* not used for constraints */
cooked->expr = expr;
cooked->is_local = false;
cooked->inhcount = 1;
RelationGetRelationName(targetrelation))));
/*
- * Don't allow ALTER TABLE on composite types.
- * We want people to use ALTER TYPE for that.
+ * Don't allow ALTER TABLE on composite types. We want people to use ALTER
+ * TYPE for that.
*/
if (relkind == RELKIND_COMPOSITE_TYPE)
ereport(ERROR,
Form_pg_class relform;
/*
- * Grab an exclusive lock on the target table, index, sequence or
- * view, which we will NOT release until end of transaction.
+ * Grab an exclusive lock on the target table, index, sequence or view,
+ * which we will NOT release until end of transaction.
*/
targetrelation = relation_open(myrelid, AccessExclusiveLock);
* We also reject these commands if there are any pending AFTER trigger events
* for the rel. This is certainly necessary for the rewriting variants of
* ALTER TABLE, because they don't preserve tuple TIDs and so the pending
- * events would try to fetch the wrong tuples. It might be overly cautious
+ * events would try to fetch the wrong tuples. It might be overly cautious
* in other cases, but again it seems better to err on the side of paranoia.
*
* REINDEX calls this with "rel" referencing the index to be rebuilt; here
if (rel->rd_refcnt != expected_refcnt)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_IN_USE),
- /* translator: first %s is a SQL command, eg ALTER TABLE */
+ /* translator: first %s is a SQL command, eg ALTER TABLE */
errmsg("cannot %s \"%s\" because "
"it is being used by active queries in this session",
stmt, RelationGetRelationName(rel))));
AfterTriggerPendingOnRel(RelationGetRelid(rel)))
ereport(ERROR,
(errcode(ERRCODE_OBJECT_IN_USE),
- /* translator: first %s is a SQL command, eg ALTER TABLE */
+ /* translator: first %s is a SQL command, eg ALTER TABLE */
errmsg("cannot %s \"%s\" because "
"it has pending trigger events",
stmt, RelationGetRelationName(rel))));
* expressions that need to be evaluated with respect to the old table
* schema.
*
- * ATRewriteCatalogs performs phase 2 for each affected table. (Note that
+ * ATRewriteCatalogs performs phase 2 for each affected table. (Note that
* phases 2 and 3 normally do no explicit recursion, since phase 1 already
* did it --- although some subcommands have to recurse in phase 2 instead.)
* Certain subcommands need to be performed before others to avoid
switch (stmt->relkind)
{
case OBJECT_TABLE:
+
/*
- * For mostly-historical reasons, we allow ALTER TABLE to apply
- * to all relation types.
+ * For mostly-historical reasons, we allow ALTER TABLE to apply to
+ * all relation types.
*/
break;
ATPrepAddColumn(wqueue, rel, recurse, cmd);
pass = AT_PASS_ADD_COL;
break;
- case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */
+ case AT_AddColumnToView: /* add column via CREATE OR REPLACE
+ * VIEW */
ATSimplePermissions(rel, true);
/* Performs own recursion */
ATPrepAddColumn(wqueue, rel, recurse, cmd);
switch (cmd->subtype)
{
case AT_AddColumn: /* ADD COLUMN */
- case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */
+ case AT_AddColumnToView: /* add column via CREATE OR REPLACE
+ * VIEW */
ATExecAddColumn(tab, rel, (ColumnDef *) cmd->def, false);
break;
case AT_ColumnDefault: /* ALTER COLUMN DEFAULT */
if (isOid && childatt->attnum != ObjectIdAttributeNumber)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("child table \"%s\" has a conflicting \"%s\" column",
- RelationGetRelationName(rel), colDef->colname)));
+ errmsg("child table \"%s\" has a conflicting \"%s\" column",
+ RelationGetRelationName(rel), colDef->colname)));
/* Bump the existing child att's inhcount */
childatt->attinhcount++;
* returned by AddRelationNewConstraints, so that the right thing happens
* when a datatype's default applies.
*
- * We skip this step completely for views. For a view, we can only get
+ * We skip this step completely for views. For a view, we can only get
* here from CREATE OR REPLACE VIEW, which historically doesn't set up
- * defaults, not even for domain-typed columns. And in any case we mustn't
- * invoke Phase 3 on a view, since it has no storage.
+ * defaults, not even for domain-typed columns. And in any case we
+ * mustn't invoke Phase 3 on a view, since it has no storage.
*/
if (relkind != RELKIND_VIEW && attribute.attnum > 0)
{
COERCION_ASSIGNMENT,
COERCE_IMPLICIT_CAST,
-1);
- if (defval == NULL) /* should not happen */
+ if (defval == NULL) /* should not happen */
elog(ERROR, "failed to coerce base type to domain");
}
}
/*
- * If we are adding an OID column, we have to tell Phase 3 to rewrite
- * the table to fix that.
+ * If we are adding an OID column, we have to tell Phase 3 to rewrite the
+ * table to fix that.
*/
if (isOid)
tab->new_changeoids = true;
/*
* ALTER TABLE SET WITH OIDS
*
- * Basically this is an ADD COLUMN for the special OID column. We have
+ * Basically this is an ADD COLUMN for the special OID column. We have
* to cons up a ColumnDef node because the ADD COLUMN code needs one.
*/
static void
performDeletion(&object, behavior);
/*
- * If we dropped the OID column, must adjust pg_class.relhasoids and
- * tell Phase 3 to physically get rid of the column.
+ * If we dropped the OID column, must adjust pg_class.relhasoids and tell
+ * Phase 3 to physically get rid of the column.
*/
if (attnum == ObjectIdAttributeNumber)
{
FkConstraint *fkconstraint = (FkConstraint *) newConstraint;
/*
- * Note that we currently never recurse for FK constraints,
- * so the "recurse" flag is silently ignored.
+ * Note that we currently never recurse for FK constraints, so
+ * the "recurse" flag is silently ignored.
*
* Assign or validate constraint name
*/
/*
* Call AddRelationNewConstraints to do the work, making sure it works on
- * a copy of the Constraint so transformExpr can't modify the original.
- * It returns a list of cooked constraints.
+ * a copy of the Constraint so transformExpr can't modify the original. It
+ * returns a list of cooked constraints.
*
* If the constraint ends up getting merged with a pre-existing one, it's
* omitted from the returned list, which is what we want: we do not need
pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
/*
- * Validity checks (permission checks wait till we have the column numbers)
+ * Validity checks (permission checks wait till we have the column
+ * numbers)
*/
if (pkrel->rd_rel->relkind != RELKIND_RELATION)
ereport(ERROR,
NULL, /* no check constraint */
NULL,
NULL,
- true, /* islocal */
- 0); /* inhcount */
+ true, /* islocal */
+ 0); /* inhcount */
/*
* Create the triggers that will enforce the constraint.
/* Don't drop inherited constraints */
if (con->coninhcount > 0 && !recursing)
ereport(ERROR,
- (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
- errmsg("cannot drop inherited constraint \"%s\" of relation \"%s\"",
- constrName, RelationGetRelationName(rel))));
+ (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+ errmsg("cannot drop inherited constraint \"%s\" of relation \"%s\"",
+ constrName, RelationGetRelationName(rel))));
/* Right now only CHECK constraints can be inherited */
if (con->contype == CONSTRAINT_CHECK)
while (HeapTupleIsValid(tuple = systable_getnext(scan)))
{
- HeapTuple copy_tuple;
+ HeapTuple copy_tuple;
con = (Form_pg_constraint) GETSTRUCT(tuple);
found = true;
- if (con->coninhcount <= 0) /* shouldn't happen */
+ if (con->coninhcount <= 0) /* shouldn't happen */
elog(ERROR, "relation %u has non-inherited constraint \"%s\"",
childrelid, constrName);
if (recurse)
{
/*
- * If the child constraint has other definition sources,
- * just decrement its inheritance count; if not, recurse
- * to delete it.
+ * If the child constraint has other definition sources, just
+ * decrement its inheritance count; if not, recurse to delete
+ * it.
*/
if (con->coninhcount == 1 && !con->conislocal)
{
else
{
/*
- * If we were told to drop ONLY in this table (no
- * recursion), we need to mark the inheritors' constraints
- * as locally defined rather than inherited.
+ * If we were told to drop ONLY in this table (no recursion),
+ * we need to mark the inheritors' constraints as locally
+ * defined rather than inherited.
*/
con->coninhcount--;
con->conislocal = true;
if (!found)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("constraint \"%s\" of relation \"%s\" does not exist",
- constrName,
- RelationGetRelationName(childrel))));
+ errmsg("constraint \"%s\" of relation \"%s\" does not exist",
+ constrName,
+ RelationGetRelationName(childrel))));
heap_close(childrel, NoLock);
}
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot use window function in transform expression")));
+ errmsg("cannot use window function in transform expression")));
}
else
{
if (defaultexpr == NULL)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("default for column \"%s\" cannot be cast to type %s",
- colName, format_type_be(targettype))));
+ errmsg("default for column \"%s\" cannot be cast to type %s",
+ colName, format_type_be(targettype))));
}
else
defaultexpr = NULL;
Datum repl_val[Natts_pg_class];
bool repl_null[Natts_pg_class];
bool repl_repl[Natts_pg_class];
- static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
+ static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
if (defList == NIL)
return; /* nothing to do */
/* Generate new proposed reloptions (text array) */
newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
- defList, NULL, validnsps, false, isReset);
+ defList, NULL, validnsps, false, isReset);
/* Validate */
switch (rel->rd_rel->relkind)
repl_repl[Anum_pg_class_reloptions - 1] = true;
newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(pgclass, &newtuple->t_self, newtuple);
datum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_reloptions, &isnull);
newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
- defList, "toast", validnsps, false, isReset);
+ defList, "toast", validnsps, false, isReset);
(void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true);
RelationOpenSmgr(rel);
/*
- * Create and copy all forks of the relation, and schedule unlinking
- * of old physical files.
+ * Create and copy all forks of the relation, and schedule unlinking of
+ * old physical files.
*
* NOTE: any conflict in relfilenode value will be caught in
- * RelationCreateStorage().
+ * RelationCreateStorage().
*/
RelationCreateStorage(newrnode, rel->rd_istemp);
while (HeapTupleIsValid(parent_tuple = systable_getnext(parent_scan)))
{
- Form_pg_constraint parent_con = (Form_pg_constraint) GETSTRUCT(parent_tuple);
- SysScanDesc child_scan;
- ScanKeyData child_key;
- HeapTuple child_tuple;
- bool found = false;
+ Form_pg_constraint parent_con = (Form_pg_constraint) GETSTRUCT(parent_tuple);
+ SysScanDesc child_scan;
+ ScanKeyData child_key;
+ HeapTuple child_tuple;
+ bool found = false;
if (parent_con->contype != CONSTRAINT_CHECK)
continue;
while (HeapTupleIsValid(child_tuple = systable_getnext(child_scan)))
{
- Form_pg_constraint child_con = (Form_pg_constraint) GETSTRUCT(child_tuple);
- HeapTuple child_copy;
+ Form_pg_constraint child_con = (Form_pg_constraint) GETSTRUCT(child_tuple);
+ HeapTuple child_copy;
if (child_con->contype != CONSTRAINT_CHECK)
continue;
heap_close(catalogRelation, RowExclusiveLock);
/*
- * Likewise, find inherited check constraints and disinherit them.
- * To do this, we first need a list of the names of the parent's check
+ * Likewise, find inherited check constraints and disinherit them. To do
+ * this, we first need a list of the names of the parent's check
* constraints. (We cheat a bit by only checking for name matches,
* assuming that the expressions will match.)
*/
while (HeapTupleIsValid(constraintTuple = systable_getnext(scan)))
{
Form_pg_constraint con = (Form_pg_constraint) GETSTRUCT(constraintTuple);
- bool match;
- ListCell *lc;
+ bool match;
+ ListCell *lc;
if (con->contype != CONSTRAINT_CHECK)
continue;
match = false;
- foreach (lc, connames)
+ foreach(lc, connames)
{
if (strcmp(NameStr(con->conname), (char *) lfirst(lc)) == 0)
{
/* Decrement inhcount and possibly set islocal to true */
HeapTuple copyTuple = heap_copytuple(constraintTuple);
Form_pg_constraint copy_con = (Form_pg_constraint) GETSTRUCT(copyTuple);
+
if (copy_con->coninhcount <= 0) /* shouldn't happen */
elog(ERROR, "relation %u has non-inherited constraint \"%s\"",
RelationGetRelid(rel), NameStr(copy_con->conname));
switch (stmttype)
{
case OBJECT_TABLE:
+
/*
- * For mostly-historical reasons, we allow ALTER TABLE to apply
- * to all relation types.
+ * For mostly-historical reasons, we allow ALTER TABLE to apply to
+ * all relation types.
*/
break;
}
/*
- * Scan pg_trigger for existing triggers on relation. We do this only
- * to give a nice error message if there's already a trigger of the same
+ * Scan pg_trigger for existing triggers on relation. We do this only to
+ * give a nice error message if there's already a trigger of the same
* name. (The unique index on tgrelid/tgname would complain anyway.)
*
* NOTE that this is cool only because we have AccessExclusiveLock on the
/*
* We do not bother to try to determine whether any other triggers remain,
- * which would be needed in order to decide whether it's safe to clear
- * the relation's relhastriggers. (In any case, there might be a
- * concurrent process adding new triggers.) Instead, just force a
- * relcache inval to make other backends (and this one too!) rebuild
- * their relcache entries. There's no great harm in leaving relhastriggers
- * true even if there are no triggers left.
+ * which would be needed in order to decide whether it's safe to clear the
+ * relation's relhastriggers. (In any case, there might be a concurrent
+ * process adding new triggers.) Instead, just force a relcache inval to
+ * make other backends (and this one too!) rebuild their relcache entries.
+ * There's no great harm in leaving relhastriggers true even if there are
+ * no triggers left.
*/
CacheInvalidateRelcache(rel);
int i;
/*
- * Allocate a working array to hold the triggers (the array is extended
- * if necessary)
+ * Allocate a working array to hold the triggers (the array is extended if
+ * necessary)
*/
maxtrigs = 16;
triggers = (Trigger *) palloc(maxtrigs * sizeof(Trigger));
if (newtuple)
ereport(ERROR,
- (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
- errmsg("BEFORE STATEMENT trigger cannot return a value")));
+ (errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
+ errmsg("BEFORE STATEMENT trigger cannot return a value")));
}
}
* Per-trigger-event data
*
* The actual per-event data, AfterTriggerEventData, includes DONE/IN_PROGRESS
- * status bits and one or two tuple CTIDs. Each event record also has an
+ * status bits and one or two tuple CTIDs. Each event record also has an
* associated AfterTriggerSharedData that is shared across all instances
* of similar events within a "chunk".
*
* Although this is mutable state, we can keep it in AfterTriggerSharedData
* because all instances of the same type of event in a given event list will
* be fired at the same time, if they were queued between the same firing
- * cycles. So we need only ensure that ats_firing_id is zero when attaching
+ * cycles. So we need only ensure that ats_firing_id is zero when attaching
* a new event to an existing AfterTriggerSharedData record.
*/
typedef uint32 TriggerFlags;
-#define AFTER_TRIGGER_OFFSET 0x0FFFFFFF /* must be low-order bits */
+#define AFTER_TRIGGER_OFFSET 0x0FFFFFFF /* must be low-order
+ * bits */
#define AFTER_TRIGGER_2CTIDS 0x10000000
#define AFTER_TRIGGER_DONE 0x20000000
#define AFTER_TRIGGER_IN_PROGRESS 0x40000000
/*
* To avoid palloc overhead, we keep trigger events in arrays in successively-
* larger chunks (a slightly more sophisticated version of an expansible
- * array). The space between CHUNK_DATA_START and freeptr is occupied by
+ * array). The space between CHUNK_DATA_START and freeptr is occupied by
* AfterTriggerEventData records; the space between endfree and endptr is
* occupied by AfterTriggerSharedData records.
*/
typedef struct AfterTriggerEventChunk
{
- struct AfterTriggerEventChunk *next; /* list link */
+ struct AfterTriggerEventChunk *next; /* list link */
char *freeptr; /* start of free space in chunk */
char *endfree; /* end of free space in chunk */
char *endptr; /* end of chunk */
/* check number of shared records in preceding chunk */
if ((chunk->endptr - chunk->endfree) <=
(100 * sizeof(AfterTriggerSharedData)))
- chunksize *= 2; /* okay, double it */
+ chunksize *= 2; /* okay, double it */
else
- chunksize /= 2; /* too many shared records */
+ chunksize /= 2; /* too many shared records */
chunksize = Min(chunksize, MAX_CHUNK_SIZE);
}
chunk = MemoryContextAlloc(afterTriggers->event_cxt, chunksize);
}
/*
- * Try to locate a matching shared-data record already in the chunk.
- * If none, make a new one.
+ * Try to locate a matching shared-data record already in the chunk. If
+ * none, make a new one.
*/
for (newshared = ((AfterTriggerShared) chunk->endptr) - 1;
(char *) newshared >= chunk->endfree;
if ((char *) newshared < chunk->endfree)
{
*newshared = *evtshared;
- newshared->ats_firing_id = 0; /* just to be sure */
+ newshared->ats_firing_id = 0; /* just to be sure */
chunk->endfree = (char *) newshared;
}
/* and clean up the tail chunk to be the right length */
events->tail->next = NULL;
events->tail->freeptr = events->tailfree;
+
/*
* We don't make any effort to remove now-unused shared data records.
* They might still be useful, anyway.
trigdesc = rInfo->ri_TrigDesc;
finfo = rInfo->ri_TrigFunctions;
instr = rInfo->ri_TrigInstrument;
- if (trigdesc == NULL) /* should not happen */
+ if (trigdesc == NULL) /* should not happen */
elog(ERROR, "relation %u has no triggers",
evtshared->ats_relid);
}
MemoryContextAlloc(TopTransactionContext,
sizeof(AfterTriggersData));
- afterTriggers->firing_counter = (CommandId) 1; /* mustn't be 0 */
+ afterTriggers->firing_counter = (CommandId) 1; /* mustn't be 0 */
afterTriggers->state = SetConstraintStateCreate(8);
afterTriggers->events.head = NULL;
afterTriggers->events.tail = NULL;
else
{
/*
- * Aborting. Release any event lists from queries being aborted,
- * and restore query_depth to its pre-subxact value.
+ * Aborting. Release any event lists from queries being aborted, and
+ * restore query_depth to its pre-subxact value.
*/
while (afterTriggers->query_depth > afterTriggers->depth_stack[my_level])
{
/*
* Make sure a snapshot has been established in case trigger
- * functions need one. Note that we avoid setting a snapshot if
+ * functions need one. Note that we avoid setting a snapshot if
* we don't find at least one trigger that has to be fired now.
* This is so that BEGIN; SET CONSTRAINTS ...; SET TRANSACTION
* ISOLATION LEVEL SERIALIZABLE; ... works properly. (If we are
RemoveTSParsers(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
if (!superuser())
ereport(ERROR,
/*
* First we identify all the objects, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the objects depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the objects depends on another.
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *names = (List *) lfirst(cell);
+ List *names = (List *) lfirst(cell);
Oid prsOid;
ObjectAddress object;
else
{
ereport(NOTICE,
- (errmsg("text search parser \"%s\" does not exist, skipping",
- NameListToString(names))));
+ (errmsg("text search parser \"%s\" does not exist, skipping",
+ NameListToString(names))));
}
continue;
}
RemoveTSDictionaries(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
/*
* First we identify all the objects, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the objects depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the objects depends on another.
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *names = (List *) lfirst(cell);
+ List *names = (List *) lfirst(cell);
Oid dictOid;
ObjectAddress object;
HeapTuple tup;
{
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("text search dictionary \"%s\" does not exist",
- NameListToString(names))));
+ errmsg("text search dictionary \"%s\" does not exist",
+ NameListToString(names))));
}
else
{
ereport(NOTICE,
- (errmsg("text search dictionary \"%s\" does not exist, skipping",
- NameListToString(names))));
+ (errmsg("text search dictionary \"%s\" does not exist, skipping",
+ NameListToString(names))));
}
continue;
}
tup = SearchSysCache(TSDICTOID,
ObjectIdGetDatum(dictOid),
0, 0, 0);
- if (!HeapTupleIsValid(tup)) /* should not happen */
+ if (!HeapTupleIsValid(tup)) /* should not happen */
elog(ERROR, "cache lookup failed for text search dictionary %u",
dictOid);
repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = true;
newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtup->t_self, newtup);
RemoveTSTemplates(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
if (!superuser())
ereport(ERROR,
/*
* First we identify all the objects, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the objects depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the objects depends on another.
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *names = (List *) lfirst(cell);
+ List *names = (List *) lfirst(cell);
Oid tmplOid;
ObjectAddress object;
RemoveTSConfigurations(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
/*
* First we identify all the objects, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the objects depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the objects depends on another.
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *names = (List *) lfirst(cell);
+ List *names = (List *) lfirst(cell);
Oid cfgOid;
Oid namespaceId;
ObjectAddress object;
{
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("text search configuration \"%s\" does not exist",
- NameListToString(names))));
+ errmsg("text search configuration \"%s\" does not exist",
+ NameListToString(names))));
}
else
{
repl_repl[Anum_pg_ts_config_map_mapdict - 1] = true;
newtup = heap_modify_tuple(maptup,
- RelationGetDescr(relMap),
- repl_val, repl_null, repl_repl);
+ RelationGetDescr(relMap),
+ repl_val, repl_null, repl_repl);
simple_heap_update(relMap, &newtup->t_self, newtup);
CatalogUpdateIndexes(relMap, newtup);
bool byValue = false;
char alignment = 'i'; /* default alignment */
char storage = 'p'; /* default TOAST storage method */
- DefElem *likeTypeEl = NULL;
- DefElem *internalLengthEl = NULL;
- DefElem *inputNameEl = NULL;
- DefElem *outputNameEl = NULL;
- DefElem *receiveNameEl = NULL;
- DefElem *sendNameEl = NULL;
- DefElem *typmodinNameEl = NULL;
- DefElem *typmodoutNameEl = NULL;
- DefElem *analyzeNameEl = NULL;
- DefElem *categoryEl = NULL;
- DefElem *preferredEl = NULL;
- DefElem *delimiterEl = NULL;
- DefElem *elemTypeEl = NULL;
- DefElem *defaultValueEl = NULL;
- DefElem *byValueEl = NULL;
- DefElem *alignmentEl = NULL;
- DefElem *storageEl = NULL;
+ DefElem *likeTypeEl = NULL;
+ DefElem *internalLengthEl = NULL;
+ DefElem *inputNameEl = NULL;
+ DefElem *outputNameEl = NULL;
+ DefElem *receiveNameEl = NULL;
+ DefElem *sendNameEl = NULL;
+ DefElem *typmodinNameEl = NULL;
+ DefElem *typmodoutNameEl = NULL;
+ DefElem *analyzeNameEl = NULL;
+ DefElem *categoryEl = NULL;
+ DefElem *preferredEl = NULL;
+ DefElem *delimiterEl = NULL;
+ DefElem *elemTypeEl = NULL;
+ DefElem *defaultValueEl = NULL;
+ DefElem *byValueEl = NULL;
+ DefElem *alignmentEl = NULL;
+ DefElem *storageEl = NULL;
Oid inputOid;
Oid outputOid;
Oid receiveOid = InvalidOid;
* As of Postgres 8.4, we require superuser privilege to create a base
* type. This is simple paranoia: there are too many ways to mess up the
* system with an incorrect type definition (for instance, representation
- * parameters that don't match what the C code expects). In practice
- * it takes superuser privilege to create the I/O functions, and so the
+ * parameters that don't match what the C code expects). In practice it
+ * takes superuser privilege to create the I/O functions, and so the
* former requirement that you own the I/O functions pretty much forced
* superuserness anyway. We're just making doubly sure here.
*
}
/*
- * Now interpret the options; we do this separately so that LIKE can
- * be overridden by other options regardless of the ordering in the
- * parameter list.
+ * Now interpret the options; we do this separately so that LIKE can be
+ * overridden by other options regardless of the ordering in the parameter
+ * list.
*/
if (likeTypeEl)
{
- Type likeType;
+ Type likeType;
Form_pg_type likeForm;
likeType = typenameType(NULL, defGetTypeName(likeTypeEl), NULL);
if (category < 32 || category > 126)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid type category \"%s\": must be simple ASCII",
- p)));
+ errmsg("invalid type category \"%s\": must be simple ASCII",
+ p)));
}
if (preferredEl)
preferred = defGetBoolean(preferredEl);
/*
* Note: if argument was an unquoted identifier, parser will have
- * applied translations to it, so be prepared to recognize
- * translated type names as well as the nominal form.
+ * applied translations to it, so be prepared to recognize translated
+ * type names as well as the nominal form.
*/
if (pg_strcasecmp(a, "double") == 0 ||
pg_strcasecmp(a, "float8") == 0 ||
typeNamespace, /* namespace */
InvalidOid, /* relation oid (n/a here) */
0, /* relation kind (ditto) */
- GetUserId(), /* owner's ID */
+ GetUserId(), /* owner's ID */
internalLength, /* internal size */
TYPTYPE_BASE, /* type-type (base type) */
category, /* type-category */
GetUserId(), /* owner's ID */
-1, /* internal size (always varlena) */
TYPTYPE_BASE, /* type-type (base type) */
- TYPCATEGORY_ARRAY, /* type-category (array) */
+ TYPCATEGORY_ARRAY, /* type-category (array) */
false, /* array types are never preferred */
delimiter, /* array element delimiter */
F_ARRAY_IN, /* input procedure */
RemoveTypes(DropStmt *drop)
{
ObjectAddresses *objects;
- ListCell *cell;
+ ListCell *cell;
/*
* First we identify all the types, then we delete them in a single
- * performMultipleDeletions() call. This is to avoid unwanted
- * DROP RESTRICT errors if one of the types depends on another.
+ * performMultipleDeletions() call. This is to avoid unwanted DROP
+ * RESTRICT errors if one of the types depends on another.
*/
objects = new_object_addresses();
foreach(cell, drop->objects)
{
- List *names = (List *) lfirst(cell);
+ List *names = (List *) lfirst(cell);
TypeName *typename;
Oid typeoid;
HeapTuple tup;
domainNamespace, /* namespace */
InvalidOid, /* relation oid (n/a here) */
0, /* relation kind (ditto) */
- GetUserId(), /* owner's ID */
+ GetUserId(), /* owner's ID */
internalLength, /* internal size */
TYPTYPE_DOMAIN, /* type-type (domain type) */
category, /* type-category */
enumNamespace, /* namespace */
InvalidOid, /* relation oid (n/a here) */
0, /* relation kind (ditto) */
- GetUserId(), /* owner's ID */
+ GetUserId(), /* owner's ID */
sizeof(Oid), /* internal size */
TYPTYPE_ENUM, /* type-type (enum type) */
TYPCATEGORY_ENUM, /* type-category (enum type) */
GetUserId(), /* owner's ID */
-1, /* internal size (always varlena) */
TYPTYPE_BASE, /* type-type (base type) */
- TYPCATEGORY_ARRAY, /* type-category (array) */
+ TYPCATEGORY_ARRAY, /* type-category (array) */
false, /* array types are never preferred */
DEFAULT_TYPDELIM, /* array element delimiter */
F_ARRAY_IN, /* input procedure */
}
newtuple = heap_modify_tuple(tup, RelationGetDescr(rel),
- new_record, new_record_nulls,
- new_record_repl);
+ new_record, new_record_nulls,
+ new_record_repl);
simple_heap_update(rel, &tup->t_self, newtuple);
/*
* If it's a composite type, we need to check that it really is a
- * free-standing composite type, and not a table's rowtype. We
- * want people to use ALTER TABLE not ALTER TYPE for that case.
+ * free-standing composite type, and not a table's rowtype. We want people
+ * to use ALTER TABLE not ALTER TYPE for that case.
*/
if (typTup->typtype == TYPTYPE_COMPOSITE &&
get_rel_relkind(typTup->typrelid) != RELKIND_COMPOSITE_TYPE)
errhint("You can alter type %s, which will alter the array type as well.",
format_type_be(typTup->typelem))));
- /*
+ /*
* If type is composite we need to rename associated pg_class entry too.
* RenameRelationInternal will call RenameTypeInternal automatically.
*/
}
new_tuple = heap_modify_tuple(tuple, pg_authid_dsc, new_record,
- new_record_nulls, new_record_repl);
+ new_record_nulls, new_record_repl);
simple_heap_update(pg_authid_rel, &tuple->t_self, new_tuple);
/* Update indexes */
}
newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(rel),
- repl_val, repl_null, repl_repl);
+ repl_val, repl_null, repl_repl);
simple_heap_update(rel, &oldtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple);
if (rolename == NULL || priv->cols != NIL)
ereport(ERROR,
(errcode(ERRCODE_INVALID_GRANT_OPERATION),
- errmsg("column names cannot be included in GRANT/REVOKE ROLE")));
+ errmsg("column names cannot be included in GRANT/REVOKE ROLE")));
roleid = get_roleid_checked(rolename);
if (stmt->is_grant)
new_record_repl[Anum_pg_auth_members_grantor - 1] = true;
new_record_repl[Anum_pg_auth_members_admin_option - 1] = true;
tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
- new_record,
- new_record_nulls, new_record_repl);
+ new_record,
+ new_record_nulls, new_record_repl);
simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);
CatalogUpdateIndexes(pg_authmem_rel, tuple);
ReleaseSysCache(authmem_tuple);
else
{
tuple = heap_form_tuple(pg_authmem_dsc,
- new_record, new_record_nulls);
+ new_record, new_record_nulls);
simple_heap_insert(pg_authmem_rel, tuple);
CatalogUpdateIndexes(pg_authmem_rel, tuple);
}
new_record_repl[Anum_pg_auth_members_admin_option - 1] = true;
tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
- new_record,
- new_record_nulls, new_record_repl);
+ new_record,
+ new_record_nulls, new_record_repl);
simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);
CatalogUpdateIndexes(pg_authmem_rel, tuple);
}
if (freezeTableLimit != NULL)
{
- int freezetable;
+ int freezetable;
/*
* Determine the table freeze age to use: as specified by the caller,
Assert(freezetable >= 0);
/*
- * Compute the cutoff XID, being careful not to generate a
- * "permanent" XID.
+ * Compute the cutoff XID, being careful not to generate a "permanent"
+ * XID.
*/
limit = ReadNewTransactionId() - freezetable;
if (!TransactionIdIsNormal(limit))
StartTransactionCommand();
/*
- * Functions in indexes may want a snapshot set. Also, setting
- * a snapshot ensures that RecentGlobalXmin is kept truly recent.
+ * Functions in indexes may want a snapshot set. Also, setting a snapshot
+ * ensures that RecentGlobalXmin is kept truly recent.
*/
PushActiveSnapshot(GetTransactionSnapshot());
if (!vacstmt->full)
{
/*
- * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets other
- * concurrent VACUUMs know that they can ignore this one while
+ * In lazy vacuum, we can set the PROC_IN_VACUUM flag, which lets
+ * other concurrent VACUUMs know that they can ignore this one while
* determining their OldestXmin. (The reason we don't set it during a
* full VACUUM is exactly that we may have to run user- defined
* functions for functional indexes, and we want to make sure that if
* contents of other tables is arguably broken, but we won't break it
* here by violating transaction semantics.)
*
- * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down
- * by autovacuum; it's used to avoid cancelling a vacuum that was
- * invoked in an emergency.
+ * We also set the VACUUM_FOR_WRAPAROUND flag, which is passed down by
+ * autovacuum; it's used to avoid cancelling a vacuum that was invoked
+ * in an emergency.
*
* Note: these flags remain set until CommitTransaction or
* AbortTransaction. We don't want to clear them until we reset
{
if (onerel->rd_rel->relisshared)
ereport(WARNING,
- (errmsg("skipping \"%s\" --- only superuser can vacuum it",
- RelationGetRelationName(onerel))));
+ (errmsg("skipping \"%s\" --- only superuser can vacuum it",
+ RelationGetRelationName(onerel))));
else if (onerel->rd_rel->relnamespace == PG_CATALOG_NAMESPACE)
ereport(WARNING,
(errmsg("skipping \"%s\" --- only superuser or database owner can vacuum it",
}
/*
- * Check that it's a vacuumable table; we used to do this in get_rel_oids()
- * but seems safer to check after we've locked the relation.
+ * Check that it's a vacuumable table; we used to do this in
+ * get_rel_oids() but seems safer to check after we've locked the
+ * relation.
*/
if (onerel->rd_rel->relkind != RELKIND_RELATION &&
onerel->rd_rel->relkind != RELKIND_TOASTVALUE)
toast_relid = InvalidOid;
/*
- * Switch to the table owner's userid, so that any index functions are
- * run as that user. (This is unnecessary, but harmless, for lazy
- * VACUUM.)
+ * Switch to the table owner's userid, so that any index functions are run
+ * as that user. (This is unnecessary, but harmless, for lazy VACUUM.)
*/
GetUserIdAndContext(&save_userid, &save_secdefcxt);
SetUserIdAndContext(onerel->rd_rel->relowner, true);
/*
* Add the page to vacuum_pages if it requires reaping, and add it to
* fraged_pages if it has a useful amount of free space. "Useful"
- * means enough for a minimal-sized tuple. But we don't know that
+ * means enough for a minimal-sized tuple. But we don't know that
* accurately near the start of the relation, so add pages
* unconditionally if they have >= BLCKSZ/10 free space. Also
* forcibly add pages with no live tuples, to avoid confusing the
* empty_end_pages logic. (In the presence of unreasonably small
- * fillfactor, it seems possible that such pages might not pass
- * the free-space test, but they had better be in the list anyway.)
+ * fillfactor, it seems possible that such pages might not pass the
+ * free-space test, but they had better be in the list anyway.)
*/
do_frag = (vacpage->free >= min_tlen || vacpage->free >= BLCKSZ / 10 ||
notup);
/* assume block# is OK (see heap_fetch comments) */
nextBuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
ItemPointerGetBlockNumber(&nextTid),
- RBM_NORMAL, vac_strategy);
+ RBM_NORMAL, vac_strategy);
nextPage = BufferGetPage(nextBuf);
/* If bogus or unused slot, assume tp is end of chain */
nextOffnum = ItemPointerGetOffsetNumber(&nextTid);
tp.t_self = vtlp->this_tid;
Pbuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
ItemPointerGetBlockNumber(&(tp.t_self)),
- RBM_NORMAL, vac_strategy);
+ RBM_NORMAL, vac_strategy);
Ppage = BufferGetPage(Pbuf);
Pitemid = PageGetItemId(Ppage,
ItemPointerGetOffsetNumber(&(tp.t_self)));
tuple.t_self = vtmove[ti].tid;
Cbuf = ReadBufferExtended(onerel, MAIN_FORKNUM,
ItemPointerGetBlockNumber(&(tuple.t_self)),
- RBM_NORMAL, vac_strategy);
+ RBM_NORMAL, vac_strategy);
/* Get page to move to */
dst_buffer = ReadBufferExtended(onerel, MAIN_FORKNUM,
return;
/*
- * Now update statistics in pg_class, but only if the index says the
- * count is accurate.
+ * Now update statistics in pg_class, but only if the index says the count
+ * is accurate.
*/
if (!stats->estimated_count)
vac_update_relstats(indrel,
return;
/*
- * Now update statistics in pg_class, but only if the index says the
- * count is accurate.
+ * Now update statistics in pg_class, but only if the index says the count
+ * is accurate.
*/
if (!stats->estimated_count)
vac_update_relstats(indrel,
{
/*
* It is correct to use PageGetExactFreeSpace() here, *not*
- * PageGetHeapFreeSpace(). This is because (a) we do our own, exact
+ * PageGetHeapFreeSpace(). This is because (a) we do our own, exact
* accounting for whether line pointers must be added, and (b) we will
* recycle any LP_DEAD line pointers before starting to add rows to a
* page, but that may not have happened yet at the time this function is
bool scanned_all; /* have we scanned all pages (this far)? */
/* Overall statistics about rel */
BlockNumber rel_pages;
- double old_rel_tuples; /* previous value of pg_class.reltuples */
+ double old_rel_tuples; /* previous value of pg_class.reltuples */
double rel_tuples; /* counts only tuples on scanned pages */
BlockNumber pages_removed;
double tuples_deleted;
vacrelstats = (LVRelStats *) palloc0(sizeof(LVRelStats));
- vacrelstats->scanned_all = true; /* will be cleared if we skip a page */
+ vacrelstats->scanned_all = true; /* will be cleared if we skip a page */
vacrelstats->old_rel_tuples = onerel->rd_rel->reltuples;
vacrelstats->num_index_scans = 0;
/* Open all indexes of the relation */
vac_open_indexes(onerel, RowExclusiveLock, &nindexes, &Irel);
vacrelstats->hasindex = (nindexes > 0);
-
+
/* Do the vacuuming */
lazy_scan_heap(onerel, vacrelstats, Irel, nindexes, scan_all);
* Update statistics in pg_class. But only if we didn't skip any pages;
* the tuple count only includes tuples from the pages we've visited, and
* we haven't frozen tuples in unvisited pages either. The page count is
- * accurate in any case, but because we use the reltuples / relpages
- * ratio in the planner, it's better to not update relpages either if we
- * can't update reltuples.
+ * accurate in any case, but because we use the reltuples / relpages ratio
+ * in the planner, it's better to not update relpages either if we can't
+ * update reltuples.
*/
if (vacrelstats->scanned_all)
vac_update_relstats(onerel,
int i;
PGRUsage ru0;
Buffer vmbuffer = InvalidBuffer;
- BlockNumber all_visible_streak;
+ BlockNumber all_visible_streak;
pg_rusage_init(&ru0);
bool all_visible;
/*
- * Skip pages that don't require vacuuming according to the
- * visibility map. But only if we've seen a streak of at least
+ * Skip pages that don't require vacuuming according to the visibility
+ * map. But only if we've seen a streak of at least
* SKIP_PAGES_THRESHOLD pages marked as clean. Since we're reading
* sequentially, the OS should be doing readahead for us and there's
* no gain in skipping a page now and then. You need a longer run of
all_visible = false;
break;
}
+
/*
- * The inserter definitely committed. But is it
- * old enough that everyone sees it as committed?
+ * The inserter definitely committed. But is it old
+ * enough that everyone sees it as committed?
*/
xmin = HeapTupleHeaderGetXmin(tuple.t_data);
if (!TransactionIdPrecedes(xmin, OldestXmin))
return;
/*
- * Now update statistics in pg_class, but only if the index says the
- * count is accurate.
+ * Now update statistics in pg_class, but only if the index says the count
+ * is accurate.
*/
if (!stats->estimated_count)
vac_update_relstats(indrel,
/*
* Try to parse it. XXX an invalid interval format will result in
- * ereport(ERROR), which is not desirable for GUC. We did what we
+ * ereport(ERROR), which is not desirable for GUC. We did what we
* could to guard against this in flatten_set_variable_args, but a
* string coming in from postgresql.conf might contain anything.
*/
{
ereport(GUC_complaint_elevel(source),
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid interval value for time zone: day not allowed")));
+ errmsg("invalid interval value for time zone: day not allowed")));
pfree(interval);
return NULL;
}
/*
* Disallow SET ROLE inside a security definer context. We need to do
* this because when we exit the context, GUC won't be notified,
- * leaving things out of sync. Note that this test is arranged so
+ * leaving things out of sync. Note that this test is arranged so
* that restoring a previously saved setting isn't prevented.
*
* XXX it would be nice to allow this case in future, with the
checkViewTupleDesc(descriptor, rel->rd_att);
/*
- * If new attributes have been added, we must add pg_attribute entries
+ * If new attributes have been added, we must add pg_attribute entries
* for them. It is convenient (although overkill) to use the ALTER
* TABLE ADD COLUMN infrastructure for this.
*/
if (list_length(attrList) > rel->rd_att->natts)
{
- List *atcmds = NIL;
- ListCell *c;
+ List *atcmds = NIL;
+ ListCell *c;
int skip = rel->rd_att->natts;
foreach(c, attrList)
if (strcmp(NameStr(newattr->attname), NameStr(oldattr->attname)) != 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
- errmsg("cannot change name of view column \"%s\" to \"%s\"",
- NameStr(oldattr->attname),
- NameStr(newattr->attname))));
+ errmsg("cannot change name of view column \"%s\" to \"%s\"",
+ NameStr(oldattr->attname),
+ NameStr(newattr->attname))));
/* XXX would it be safe to allow atttypmod to change? Not sure */
if (newattr->atttypid != oldattr->atttypid ||
newattr->atttypmod != oldattr->atttypmod)
/*
* This table didn't produce the cursor's current row; some other
- * inheritance child of the same parent must have. Signal caller
- * to do nothing on this table.
+ * inheritance child of the same parent must have. Signal caller to
+ * do nothing on this table.
*/
return false;
}
/* Hooks for plugins to get control in ExecutorStart/Run/End() */
-ExecutorStart_hook_type ExecutorStart_hook = NULL;
-ExecutorRun_hook_type ExecutorRun_hook = NULL;
-ExecutorEnd_hook_type ExecutorEnd_hook = NULL;
+ExecutorStart_hook_type ExecutorStart_hook = NULL;
+ExecutorRun_hook_type ExecutorRun_hook = NULL;
+ExecutorEnd_hook_type ExecutorEnd_hook = NULL;
typedef struct evalPlanQual
{
}
/*
- * Basically the same for the mod columns, with either INSERT or UPDATE
- * privilege as specified by remainingPerms.
+ * Basically the same for the mod columns, with either INSERT or
+ * UPDATE privilege as specified by remainingPerms.
*/
remainingPerms &= ~ACL_SELECT;
if (remainingPerms != 0)
{
/*
- * When the query doesn't explicitly change any columns, allow
- * the query if we have permission on any column of the rel. This
- * is to handle SELECT FOR UPDATE as well as possible corner cases
- * in INSERT and UPDATE.
+ * When the query doesn't explicitly change any columns, allow the
+ * query if we have permission on any column of the rel. This is
+ * to handle SELECT FOR UPDATE as well as possible corner cases in
+ * INSERT and UPDATE.
*/
if (bms_is_empty(rte->modifiedCols))
{
/*
* Initialize the junk filter if needed. SELECT and INSERT queries need a
- * filter if there are any junk attrs in the tlist. UPDATE and
- * DELETE always need a filter, since there's always a junk 'ctid'
- * attribute present --- no need to look first.
+ * filter if there are any junk attrs in the tlist. UPDATE and DELETE
+ * always need a filter, since there's always a junk 'ctid' attribute
+ * present --- no need to look first.
*
* This section of code is also a convenient place to verify that the
* output of an INSERT or UPDATE matches the target table(s).
errdetail("Table has type %s at ordinal position %d, but query expects %s.",
format_type_be(attr->atttypid),
attno,
- format_type_be(exprType((Node *) tle->expr)))));
+ format_type_be(exprType((Node *) tle->expr)))));
}
else
{
if (attno != resultDesc->natts)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("table row type and query-specified row type do not match"),
+ errmsg("table row type and query-specified row type do not match"),
errdetail("Query has too few columns.")));
}
/* if child rel, must check whether it produced this row */
if (erm->rti != erm->prti)
{
- Oid tableoid;
+ Oid tableoid;
datum = ExecGetJunkAttribute(slot,
erm->toidAttNo,
* rowtype.
*
* XXX if we ever wanted to allow users to assign their own OIDs to new
- * rows, this'd be the place to do it. For the moment, we make a point
- * of doing this before calling triggers, so that a user-supplied trigger
+ * rows, this'd be the place to do it. For the moment, we make a point of
+ * doing this before calling triggers, so that a user-supplied trigger
* could hack the OID if desired.
*/
if (resultRelationDesc->rd_rel->relhasoids)
Oid intoRelationId;
TupleDesc tupdesc;
DR_intorel *myState;
- static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
+ static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
Assert(into);
myState->rel = intoRelationDesc;
/*
- * We can skip WAL-logging the insertions, unless PITR is in use. We
- * can skip the FSM in any case.
+ * We can skip WAL-logging the insertions, unless PITR is in use. We can
+ * skip the FSM in any case.
*/
myState->hi_options = HEAP_INSERT_SKIP_FSM |
(XLogArchivingActive() ? 0 : HEAP_INSERT_SKIP_WAL);
ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalWindowFunc(WindowFuncExprState *wfunc,
- ExprContext *econtext,
- bool *isNull, ExprDoneCond *isDone);
+ ExprContext *econtext,
+ bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalVar(ExprState *exprstate, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalScalarVar(ExprState *exprstate, ExprContext *econtext,
static Datum ExecEvalParam(ExprState *exprstate, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static void init_fcache(Oid foid, FuncExprState *fcache,
- MemoryContext fcacheCxt, bool needDescForSets);
+ MemoryContext fcacheCxt, bool needDescForSets);
static void ShutdownFuncExpr(Datum arg);
static TupleDesc get_cached_rowtype(Oid type_id, int32 typmod,
TupleDesc *cache_field, ExprContext *econtext);
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("table row type and query-specified row type do not match"),
errdetail_plural("Table row contains %d attribute, but query expects %d.",
- "Table row contains %d attributes, but query expects %d.",
+ "Table row contains %d attributes, but query expects %d.",
slot_tupdesc->natts,
slot_tupdesc->natts,
var_tupdesc->natts)));
if (list_length(fcache->args) > FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
- errmsg_plural("cannot pass more than %d argument to a function",
- "cannot pass more than %d arguments to a function",
- FUNC_MAX_ARGS,
- FUNC_MAX_ARGS)));
+ errmsg_plural("cannot pass more than %d argument to a function",
+ "cannot pass more than %d arguments to a function",
+ FUNC_MAX_ARGS,
+ FUNC_MAX_ARGS)));
/* Set up the primary fmgr lookup information */
fmgr_info_cxt(foid, &(fcache->func), fcacheCxt);
* ExecPrepareTuplestoreResult
*
* Subroutine for ExecMakeFunctionResult: prepare to extract rows from a
- * tuplestore function result. We must set up a funcResultSlot (unless
+ * tuplestore function result. We must set up a funcResultSlot (unless
* already done in a previous call cycle) and verify that the function
* returned the expected tuple descriptor.
*/
}
/*
- * If function provided a tupdesc, cross-check it. We only really
- * need to do this for functions returning RECORD, but might as well
- * do it always.
+ * If function provided a tupdesc, cross-check it. We only really need to
+ * do this for functions returning RECORD, but might as well do it always.
*/
if (resultDesc)
{
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("function return row and query-specified return row do not match"),
errdetail_plural("Returned row contains %d attribute, but query expects %d.",
- "Returned row contains %d attributes, but query expects %d.",
+ "Returned row contains %d attributes, but query expects %d.",
src_tupdesc->natts,
src_tupdesc->natts, dst_tupdesc->natts)));
* init_fcache is presumed already run on the FuncExprState.
*
* This function handles the most general case, wherein the function or
- * one of its arguments might (or might not) return a set. If we find
+ * one of its arguments might (or might not) return a set. If we find
* no sets involved, we will change the FuncExprState's function pointer
* to use a simpler method on subsequent calls.
*/
check_stack_depth();
/*
- * If a previous call of the function returned a set result in the form
- * of a tuplestore, continue reading rows from the tuplestore until it's
+ * If a previous call of the function returned a set result in the form of
+ * a tuplestore, continue reading rows from the tuplestore until it's
* empty.
*/
if (fcache->funcResultStore)
{
- Assert(isDone); /* it was provided before ... */
+ Assert(isDone); /* it was provided before ... */
if (tuplestore_gettupleslot(fcache->funcResultStore, true, false,
fcache->funcResultSlot))
{
* For non-set-returning functions, we just use a local-variable
* FunctionCallInfoData. For set-returning functions we keep the callinfo
* record in fcache->setArgs so that it can survive across multiple
- * value-per-call invocations. (The reason we don't just do the latter
- * all the time is that plpgsql expects to be able to use simple expression
- * trees re-entrantly. Which might not be a good idea, but the penalty
- * for not doing so is high.)
+ * value-per-call invocations. (The reason we don't just do the latter
+ * all the time is that plpgsql expects to be able to use simple
+ * expression trees re-entrantly. Which might not be a good idea, but the
+ * penalty for not doing so is high.)
*/
if (fcache->func.fn_retset)
fcinfo = &fcache->setArgs;
*isDone = rsinfo.isDone;
pgstat_end_function_usage(&fcusage,
- rsinfo.isDone != ExprMultipleResult);
+ rsinfo.isDone != ExprMultipleResult);
}
else
{
{
RegisterExprContextCallback(econtext,
ShutdownFuncExpr,
- PointerGetDatum(fcache));
+ PointerGetDatum(fcache));
fcache->shutdown_reg = true;
}
}
}
/*
- * If function provided a tupdesc, cross-check it. We only really
- * need to do this for functions returning RECORD, but might as well
- * do it always.
+ * If function provided a tupdesc, cross-check it. We only really need to
+ * do this for functions returning RECORD, but might as well do it always.
*/
if (rsinfo.setDesc)
{
break;
case IS_XMLFOREST:
- {
- StringInfoData buf;
-
- initStringInfo(&buf);
- forboth(arg, xmlExpr->named_args, narg, xexpr->arg_names)
{
- ExprState *e = (ExprState *) lfirst(arg);
- char *argname = strVal(lfirst(narg));
+ StringInfoData buf;
- value = ExecEvalExpr(e, econtext, &isnull, NULL);
- if (!isnull)
+ initStringInfo(&buf);
+ forboth(arg, xmlExpr->named_args, narg, xexpr->arg_names)
{
- appendStringInfo(&buf, "<%s>%s</%s>",
- argname,
- map_sql_value_to_xml_value(value, exprType((Node *) e->expr), true),
- argname);
- *isNull = false;
+ ExprState *e = (ExprState *) lfirst(arg);
+ char *argname = strVal(lfirst(narg));
+
+ value = ExecEvalExpr(e, econtext, &isnull, NULL);
+ if (!isnull)
+ {
+ appendStringInfo(&buf, "<%s>%s</%s>",
+ argname,
+ map_sql_value_to_xml_value(value, exprType((Node *) e->expr), true),
+ argname);
+ *isNull = false;
+ }
}
- }
- if (*isNull)
- {
- pfree(buf.data);
- return (Datum) 0;
- }
- else
- {
- text *result;
+ if (*isNull)
+ {
+ pfree(buf.data);
+ return (Datum) 0;
+ }
+ else
+ {
+ text *result;
- result = cstring_to_text_with_len(buf.data, buf.len);
- pfree(buf.data);
+ result = cstring_to_text_with_len(buf.data, buf.len);
+ pfree(buf.data);
- return PointerGetDatum(result);
+ return PointerGetDatum(result);
+ }
}
- }
break;
case IS_XMLELEMENT:
*
* Any Aggref, WindowFunc, or SubPlan nodes found in the tree are added to the
* lists of such nodes held by the parent PlanState. Otherwise, we do very
- * little initialization here other than building the state-node tree. Any
+ * little initialization here other than building the state-node tree. Any
* nontrivial work associated with initializing runtime info for a node should
- * happen during the first actual evaluation of that node. (This policy lets
+ * happen during the first actual evaluation of that node. (This policy lets
* us avoid work if the node is never actually evaluated.)
*
* Note: there is no ExecEndExpr function; we assume that any resource
if (nfuncs != winstate->numfuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("window function calls cannot be nested")));
+ errmsg("window function calls cannot be nested")));
}
else
{
numSimpleVars = projInfo->pi_numSimpleVars;
if (numSimpleVars > 0)
{
- Datum *values = slot->tts_values;
- bool *isnull = slot->tts_isnull;
- int *varSlotOffsets = projInfo->pi_varSlotOffsets;
- int *varNumbers = projInfo->pi_varNumbers;
- int i;
+ Datum *values = slot->tts_values;
+ bool *isnull = slot->tts_isnull;
+ int *varSlotOffsets = projInfo->pi_varSlotOffsets;
+ int *varNumbers = projInfo->pi_varNumbers;
+ int i;
if (projInfo->pi_directMap)
{
else
{
/* we have to pay attention to varOutputCols[] */
- int *varOutputCols = projInfo->pi_varOutputCols;
+ int *varOutputCols = projInfo->pi_varOutputCols;
for (i = 0; i < numSimpleVars; i++)
{
/*
* If there are any generic expressions, evaluate them. It's possible
- * that there are set-returning functions in such expressions; if so
- * and we have reached the end of the set, we return the result slot,
- * which we already marked empty.
+ * that there are set-returning functions in such expressions; if so and
+ * we have reached the end of the set, we return the result slot, which we
+ * already marked empty.
*/
if (projInfo->pi_targetlist)
{
/*
* Note: we may now have a situation where we have a local minimal tuple
- * attached to a virtual or non-local physical tuple. There seems no
- * harm in that at the moment, but if any materializes, we should change
- * this function to force the slot into minimal-tuple-only state.
+ * attached to a virtual or non-local physical tuple. There seems no harm
+ * in that at the moment, but if any materializes, we should change this
+ * function to force the slot into minimal-tuple-only state.
*/
return slot->tts_mintuple;
slot->tts_buffer = InvalidBuffer;
/*
- * Mark extracted state invalid. This is important because the slot
- * is not supposed to depend any more on the previous external data;
- * we mustn't leave any dangling pass-by-reference datums in tts_values.
+ * Mark extracted state invalid. This is important because the slot is
+ * not supposed to depend any more on the previous external data; we
+ * mustn't leave any dangling pass-by-reference datums in tts_values.
* However, we have not actually invalidated any such datums, if there
* happen to be any previously fetched from the slot. (Note in particular
* that we have not pfree'd tts_mintuple, if there is one.)
/*
* On the same principle of not depending on previous remote storage,
- * forget the mintuple if it's not local storage. (If it is local storage,
- * we must not pfree it now, since callers might have already fetched
- * datum pointers referencing it.)
+ * forget the mintuple if it's not local storage. (If it is local
+ * storage, we must not pfree it now, since callers might have already
+ * fetched datum pointers referencing it.)
*/
if (!slot->tts_shouldFreeMin)
slot->tts_mintuple = NULL;
/*
* We separate the target list elements into simple Var references and
- * expressions which require the full ExecTargetList machinery. To be
- * a simple Var, a Var has to be a user attribute and not mismatch the
+ * expressions which require the full ExecTargetList machinery. To be a
+ * simple Var, a Var has to be a user attribute and not mismatch the
* inputDesc. (Note: if there is a type mismatch then ExecEvalVar will
* probably throw an error at runtime, but we leave that to it.)
*/
varNumbers[numSimpleVars] = attnum;
varOutputCols[numSimpleVars] = tle->resno;
- if (tle->resno != numSimpleVars+1)
+ if (tle->resno != numSimpleVars + 1)
directMap = false;
switch (variable->varno)
return false;
if (IsA(node, Var))
{
- Var *variable = (Var *) node;
+ Var *variable = (Var *) node;
AttrNumber attnum = variable->varattno;
switch (variable->varno)
}
return false;
}
+
/*
- * Don't examine the arguments of Aggrefs or WindowFuncs, because those
- * do not represent expressions to be evaluated within the overall
+ * Don't examine the arguments of Aggrefs or WindowFuncs, because those do
+ * not represent expressions to be evaluated within the overall
* targetlist's econtext.
*/
if (IsA(node, Aggref))
/* non-export function prototypes */
static execution_state *init_execution_state(List *queryTree_list,
- SQLFunctionCachePtr fcache,
- bool lazyEvalOK);
+ SQLFunctionCachePtr fcache,
+ bool lazyEvalOK);
static void init_sql_fcache(FmgrInfo *finfo, bool lazyEvalOK);
static void postquel_start(execution_state *es, SQLFunctionCachePtr fcache);
static bool postquel_getnext(execution_state *es, SQLFunctionCachePtr fcache);
newes->next = NULL;
newes->status = F_EXEC_START;
- newes->setsResult = false; /* might change below */
- newes->lazyEval = false; /* might change below */
+ newes->setsResult = false; /* might change below */
+ newes->lazyEval = false; /* might change below */
newes->stmt = stmt;
newes->qd = NULL;
}
/*
- * Mark the last canSetTag query as delivering the function result;
- * then, if it is a plain SELECT, mark it for lazy evaluation.
- * If it's not a SELECT we must always run it to completion.
+ * Mark the last canSetTag query as delivering the function result; then,
+ * if it is a plain SELECT, mark it for lazy evaluation. If it's not a
+ * SELECT we must always run it to completion.
*
* Note: at some point we might add additional criteria for whether to use
* lazy eval. However, we should prefer to use it whenever the function
*
* Note: don't set setsResult if the function returns VOID, as evidenced
* by not having made a junkfilter. This ensures we'll throw away any
- * output from a utility statement that check_sql_fn_retval deemed to
- * not have output.
+ * output from a utility statement that check_sql_fn_retval deemed to not
+ * have output.
*/
if (lasttages && fcache->junkFilter)
{
* Note: we set fcache->returnsTuple according to whether we are returning
* the whole tuple result or just a single column. In the latter case we
* clear returnsTuple because we need not act different from the scalar
- * result case, even if it's a rowtype column. (However, we have to
- * force lazy eval mode in that case; otherwise we'd need extra code to
- * expand the rowtype column into multiple columns, since we have no
- * way to notify the caller that it should do that.)
+ * result case, even if it's a rowtype column. (However, we have to force
+ * lazy eval mode in that case; otherwise we'd need extra code to expand
+ * the rowtype column into multiple columns, since we have no way to
+ * notify the caller that it should do that.)
*
* check_sql_fn_retval will also construct a JunkFilter we can use to
* coerce the returned rowtype to the desired form (unless the result type
es->qd->utilitystmt),
fcache->src,
es->qd->params,
- false, /* not top level */
+ false, /* not top level */
es->qd->dest,
NULL);
result = true; /* never stops early */
/*
* Set up to return the function value. For pass-by-reference datatypes,
* be sure to allocate the result in resultcontext, not the current memory
- * context (which has query lifespan). We can't leave the data in the
+ * context (which has query lifespan). We can't leave the data in the
* TupleTableSlot because we intend to clear the slot before returning.
*/
oldcontext = MemoryContextSwitchTo(resultcontext);
postquel_sub_params(fcache, fcinfo);
/*
- * Build tuplestore to hold results, if we don't have one already.
- * Note it's in the query-lifespan context.
+ * Build tuplestore to hold results, if we don't have one already. Note
+ * it's in the query-lifespan context.
*/
if (!fcache->tstore)
fcache->tstore = tuplestore_begin_heap(randomAccess, false, work_mem);
*/
while (es)
{
- bool completed;
+ bool completed;
if (es->status == F_EXEC_START)
postquel_start(es, fcache);
completed = postquel_getnext(es, fcache);
/*
- * If we ran the command to completion, we can shut it down now.
- * Any row(s) we need to return are safely stashed in the tuplestore,
- * and we want to be sure that, for example, AFTER triggers get fired
+ * If we ran the command to completion, we can shut it down now. Any
+ * row(s) we need to return are safely stashed in the tuplestore, and
+ * we want to be sure that, for example, AFTER triggers get fired
* before we return anything. Also, if the function doesn't return
- * set, we can shut it down anyway because it must be a SELECT and
- * we don't care about fetching any more result rows.
+ * set, we can shut it down anyway because it must be a SELECT and we
+ * don't care about fetching any more result rows.
*/
if (completed || !fcache->returnsSet)
postquel_end(es);
/*
* Break from loop if we didn't shut down (implying we got a
- * lazily-evaluated row). Otherwise we'll press on till the
- * whole function is done, relying on the tuplestore to keep hold
- * of the data to eventually be returned. This is necessary since
- * an INSERT/UPDATE/DELETE RETURNING that sets the result might be
+ * lazily-evaluated row). Otherwise we'll press on till the whole
+ * function is done, relying on the tuplestore to keep hold of the
+ * data to eventually be returned. This is necessary since an
+ * INSERT/UPDATE/DELETE RETURNING that sets the result might be
* followed by additional rule-inserted commands, and we want to
* finish doing all those commands before we return anything.
*/
if (es)
{
/*
- * If we stopped short of being done, we must have a lazy-eval row.
+ * If we stopped short of being done, we must have a lazy-eval
+ * row.
*/
Assert(es->lazyEval);
/* Re-use the junkfilter's output slot to fetch back the tuple */
else if (fcache->lazyEval)
{
/*
- * We are done with a lazy evaluation. Clean up.
+ * We are done with a lazy evaluation. Clean up.
*/
tuplestore_clear(fcache->tstore);
else
{
/*
- * We are done with a non-lazy evaluation. Return whatever is
- * in the tuplestore. (It is now caller's responsibility to
- * free the tuplestore when done.)
+ * We are done with a non-lazy evaluation. Return whatever is in
+ * the tuplestore. (It is now caller's responsibility to free the
+ * tuplestore when done.)
*/
rsi->returnMode = SFRM_Materialize;
rsi->setResult = fcache->tstore;
}
/*
- * If we've gone through every command in the function, we are done.
- * Reset the execution states to start over again on next call.
+ * If we've gone through every command in the function, we are done. Reset
+ * the execution states to start over again on next call.
*/
if (es == NULL)
{
* function definition of a polymorphic function.)
*
* This function returns true if the sql function returns the entire tuple
- * result of its final statement, and false otherwise. Note that because we
+ * result of its final statement, and false otherwise. Note that because we
* allow "SELECT rowtype_expression", this may be false even when the declared
* function return type is a rowtype.
*
*junkFilter = NULL; /* initialize in case of VOID result */
/*
- * Find the last canSetTag query in the list. This isn't necessarily
- * the last parsetree, because rule rewriting can insert queries after
- * what the user wrote.
+ * Find the last canSetTag query in the list. This isn't necessarily the
+ * last parsetree, because rule rewriting can insert queries after what
+ * the user wrote.
*/
parse = NULL;
foreach(lc, queryTreeList)
{
- Query *q = (Query *) lfirst(lc);
+ Query *q = (Query *) lfirst(lc);
if (q->canSetTag)
parse = q;
/*
* If it's a plain SELECT, it returns whatever the targetlist says.
- * Otherwise, if it's INSERT/UPDATE/DELETE with RETURNING, it returns that.
- * Otherwise, the function return type must be VOID.
+ * Otherwise, if it's INSERT/UPDATE/DELETE with RETURNING, it returns
+ * that. Otherwise, the function return type must be VOID.
*
* Note: eventually replace this test with QueryReturnsTuples? We'd need
- * a more general method of determining the output type, though. Also,
- * it seems too dangerous to consider FETCH or EXECUTE as returning a
+ * a more general method of determining the output type, though. Also, it
+ * seems too dangerous to consider FETCH or EXECUTE as returning a
* determinable rowtype, since they depend on relatively short-lived
* entities.
*/
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("return type mismatch in function declared to return %s",
format_type_be(rettype)),
- errdetail("Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING.")));
+ errdetail("Function's final statement must be SELECT or INSERT/UPDATE/DELETE RETURNING.")));
return false;
}
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("return type mismatch in function declared to return %s",
format_type_be(rettype)),
- errdetail("Final statement must return exactly one column.")));
+ errdetail("Final statement must return exactly one column.")));
/* We assume here that non-junk TLEs must come first in tlists */
tle = (TargetEntry *) linitial(tlist);
* If the target list is of length 1, and the type of the varnode in
* the target list matches the declared return type, this is okay.
* This can happen, for example, where the body of the function is
- * 'SELECT func2()', where func2 has the same composite return type
- * as the function that's calling it.
+ * 'SELECT func2()', where func2 has the same composite return type as
+ * the function that's calling it.
*/
if (tlistlen == 1)
{
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("return type mismatch in function declared to return %s",
format_type_be(rettype)),
- errdetail("Final statement returns too many columns.")));
+ errdetail("Final statement returns too many columns.")));
attr = tupdesc->attrs[colindex - 1];
} while (attr->attisdropped);
tuplogcols++;
}
/*
- * If we haven't yet performed the underlying index scan, do it, and
- * begin the iteration over the bitmap.
+ * If we haven't yet performed the underlying index scan, do it, and begin
+ * the iteration over the bitmap.
*
* For prefetching, we use *two* iterators, one for the pages we are
* actually scanning and another that runs ahead of the first for
- * prefetching. node->prefetch_pages tracks exactly how many pages
- * ahead the prefetch iterator is. Also, node->prefetch_target tracks
- * the desired prefetch distance, which starts small and increases up
- * to the GUC-controlled maximum, target_prefetch_pages. This is to
- * avoid doing a lot of prefetching in a scan that stops after a few
- * tuples because of a LIMIT.
+ * prefetching. node->prefetch_pages tracks exactly how many pages ahead
+ * the prefetch iterator is. Also, node->prefetch_target tracks the
+ * desired prefetch distance, which starts small and increases up to the
+ * GUC-controlled maximum, target_prefetch_pages. This is to avoid doing
+ * a lot of prefetching in a scan that stops after a few tuples because of
+ * a LIMIT.
*/
if (tbm == NULL)
{
node->prefetch_pages = 0;
node->prefetch_target = -1;
}
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
for (;;)
if (tbmpre == NULL || tbmpre->blockno != tbmres->blockno)
elog(ERROR, "prefetch and main iterators are out of sync");
}
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
/*
* Ignore any claimed entries past what we think is the end of the
scan->rs_cindex = 0;
#ifdef USE_PREFETCH
+
/*
- * Increase prefetch target if it's not yet at the max. Note
- * that we will increase it to zero after fetching the very
- * first page/tuple, then to one after the second tuple is
- * fetched, then it doubles as later pages are fetched.
+ * Increase prefetch target if it's not yet at the max. Note that
+ * we will increase it to zero after fetching the very first
+ * page/tuple, then to one after the second tuple is fetched, then
+ * it doubles as later pages are fetched.
*/
if (node->prefetch_target >= target_prefetch_pages)
- /* don't increase any further */ ;
+ /* don't increase any further */ ;
else if (node->prefetch_target >= target_prefetch_pages / 2)
node->prefetch_target = target_prefetch_pages;
else if (node->prefetch_target > 0)
node->prefetch_target *= 2;
else
node->prefetch_target++;
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
else
{
scan->rs_cindex++;
#ifdef USE_PREFETCH
+
/*
* Try to prefetch at least a few pages even before we get to the
* second page if we don't stop reading after the first tuple.
*/
if (node->prefetch_target < target_prefetch_pages)
node->prefetch_target++;
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
/*
}
#ifdef USE_PREFETCH
+
/*
- * We issue prefetch requests *after* fetching the current page
- * to try to avoid having prefetching interfere with the main I/O.
- * Also, this should happen only when we have determined there is
- * still something to do on the current page, else we may uselessly
- * prefetch the same page we are just about to request for real.
+ * We issue prefetch requests *after* fetching the current page to try
+ * to avoid having prefetching interfere with the main I/O. Also, this
+ * should happen only when we have determined there is still something
+ * to do on the current page, else we may uselessly prefetch the same
+ * page we are just about to request for real.
*/
if (prefetch_iterator)
{
PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno);
}
}
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
/*
* Okay to fetch the tuple
doscan = ExecIndexAdvanceArrayKeys(node->biss_ArrayKeys,
node->biss_NumArrayKeys);
- if (doscan) /* reset index scan */
+ if (doscan) /* reset index scan */
index_rescan(node->biss_ScanDesc, node->biss_ScanKeys);
}
* If we can fetch another tuple from the tuplestore, return it.
*
* Note: we have to use copy=true in the tuplestore_gettupleslot call,
- * because we are sharing the tuplestore with other nodes that might
- * write into the tuplestore before we get called again.
+ * because we are sharing the tuplestore with other nodes that might write
+ * into the tuplestore before we get called again.
*/
if (!eof_tuplestore)
{
* Append a copy of the returned tuple to tuplestore. NOTE: because
* our read pointer is certainly in EOF state, its read position will
* move forward over the added tuple. This is what we want. Also,
- * any other readers will *not* move past the new tuple, which is
- * what they want.
+ * any other readers will *not* move past the new tuple, which is what
+ * they want.
*/
tuplestore_puttupleslot(tuplestorestate, cteslot);
/*
- * We MUST copy the CTE query's output tuple into our own slot.
- * This is because other CteScan nodes might advance the CTE query
- * before we are called again, and our output tuple must stay
- * stable over that.
+ * We MUST copy the CTE query's output tuple into our own slot. This
+ * is because other CteScan nodes might advance the CTE query before
+ * we are called again, and our output tuple must stay stable over
+ * that.
*/
return ExecCopySlot(slot, cteslot);
}
node->ctePlanId - 1);
/*
- * The Param slot associated with the CTE query is used to hold a
- * pointer to the CteState of the first CteScan node that initializes
- * for this CTE. This node will be the one that holds the shared
- * state for all the CTEs.
+ * The Param slot associated with the CTE query is used to hold a pointer
+ * to the CteState of the first CteScan node that initializes for this
+ * CTE. This node will be the one that holds the shared state for all the
+ * CTEs.
*/
prmdata = &(estate->es_param_exec_vals[node->cteParam]);
Assert(prmdata->execPlan == NULL);
if (node->leader == node)
{
/*
- * The leader is responsible for clearing the tuplestore if a new
- * scan of the underlying CTE is required.
+ * The leader is responsible for clearing the tuplestore if a new scan
+ * of the underlying CTE is required.
*/
if (node->cteplanstate->chgParam != NULL)
{
/*
* Here we have a choice whether to drop the tuplestore (and recompute the
* function outputs) or just rescan it. We must recompute if the
- * expression contains parameters, else we rescan. XXX maybe we should
+ * expression contains parameters, else we rescan. XXX maybe we should
* recompute if the function is volatile?
*/
if (node->ss.ps.chgParam != NULL)
static void ExecHashIncreaseNumBatches(HashJoinTable hashtable);
static void ExecHashBuildSkewHash(HashJoinTable hashtable, Hash *node,
- int mcvsToUse);
+ int mcvsToUse);
static void ExecHashSkewTableInsert(HashJoinTable hashtable,
- TupleTableSlot *slot,
- uint32 hashvalue,
- int bucketNumber);
+ TupleTableSlot *slot,
+ uint32 hashvalue,
+ int bucketNumber);
static void ExecHashRemoveNextSkewBucket(HashJoinTable hashtable);
if (ExecHashGetHashValue(hashtable, econtext, hashkeys, false, false,
&hashvalue))
{
- int bucketNumber;
+ int bucketNumber;
bucketNumber = ExecHashGetSkewBucket(hashtable, hashvalue);
if (bucketNumber != INVALID_SKEW_BUCKET_NO)
/*
* Set up for skew optimization, if possible and there's a need for more
- * than one batch. (In a one-batch join, there's no point in it.)
+ * than one batch. (In a one-batch join, there's no point in it.)
*/
if (nbatch > 1)
ExecHashBuildSkewHash(hashtable, node, num_skew_mcvs);
skew_table_bytes = hash_table_bytes * SKEW_WORK_MEM_PERCENT / 100;
*num_skew_mcvs = skew_table_bytes / (
- /* size of a hash tuple */
- tupsize +
- /* worst-case size of skewBucket[] per MCV */
- (8 * sizeof(HashSkewBucket *)) +
- /* size of skewBucketNums[] entry */
- sizeof(int) +
- /* size of skew bucket struct itself */
- SKEW_BUCKET_OVERHEAD
+ /* size of a hash tuple */
+ tupsize +
+ /* worst-case size of skewBucket[] per MCV */
+ (8 * sizeof(HashSkewBucket *)) +
+ /* size of skewBucketNums[] entry */
+ sizeof(int) +
+ /* size of skew bucket struct itself */
+ SKEW_BUCKET_OVERHEAD
);
if (*num_skew_mcvs > 0)
static void
ExecHashBuildSkewHash(HashJoinTable hashtable, Hash *node, int mcvsToUse)
{
- HeapTupleData *statsTuple;
- Datum *values;
- int nvalues;
- float4 *numbers;
- int nnumbers;
+ HeapTupleData *statsTuple;
+ Datum *values;
+ int nvalues;
+ float4 *numbers;
+ int nnumbers;
/* Do nothing if planner didn't identify the outer relation's join key */
if (!OidIsValid(node->skewTable))
*
* skewBucket[] is an open addressing hashtable with a power of 2 size
* that is greater than the number of MCV values. (This ensures there
- * will be at least one null entry, so searches will always terminate.)
+ * will be at least one null entry, so searches will always
+ * terminate.)
*
- * Note: this code could fail if mcvsToUse exceeds INT_MAX/8, but
- * that is not currently possible since we limit pg_statistic entries
- * to much less than that.
+ * Note: this code could fail if mcvsToUse exceeds INT_MAX/8, but that
+ * is not currently possible since we limit pg_statistic entries to
+ * much less than that.
*/
nbuckets = 2;
while (nbuckets <= mcvsToUse)
hashtable->skewBucketLen = nbuckets;
/*
- * We allocate the bucket memory in the hashtable's batch context.
- * It is only needed during the first batch, and this ensures it
- * will be automatically removed once the first batch is done.
+ * We allocate the bucket memory in the hashtable's batch context. It
+ * is only needed during the first batch, and this ensures it will be
+ * automatically removed once the first batch is done.
*/
hashtable->skewBucket = (HashSkewBucket **)
MemoryContextAllocZero(hashtable->batchCxt,
/*
* Create a skew bucket for each MCV hash value.
*
- * Note: it is very important that we create the buckets in order
- * of decreasing MCV frequency. If we have to remove some buckets,
- * they must be removed in reverse order of creation (see notes in
- * ExecHashRemoveNextSkewBucket) and we want the least common MCVs
- * to be removed first.
+ * Note: it is very important that we create the buckets in order of
+ * decreasing MCV frequency. If we have to remove some buckets, they
+ * must be removed in reverse order of creation (see notes in
+ * ExecHashRemoveNextSkewBucket) and we want the least common MCVs to
+ * be removed first.
*/
hashfunctions = hashtable->outer_hashfunctions;
for (i = 0; i < mcvsToUse; i++)
{
- uint32 hashvalue;
- int bucket;
+ uint32 hashvalue;
+ int bucket;
hashvalue = DatumGetUInt32(FunctionCall1(&hashfunctions[0],
values[i]));
/*
* While we have not hit a hole in the hashtable and have not hit
* the desired bucket, we have collided with some previous hash
- * value, so try the next bucket location. NB: this code must
+ * value, so try the next bucket location. NB: this code must
* match ExecHashGetSkewBucket.
*/
bucket = hashvalue & (nbuckets - 1);
bucket = (bucket + 1) & (nbuckets - 1);
/*
- * If we found an existing bucket with the same hashvalue,
- * leave it alone. It's okay for two MCVs to share a hashvalue.
+ * If we found an existing bucket with the same hashvalue, leave
+ * it alone. It's okay for two MCVs to share a hashvalue.
*/
if (hashtable->skewBucket[bucket] != NULL)
continue;
int bucket;
/*
- * Always return INVALID_SKEW_BUCKET_NO if not doing skew optimization
- * (in particular, this happens after the initial batch is done).
+ * Always return INVALID_SKEW_BUCKET_NO if not doing skew optimization (in
+ * particular, this happens after the initial batch is done).
*/
if (!hashtable->skewEnabled)
return INVALID_SKEW_BUCKET_NO;
/*
* While we have not hit a hole in the hashtable and have not hit the
- * desired bucket, we have collided with some other hash value, so try
- * the next bucket location.
+ * desired bucket, we have collided with some other hash value, so try the
+ * next bucket location.
*/
while (hashtable->skewBucket[bucket] != NULL &&
hashtable->skewBucket[bucket]->hashvalue != hashvalue)
static void
ExecHashRemoveNextSkewBucket(HashJoinTable hashtable)
{
- int bucketToRemove;
+ int bucketToRemove;
HashSkewBucket *bucket;
- uint32 hashvalue;
- int bucketno;
- int batchno;
+ uint32 hashvalue;
+ int bucketno;
+ int batchno;
HashJoinTuple hashTuple;
/* Locate the bucket to remove */
/*
* Calculate which bucket and batch the tuples belong to in the main
* hashtable. They all have the same hash value, so it's the same for all
- * of them. Also note that it's not possible for nbatch to increase
- * while we are processing the tuples.
+ * of them. Also note that it's not possible for nbatch to increase while
+ * we are processing the tuples.
*/
hashvalue = bucket->hashvalue;
ExecHashGetBucketAndBatch(hashtable, hashvalue, &bucketno, &batchno);
{
HashJoinTuple nextHashTuple = hashTuple->next;
MinimalTuple tuple;
- Size tupleSize;
+ Size tupleSize;
/*
* This code must agree with ExecHashTableInsert. We do not use
*
* NOTE: this is not nearly as simple as it looks on the surface, because
* of the possibility of collisions in the hashtable. Suppose that hash
- * values A and B collide at a particular hashtable entry, and that A
- * was entered first so B gets shifted to a different table entry. If
- * we were to remove A first then ExecHashGetSkewBucket would mistakenly
- * start reporting that B is not in the hashtable, because it would hit
- * the NULL before finding B. However, we always remove entries in the
- * reverse order of creation, so this failure cannot happen.
+ * values A and B collide at a particular hashtable entry, and that A was
+ * entered first so B gets shifted to a different table entry. If we were
+ * to remove A first then ExecHashGetSkewBucket would mistakenly start
+ * reporting that B is not in the hashtable, because it would hit the NULL
+ * before finding B. However, we always remove entries in the reverse
+ * order of creation, so this failure cannot happen.
*/
hashtable->skewBucket[bucketToRemove] = NULL;
hashtable->nSkewBuckets--;
/* Returns true for JOIN_LEFT and JOIN_ANTI jointypes */
-#define HASHJOIN_IS_OUTER(hjstate) ((hjstate)->hj_NullInnerTupleSlot != NULL)
+#define HASHJOIN_IS_OUTER(hjstate) ((hjstate)->hj_NullInnerTupleSlot != NULL)
static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState *outerNode,
HashJoinState *hjstate,
/*
* Now we've got an outer tuple and the corresponding hash bucket,
- * but it might not belong to the current batch, or it might
- * match a skew bucket.
+ * but it might not belong to the current batch, or it might match
+ * a skew bucket.
*/
if (batchno != hashtable->curbatch &&
node->hj_CurSkewBucketNo == INVALID_SKEW_BUCKET_NO)
BufFileClose(hashtable->outerBatchFile[curbatch]);
hashtable->outerBatchFile[curbatch] = NULL;
}
- else /* we just finished the first batch */
+ else /* we just finished the first batch */
{
/*
- * Reset some of the skew optimization state variables, since we
- * no longer need to consider skew tuples after the first batch.
- * The memory context reset we are about to do will release the
- * skew hashtable itself.
+ * Reset some of the skew optimization state variables, since we no
+ * longer need to consider skew tuples after the first batch. The
+ * memory context reset we are about to do will release the skew
+ * hashtable itself.
*/
hashtable->skewEnabled = false;
hashtable->skewBucket = NULL;
/*
* Note we advance the rightmost array key most quickly, since it will
* correspond to the lowest-order index column among the available
- * qualifications. This is hypothesized to result in better locality
- * of access in the index.
+ * qualifications. This is hypothesized to result in better locality of
+ * access in the index.
*/
for (j = numArrayKeys - 1; j >= 0; j--)
{
extra_scan_keys = n_scan_keys;
/*
- * for each opclause in the given qual, convert the opclause into
- * a single scan key
+ * for each opclause in the given qual, convert the opclause into a single
+ * scan key
*/
j = 0;
foreach(qual_cell, quals)
Oid opno; /* operator's OID */
RegProcedure opfuncid; /* operator proc id used in scan */
Oid opfamily; /* opfamily of index column */
- int op_strategy; /* operator's strategy number */
- Oid op_lefttype; /* operator's declared input types */
+ int op_strategy; /* operator's strategy number */
+ Oid op_lefttype; /* operator's declared input types */
Oid op_righttype;
Expr *leftop; /* expr on lhs of operator */
Expr *rightop; /* expr on rhs ... */
ScanKeyEntryInitialize(this_scan_key,
flags,
varattno, /* attribute number to scan */
- op_strategy, /* op's strategy */
- op_righttype, /* strategy subtype */
+ op_strategy, /* op's strategy */
+ op_righttype, /* strategy subtype */
opfuncid, /* reg proc to use */
scanvalue); /* constant */
}
ScanKeyEntryInitialize(this_scan_key,
0, /* flags */
varattno, /* attribute number to scan */
- op_strategy, /* op's strategy */
- op_righttype, /* strategy subtype */
+ op_strategy, /* op's strategy */
+ op_righttype, /* strategy subtype */
opfuncid, /* reg proc to use */
(Datum) 0); /* constant */
}
ScanKeyEntryInitialize(this_scan_key,
SK_ISNULL | SK_SEARCHNULL,
varattno, /* attribute number to scan */
- InvalidStrategy, /* no strategy */
+ InvalidStrategy, /* no strategy */
InvalidOid, /* no strategy subtype */
InvalidOid, /* no reg proc for this */
(Datum) 0); /* constant */
node->offset = DatumGetInt64(val);
if (node->offset < 0)
ereport(ERROR,
- (errcode(ERRCODE_INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE),
- errmsg("OFFSET must not be negative")));
+ (errcode(ERRCODE_INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE),
+ errmsg("OFFSET must not be negative")));
}
}
else
if (node->eflags & EXEC_FLAG_MARK)
{
/*
- * Allocate a second read pointer to serve as the mark.
- * We know it must have index 1, so needn't store that.
+ * Allocate a second read pointer to serve as the mark. We know it
+ * must have index 1, so needn't store that.
*/
- int ptrno;
+ int ptrno;
ptrno = tuplestore_alloc_read_pointer(tuplestorestate,
node->eflags);
/*
* Tuplestore's interpretation of the flag bits is subtly different from
* the general executor meaning: it doesn't think BACKWARD necessarily
- * means "backwards all the way to start". If told to support BACKWARD we
+ * means "backwards all the way to start". If told to support BACKWARD we
* must include REWIND in the tuplestore eflags, else tuplestore_trim
* might throw away too much.
*/
}
/*
- * In a semijoin, we'll consider returning the first match,
- * but after that we're done with this outer tuple.
+ * In a semijoin, we'll consider returning the first
+ * match, but after that we're done with this outer tuple.
*/
if (node->js.jointype == JOIN_SEMI)
node->mj_JoinState = EXEC_MJ_NEXTOUTER;
}
/*
- * In a semijoin, we'll consider returning the first match,
- * but after that we're done with this outer tuple.
+ * In a semijoin, we'll consider returning the first match, but
+ * after that we're done with this outer tuple.
*/
if (node->js.jointype == JOIN_SEMI)
node->nl_NeedNewOuter = true;
static void
build_hash_table(RecursiveUnionState *rustate)
{
- RecursiveUnion *node = (RecursiveUnion *) rustate->ps.plan;
+ RecursiveUnion *node = (RecursiveUnion *) rustate->ps.plan;
Assert(node->numCols > 0);
Assert(node->numGroups > 0);
* ExecRecursiveUnion(node)
*
* Scans the recursive query sequentially and returns the next
- * qualifying tuple.
+ * qualifying tuple.
*
* 1. evaluate non recursive term and assign the result to RT
*
}
/* Else, tuple is good; stash it in intermediate table ... */
- node->intermediate_empty = false;
- tuplestore_puttupleslot(node->intermediate_table, slot);
+ node->intermediate_empty = false;
+ tuplestore_puttupleslot(node->intermediate_table, slot);
/* ... and return it */
return slot;
}
ExecInitResultTupleSlot(estate, &rustate->ps);
/*
- * Initialize result tuple type and projection info. (Note: we have
- * to set up the result type before initializing child nodes, because
+ * Initialize result tuple type and projection info. (Note: we have to
+ * set up the result type before initializing child nodes, because
* nodeWorktablescan.c expects it to be valid.)
*/
ExecAssignResultTypeFromTL(&rustate->ps);
innerPlanState(rustate) = ExecInitNode(innerPlan(node), estate, eflags);
/*
- * If hashing, precompute fmgr lookup data for inner loop, and create
- * the hash table.
+ * If hashing, precompute fmgr lookup data for inner loop, and create the
+ * hash table.
*/
if (node->numCols > 0)
{
RecursiveUnion *plan = (RecursiveUnion *) node->ps.plan;
/*
- * Set recursive term's chgParam to tell it that we'll modify the
- * working table and therefore it has to rescan.
+ * Set recursive term's chgParam to tell it that we'll modify the working
+ * table and therefore it has to rescan.
*/
innerPlan->chgParam = bms_add_member(innerPlan->chgParam, plan->wtParam);
/*
* if chgParam of subnode is not null then plan will be re-scanned by
- * first ExecProcNode. Because of above, we only have to do this to
- * the non-recursive term.
+ * first ExecProcNode. Because of above, we only have to do this to the
+ * non-recursive term.
*/
if (outerPlan->chgParam == NULL)
ExecReScan(outerPlan, exprCtxt);
*
* The input of a SetOp node consists of tuples from two relations,
* which have been combined into one dataset, with a junk attribute added
- * that shows which relation each tuple came from. In SETOP_SORTED mode,
+ * that shows which relation each tuple came from. In SETOP_SORTED mode,
* the input has furthermore been sorted according to all the grouping
* columns (ie, all the non-junk attributes). The SetOp node scans each
* group of identical tuples to determine how many came from each input
* relation is the left-hand one for EXCEPT, and tries to make the smaller
* input relation come first for INTERSECT. We build a hash table in memory
* with one entry for each group of identical tuples, and count the number of
- * tuples in the group from each relation. After seeing all the input, we
+ * tuples in the group from each relation. After seeing all the input, we
* scan the hashtable and generate the correct output using those counts.
* We can avoid making hashtable entries for any tuples appearing only in the
* second input relation, since they cannot result in any output.
}
/*
- * Store the copied first input tuple in the tuple table slot
- * reserved for it. The tuple will be deleted when it is cleared
- * from the slot.
+ * Store the copied first input tuple in the tuple table slot reserved
+ * for it. The tuple will be deleted when it is cleared from the
+ * slot.
*/
ExecStoreTuple(setopstate->grp_firstTuple,
resultTupleSlot,
InvalidBuffer,
true);
- setopstate->grp_firstTuple = NULL; /* don't keep two pointers */
+ setopstate->grp_firstTuple = NULL; /* don't keep two pointers */
/* Initialize working state for a new input tuple group */
initialize_counts(pergroup);
}
/*
- * Done scanning input tuple group. See if we should emit any
- * copies of result tuple, and if so return the first copy.
+ * Done scanning input tuple group. See if we should emit any copies
+ * of result tuple, and if so return the first copy.
*/
set_output_count(setopstate, pergroup);
/*
* initialize child nodes
*
- * If we are hashing then the child plan does not need
- * to handle REWIND efficiently; see ExecReScanSetOp.
+ * If we are hashing then the child plan does not need to handle REWIND
+ * efficiently; see ExecReScanSetOp.
*/
if (node->strategy == SETOP_HASHED)
eflags &= ~EXEC_FLAG_REWIND;
bool *isNull,
ExprDoneCond *isDone);
static Datum ExecAlternativeSubPlan(AlternativeSubPlanState *node,
- ExprContext *econtext,
- bool *isNull,
- ExprDoneCond *isDone);
+ ExprContext *econtext,
+ bool *isNull,
+ ExprDoneCond *isDone);
static Datum ExecHashSubPlan(SubPlanState *node,
ExprContext *econtext,
bool *isNull);
*
* CTE subplans are never executed via parameter recalculation; instead
* they get run when called by nodeCtescan.c. So don't mark the output
- * parameter of a CTE subplan as dirty, but do set the chgParam bit
- * for it so that dependent plan nodes will get told to rescan.
+ * parameter of a CTE subplan as dirty, but do set the chgParam bit for it
+ * so that dependent plan nodes will get told to rescan.
*/
foreach(l, subplan->setParam)
{
{
AlternativeSubPlanState *asstate = makeNode(AlternativeSubPlanState);
double num_calls;
- SubPlan *subplan1;
- SubPlan *subplan2;
+ SubPlan *subplan1;
+ SubPlan *subplan2;
Cost cost1;
Cost cost2;
asstate->xprstate.expr = (Expr *) asplan;
/*
- * Initialize subplans. (Can we get away with only initializing the
- * one we're going to use?)
+ * Initialize subplans. (Can we get away with only initializing the one
+ * we're going to use?)
*/
asstate->subplans = (List *) ExecInitExpr((Expr *) asplan->subplans,
parent);
/*
- * Select the one to be used. For this, we need an estimate of the
- * number of executions of the subplan. We use the number of output
- * rows expected from the parent plan node. This is a good estimate
- * if we are in the parent's targetlist, and an underestimate (but
- * probably not by more than a factor of 2) if we are in the qual.
+ * Select the one to be used. For this, we need an estimate of the number
+ * of executions of the subplan. We use the number of output rows
+ * expected from the parent plan node. This is a good estimate if we are
+ * in the parent's targetlist, and an underestimate (but probably not by
+ * more than a factor of 2) if we are in the qual.
*/
num_calls = parent->plan->plan_rows;
ExprDoneCond *isDone)
{
/* Just pass control to the active subplan */
- SubPlanState *activesp = (SubPlanState *) list_nth(node->subplans,
- node->active);
+ SubPlanState *activesp = (SubPlanState *) list_nth(node->subplans,
+ node->active);
Assert(IsA(activesp, SubPlanState));
ListCell *l;
/*
- * We silently discard any TIDs that are out of range at the time of
- * scan start. (Since we hold at least AccessShareLock on the table,
- * it won't be possible for someone to truncate away the blocks we
- * intend to visit.)
+ * We silently discard any TIDs that are out of range at the time of scan
+ * start. (Since we hold at least AccessShareLock on the table, it won't
+ * be possible for someone to truncate away the blocks we intend to
+ * visit.)
*/
nblocks = RelationGetNumberOfBlocks(tidstate->ss.ss_currentRelation);
* Routines to handle unique'ing of queries where appropriate
*
* Unique is a very simple node type that just filters out duplicate
- * tuples from a stream of sorted tuples from its subplan. It's essentially
+ * tuples from a stream of sorted tuples from its subplan. It's essentially
* a dumbed-down form of Group: the duplicate-removal functionality is
* identical. However, Unique doesn't do projection nor qual checking,
* so it's marginally more efficient for cases where neither is needed.
/*
* now loop, returning only non-duplicate tuples. We assume that the
- * tuples arrive in sorted order so we can detect duplicates easily.
- * The first tuple of each group is returned.
+ * tuples arrive in sorted order so we can detect duplicates easily. The
+ * first tuple of each group is returned.
*/
for (;;)
{
* routines to handle WindowAgg nodes.
*
* A WindowAgg node evaluates "window functions" across suitable partitions
- * of the input tuple set. Any one WindowAgg works for just a single window
+ * of the input tuple set. Any one WindowAgg works for just a single window
* specification, though it can evaluate multiple window functions sharing
* identical window specifications. The input tuples are required to be
* delivered in sorted order, with the PARTITION BY columns (if any) as
*
* Since window functions can require access to any or all of the rows in
* the current partition, we accumulate rows of the partition into a
- * tuplestore. The window functions are called using the WindowObject API
+ * tuplestore. The window functions are called using the WindowObject API
* so that they can access those rows as needed.
*
* We also support using plain aggregate functions as window functions.
{
/* Links to WindowFunc expr and state nodes this working state is for */
WindowFuncExprState *wfuncstate;
- WindowFunc *wfunc;
+ WindowFunc *wfunc;
int numArguments; /* number of arguments */
FmgrInfo flinfo; /* fmgr lookup data for window function */
/*
- * We need the len and byval info for the result of each function
- * in order to know how to copy/delete values.
+ * We need the len and byval info for the result of each function in order
+ * to know how to copy/delete values.
*/
int16 resulttypeLen;
bool resulttypeByVal;
bool plain_agg; /* is it just a plain aggregate function? */
int aggno; /* if so, index of its PerAggData */
- WindowObject winobj; /* object used in window function API */
+ WindowObject winobj; /* object used in window function API */
} WindowStatePerFuncData;
/*
} WindowStatePerAggData;
static void initialize_windowaggregate(WindowAggState *winstate,
- WindowStatePerFunc perfuncstate,
- WindowStatePerAgg peraggstate);
+ WindowStatePerFunc perfuncstate,
+ WindowStatePerAgg peraggstate);
static void advance_windowaggregate(WindowAggState *winstate,
- WindowStatePerFunc perfuncstate,
- WindowStatePerAgg peraggstate);
+ WindowStatePerFunc perfuncstate,
+ WindowStatePerAgg peraggstate);
static void finalize_windowaggregate(WindowAggState *winstate,
- WindowStatePerFunc perfuncstate,
- WindowStatePerAgg peraggstate,
- Datum *result, bool *isnull);
+ WindowStatePerFunc perfuncstate,
+ WindowStatePerAgg peraggstate,
+ Datum *result, bool *isnull);
static void eval_windowaggregates(WindowAggState *winstate);
static void eval_windowfunction(WindowAggState *winstate,
- WindowStatePerFunc perfuncstate,
- Datum *result, bool *isnull);
+ WindowStatePerFunc perfuncstate,
+ Datum *result, bool *isnull);
static void begin_partition(WindowAggState *winstate);
static void spool_tuples(WindowAggState *winstate, int64 pos);
static void release_partition(WindowAggState *winstate);
static bool row_is_in_frame(WindowAggState *winstate, int64 pos,
- TupleTableSlot *slot);
+ TupleTableSlot *slot);
static void update_frametailpos(WindowObject winobj, TupleTableSlot *slot);
static WindowStatePerAggData *initialize_peragg(WindowAggState *winstate,
- WindowFunc *wfunc,
- WindowStatePerAgg peraggstate);
+ WindowFunc *wfunc,
+ WindowStatePerAgg peraggstate);
static Datum GetAggInitVal(Datum textInitVal, Oid transtype);
static bool are_peers(WindowAggState *winstate, TupleTableSlot *slot1,
- TupleTableSlot *slot2);
+ TupleTableSlot *slot2);
static bool window_gettupleslot(WindowObject winobj, int64 pos,
- TupleTableSlot *slot);
+ TupleTableSlot *slot);
/*
WindowStatePerFunc perfuncstate,
WindowStatePerAgg peraggstate)
{
- MemoryContext oldContext;
+ MemoryContext oldContext;
if (peraggstate->initValueIsNull)
peraggstate->transValue = peraggstate->initValue;
WindowStatePerFunc perfuncstate,
WindowStatePerAgg peraggstate)
{
- WindowFuncExprState *wfuncstate = perfuncstate->wfuncstate;
- int numArguments = perfuncstate->numArguments;
- FunctionCallInfoData fcinfodata;
- FunctionCallInfo fcinfo = &fcinfodata;
- Datum newVal;
- ListCell *arg;
- int i;
- MemoryContext oldContext;
+ WindowFuncExprState *wfuncstate = perfuncstate->wfuncstate;
+ int numArguments = perfuncstate->numArguments;
+ FunctionCallInfoData fcinfodata;
+ FunctionCallInfo fcinfo = &fcinfodata;
+ Datum newVal;
+ ListCell *arg;
+ int i;
+ MemoryContext oldContext;
ExprContext *econtext = winstate->tmpcontext;
oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
i = 1;
foreach(arg, wfuncstate->args)
{
- ExprState *argstate = (ExprState *) lfirst(arg);
+ ExprState *argstate = (ExprState *) lfirst(arg);
fcinfo->arg[i] = ExecEvalExpr(argstate, econtext,
&fcinfo->argnull[i], NULL);
*/
MemoryContextSwitchTo(winstate->wincontext);
peraggstate->transValue = datumCopy(fcinfo->arg[1],
- peraggstate->transtypeByVal,
- peraggstate->transtypeLen);
+ peraggstate->transtypeByVal,
+ peraggstate->transtypeLen);
peraggstate->transValueIsNull = false;
peraggstate->noTransValue = false;
MemoryContextSwitchTo(oldContext);
WindowStatePerAgg peraggstate,
Datum *result, bool *isnull)
{
- MemoryContext oldContext;
+ MemoryContext oldContext;
oldContext = MemoryContextSwitchTo(winstate->ss.ps.ps_ExprContext->ecxt_per_tuple_memory);
*/
if (OidIsValid(peraggstate->finalfn_oid))
{
- FunctionCallInfoData fcinfo;
+ FunctionCallInfoData fcinfo;
InitFunctionCallInfoData(fcinfo, &(peraggstate->finalfn), 1,
(void *) winstate, NULL);
static void
eval_windowaggregates(WindowAggState *winstate)
{
- WindowStatePerAgg peraggstate;
- int wfuncno, numaggs;
- int i;
- MemoryContext oldContext;
- ExprContext *econtext;
- TupleTableSlot *agg_row_slot;
+ WindowStatePerAgg peraggstate;
+ int wfuncno,
+ numaggs;
+ int i;
+ MemoryContext oldContext;
+ ExprContext *econtext;
+ TupleTableSlot *agg_row_slot;
numaggs = winstate->numaggs;
if (numaggs == 0)
/*
* Currently, we support only a subset of the SQL-standard window framing
- * rules. In all the supported cases, the window frame always consists
- * of a contiguous group of rows extending forward from the start of the
- * partition, and rows only enter the frame, never exit it, as the
- * current row advances forward. This makes it possible to use an
- * incremental strategy for evaluating aggregates: we run the transition
- * function for each row added to the frame, and run the final function
- * whenever we need the current aggregate value. This is considerably
- * more efficient than the naive approach of re-running the entire
- * aggregate calculation for each current row. It does assume that the
- * final function doesn't damage the running transition value. (Some
- * C-coded aggregates do that for efficiency's sake --- but they are
- * supposed to do so only when their fcinfo->context is an AggState, not
- * a WindowAggState.)
+ * rules. In all the supported cases, the window frame always consists of
+ * a contiguous group of rows extending forward from the start of the
+ * partition, and rows only enter the frame, never exit it, as the current
+ * row advances forward. This makes it possible to use an incremental
+ * strategy for evaluating aggregates: we run the transition function for
+ * each row added to the frame, and run the final function whenever we
+ * need the current aggregate value. This is considerably more efficient
+ * than the naive approach of re-running the entire aggregate calculation
+ * for each current row. It does assume that the final function doesn't
+ * damage the running transition value. (Some C-coded aggregates do that
+ * for efficiency's sake --- but they are supposed to do so only when
+ * their fcinfo->context is an AggState, not a WindowAggState.)
*
- * In many common cases, multiple rows share the same frame and hence
- * the same aggregate value. (In particular, if there's no ORDER BY in
- * a RANGE window, then all rows are peers and so they all have window
- * frame equal to the whole partition.) We optimize such cases by
- * calculating the aggregate value once when we reach the first row of a
- * peer group, and then returning the saved value for all subsequent rows.
+ * In many common cases, multiple rows share the same frame and hence the
+ * same aggregate value. (In particular, if there's no ORDER BY in a RANGE
+ * window, then all rows are peers and so they all have window frame equal
+ * to the whole partition.) We optimize such cases by calculating the
+ * aggregate value once when we reach the first row of a peer group, and
+ * then returning the saved value for all subsequent rows.
*
* 'aggregatedupto' keeps track of the first row that has not yet been
* accumulated into the aggregate transition values. Whenever we start a
* new peer group, we accumulate forward to the end of the peer group.
*
- * TODO: In the future, we should implement the full SQL-standard set
- * of framing rules. We could implement the other cases by recalculating
- * the aggregates whenever a row exits the frame. That would be pretty
- * slow, though. For aggregates like SUM and COUNT we could implement a
+ * TODO: In the future, we should implement the full SQL-standard set of
+ * framing rules. We could implement the other cases by recalculating the
+ * aggregates whenever a row exits the frame. That would be pretty slow,
+ * though. For aggregates like SUM and COUNT we could implement a
* "negative transition function" that would be called for each row as it
* exits the frame. We'd have to think about avoiding recalculation of
* volatile arguments of aggregate functions, too.
*/
/*
- * If we've already aggregated up through current row, reuse the
- * saved result values. NOTE: this test works for the currently
- * supported framing rules, but will need fixing when more are added.
+ * If we've already aggregated up through current row, reuse the saved
+ * result values. NOTE: this test works for the currently supported
+ * framing rules, but will need fixing when more are added.
*/
if (winstate->aggregatedupto > winstate->currentpos)
{
/*
* Advance until we reach a row not in frame (or end of partition).
*
- * Note the loop invariant: agg_row_slot is either empty or holds the
- * row at position aggregatedupto. The agg_ptr read pointer must always
- * point to the next row to read into agg_row_slot.
+ * Note the loop invariant: agg_row_slot is either empty or holds the row
+ * at position aggregatedupto. The agg_ptr read pointer must always point
+ * to the next row to read into agg_row_slot.
*/
agg_row_slot = winstate->agg_row_slot;
for (;;)
/*
* save the result in case next row shares the same frame.
*
- * XXX in some framing modes, eg ROWS/END_CURRENT_ROW, we can know
- * in advance that the next row can't possibly share the same frame.
- * Is it worth detecting that and skipping this code?
+ * XXX in some framing modes, eg ROWS/END_CURRENT_ROW, we can know in
+ * advance that the next row can't possibly share the same frame. Is
+ * it worth detecting that and skipping this code?
*/
if (!peraggstate->resulttypeByVal)
{
/*
- * clear old resultValue in order not to leak memory. (Note:
- * the new result can't possibly be the same datum as old
- * resultValue, because we never passed it to the trans function.)
+ * clear old resultValue in order not to leak memory. (Note: the
+ * new result can't possibly be the same datum as old resultValue,
+ * because we never passed it to the trans function.)
*/
if (!peraggstate->resultValueIsNull)
pfree(DatumGetPointer(peraggstate->resultValue));
Datum *result, bool *isnull)
{
FunctionCallInfoData fcinfo;
- MemoryContext oldContext;
+ MemoryContext oldContext;
oldContext = MemoryContextSwitchTo(winstate->ss.ps.ps_ExprContext->ecxt_per_tuple_memory);
/*
- * We don't pass any normal arguments to a window function, but we do
- * pass it the number of arguments, in order to permit window function
- * implementations to support varying numbers of arguments. The real
- * info goes through the WindowObject, which is passed via fcinfo->context.
+ * We don't pass any normal arguments to a window function, but we do pass
+ * it the number of arguments, in order to permit window function
+ * implementations to support varying numbers of arguments. The real info
+ * goes through the WindowObject, which is passed via fcinfo->context.
*/
InitFunctionCallInfoData(fcinfo, &(perfuncstate->flinfo),
perfuncstate->numArguments,
*isnull = fcinfo.isnull;
/*
- * Make sure pass-by-ref data is allocated in the appropriate context.
- * (We need this in case the function returns a pointer into some
- * short-lived tuple, as is entirely possible.)
+ * Make sure pass-by-ref data is allocated in the appropriate context. (We
+ * need this in case the function returns a pointer into some short-lived
+ * tuple, as is entirely possible.)
*/
if (!perfuncstate->resulttypeByVal && !fcinfo.isnull &&
!MemoryContextContains(CurrentMemoryContext,
static void
begin_partition(WindowAggState *winstate)
{
- PlanState *outerPlan = outerPlanState(winstate);
- int numfuncs = winstate->numfuncs;
- int i;
+ PlanState *outerPlan = outerPlanState(winstate);
+ int numfuncs = winstate->numfuncs;
+ int i;
winstate->partition_spooled = false;
winstate->frametail_valid = false;
ExecClearTuple(winstate->agg_row_slot);
/*
- * If this is the very first partition, we need to fetch the first
- * input row to store in first_part_slot.
+ * If this is the very first partition, we need to fetch the first input
+ * row to store in first_part_slot.
*/
if (TupIsNull(winstate->first_part_slot))
{
TupleTableSlot *outerslot = ExecProcNode(outerPlan);
if (!TupIsNull(outerslot))
- ExecCopySlot(winstate->first_part_slot, outerslot);
+ ExecCopySlot(winstate->first_part_slot, outerslot);
else
{
/* outer plan is empty, so we have nothing to do */
/* create mark and read pointers for each real window function */
for (i = 0; i < numfuncs; i++)
{
- WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
+ WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
if (!perfuncstate->plain_agg)
{
- WindowObject winobj = perfuncstate->winobj;
+ WindowObject winobj = perfuncstate->winobj;
winobj->markptr = tuplestore_alloc_read_pointer(winstate->buffer,
0);
winobj->readptr = tuplestore_alloc_read_pointer(winstate->buffer,
- EXEC_FLAG_BACKWARD);
+ EXEC_FLAG_BACKWARD);
winobj->markpos = -1;
winobj->seekpos = -1;
}
static void
spool_tuples(WindowAggState *winstate, int64 pos)
{
- WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
- PlanState *outerPlan;
+ WindowAgg *node = (WindowAgg *) winstate->ss.ps.plan;
+ PlanState *outerPlan;
TupleTableSlot *outerslot;
MemoryContext oldcontext;
/*
* If the tuplestore has spilled to disk, alternate reading and writing
- * becomes quite expensive due to frequent buffer flushes. It's cheaper
+ * becomes quite expensive due to frequent buffer flushes. It's cheaper
* to force the entire partition to get spooled in one go.
*
* XXX this is a horrid kluge --- it'd be better to fix the performance
static void
release_partition(WindowAggState *winstate)
{
- int i;
+ int i;
for (i = 0; i < winstate->numfuncs; i++)
{
- WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
+ WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
/* Release any partition-local state of this window function */
if (perfuncstate->winobj)
* to our window framing rule
*
* The caller must have already determined that the row is in the partition
- * and fetched it into a slot. This function just encapsulates the framing
+ * and fetched it into a slot. This function just encapsulates the framing
* rules.
*/
static bool
}
/*
- * Else we have to search for the first non-peer of the current row.
- * We assume the current value of frametailpos is a lower bound on the
+ * Else we have to search for the first non-peer of the current row. We
+ * assume the current value of frametailpos is a lower bound on the
* possible frame tail location, ie, frame tail never goes backward, and
* that currentpos is also a lower bound, ie, current row is always in
* frame.
ExecWindowAgg(WindowAggState *winstate)
{
TupleTableSlot *result;
- ExprDoneCond isDone;
- ExprContext *econtext;
- int i;
- int numfuncs;
+ ExprDoneCond isDone;
+ ExprContext *econtext;
+ int i;
+ int numfuncs;
if (winstate->all_done)
return NULL;
/*
- * Check to see if we're still projecting out tuples from a previous output
- * tuple (because there is a function-returning-set in the projection
- * expressions). If so, try to project another one.
+ * Check to see if we're still projecting out tuples from a previous
+ * output tuple (because there is a function-returning-set in the
+ * projection expressions). If so, try to project another one.
*/
if (winstate->ss.ps.ps_TupFromTlist)
{
* Read the current row from the tuplestore, and save in ScanTupleSlot.
* (We can't rely on the outerplan's output slot because we may have to
* read beyond the current row. Also, we have to actually copy the row
- * out of the tuplestore, since window function evaluation might cause
- * the tuplestore to dump its state to disk.)
+ * out of the tuplestore, since window function evaluation might cause the
+ * tuplestore to dump its state to disk.)
*
* Current row must be in the tuplestore, since we spooled it above.
*/
numfuncs = winstate->numfuncs;
for (i = 0; i < numfuncs; i++)
{
- WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
+ WindowStatePerFunc perfuncstate = &(winstate->perfunc[i]);
if (perfuncstate->plain_agg)
continue;
eval_windowfunction(winstate, perfuncstate,
- &(econtext->ecxt_aggvalues[perfuncstate->wfuncstate->wfuncno]),
- &(econtext->ecxt_aggnulls[perfuncstate->wfuncstate->wfuncno]));
+ &(econtext->ecxt_aggvalues[perfuncstate->wfuncstate->wfuncno]),
+ &(econtext->ecxt_aggnulls[perfuncstate->wfuncstate->wfuncno]));
}
/*
tuplestore_trim(winstate->buffer);
/*
- * Form and return a projection tuple using the windowfunc results
- * and the current row. Setting ecxt_outertuple arranges that any
- * Vars will be evaluated with respect to that row.
+ * Form and return a projection tuple using the windowfunc results and the
+ * current row. Setting ecxt_outertuple arranges that any Vars will be
+ * evaluated with respect to that row.
*/
econtext->ecxt_outertuple = winstate->ss.ss_ScanTupleSlot;
result = ExecProject(winstate->ss.ps.ps_ProjInfo, &isDone);
Plan *outerPlan;
ExprContext *econtext;
ExprContext *tmpcontext;
- WindowStatePerFunc perfunc;
- WindowStatePerAgg peragg;
+ WindowStatePerFunc perfunc;
+ WindowStatePerAgg peragg;
int numfuncs,
wfuncno,
numaggs,
/* Set up data for comparing tuples */
if (node->partNumCols > 0)
winstate->partEqfunctions = execTuplesMatchPrepare(node->partNumCols,
- node->partOperators);
+ node->partOperators);
if (node->ordNumCols > 0)
winstate->ordEqfunctions = execTuplesMatchPrepare(node->ordNumCols,
node->ordOperators);
aggno = -1;
foreach(l, winstate->funcs)
{
- WindowFuncExprState *wfuncstate = (WindowFuncExprState *) lfirst(l);
- WindowFunc *wfunc = (WindowFunc *) wfuncstate->xprstate.expr;
+ WindowFuncExprState *wfuncstate = (WindowFuncExprState *) lfirst(l);
+ WindowFunc *wfunc = (WindowFunc *) wfuncstate->xprstate.expr;
WindowStatePerFunc perfuncstate;
AclResult aclresult;
int i;
- if (wfunc->winref != node->winref) /* planner screwed up? */
+ if (wfunc->winref != node->winref) /* planner screwed up? */
elog(ERROR, "WindowFunc with winref %u assigned to WindowAgg with winref %u",
wfunc->winref, node->winref);
&perfuncstate->resulttypeByVal);
/*
- * If it's really just a plain aggregate function,
- * we'll emulate the Agg environment for it.
+ * If it's really just a plain aggregate function, we'll emulate the
+ * Agg environment for it.
*/
perfuncstate->plain_agg = wfunc->winagg;
if (wfunc->winagg)
{
- WindowStatePerAgg peraggstate;
+ WindowStatePerAgg peraggstate;
perfuncstate->aggno = ++aggno;
peraggstate = &winstate->peragg[aggno];
void
ExecReScanWindowAgg(WindowAggState *node, ExprContext *exprCtxt)
{
- ExprContext *econtext = node->ss.ps.ps_ExprContext;
+ ExprContext *econtext = node->ss.ps.ps_ExprContext;
node->all_done = false;
aggtranstype);
/*
- * If the transfn is strict and the initval is NULL, make sure input
- * type and transtype are the same (or at least binary-compatible), so
- * that it's OK to use the first input value as the initial
- * transValue. This should have been checked at agg definition time,
- * but just in case...
+ * If the transfn is strict and the initval is NULL, make sure input type
+ * and transtype are the same (or at least binary-compatible), so that
+ * it's OK to use the first input value as the initial transValue. This
+ * should have been checked at agg definition time, but just in case...
*/
if (peraggstate->transfn.fn_strict && peraggstate->initValueIsNull)
{
tuplestore_select_read_pointer(winstate->buffer, winobj->readptr);
/*
- * There's no API to refetch the tuple at the current position. We
- * have to move one tuple forward, and then one backward. (We don't
- * do it the other way because we might try to fetch the row before
- * our mark, which isn't allowed.)
+ * There's no API to refetch the tuple at the current position. We have to
+ * move one tuple forward, and then one backward. (We don't do it the
+ * other way because we might try to fetch the row before our mark, which
+ * isn't allowed.)
*/
if (winobj->seekpos == pos)
{
* requested amount of space. Subsequent calls just return the same chunk.
*
* Memory obtained this way is normally used to hold state that should be
- * automatically reset for each new partition. If a window function wants
+ * automatically reset for each new partition. If a window function wants
* to hold state across the whole query, fcinfo->fn_extra can be used in the
* usual way for that.
*/
WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2)
{
WindowAggState *winstate;
- WindowAgg *node;
+ WindowAgg *node;
TupleTableSlot *slot1;
TupleTableSlot *slot2;
- bool res;
+ bool res;
Assert(WindowObjectIsValid(winobj));
winstate = winobj->winstate;
break;
default:
elog(ERROR, "unrecognized window seek type: %d", seektype);
- abs_pos = 0; /* keep compiler quiet */
+ abs_pos = 0; /* keep compiler quiet */
break;
}
break;
default:
elog(ERROR, "unrecognized window seek type: %d", seektype);
- abs_pos = 0; /* keep compiler quiet */
+ abs_pos = 0; /* keep compiler quiet */
break;
}
ExecWorkTableScan(WorkTableScanState *node)
{
/*
- * On the first call, find the ancestor RecursiveUnion's state
- * via the Param slot reserved for it. (We can't do this during node
- * init because there are corner cases where we'll get the init call
- * before the RecursiveUnion does.)
+ * On the first call, find the ancestor RecursiveUnion's state via the
+ * Param slot reserved for it. (We can't do this during node init because
+ * there are corner cases where we'll get the init call before the
+ * RecursiveUnion does.)
*/
if (node->rustate == NULL)
{
ExecGetResultType(&node->rustate->ps));
/*
- * Now we can initialize the projection info. This must be
- * completed before we can call ExecScan().
+ * Now we can initialize the projection info. This must be completed
+ * before we can call ExecScan().
*/
ExecAssignScanProjectionInfo(&node->ss);
}
static int _SPI_curid = -1;
static Portal SPI_cursor_open_internal(const char *name, SPIPlanPtr plan,
- Datum *Values, const char *Nulls,
- bool read_only, int pflags);
+ Datum *Values, const char *Nulls,
+ bool read_only, int pflags);
static void _SPI_prepare_plan(const char *src, SPIPlanPtr plan,
- ParamListInfo boundParams);
+ ParamListInfo boundParams);
static int _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
Snapshot snapshot, Snapshot crosscheck_snapshot,
bool
SPI_push_conditional(void)
{
- bool pushed = (_SPI_curid != _SPI_connected);
+ bool pushed = (_SPI_curid != _SPI_connected);
if (pushed)
{
/*
* SPI_cursor_open_with_args()
*
- * Parse and plan a query and open it as a portal. Like SPI_execute_with_args,
+ * Parse and plan a query and open it as a portal. Like SPI_execute_with_args,
* we can tell the planner to rely on the parameter values as constants,
* because the plan will only be used once.
*/
}
/*
- * Set up the snapshot to use. (PortalStart will do PushActiveSnapshot, so
- * we skip that here.)
+ * Set up the snapshot to use. (PortalStart will do PushActiveSnapshot,
+ * so we skip that here.)
*/
if (read_only)
snapshot = GetActiveSnapshot();
if (read_only && !CommandIsReadOnly(stmt))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is a SQL statement name */
- errmsg("%s is not allowed in a non-volatile function",
- CreateCommandTag(stmt))));
+ /* translator: %s is a SQL statement name */
+ errmsg("%s is not allowed in a non-volatile function",
+ CreateCommandTag(stmt))));
/*
- * If not read-only mode, advance the command counter before
- * each command.
+ * If not read-only mode, advance the command counter before each
+ * command.
*/
if (!read_only)
CommandCounterIncrement();
{
/*
* Default read_only behavior is to use the entry-time
- * ActiveSnapshot, if any; if read-write, grab a full new snap.
+ * ActiveSnapshot, if any; if read-write, grab a full new
+ * snap.
*/
if (read_only)
{
{
/*
* We interpret read_only with a specified snapshot to be
- * exactly that snapshot, but read-write means use the
- * snap with advancing of command ID.
+ * exactly that snapshot, but read-write means use the snap
+ * with advancing of command ID.
*/
if (read_only)
PushActiveSnapshot(snapshot);
ProcessUtility(stmt,
plansource->query_string,
paramLI,
- false, /* not top level */
+ false, /* not top level */
dest,
NULL);
/* Update "processed" if stmt returned tuples */
PopActiveSnapshot();
/*
- * The last canSetTag query sets the status values returned to
- * the caller. Be careful to free any tuptables not returned,
- * to avoid intratransaction memory leak.
+ * The last canSetTag query sets the status values returned to the
+ * caller. Be careful to free any tuptables not returned, to
+ * avoid intratransaction memory leak.
*/
if (canSetTag)
{
cplan = NULL;
/*
- * If not read-only mode, advance the command counter after the
- * last command. This ensures that its effects are visible, in
- * case it was DDL that would affect the next CachedPlanSource.
+ * If not read-only mode, advance the command counter after the last
+ * command. This ensures that its effects are visible, in case it was
+ * DDL that would affect the next CachedPlanSource.
*/
if (!read_only)
CommandCounterIncrement();
_SPI_current->tuptable = NULL;
/*
- * If none of the queries had canSetTag, return SPI_OK_REWRITTEN. Prior
- * to 8.4, we used return the last query's result code, but not its
- * auxiliary results, but that's confusing.
+ * If none of the queries had canSetTag, return SPI_OK_REWRITTEN. Prior to
+ * 8.4, we used return the last query's result code, but not its auxiliary
+ * results, but that's confusing.
*/
if (my_res == 0)
my_res = SPI_OK_REWRITTEN;
/* sizeof(ParamListInfoData) includes the first array element */
paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) +
- (nargs - 1) *sizeof(ParamExternData));
+ (nargs - 1) *sizeof(ParamExternData));
paramLI->numParams = nargs;
for (i = 0; i < nargs; i++)
* a Tuplestore.
*
* Optionally, we can force detoasting (but not decompression) of out-of-line
- * toasted values. This is to support cursors WITH HOLD, which must retain
+ * toasted values. This is to support cursors WITH HOLD, which must retain
* data even if the underlying table is dropped.
*
*
/*
* Fetch back any out-of-line datums. We build the new datums array in
- * myState->outvalues[] (but we can re-use the slot's isnull array).
- * Also, remember the fetched values to free afterwards.
+ * myState->outvalues[] (but we can re-use the slot's isnull array). Also,
+ * remember the fetched values to free afterwards.
*/
nfree = 0;
for (i = 0; i < natts; i++)
if (VARATT_IS_EXTERNAL(DatumGetPointer(val)))
{
val = PointerGetDatum(heap_tuple_fetch_attr((struct varlena *)
- DatumGetPointer(val)));
+ DatumGetPointer(val)));
myState->tofree[nfree++] = val;
}
}
/*-------------------------------------------------------------------------
*
* foreign.c
- * support for foreign-data wrappers, servers and user mappings.
+ * support for foreign-data wrappers, servers and user mappings.
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $PostgreSQL$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*/
/*
- * GetForeignDataWrapper - look up the foreign-data wrapper by OID.
+ * GetForeignDataWrapper - look up the foreign-data wrapper by OID.
*/
ForeignDataWrapper *
GetForeignDataWrapper(Oid fdwid)
{
- Form_pg_foreign_data_wrapper fdwform;
- ForeignDataWrapper *fdw;
- Datum datum;
- HeapTuple tp;
- bool isnull;
+ Form_pg_foreign_data_wrapper fdwform;
+ ForeignDataWrapper *fdw;
+ Datum datum;
+ HeapTuple tp;
+ bool isnull;
tp = SearchSysCache(FOREIGNDATAWRAPPEROID,
ObjectIdGetDatum(fdwid),
Oid
GetForeignDataWrapperOidByName(const char *fdwname, bool missing_ok)
{
- Oid fdwId;
+ Oid fdwId;
fdwId = GetSysCacheOid(FOREIGNDATAWRAPPERNAME,
CStringGetDatum(fdwname),
if (!OidIsValid(fdwId) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("foreign-data wrapper \"%s\" does not exist", fdwname)));
+ errmsg("foreign-data wrapper \"%s\" does not exist", fdwname)));
return fdwId;
}
ForeignDataWrapper *
GetForeignDataWrapperByName(const char *fdwname, bool missing_ok)
{
- Oid fdwId = GetForeignDataWrapperOidByName(fdwname, missing_ok);
+ Oid fdwId = GetForeignDataWrapperOidByName(fdwname, missing_ok);
if (!OidIsValid(fdwId) && missing_ok)
return NULL;
ForeignServer *
GetForeignServer(Oid serverid)
{
- Form_pg_foreign_server serverform;
- ForeignServer *server;
- HeapTuple tp;
- Datum datum;
- bool isnull;
+ Form_pg_foreign_server serverform;
+ ForeignServer *server;
+ HeapTuple tp;
+ Datum datum;
+ bool isnull;
tp = SearchSysCache(FOREIGNSERVEROID,
ObjectIdGetDatum(serverid),
Oid
GetForeignServerOidByName(const char *srvname, bool missing_ok)
{
- Oid serverid;
+ Oid serverid;
serverid = GetSysCacheOid(FOREIGNSERVERNAME,
CStringGetDatum(srvname),
if (!OidIsValid(serverid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("server \"%s\" does not exist", srvname)));
+ errmsg("server \"%s\" does not exist", srvname)));
return serverid;
}
ForeignServer *
GetForeignServerByName(const char *srvname, bool missing_ok)
{
- Oid serverid = GetForeignServerOidByName(srvname, missing_ok);
+ Oid serverid = GetForeignServerOidByName(srvname, missing_ok);
if (!OidIsValid(serverid) && missing_ok)
return NULL;
UserMapping *
GetUserMapping(Oid userid, Oid serverid)
{
- Form_pg_user_mapping umform;
+ Form_pg_user_mapping umform;
Datum datum;
- HeapTuple tp;
+ HeapTuple tp;
bool isnull;
- UserMapping *um;
+ UserMapping *um;
tp = SearchSysCache(USERMAPPINGUSERSERVER,
ObjectIdGetDatum(userid),
if (!HeapTupleIsValid(tp))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("user mapping not found for \"%s\"",
- MappingUserName(userid))));
+ errmsg("user mapping not found for \"%s\"",
+ MappingUserName(userid))));
umform = (Form_pg_user_mapping) GETSTRUCT(tp);
TupleDesc tupdesc;
Tuplestorestate *tupstore;
Datum values[2];
- bool nulls[2] = { 0 };
+ bool nulls[2] = {0};
MemoryContext per_query_ctx;
MemoryContext oldcontext;
rsinfo->setResult = tupstore;
rsinfo->setDesc = tupdesc;
- foreach (cell, options)
+ foreach(cell, options)
{
- DefElem *def = lfirst(cell);
+ DefElem *def = lfirst(cell);
values[0] = CStringGetTextDatum(def->defname);
- values[1] = CStringGetTextDatum(((Value *)def->arg)->val.str);
+ values[1] = CStringGetTextDatum(((Value *) def->arg)->val.str);
tuplestore_putvalues(tupstore, tupdesc, values, nulls);
}
Datum
pg_options_to_table(PG_FUNCTION_ARGS)
{
- Datum array = PG_GETARG_DATUM(0);
+ Datum array = PG_GETARG_DATUM(0);
deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, untransformRelOptions(array));
/*
* Describes the valid options for postgresql FDW, server, and user mapping.
*/
-struct ConnectionOption {
- const char *optname;
- Oid optcontext; /* Oid of catalog in which option may appear */
+struct ConnectionOption
+{
+ const char *optname;
+ Oid optcontext; /* Oid of catalog in which option may appear */
};
/*
* The list is small - don't bother with bsearch if it stays so.
*/
static struct ConnectionOption libpq_conninfo_options[] = {
- { "authtype", ForeignServerRelationId },
- { "service", ForeignServerRelationId },
- { "user", UserMappingRelationId },
- { "password", UserMappingRelationId },
- { "connect_timeout", ForeignServerRelationId },
- { "dbname", ForeignServerRelationId },
- { "host", ForeignServerRelationId },
- { "hostaddr", ForeignServerRelationId },
- { "port", ForeignServerRelationId },
- { "tty", ForeignServerRelationId },
- { "options", ForeignServerRelationId },
- { "requiressl", ForeignServerRelationId },
- { "sslmode", ForeignServerRelationId },
- { "gsslib", ForeignServerRelationId },
- { NULL, InvalidOid }
+ {"authtype", ForeignServerRelationId},
+ {"service", ForeignServerRelationId},
+ {"user", UserMappingRelationId},
+ {"password", UserMappingRelationId},
+ {"connect_timeout", ForeignServerRelationId},
+ {"dbname", ForeignServerRelationId},
+ {"host", ForeignServerRelationId},
+ {"hostaddr", ForeignServerRelationId},
+ {"port", ForeignServerRelationId},
+ {"tty", ForeignServerRelationId},
+ {"options", ForeignServerRelationId},
+ {"requiressl", ForeignServerRelationId},
+ {"sslmode", ForeignServerRelationId},
+ {"gsslib", ForeignServerRelationId},
+ {NULL, InvalidOid}
};
Datum
postgresql_fdw_validator(PG_FUNCTION_ARGS)
{
- List* options_list = untransformRelOptions(PG_GETARG_DATUM(0));
- Oid catalog = PG_GETARG_OID(1);
+ List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
+ Oid catalog = PG_GETARG_OID(1);
- ListCell *cell;
+ ListCell *cell;
- foreach (cell, options_list)
+ foreach(cell, options_list)
{
DefElem *def = lfirst(cell);
if (!is_conninfo_option(def->defname, catalog))
{
- struct ConnectionOption *opt;
- StringInfoData buf;
+ struct ConnectionOption *opt;
+ StringInfoData buf;
/*
* Unknown option specified, complain about it. Provide a hint
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid option \"%s\"", def->defname),
- errhint("Valid options in this context are: %s", buf.data)));
+ errhint("Valid options in this context are: %s", buf.data)));
PG_RETURN_BOOL(false);
}
#include <sys/ucred.h>
#endif
#ifdef HAVE_UCRED_H
-# include <ucred.h>
+#include <ucred.h>
#endif
#include <netinet/in.h>
#include <arpa/inet.h>
#include "storage/ipc.h"
/*----------------------------------------------------------------
- * Global authentication functions
+ * Global authentication functions
*----------------------------------------------------------------
*/
static void sendAuthRequest(Port *port, AuthRequest areq);
/* Standard TCP port number for Ident service. Assigned by IANA */
#define IDENT_PORT 113
-static int authident(hbaPort *port);
+static int authident(hbaPort *port);
/*----------------------------------------------------------------
/* Correct header from the Platform SDK */
typedef
-ULONG(*__ldap_start_tls_sA) (
- IN PLDAP ExternalHandle,
- OUT PULONG ServerReturnValue,
- OUT LDAPMessage ** result,
- IN PLDAPControlA * ServerControls,
- IN PLDAPControlA * ClientControls
+ULONG (*__ldap_start_tls_sA) (
+ IN PLDAP ExternalHandle,
+ OUT PULONG ServerReturnValue,
+ OUT LDAPMessage **result,
+ IN PLDAPControlA * ServerControls,
+ IN PLDAPControlA * ClientControls
);
#endif
static int CheckLDAPAuth(Port *port);
-#endif /* USE_LDAP */
+#endif /* USE_LDAP */
/*----------------------------------------------------------------
* Cert authentication
*----------------------------------------------------------------
*/
#ifdef KRB5
-static int pg_krb5_recvauth(Port *port);
+static int pg_krb5_recvauth(Port *port);
#include <krb5.h>
/* Some old versions of Kerberos do not include <com_err.h> in <krb5.h> */
static krb5_context pg_krb5_context;
static krb5_keytab pg_krb5_keytab;
static krb5_principal pg_krb5_server;
-#endif /* KRB5 */
+#endif /* KRB5 */
/*----------------------------------------------------------------
#include <gssapi/gssapi.h>
#endif
-static int pg_GSS_recvauth(Port *port);
-#endif /* ENABLE_GSS */
+static int pg_GSS_recvauth(Port *port);
+#endif /* ENABLE_GSS */
/*----------------------------------------------------------------
*----------------------------------------------------------------
*/
#ifdef ENABLE_SSPI
-typedef SECURITY_STATUS
+typedef SECURITY_STATUS
(WINAPI * QUERY_SECURITY_CONTEXT_TOKEN_FN) (
PCtxtHandle, void **);
-static int pg_SSPI_recvauth(Port *port);
+static int pg_SSPI_recvauth(Port *port);
#endif
errhint("See server log for details.")));
/*
- * This is the first point where we have access to the hba record for
- * the current connection, so perform any verifications based on the
- * hba options field that should be done *before* the authentication
- * here.
+ * This is the first point where we have access to the hba record for the
+ * current connection, so perform any verifications based on the hba
+ * options field that should be done *before* the authentication here.
*/
if (port->hba->clientcert)
{
{
ereport(FATAL,
(errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
- errmsg("connection requires a valid client certificate")));
+ errmsg("connection requires a valid client certificate")));
}
#else
+
/*
- * hba.c makes sure hba->clientcert can't be set unless OpenSSL
- * is present.
+ * hba.c makes sure hba->clientcert can't be set unless OpenSSL is
+ * present.
*/
Assert(false);
#endif
if (cp)
{
/*
- * If we are not going to include the realm in the username that is passed
- * to the ident map, destructively modify it here to remove the realm. Then
- * advance past the separator to check the realm.
+ * If we are not going to include the realm in the username that is
+ * passed to the ident map, destructively modify it here to remove the
+ * realm. Then advance past the separator to check the realm.
*/
if (!port->hba->include_realm)
*cp = '\0';
}
}
}
- else if (port->hba->krb_realm&& strlen(port->hba->krb_realm))
+ else if (port->hba->krb_realm && strlen(port->hba->krb_realm))
{
elog(DEBUG2,
"krb5 did not return realm but realm matching was requested");
/*
* GSS auth is not supported for protocol versions before 3, because it
* relies on the overall message length word to determine the GSS payload
- * size in AuthenticationGSSContinue and PasswordMessage messages.
- * (This is, in fact, a design error in our GSS support, because protocol
+ * size in AuthenticationGSSContinue and PasswordMessage messages. (This
+ * is, in fact, a design error in our GSS support, because protocol
* messages are supposed to be parsable without relying on the length
* word; but it's not worth changing it now.)
*/
*/
if (getenv("KRB5_KTNAME") == NULL)
{
- size_t kt_len = strlen(pg_krb_server_keyfile) + 14;
- char *kt_path = malloc(kt_len);
+ size_t kt_len = strlen(pg_krb_server_keyfile) + 14;
+ char *kt_path = malloc(kt_len);
if (!kt_path)
{
char *cp = strchr(gbuf.value, '@');
/*
- * If we are not going to include the realm in the username that is passed
- * to the ident map, destructively modify it here to remove the realm. Then
- * advance past the separator to check the realm.
+ * If we are not going to include the realm in the username that is
+ * passed to the ident map, destructively modify it here to remove the
+ * realm. Then advance past the separator to check the realm.
*/
if (!port->hba->include_realm)
*cp = '\0';
/*
* SSPI auth is not supported for protocol versions before 3, because it
* relies on the overall message length word to determine the SSPI payload
- * size in AuthenticationGSSContinue and PasswordMessage messages.
- * (This is, in fact, a design error in our SSPI support, because protocol
+ * size in AuthenticationGSSContinue and PasswordMessage messages. (This
+ * is, in fact, a design error in our SSPI support, because protocol
* messages are supposed to be parsable without relying on the length
* word; but it's not worth changing it now.)
*/
*/
if (port->hba->include_realm)
{
- char *namebuf;
- int retval;
+ char *namebuf;
+ int retval;
namebuf = palloc(strlen(accountname) + strlen(domainname) + 2);
sprintf(namebuf, "%s@%s", accountname, domainname);
/* Solaris > 10 */
uid_t uid;
struct passwd *pass;
- ucred_t *ucred;
+ ucred_t *ucred;
- ucred = NULL; /* must be initialized to NULL */
+ ucred = NULL; /* must be initialized to NULL */
if (getpeerucred(sock, &ucred) == -1)
{
ereport(LOG,
{
ereport(LOG,
(errcode_for_socket_access(),
- errmsg("could not get effective UID from peer credentials: %m")));
+ errmsg("could not get effective UID from peer credentials: %m")));
return false;
}
if (pass == NULL)
{
ereport(LOG,
- (errmsg("local user with ID %d does not exist",
- (int) uid)));
+ (errmsg("local user with ID %d does not exist",
+ (int) uid)));
return false;
}
int ldapversion = LDAP_VERSION3;
char fulluser[NAMEDATALEN + 256 + 1];
- if (!port->hba->ldapserver|| port->hba->ldapserver[0] == '\0')
+ if (!port->hba->ldapserver || port->hba->ldapserver[0] == '\0')
{
ereport(LOG,
(errmsg("LDAP server not specified")));
/* Just pass the certificate CN to the usermap check */
return check_usermap(port->hba->usermap, port->user_name, port->peer_cn, false);
}
+
#endif
static int newLOfd(LargeObjectDesc *lobjCookie);
static void deleteLOfd(int fd);
-static Oid lo_import_internal(text *filename, Oid lobjOid);
+static Oid lo_import_internal(text *filename, Oid lobjOid);
/*****************************************************************************
lo_import_with_oid(PG_FUNCTION_ARGS)
{
text *filename = PG_GETARG_TEXT_PP(0);
- Oid oid = PG_GETARG_OID(1);
+ Oid oid = PG_GETARG_OID(1);
PG_RETURN_OID(lo_import_internal(filename, oid));
}
char buf[BUFSIZE];
char fnamebuf[MAXPGPATH];
LargeObjectDesc *lobj;
- Oid oid;
-
+ Oid oid;
+
#ifndef ALLOW_DANGEROUS_LO_FUNCTIONS
if (!superuser())
ereport(ERROR,
* Load and verify certificate and private key
*/
if (SSL_CTX_use_certificate_chain_file(SSL_context,
- SERVER_CERT_FILE) != 1)
+ SERVER_CERT_FILE) != 1)
ereport(FATAL,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("could not load server certificate file \"%s\": %s",
if (!S_ISREG(buf.st_mode) || buf.st_mode & (S_IRWXG | S_IRWXO))
ereport(FATAL,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("private key file \"%s\" has group or world access",
- SERVER_PRIVATE_KEY_FILE),
- errdetail("Permissions should be u=rw (0600) or less.")));
+ errmsg("private key file \"%s\" has group or world access",
+ SERVER_PRIVATE_KEY_FILE),
+ errdetail("Permissions should be u=rw (0600) or less.")));
#endif
if (SSL_CTX_use_PrivateKey_file(SSL_context,
- SERVER_PRIVATE_KEY_FILE,
- SSL_FILETYPE_PEM) != 1)
+ SERVER_PRIVATE_KEY_FILE,
+ SSL_FILETYPE_PEM) != 1)
ereport(FATAL,
(errmsg("could not load private key file \"%s\": %s",
SERVER_PRIVATE_KEY_FILE, SSLerrmessage())));
elog(FATAL, "could not set the cipher list (no valid ciphers available)");
/*
- * Attempt to load CA store, so we can verify client certificates if needed.
+ * Attempt to load CA store, so we can verify client certificates if
+ * needed.
*/
if (access(ROOT_CERT_FILE, R_OK))
{
ssl_loaded_verify_locations = false;
/*
- * If root certificate file simply not found. Don't log an error here, because
- * it's quite likely the user isn't planning on using client certificates.
- * If we can't access it for other reasons, it is an error.
+ * If root certificate file simply not found. Don't log an error here,
+ * because it's quite likely the user isn't planning on using client
+ * certificates. If we can't access it for other reasons, it is an
+ * error.
*/
if (errno != ENOENT)
{
ereport(FATAL,
- (errmsg("could not access root certificate file \"%s\": %m",
- ROOT_CERT_FILE)));
+ (errmsg("could not access root certificate file \"%s\": %m",
+ ROOT_CERT_FILE)));
}
}
else if (SSL_CTX_load_verify_locations(SSL_context, ROOT_CERT_FILE, NULL) != 1)
{
/*
- * File was there, but we could not load it. This means the file is somehow
- * broken, and we cannot do verification at all - so abort here.
+ * File was there, but we could not load it. This means the file is
+ * somehow broken, and we cannot do verification at all - so abort
+ * here.
*/
ssl_loaded_verify_locations = false;
ereport(FATAL,
}
/*
- * Always ask for SSL client cert, but don't fail if it's not presented. We'll fail later in this case,
- * based on what we find in pg_hba.conf.
+ * Always ask for SSL client cert, but don't fail if it's not
+ * presented. We'll fail later in this case, based on what we find
+ * in pg_hba.conf.
*/
SSL_CTX_set_verify(SSL_context,
(SSL_VERIFY_PEER |
/*
* Macros used to check and report on invalid configuration options.
* INVALID_AUTH_OPTION = reports when an option is specified for a method where it's
- * not supported.
+ * not supported.
* REQUIRE_AUTH_OPTION = same as INVALID_AUTH_OPTION, except it also checks if the
- * method is actually the one specified. Used as a shortcut when
- * the option is only valid for one authentication method.
+ * method is actually the one specified. Used as a shortcut when
+ * the option is only valid for one authentication method.
* MANDATORY_AUTH_ARG = check if a required option is set for an authentication method,
- * reporting error if it's not.
+ * reporting error if it's not.
*/
#define INVALID_AUTH_OPTION(optname, validmethods) do {\
ereport(LOG, \
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("hostssl not supported on this platform"),
- errhint("compile with --enable-ssl to use SSL connections"),
+ errhint("compile with --enable-ssl to use SSL connections"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
#endif
}
parsedline->conntype = ctHostNoSSL;
}
#endif
- else
+ else
{
/* "host", or "hostnossl" and SSL support not built in */
parsedline->conntype = ctHost;
}
- } /* record type */
+ } /* record type */
else
{
ereport(LOG,
errmsg("invalid connection type \"%s\"",
token),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("end-of-line before database specification"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
parsedline->database = pstrdup(lfirst(line_item));
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("end-of-line before role specification"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
parsedline->role = pstrdup(lfirst(line_item));
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("end-of-line before ip address specification"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
token = pstrdup(lfirst(line_item));
errmsg("invalid IP address \"%s\": %s",
token, gai_strerror(ret)),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
if (cidr_slash)
*cidr_slash = '/';
if (gai_result)
errmsg("invalid CIDR mask in address \"%s\"",
token),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
}
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("end-of-line before netmask specification"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
token = lfirst(line_item);
errmsg("invalid IP mask \"%s\": %s",
token, gai_strerror(ret)),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
if (gai_result)
pg_freeaddrinfo_all(hints.ai_family, gai_result);
return false;
return false;
}
}
- } /* != ctLocal */
+ } /* != ctLocal */
/* Get the authentication method */
line_item = lnext(line_item);
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("end-of-line before authentication method"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
token = lfirst(line_item);
errmsg("invalid authentication method \"%s\"",
token),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
errmsg("invalid authentication method \"%s\": not supported on this platform",
token),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
{
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("krb5 authentication is not supported on local sockets"),
+ errmsg("krb5 authentication is not supported on local sockets"),
errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ line_num, HbaFileName)));
return false;
}
/* Parse remaining arguments */
while ((line_item = lnext(line_item)) != NULL)
{
- char *c;
+ char *c;
token = lfirst(line_item);
}
else
{
- *c++ = '\0'; /* token now holds "name", c holds "value" */
+ *c++ = '\0'; /* token now holds "name", c holds "value" */
if (strcmp(token, "map") == 0)
{
if (parsedline->auth_method != uaIdent &&
else if (strcmp(token, "clientcert") == 0)
{
/*
- * Since we require ctHostSSL, this really can never happen on non-SSL-enabled
- * builds, so don't bother checking for USE_SSL.
+ * Since we require ctHostSSL, this really can never happen on
+ * non-SSL-enabled builds, so don't bother checking for
+ * USE_SSL.
*/
if (parsedline->conntype != ctHostSSL)
{
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("clientcert can only be configured for \"hostssl\" rows"),
- errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ errcontext("line %d of configuration file \"%s\"",
+ line_num, HbaFileName)));
return false;
}
if (strcmp(c, "1") == 0)
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("client certificates can only be checked if a root certificate store is available"),
errdetail("make sure the root certificate store is present and readable"),
- errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ errcontext("line %d of configuration file \"%s\"",
+ line_num, HbaFileName)));
return false;
}
parsedline->clientcert = true;
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("clientcert can not be set to 0 when using \"cert\" authentication"),
- errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ errcontext("line %d of configuration file \"%s\"",
+ line_num, HbaFileName)));
return false;
}
parsedline->clientcert = false;
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("invalid LDAP port number: \"%s\"", c),
- errcontext("line %d of configuration file \"%s\"",
- line_num, HbaFileName)));
+ errcontext("line %d of configuration file \"%s\"",
+ line_num, HbaFileName)));
return false;
}
}
{
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("unknown authentication option name: \"%s\"", token),
+ errmsg("unknown authentication option name: \"%s\"", token),
errcontext("line %d of configuration file \"%s\"",
line_num, HbaFileName)));
return false;
}
/*
- * Check if the selected authentication method has any mandatory arguments that
- * are not set.
+ * Check if the selected authentication method has any mandatory arguments
+ * that are not set.
*/
if (parsedline->auth_method == uaLDAP)
{
{
parsedline->clientcert = true;
}
-
+
return true;
}
check_hba(hbaPort *port)
{
ListCell *line;
- HbaLine *hba;
+ HbaLine *hba;
foreach(line, parsed_hba_lines)
{
continue;
}
#ifdef HAVE_IPV6
- else if (hba->addr.ss_family == AF_INET &&
- port->raddr.addr.ss_family == AF_INET6)
+ else if (hba->addr.ss_family == AF_INET &&
+ port->raddr.addr.ss_family == AF_INET6)
{
/*
- * Wrong address family. We allow only one case: if the file has
- * IPv4 and the port is IPv6, promote the file address to IPv6 and
- * try to match that way.
+ * Wrong address family. We allow only one case: if the file
+ * has IPv4 and the port is IPv6, promote the file address to
+ * IPv6 and try to match that way.
*/
- struct sockaddr_storage addrcopy, maskcopy;
+ struct sockaddr_storage addrcopy,
+ maskcopy;
+
memcpy(&addrcopy, &hba->addr, sizeof(addrcopy));
memcpy(&maskcopy, &hba->mask, sizeof(maskcopy));
pg_promote_v4_to_v6_addr(&addrcopy);
pg_promote_v4_to_v6_mask(&maskcopy);
-
+
if (!pg_range_sockaddr(&port->raddr.addr, &addrcopy, &maskcopy))
continue;
}
-#endif /* HAVE_IPV6 */
+#endif /* HAVE_IPV6 */
else
/* Wrong address family, no IPV6 */
continue;
- } /* != ctLocal */
+ } /* != ctLocal */
/* Check database and role */
if (!check_db(port->database_name, port->user_name, hba->database))
port->hba = hba;
return true;
- /* XXX:
- * Return false only happens if we have a parsing error, which we can
+ /*
+ * XXX: Return false only happens if we have a parsing error, which we can
* no longer have (parsing now in postmaster). Consider changing API.
*/
}
static void
clean_hba_list(List *lines)
{
- ListCell *line;
+ ListCell *line;
foreach(line, lines)
{
- HbaLine *parsed = (HbaLine *)lfirst(line);
+ HbaLine *parsed = (HbaLine *) lfirst(line);
+
if (parsed)
free_hba_record(parsed);
}
load_hba(void)
{
FILE *file;
- List *hba_lines = NIL;
- List *hba_line_nums = NIL;
- ListCell *line, *line_num;
- List *new_parsed_lines = NIL;
- bool ok = true;
+ List *hba_lines = NIL;
+ List *hba_line_nums = NIL;
+ ListCell *line,
+ *line_num;
+ List *new_parsed_lines = NIL;
+ bool ok = true;
file = AllocateFile(HbaFileName, "r");
if (file == NULL)
(errcode_for_file_access(),
errmsg("could not open configuration file \"%s\": %m",
HbaFileName)));
+
/*
* Caller will take care of making this a FATAL error in case this is
- * the initial startup. If it happens on reload, we just keep the
- * old version around.
+ * the initial startup. If it happens on reload, we just keep the old
+ * version around.
*/
return false;
}
/* Now parse all the lines */
forboth(line, hba_lines, line_num, hba_line_nums)
{
- HbaLine *newline;
+ HbaLine *newline;
newline = palloc0(sizeof(HbaLine));
pfree(newline);
/*
- * Keep parsing the rest of the file so we can report errors
- * on more than the first row. Error has already been reported
- * in the parsing function, so no need to log it here.
+ * Keep parsing the rest of the file so we can report errors on
+ * more than the first row. Error has already been reported in the
+ * parsing function, so no need to log it here.
*/
ok = false;
continue;
if (file_ident_user[0] == '/')
{
/*
- * When system username starts with a slash, treat it as a regular expression.
- * In this case, we process the system username as a regular expression that
- * returns exactly one match. This is replaced for \1 in the database username
- * string, if present.
+ * When system username starts with a slash, treat it as a regular
+ * expression. In this case, we process the system username as a
+ * regular expression that returns exactly one match. This is replaced
+ * for \1 in the database username string, if present.
*/
int r;
regex_t re;
char *ofs;
char *regexp_pgrole;
- wstr = palloc((strlen(file_ident_user+1) + 1) * sizeof(pg_wchar));
- wlen = pg_mb2wchar_with_len(file_ident_user+1, wstr, strlen(file_ident_user+1));
+ wstr = palloc((strlen(file_ident_user + 1) + 1) * sizeof(pg_wchar));
+ wlen = pg_mb2wchar_with_len(file_ident_user + 1, wstr, strlen(file_ident_user + 1));
/*
- * XXX: Major room for optimization: regexps could be compiled when the file is loaded
- * and then re-used in every connection.
+ * XXX: Major room for optimization: regexps could be compiled when
+ * the file is loaded and then re-used in every connection.
*/
r = pg_regcomp(&re, wstr, wlen, REG_ADVANCED);
if (r)
{
- char errstr[100];
+ char errstr[100];
pg_regerror(r, &re, errstr, sizeof(errstr));
ereport(ERROR,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
- errmsg("invalid regular expression \"%s\": %s", file_ident_user+1, errstr)));
+ errmsg("invalid regular expression \"%s\": %s", file_ident_user + 1, errstr)));
pfree(wstr);
*error_p = true;
wstr = palloc((strlen(ident_user) + 1) * sizeof(pg_wchar));
wlen = pg_mb2wchar_with_len(ident_user, wstr, strlen(ident_user));
- r = pg_regexec(&re, wstr, wlen, 0, NULL, 2, matches,0);
+ r = pg_regexec(&re, wstr, wlen, 0, NULL, 2, matches, 0);
if (r)
{
- char errstr[100];
+ char errstr[100];
if (r != REG_NOMATCH)
{
pg_regerror(r, &re, errstr, sizeof(errstr));
ereport(ERROR,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
- errmsg("regular expression match for \"%s\" failed: %s", file_ident_user+1, errstr)));
+ errmsg("regular expression match for \"%s\" failed: %s", file_ident_user + 1, errstr)));
*error_p = true;
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
errmsg("regular expression \"%s\" has no subexpressions as requested by backreference in \"%s\"",
- file_ident_user+1, file_pgrole)));
- /* length: original length minus length of \1 plus length of match plus null terminator */
- regexp_pgrole = palloc0(strlen(file_pgrole) - 2 + (matches[1].rm_eo-matches[1].rm_so) + 1);
- strncpy(regexp_pgrole, file_pgrole, (ofs-file_pgrole));
- memcpy(regexp_pgrole+strlen(regexp_pgrole),
- ident_user+matches[1].rm_so,
- matches[1].rm_eo-matches[1].rm_so);
- strcat(regexp_pgrole, ofs+2);
+ file_ident_user + 1, file_pgrole)));
+
+ /*
+ * length: original length minus length of \1 plus length of match
+ * plus null terminator
+ */
+ regexp_pgrole = palloc0(strlen(file_pgrole) - 2 + (matches[1].rm_eo - matches[1].rm_so) + 1);
+ strncpy(regexp_pgrole, file_pgrole, (ofs - file_pgrole));
+ memcpy(regexp_pgrole + strlen(regexp_pgrole),
+ ident_user + matches[1].rm_so,
+ matches[1].rm_eo - matches[1].rm_so);
+ strcat(regexp_pgrole, ofs + 2);
}
else
{
pg_regfree(&re);
- /* now check if the username actually matched what the user is trying to connect as */
+ /*
+ * now check if the username actually matched what the user is trying
+ * to connect as
+ */
if (case_insensitive)
{
if (pg_strcasecmp(regexp_pgrole, pg_role) == 0)
* See if the user with ident username "ident_user" is allowed to act
* as Postgres user "pgrole" according to usermap "usermap_name".
*
- * Special case: Usermap NULL, equivalent to what was previously called
- * "sameuser" or "samerole", don't look in the usermap
+ * Special case: Usermap NULL, equivalent to what was previously called
+ * "sameuser" or "samerole", don't look in the usermap
* file. That's an implied map where "pgrole" must be identical to
* "ident_user" in order to be authorized.
*
*/
int
check_usermap(const char *usermap_name,
- const char *pg_role,
- const char *auth_user,
- bool case_insensitive)
+ const char *pg_role,
+ const char *auth_user,
+ bool case_insensitive)
{
bool found_entry = false,
error = false;
if (pg_strcasecmp(pg_role, auth_user) == 0)
return STATUS_OK;
}
- else {
+ else
+ {
if (strcmp(pg_role, auth_user) == 0)
return STATUS_OK;
}
forboth(line_cell, ident_lines, num_cell, ident_line_nums)
{
parse_ident_usermap(lfirst(line_cell), lfirst_int(num_cell),
- usermap_name, pg_role, auth_user, case_insensitive,
+ usermap_name, pg_role, auth_user, case_insensitive,
&found_entry, &error);
if (found_entry || error)
break;
if (!found_entry && !error)
{
ereport(LOG,
- (errmsg("no match in usermap for user \"%s\" authenticated as \"%s\"",
- pg_role, auth_user),
- errcontext("usermap \"%s\"", usermap_name)));
+ (errmsg("no match in usermap for user \"%s\" authenticated as \"%s\"",
+ pg_role, auth_user),
+ errcontext("usermap \"%s\"", usermap_name)));
}
- return found_entry?STATUS_OK:STATUS_ERROR;
+ return found_entry ? STATUS_OK : STATUS_ERROR;
}
/* NULL has special meaning to getaddrinfo(). */
rc = getaddrinfo((!hostname || hostname[0] == '\0') ? NULL : hostname,
servname, hintp, result);
-
-#else /* _AIX */
+#else /* _AIX */
/*
* Various versions of AIX have various bugs in getaddrinfo()'s handling
}
}
}
-#endif /* _AIX */
+#endif /* _AIX */
return rc;
}
{
while (*str)
{
- char ch = *str++;
+ char ch = *str++;
if (IS_HIGHBIT_SET(ch))
ch = '?';
static RecursiveUnion *
_copyRecursiveUnion(RecursiveUnion *from)
{
- RecursiveUnion *newnode = makeNode(RecursiveUnion);
+ RecursiveUnion *newnode = makeNode(RecursiveUnion);
/*
* copy node superclass fields
static CteScan *
_copyCteScan(CteScan *from)
{
- CteScan *newnode = makeNode(CteScan);
+ CteScan *newnode = makeNode(CteScan);
/*
* copy node superclass fields
static A_Star *
_copyAStar(A_Star *from)
{
- A_Star *newnode = makeNode(A_Star);
+ A_Star *newnode = makeNode(A_Star);
return newnode;
}
static A_ArrayExpr *
_copyA_ArrayExpr(A_ArrayExpr *from)
{
- A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
+ A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
COPY_NODE_FIELD(elements);
COPY_LOCATION_FIELD(location);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(indexname);
- COPY_SCALAR_FIELD(verbose) ;
+ COPY_SCALAR_FIELD(verbose);
return newnode;
}
_equalPlaceHolderVar(PlaceHolderVar *a, PlaceHolderVar *b)
{
/*
- * We intentionally do not compare phexpr. Two PlaceHolderVars with the
+ * We intentionally do not compare phexpr. Two PlaceHolderVars with the
* same ID and levelsup should be considered equal even if the contained
- * expressions have managed to mutate to different states. One way in
+ * expressions have managed to mutate to different states. One way in
* which that can happen is that initplan sublinks would get replaced by
* differently-numbered Params when sublink folding is done. (The end
* result of such a situation would be some unreferenced initplans, which
* "intersection" if list1 is known unique beforehand.
*
* This variant works on lists of pointers, and determines list
- * membership via equal(). Note that the list1 member will be pointed
+ * membership via equal(). Note that the list1 member will be pointed
* to in the result.
*/
List *
/*
* exprTypmod -
* returns the type-specific modifier of the expression's result type,
- * if it can be determined. In many cases, it can't and we return -1.
+ * if it can be determined. In many cases, it can't and we return -1.
*/
int32
exprTypmod(Node *expr)
case T_DistinctExpr: /* struct-equivalent to OpExpr */
case T_NullIfExpr: /* struct-equivalent to OpExpr */
{
- OpExpr *opexpr = (OpExpr *) expr;
+ OpExpr *opexpr = (OpExpr *) expr;
/* consider both operator name and leftmost arg */
loc = leftmostLoc(opexpr->location,
break;
case T_SubLink:
{
- SubLink *sublink = (SubLink *) expr;
+ SubLink *sublink = (SubLink *) expr;
/* check the testexpr, if any, and the operator/keyword */
loc = leftmostLoc(exprLocation(sublink->testexpr),
break;
case T_XmlExpr:
{
- XmlExpr *xexpr = (XmlExpr *) expr;
+ XmlExpr *xexpr = (XmlExpr *) expr;
/* consider both function name and leftmost arg */
loc = leftmostLoc(xexpr->location,
break;
case T_A_Expr:
{
- A_Expr *aexpr = (A_Expr *) expr;
+ A_Expr *aexpr = (A_Expr *) expr;
/* use leftmost of operator or left operand (if any) */
/* we assume right operand can't be to left of operator */
break;
case T_FuncCall:
{
- FuncCall *fc = (FuncCall *) expr;
+ FuncCall *fc = (FuncCall *) expr;
/* consider both function name and leftmost arg */
loc = leftmostLoc(fc->location,
break;
case T_TypeCast:
{
- TypeCast *tc = (TypeCast *) expr;
+ TypeCast *tc = (TypeCast *) expr;
/*
- * This could represent CAST(), ::, or TypeName 'literal',
- * so any of the components might be leftmost.
+ * This could represent CAST(), ::, or TypeName 'literal', so
+ * any of the components might be leftmost.
*/
loc = exprLocation(tc->arg);
loc = leftmostLoc(loc, tc->typename->location);
break;
case T_WindowClause:
{
- WindowClause *wc = (WindowClause *) node;
+ WindowClause *wc = (WindowClause *) node;
if (walker(wc->partitionClause, context))
return true;
CommonTableExpr *cte = (CommonTableExpr *) node;
/*
- * Invoke the walker on the CTE's Query node, so it
- * can recurse into the sub-query if it wants to.
+ * Invoke the walker on the CTE's Query node, so it can
+ * recurse into the sub-query if it wants to.
*/
return walker(cte->ctequery, context);
}
{
case RTE_RELATION:
case RTE_SPECIAL:
- case RTE_CTE:
+ case RTE_CTE:
/* nothing to do */
break;
case RTE_SUBQUERY:
return node;
case T_WindowClause:
{
- WindowClause *wc = (WindowClause *) node;
- WindowClause *newnode;
+ WindowClause *wc = (WindowClause *) node;
+ WindowClause *newnode;
FLATCOPY(newnode, wc, WindowClause);
MUTATE(newnode->partitionClause, wc->partitionClause, List *);
FLATCOPY(newnode, cte, CommonTableExpr);
/*
- * Also invoke the mutator on the CTE's Query node, so it
- * can recurse into the sub-query if it wants to.
+ * Also invoke the mutator on the CTE's Query node, so it can
+ * recurse into the sub-query if it wants to.
*/
MUTATE(newnode->ctequery, cte->ctequery, Node *);
return (Node *) newnode;
MUTATE(query->limitCount, query->limitCount, Node *);
if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))
MUTATE(query->cteList, query->cteList, List *);
- else /* else copy CTE list as-is */
+ else /* else copy CTE list as-is */
query->cteList = copyObject(query->cteList);
query->rtable = range_table_mutator(query->rtable,
mutator, context, flags);
* that could appear under it, but not other statement types.
*/
bool
-raw_expression_tree_walker(Node *node, bool (*walker) (), void *context)
+ raw_expression_tree_walker(Node *node, bool (*walker) (), void *context)
{
ListCell *temp;
break;
case T_A_Expr:
{
- A_Expr *expr = (A_Expr *) node;
+ A_Expr *expr = (A_Expr *) node;
if (walker(expr->lexpr, context))
return true;
break;
case T_FuncCall:
{
- FuncCall *fcall = (FuncCall *) node;
+ FuncCall *fcall = (FuncCall *) node;
if (walker(fcall->args, context))
return true;
break;
case T_A_Indices:
{
- A_Indices *indices = (A_Indices *) node;
+ A_Indices *indices = (A_Indices *) node;
if (walker(indices->lidx, context))
return true;
return walker(((A_ArrayExpr *) node)->elements, context);
case T_ResTarget:
{
- ResTarget *rt = (ResTarget *) node;
+ ResTarget *rt = (ResTarget *) node;
if (walker(rt->indirection, context))
return true;
break;
case T_TypeCast:
{
- TypeCast *tc = (TypeCast *) node;
+ TypeCast *tc = (TypeCast *) node;
if (walker(tc->arg, context))
return true;
return walker(((SortBy *) node)->node, context);
case T_WindowDef:
{
- WindowDef *wd = (WindowDef *) node;
+ WindowDef *wd = (WindowDef *) node;
if (walker(wd->partitionClause, context))
return true;
break;
case T_TypeName:
{
- TypeName *tn = (TypeName *) node;
+ TypeName *tn = (TypeName *) node;
if (walker(tn->typmods, context))
return true;
break;
case T_ColumnDef:
{
- ColumnDef *coldef = (ColumnDef *) node;
+ ColumnDef *coldef = (ColumnDef *) node;
if (walker(coldef->typename, context))
return true;
static void
_outRecursiveUnion(StringInfo str, RecursiveUnion *node)
{
- int i;
+ int i;
WRITE_NODE_TYPE("RECURSIVEUNION");
static void
_outAgg(StringInfo str, Agg *node)
{
- int i;
+ int i;
WRITE_NODE_TYPE("AGG");
WRITE_INT_FIELD(ordNumCols);
appendStringInfo(str, " :ordColIdx");
- for (i = 0; i< node->ordNumCols; i++)
+ for (i = 0; i < node->ordNumCols; i++)
appendStringInfo(str, " %d", node->ordColIdx[i]);
appendStringInfo(str, " :ordOperations");
#define READ_LOCATION_FIELD(fldname) \
token = pg_strtok(&length); /* skip :fldname */ \
token = pg_strtok(&length); /* get field value */ \
- local_node->fldname = -1 /* set field to "unknown" */
+ local_node->fldname = -1 /* set field to "unknown" */
/* Read a Node field */
#define READ_NODE_FIELD(fldname) \
static Bitmapset *
_readBitmapset(void)
{
- Bitmapset *result = NULL;
+ Bitmapset *result = NULL;
+
READ_TEMP_LOCALS();
token = pg_strtok(&length);
for (;;)
{
- int val;
- char *endptr;
+ int val;
+ char *endptr;
token = pg_strtok(&length);
if (token == NULL)
* of lossiness. In theory we could fall back to page ranges at some
* point, but for now that seems useless complexity.
*
- * We also support the notion of candidate matches, or rechecking. This
+ * We also support the notion of candidate matches, or rechecking. This
* means we know that a search need visit only some tuples on a page,
* but we are not certain that all of those tuples are real matches.
* So the eventual heap scan must recheck the quals for these tuples only,
/*
* When iterating over a bitmap in sorted order, a TBMIterator is used to
- * track our progress. There can be several iterators scanning the same
+ * track our progress. There can be several iterators scanning the same
* bitmap concurrently. Note that the bitmap becomes read-only as soon as
* any iterator is created.
*/
else if (tbm_page_is_lossy(b, apage->blockno))
{
/*
- * Some of the tuples in 'a' might not satisfy the quals for 'b',
- * but because the page 'b' is lossy, we don't know which ones.
- * Therefore we mark 'a' as requiring rechecks, to indicate that
- * at most those tuples set in 'a' are matches.
+ * Some of the tuples in 'a' might not satisfy the quals for 'b', but
+ * because the page 'b' is lossy, we don't know which ones. Therefore
+ * we mark 'a' as requiring rechecks, to indicate that at most those
+ * tuples set in 'a' are matches.
*/
apage->recheck = true;
return false;
* needs of the TBMIterateResult sub-struct.
*/
iterator = (TBMIterator *) palloc(sizeof(TBMIterator) +
- MAX_TUPLES_PER_PAGE * sizeof(OffsetNumber));
+ MAX_TUPLES_PER_PAGE * sizeof(OffsetNumber));
iterator->tbm = tbm;
/*
iterator->schunkbit = 0;
/*
- * If we have a hashtable, create and fill the sorted page lists,
- * unless we already did that for a previous iterator. Note that the
- * lists are attached to the bitmap not the iterator, so they can be
- * used by more than one iterator.
+ * If we have a hashtable, create and fill the sorted page lists, unless
+ * we already did that for a previous iterator. Note that the lists are
+ * attached to the bitmap not the iterator, so they can be used by more
+ * than one iterator.
*/
if (tbm->status == TBM_HASH && !tbm->iterating)
{
TBMIterateResult *
tbm_iterate(TBMIterator *iterator)
{
- TIDBitmap *tbm = iterator->tbm;
+ TIDBitmap *tbm = iterator->tbm;
TBMIterateResult *output = &(iterator->output);
Assert(tbm->iterating);
static void set_values_pathlist(PlannerInfo *root, RelOptInfo *rel,
RangeTblEntry *rte);
static void set_cte_pathlist(PlannerInfo *root, RelOptInfo *rel,
- RangeTblEntry *rte);
+ RangeTblEntry *rte);
static void set_worktable_pathlist(PlannerInfo *root, RelOptInfo *rel,
- RangeTblEntry *rte);
+ RangeTblEntry *rte);
static RelOptInfo *make_rel_from_joinlist(PlannerInfo *root, List *joinlist);
static bool subquery_is_pushdown_safe(Query *subquery, Query *topquery,
bool *differentTypes);
/*
* Initialize to compute size estimates for whole append relation.
*
- * We handle width estimates by weighting the widths of different
- * child rels proportionally to their number of rows. This is sensible
- * because the use of width estimates is mainly to compute the total
- * relation "footprint" if we have to sort or hash it. To do this,
- * we sum the total equivalent size (in "double" arithmetic) and then
- * divide by the total rowcount estimate. This is done separately for
- * the total rel width and each attribute.
+ * We handle width estimates by weighting the widths of different child
+ * rels proportionally to their number of rows. This is sensible because
+ * the use of width estimates is mainly to compute the total relation
+ * "footprint" if we have to sort or hash it. To do this, we sum the
+ * total equivalent size (in "double" arithmetic) and then divide by the
+ * total rowcount estimate. This is done separately for the total rel
+ * width and each attribute.
*
* Note: if you consider changing this logic, beware that child rels could
* have zero rows and/or width, if they were excluded by constraints.
}
/*
- * Note: we could compute appropriate attr_needed data for the
- * child's variables, by transforming the parent's attr_needed
- * through the translated_vars mapping. However, currently there's
- * no need because attr_needed is only examined for base relations
- * not otherrels. So we just leave the child's attr_needed empty.
+ * Note: we could compute appropriate attr_needed data for the child's
+ * variables, by transforming the parent's attr_needed through the
+ * translated_vars mapping. However, currently there's no need
+ * because attr_needed is only examined for base relations not
+ * otherrels. So we just leave the child's attr_needed empty.
*/
/*
rel->rows = parent_rows;
if (parent_rows > 0)
{
- int i;
+ int i;
rel->width = rint(parent_size / parent_rows);
for (i = 0; i < nattrs; i++)
if (!cteroot) /* shouldn't happen */
elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
}
+
/*
* Note: cte_plan_ids can be shorter than cteList, if we are still working
* on planning the CTEs (ie, this is a side-reference from another CTE).
/*
* We need to find the non-recursive term's plan, which is in the plan
- * level that's processing the recursive UNION, which is one level
- * *below* where the CTE comes from.
+ * level that's processing the recursive UNION, which is one level *below*
+ * where the CTE comes from.
*/
levelsup = rte->ctelevelsup;
if (levelsup == 0) /* shouldn't happen */
* of rows returned. (This condition is vacuous for DISTINCT, because then
* there are no non-DISTINCT output columns, so we needn't check. But note
* we are assuming that the qual can't distinguish values that the DISTINCT
- * operator sees as equal. This is a bit shaky but we have no way to test
+ * operator sees as equal. This is a bit shaky but we have no way to test
* for the case, and it's unlikely enough that we shouldn't refuse the
* optimization just because it could theoretically happen.)
*
return false;
/*
- * It would be unsafe to push down window function calls, but at least
- * for the moment we could never see any in a qual anyhow.
+ * It would be unsafe to push down window function calls, but at least for
+ * the moment we could never see any in a qual anyhow.
*/
Assert(!contain_window_function(qual));
ListCell *l;
/*
- * If there's exactly one clause, then no use in trying to match up
- * pairs, so just go directly to clause_selectivity().
+ * If there's exactly one clause, then no use in trying to match up pairs,
+ * so just go directly to clause_selectivity().
*/
if (list_length(clauses) == 1)
return clause_selectivity(root, (Node *) linitial(clauses),
if (varRelid != 0)
{
/*
- * Caller is forcing restriction mode (eg, because we are examining
- * an inner indexscan qual).
+ * Caller is forcing restriction mode (eg, because we are examining an
+ * inner indexscan qual).
*/
return false;
}
else if (sjinfo == NULL)
{
/*
- * It must be a restriction clause, since it's being evaluated at
- * a scan node.
+ * It must be a restriction clause, since it's being evaluated at a
+ * scan node.
*/
return false;
}
else
{
/*
- * Otherwise, it's a join if there's more than one relation used.
- * We can optimize this calculation if an rinfo was passed.
+ * Otherwise, it's a join if there's more than one relation used. We
+ * can optimize this calculation if an rinfo was passed.
*
- * XXX Since we know the clause is being evaluated at a join,
- * the only way it could be single-relation is if it was delayed
- * by outer joins. Although we can make use of the restriction
- * qual estimators anyway, it seems likely that we ought to account
- * for the probability of injected nulls somehow.
+ * XXX Since we know the clause is being evaluated at a join, the
+ * only way it could be single-relation is if it was delayed by outer
+ * joins. Although we can make use of the restriction qual estimators
+ * anyway, it seems likely that we ought to account for the
+ * probability of injected nulls somehow.
*/
if (rinfo)
return (bms_membership(rinfo->clause_relids) == BMS_MULTIPLE);
* if the clause isn't a join clause.
*
* sjinfo is NULL for a non-join clause, otherwise it provides additional
- * context information about the join being performed. There are some
+ * context information about the join being performed. There are some
* special cases:
* 1. For a special (not INNER) join, sjinfo is always a member of
* root->join_info_list.
* contains only vars of that relid --- otherwise varRelid will affect
* the result, so mustn't cache. Outer join quals might be examined
* with either their join's actual jointype or JOIN_INNER, so we need
- * two cache variables to remember both cases. Note: we assume the
+ * two cache variables to remember both cases. Note: we assume the
* result won't change if we are switching the input relations or
* considering a unique-ified case, so we only need one cache variable
* for all non-JOIN_INNER cases.
{
/*
* A Var at the top of a clause must be a bool Var. This is
- * equivalent to the clause reln.attribute = 't', so we
- * compute the selectivity as if that is what we have.
+ * equivalent to the clause reln.attribute = 't', so we compute
+ * the selectivity as if that is what we have.
*/
s1 = restriction_selectivity(root,
BooleanEqualOperator,
Selectivity *match_count,
bool *indexed_join_quals);
static double approx_tuple_count(PlannerInfo *root, JoinPath *path,
- List *quals);
+ List *quals);
static void set_rel_width(PlannerInfo *root, RelOptInfo *rel);
static double relation_byte_size(double tuples, int width);
static double page_size(double tuples, int width);
*
* Note: this is used for both self-reference and regular CTEs; the
* possible cost differences are below the threshold of what we could
- * estimate accurately anyway. Note that the costs of evaluating the
+ * estimate accurately anyway. Note that the costs of evaluating the
* referenced CTE query are added into the final plan as initplan costs,
* and should NOT be counted here.
*/
/*
* We arbitrarily assume that about 10 recursive iterations will be
- * needed, and that we've managed to get a good fix on the cost and
- * output size of each one of them. These are mighty shaky assumptions
- * but it's hard to see how to do better.
+ * needed, and that we've managed to get a good fix on the cost and output
+ * size of each one of them. These are mighty shaky assumptions but it's
+ * hard to see how to do better.
*/
total_cost += 10 * rterm->total_cost;
total_rows += 10 * rterm->plan_rows;
double outer_path_rows = PATH_ROWS(outer_path);
double inner_path_rows = nestloop_inner_path_rows(inner_path);
double ntuples;
- Selectivity outer_match_frac;
- Selectivity match_count;
+ Selectivity outer_match_frac;
+ Selectivity match_count;
bool indexed_join_quals;
if (!enable_nestloop)
&indexed_join_quals))
{
double outer_matched_rows;
- Selectivity inner_scan_frac;
+ Selectivity inner_scan_frac;
/*
* SEMI or ANTI join: executor will stop after first match.
/*
* For unmatched outer-rel rows, there are two cases. If the inner
- * path is an indexscan using all the joinquals as indexquals, then
- * an unmatched row results in an indexscan returning no rows, which
- * is probably quite cheap. We estimate this case as the same cost
- * to return the first tuple of a nonempty scan. Otherwise, the
- * executor will have to scan the whole inner rel; not so cheap.
+ * path is an indexscan using all the joinquals as indexquals, then an
+ * unmatched row results in an indexscan returning no rows, which is
+ * probably quite cheap. We estimate this case as the same cost to
+ * return the first tuple of a nonempty scan. Otherwise, the executor
+ * will have to scan the whole inner rel; not so cheap.
*/
if (indexed_join_quals)
{
qp_qual_cost.per_tuple -= merge_qual_cost.per_tuple;
/*
- * Get approx # tuples passing the mergequals. We use approx_tuple_count
+ * Get approx # tuples passing the mergequals. We use approx_tuple_count
* here because we need an estimate done with JOIN_INNER semantics.
*/
mergejointuples = approx_tuple_count(root, &path->jpath, mergeclauses);
* estimated approximately as size of merge join output minus size of
* inner relation. Assume that the distinct key values are 1, 2, ..., and
* denote the number of values of each key in the outer relation as m1,
- * m2, ...; in the inner relation, n1, n2, ... Then we have
+ * m2, ...; in the inner relation, n1, n2, ... Then we have
*
* size of join = m1 * n1 + m2 * n2 + ...
*
* (unless it's an outer join, in which case the outer side has to be
* scanned all the way anyway). Estimate fraction of the left and right
* inputs that will actually need to be scanned. Likewise, we can
- * estimate the number of rows that will be skipped before the first
- * join pair is found, which should be factored into startup cost.
- * We use only the first (most significant) merge clause for this purpose.
- * Since mergejoinscansel() is a fairly expensive computation, we cache
- * the results in the merge clause RestrictInfo.
+ * estimate the number of rows that will be skipped before the first join
+ * pair is found, which should be factored into startup cost. We use only
+ * the first (most significant) merge clause for this purpose. Since
+ * mergejoinscansel() is a fairly expensive computation, we cache the
+ * results in the merge clause RestrictInfo.
*/
if (mergeclauses && path->jpath.jointype != JOIN_FULL)
{
* clauses that are to be applied at the join. (This is pessimistic since
* not all of the quals may get evaluated at each tuple.)
*
- * Note: we could adjust for SEMI/ANTI joins skipping some qual evaluations
- * here, but it's probably not worth the trouble.
+ * Note: we could adjust for SEMI/ANTI joins skipping some qual
+ * evaluations here, but it's probably not worth the trouble.
*/
startup_cost += qp_qual_cost.startup;
cpu_per_tuple = cpu_tuple_cost + qp_qual_cost.per_tuple;
int num_skew_mcvs;
double virtualbuckets;
Selectivity innerbucketsize;
- Selectivity outer_match_frac;
- Selectivity match_count;
+ Selectivity outer_match_frac;
+ Selectivity match_count;
ListCell *hcl;
if (!enable_hashjoin)
*/
ExecChooseHashTableSize(inner_path_rows,
inner_path->parent->width,
- true, /* useskew */
+ true, /* useskew */
&numbuckets,
&numbatches,
&num_skew_mcvs);
virtualbuckets = (double) numbuckets *(double) numbatches;
+
/* mark the path with estimated # of batches */
path->num_batches = numbatches;
NULL))
{
double outer_matched_rows;
- Selectivity inner_scan_frac;
+ Selectivity inner_scan_frac;
/*
* SEMI or ANTI join: executor will stop after first match.
* preferentially hit heavily-populated buckets; instead assume they
* are uncorrelated with the inner distribution and so they see an
* average bucket size of inner_path_rows / virtualbuckets. In the
- * second place, it seems likely that they will have few if any
- * exact hash-code matches and so very few of the tuples in the
- * bucket will actually require eval of the hash quals. We don't
- * have any good way to estimate how many will, but for the moment
- * assume that the effective cost per bucket entry is one-tenth what
- * it is for matchable tuples.
+ * second place, it seems likely that they will have few if any exact
+ * hash-code matches and so very few of the tuples in the bucket will
+ * actually require eval of the hash quals. We don't have any good
+ * way to estimate how many will, but for the moment assume that the
+ * effective cost per bucket entry is one-tenth what it is for
+ * matchable tuples.
*/
run_cost += hash_qual_cost.per_tuple *
(outer_path_rows - outer_matched_rows) *
/*
* The per-tuple costs include the cost of evaluating the lefthand
* expressions, plus the cost of probing the hashtable. We already
- * accounted for the lefthand expressions as part of the testexpr,
- * and will also have counted one cpu_operator_cost for each
- * comparison operator. That is probably too low for the probing
- * cost, but it's hard to make a better estimate, so live with it for
- * now.
+ * accounted for the lefthand expressions as part of the testexpr, and
+ * will also have counted one cpu_operator_cost for each comparison
+ * operator. That is probably too low for the probing cost, but it's
+ * hard to make a better estimate, so live with it for now.
*/
}
else
{
/*
* Otherwise we will be rescanning the subplan output on each
- * evaluation. We need to estimate how much of the output we will
+ * evaluation. We need to estimate how much of the output we will
* actually need to scan. NOTE: this logic should agree with the
* tuple_fraction estimates used by make_subplan() in
* plan/subselect.c.
* Vars and Consts are charged zero, and so are boolean operators (AND,
* OR, NOT). Simplistic, but a lot better than no model at all.
*
- * Note that Aggref and WindowFunc nodes are (and should be) treated
- * like Vars --- whatever execution cost they have is absorbed into
- * plan-node-specific costing. As far as expression evaluation is
+ * Note that Aggref and WindowFunc nodes are (and should be) treated like
+ * Vars --- whatever execution cost they have is absorbed into
+ * plan-node-specific costing. As far as expression evaluation is
* concerned they're just like Vars.
*
* Should we try to account for the possibility of short-circuit
else if (IsA(node, AlternativeSubPlan))
{
/*
- * Arbitrarily use the first alternative plan for costing. (We should
+ * Arbitrarily use the first alternative plan for costing. (We should
* certainly only include one alternative, and we don't yet have
- * enough information to know which one the executor is most likely
- * to use.)
+ * enough information to know which one the executor is most likely to
+ * use.)
*/
AlternativeSubPlan *asplan = (AlternativeSubPlan *) node;
*/
/*
- * In an ANTI join, we must ignore clauses that are "pushed down",
- * since those won't affect the match logic. In a SEMI join, we do not
+ * In an ANTI join, we must ignore clauses that are "pushed down", since
+ * those won't affect the match logic. In a SEMI join, we do not
* distinguish joinquals from "pushed down" quals, so just use the whole
* restrictinfo list.
*/
/*
* jselec can be interpreted as the fraction of outer-rel rows that have
- * any matches (this is true for both SEMI and ANTI cases). And nselec
- * is the fraction of the Cartesian product that matches. So, the
- * average number of matches for each outer-rel row that has at least
- * one match is nselec * inner_rows / jselec.
+ * any matches (this is true for both SEMI and ANTI cases). And nselec is
+ * the fraction of the Cartesian product that matches. So, the average
+ * number of matches for each outer-rel row that has at least one match is
+ * nselec * inner_rows / jselec.
*
* Note: it is correct to use the inner rel's "rows" count here, not
* PATH_ROWS(), even if the inner path under consideration is an inner
- * indexscan. This is because we have included all the join clauses
- * in the selectivity estimate, even ones used in an inner indexscan.
+ * indexscan. This is because we have included all the join clauses in
+ * the selectivity estimate, even ones used in an inner indexscan.
*/
if (jselec > 0) /* protect against zero divide */
{
*match_count = avgmatch;
/*
- * If requested, check whether the inner path uses all the joinquals
- * as indexquals. (If that's true, we can assume that an unmatched
- * outer tuple is cheap to process, whereas otherwise it's probably
- * expensive.)
+ * If requested, check whether the inner path uses all the joinquals as
+ * indexquals. (If that's true, we can assume that an unmatched outer
+ * tuple is cheap to process, whereas otherwise it's probably expensive.)
*/
if (indexed_join_quals)
{
if (rte->self_reference)
{
/*
- * In a self-reference, arbitrarily assume the average worktable
- * size is about 10 times the nonrecursive term's size.
+ * In a self-reference, arbitrarily assume the average worktable size
+ * is about 10 times the nonrecursive term's size.
*/
rel->tuples = 10 * cteplan->plan_rows;
}
ndx = var->varattno - rel->min_attr;
/*
- * The width probably hasn't been cached yet, but may as well check
+ * The width probably hasn't been cached yet, but may as well
+ * check
*/
if (rel->attr_widths[ndx] > 0)
{
/*
* add_eq_member doesn't check for volatile functions, set-returning
- * functions, aggregates, or window functions, but such could appear
- * in sort expressions; so we have to check whether its const-marking
- * was correct.
+ * functions, aggregates, or window functions, but such could appear in
+ * sort expressions; so we have to check whether its const-marking was
+ * correct.
*/
if (newec->ec_has_const)
{
ListCell *lc;
/*
- * In the trivial case where we just had one "var = const" clause,
- * push the original clause back into the main planner machinery. There
- * is nothing to be gained by doing it differently, and we save the
- * effort to re-build and re-analyze an equality clause that will be
- * exactly equivalent to the old one.
+ * In the trivial case where we just had one "var = const" clause, push
+ * the original clause back into the main planner machinery. There is
+ * nothing to be gained by doing it differently, and we save the effort to
+ * re-build and re-analyze an equality clause that will be exactly
+ * equivalent to the old one.
*/
if (list_length(ec->ec_members) == 2 &&
list_length(ec->ec_sources) == 1)
*
* Outer join clauses that are marked outerjoin_delayed are special: this
* condition means that one or both VARs might go to null due to a lower
- * outer join. We can still push a constant through the clause, but only
+ * outer join. We can still push a constant through the clause, but only
* if its operator is strict; and we *have to* throw the clause back into
* regular joinclause processing. By keeping the strict join clause,
* we ensure that any null-extended rows that are mistakenly generated due
* path to look through ec_sources. Checking the members anyway is OK
* as a possibly-overoptimistic heuristic.
*
- * We don't test ec_has_const either, even though a const eclass
- * won't generate real join clauses. This is because if we had
- * "WHERE a.x = b.y and a.x = 42", it is worth considering a join
- * between a and b, since the join result is likely to be small even
- * though it'll end up being an unqualified nestloop.
+ * We don't test ec_has_const either, even though a const eclass won't
+ * generate real join clauses. This is because if we had "WHERE a.x =
+ * b.y and a.x = 42", it is worth considering a join between a and b,
+ * since the join result is likely to be small even though it'll end
+ * up being an unqualified nestloop.
*/
/* Needn't scan if it couldn't contain members from each rel */
* path to look through ec_sources. Checking the members anyway is OK
* as a possibly-overoptimistic heuristic.
*
- * We don't test ec_has_const either, even though a const eclass
- * won't generate real join clauses. This is because if we had
- * "WHERE a.x = b.y and a.x = 42", it is worth considering a join
- * between a and b, since the join result is likely to be small even
- * though it'll end up being an unqualified nestloop.
+ * We don't test ec_has_const either, even though a const eclass won't
+ * generate real join clauses. This is because if we had "WHERE a.x =
+ * b.y and a.x = 42", it is worth considering a join between a and b,
+ * since the join result is likely to be small even though it'll end
+ * up being an unqualified nestloop.
*/
/* Needn't scan if it couldn't contain members from each rel */
true, NULL, SAOP_FORBID, ST_ANYSCAN);
/*
- * Submit all the ones that can form plain IndexScan plans to add_path.
- * (A plain IndexPath always represents a plain IndexScan plan; however
- * some of the indexes might support only bitmap scans, and those we
- * mustn't submit to add_path here.) Also, pick out the ones that might
- * be useful as bitmap scans. For that, we must discard indexes that
- * don't support bitmap scans, and we also are only interested in paths
- * that have some selectivity; we should discard anything that was
- * generated solely for ordering purposes.
+ * Submit all the ones that can form plain IndexScan plans to add_path. (A
+ * plain IndexPath always represents a plain IndexScan plan; however some
+ * of the indexes might support only bitmap scans, and those we mustn't
+ * submit to add_path here.) Also, pick out the ones that might be useful
+ * as bitmap scans. For that, we must discard indexes that don't support
+ * bitmap scans, and we also are only interested in paths that have some
+ * selectivity; we should discard anything that was generated solely for
+ * ordering purposes.
*/
bitindexpaths = NIL;
foreach(l, indexpaths)
/*
* If it's a btree index, we can reject it if its opfamily isn't
- * compatible with the EC, since no clause generated from the
- * EC could be used with the index. For non-btree indexes,
- * we can't easily tell whether clauses generated from the EC
- * could be used with the index, so only check for expression
- * match. This might mean we return "true" for a useless index,
- * but that will just cause some wasted planner cycles; it's
- * better than ignoring useful indexes.
+ * compatible with the EC, since no clause generated from the EC
+ * could be used with the index. For non-btree indexes, we can't
+ * easily tell whether clauses generated from the EC could be used
+ * with the index, so only check for expression match. This might
+ * mean we return "true" for a useless index, but that will just
+ * cause some wasted planner cycles; it's better than ignoring
+ * useful indexes.
*/
if ((index->relam != BTREE_AM_OID ||
list_member_oid(ec->ec_opfamilies, curFamily)) &&
* want to apply. (A hash index, for example, will not support ">=".)
* Currently, only btree supports the operators we need.
*
- * Note: actually, in the Pattern_Prefix_Exact case, we only need "="
- * so a hash index would work. Currently it doesn't seem worth checking
- * for that, however.
+ * Note: actually, in the Pattern_Prefix_Exact case, we only need "=" so a
+ * hash index would work. Currently it doesn't seem worth checking for
+ * that, however.
*
* We insist on the opfamily being the specific one we expect, else we'd
* do the wrong thing if someone were to make a reverse-sort opfamily with
/*
* LIKE and regex operators are not members of any btree index opfamily,
* but they can be members of opfamilies for more exotic index types such
- * as GIN. Therefore, we should only do expansion if the operator is
+ * as GIN. Therefore, we should only do expansion if the operator is
* actually not in the opfamily. But checking that requires a syscache
* lookup, so it's best to first see if the operator is one we are
* interested in.
* Note: it would be bad if this condition failed for an otherwise
* mergejoinable FULL JOIN clause, since that would result in
* undesirable planner failure. I believe that is not possible
- * however; a variable involved in a full join could only appear
- * in below_outer_join eclasses, which aren't considered redundant.
+ * however; a variable involved in a full join could only appear in
+ * below_outer_join eclasses, which aren't considered redundant.
*
- * This case *can* happen for left/right join clauses: the
- * outer-side variable could be equated to a constant. Because we
- * will propagate that constant across the join clause, the loss of
- * ability to do a mergejoin is not really all that big a deal, and
- * so it's not clear that improving this is important.
+ * This case *can* happen for left/right join clauses: the outer-side
+ * variable could be equated to a constant. Because we will propagate
+ * that constant across the join clause, the loss of ability to do a
+ * mergejoin is not really all that big a deal, and so it's not clear
+ * that improving this is important.
*/
cache_mergeclause_eclasses(root, restrictinfo);
ListCell *l;
/*
- * Ensure output params are set on failure return. This is just to
+ * Ensure output params are set on failure return. This is just to
* suppress uninitialized-variable warnings from overly anal compilers.
*/
*sjinfo_p = NULL;
/*
* If we have any special joins, the proposed join might be illegal; and
- * in any case we have to determine its join type. Scan the join info
+ * in any case we have to determine its join type. Scan the join info
* list for conflicts.
*/
match_sjinfo = NULL;
/*
* If it's a plain inner join, then we won't have found anything in
- * join_info_list. Make up a SpecialJoinInfo so that selectivity
+ * join_info_list. Make up a SpecialJoinInfo so that selectivity
* estimation functions will know what's being joined.
*/
if (sjinfo == NULL)
&restrictlist);
/*
- * If we've already proven this join is empty, we needn't consider
- * any more paths for it.
+ * If we've already proven this join is empty, we needn't consider any
+ * more paths for it.
*/
if (is_dummy_rel(joinrel))
{
}
/*
- * Consider paths using each rel as both outer and inner. Depending
- * on the join type, a provably empty outer or inner rel might mean
- * the join is provably empty too; in which case throw away any
- * previously computed paths and mark the join as dummy. (We do it
- * this way since it's conceivable that dummy-ness of a multi-element
- * join might only be noticeable for certain construction paths.)
+ * Consider paths using each rel as both outer and inner. Depending on
+ * the join type, a provably empty outer or inner rel might mean the join
+ * is provably empty too; in which case throw away any previously computed
+ * paths and mark the join as dummy. (We do it this way since it's
+ * conceivable that dummy-ness of a multi-element join might only be
+ * noticeable for certain construction paths.)
*
* Also, a provably constant-false join restriction typically means that
- * we can skip evaluating one or both sides of the join. We do this
- * by marking the appropriate rel as dummy.
+ * we can skip evaluating one or both sides of the join. We do this by
+ * marking the appropriate rel as dummy.
*
- * We need only consider the jointypes that appear in join_info_list,
- * plus JOIN_INNER.
+ * We need only consider the jointypes that appear in join_info_list, plus
+ * JOIN_INNER.
*/
switch (sjinfo->jointype)
{
restrictlist);
break;
case JOIN_SEMI:
+
/*
* We might have a normal semijoin, or a case where we don't have
* enough rels to do the semijoin but can unique-ify the RHS and
*/
foreach(lc, restrictlist)
{
- RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
Assert(IsA(rinfo, RestrictInfo));
if (rinfo->clause && IsA(rinfo->clause, Const))
{
- Const *con = (Const *) rinfo->clause;
+ Const *con = (Const *) rinfo->clause;
/* constant NULL is as good as constant FALSE for our purposes */
if (con->constisnull)
* enforced at the relation scan level.
*
* We must also ignore clauses that are marked !is_pushed_down (ie they
- * are themselves outer-join clauses). It would be safe to extract an
+ * are themselves outer-join clauses). It would be safe to extract an
* index condition from such a clause if we are within the nullable rather
* than the non-nullable side of its join, but we haven't got enough
- * context here to tell which applies. OR clauses in outer-join quals
+ * context here to tell which applies. OR clauses in outer-join quals
* aren't exactly common, so we'll let that case go unoptimized for now.
*/
foreach(i, rel->joininfo)
static ValuesScan *create_valuesscan_plan(PlannerInfo *root, Path *best_path,
List *tlist, List *scan_clauses);
static CteScan *create_ctescan_plan(PlannerInfo *root, Path *best_path,
- List *tlist, List *scan_clauses);
+ List *tlist, List *scan_clauses);
static WorkTableScan *create_worktablescan_plan(PlannerInfo *root, Path *best_path,
- List *tlist, List *scan_clauses);
+ List *tlist, List *scan_clauses);
static NestLoop *create_nestloop_plan(PlannerInfo *root, NestPath *best_path,
Plan *outer_plan, Plan *inner_plan);
static MergeJoin *create_mergejoin_plan(PlannerInfo *root, MergePath *best_path,
static ValuesScan *make_valuesscan(List *qptlist, List *qpqual,
Index scanrelid, List *values_lists);
static CteScan *make_ctescan(List *qptlist, List *qpqual,
- Index scanrelid, int ctePlanId, int cteParam);
+ Index scanrelid, int ctePlanId, int cteParam);
static WorkTableScan *make_worktablescan(List *qptlist, List *qpqual,
- Index scanrelid, int wtParam);
+ Index scanrelid, int wtParam);
static BitmapAnd *make_bitmap_and(List *bitmapplans);
static BitmapOr *make_bitmap_or(List *bitmapplans);
static NestLoop *make_nestloop(List *tlist,
Plan *lefttree, Plan *righttree,
JoinType jointype);
static Hash *make_hash(Plan *lefttree,
- Oid skewTable,
- AttrNumber skewColumn,
- Oid skewColType,
- int32 skewColTypmod);
+ Oid skewTable,
+ AttrNumber skewColumn,
+ Oid skewColType,
+ int32 skewColTypmod);
static MergeJoin *make_mergejoin(List *tlist,
List *joinclauses, List *otherclauses,
List *mergeclauses,
foreach(v, rel->reltargetlist)
{
/* Do we really need to copy here? Not sure */
- Node *node = (Node *) copyObject(lfirst(v));
+ Node *node = (Node *) copyObject(lfirst(v));
tlist = lappend(tlist, makeTargetEntry((Expr *) node,
resno,
return subplan;
/*
- * As constructed, the subplan has a "flat" tlist containing just the
- * Vars needed here and at upper levels. The values we are supposed
- * to unique-ify may be expressions in these variables. We have to
- * add any such expressions to the subplan's tlist.
+ * As constructed, the subplan has a "flat" tlist containing just the Vars
+ * needed here and at upper levels. The values we are supposed to
+ * unique-ify may be expressions in these variables. We have to add any
+ * such expressions to the subplan's tlist.
*
- * The subplan may have a "physical" tlist if it is a simple scan plan.
- * If we're going to sort, this should be reduced to the regular tlist,
- * so that we don't sort more data than we need to. For hashing, the
- * tlist should be left as-is if we don't need to add any expressions;
- * but if we do have to add expressions, then a projection step will be
- * needed at runtime anyway, so we may as well remove unneeded items.
- * Therefore newtlist starts from build_relation_tlist() not just a
- * copy of the subplan's tlist; and we don't install it into the subplan
- * unless we are sorting or stuff has to be added.
+ * The subplan may have a "physical" tlist if it is a simple scan plan. If
+ * we're going to sort, this should be reduced to the regular tlist, so
+ * that we don't sort more data than we need to. For hashing, the tlist
+ * should be left as-is if we don't need to add any expressions; but if we
+ * do have to add expressions, then a projection step will be needed at
+ * runtime anyway, so we may as well remove unneeded items. Therefore
+ * newtlist starts from build_relation_tlist() not just a copy of the
+ * subplan's tlist; and we don't install it into the subplan unless we are
+ * sorting or stuff has to be added.
*/
in_operators = best_path->in_operators;
uniq_exprs = best_path->uniq_exprs;
qpqual = order_qual_clauses(root, qpqual);
/*
- * When dealing with special operators, we will at this point
- * have duplicate clauses in qpqual and bitmapqualorig. We may as well
- * drop 'em from bitmapqualorig, since there's no point in making the
- * tests twice.
+ * When dealing with special operators, we will at this point have
+ * duplicate clauses in qpqual and bitmapqualorig. We may as well drop
+ * 'em from bitmapqualorig, since there's no point in making the tests
+ * twice.
*/
bitmapqualorig = list_difference_ptr(bitmapqualorig, qpqual);
create_ctescan_plan(PlannerInfo *root, Path *best_path,
List *tlist, List *scan_clauses)
{
- CteScan *scan_plan;
+ CteScan *scan_plan;
Index scan_relid = best_path->parent->relid;
RangeTblEntry *rte;
- SubPlan *ctesplan = NULL;
+ SubPlan *ctesplan = NULL;
int plan_id;
int cte_param_id;
PlannerInfo *cteroot;
if (!cteroot) /* shouldn't happen */
elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
}
+
/*
* Note: cte_plan_ids can be shorter than cteList, if we are still working
* on planning the CTEs (ie, this is a side-reference from another CTE).
elog(ERROR, "could not find plan for CTE \"%s\"", rte->ctename);
/*
- * We need the CTE param ID, which is the sole member of the
- * SubPlan's setParam list.
+ * We need the CTE param ID, which is the sole member of the SubPlan's
+ * setParam list.
*/
cte_param_id = linitial_int(ctesplan->setParam);
/*
* We need to find the worktable param ID, which is in the plan level
- * that's processing the recursive UNION, which is one level *below*
- * where the CTE comes from.
+ * that's processing the recursive UNION, which is one level *below* where
+ * the CTE comes from.
*/
levelsup = rte->ctelevelsup;
if (levelsup == 0) /* shouldn't happen */
- elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
+ elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
levelsup--;
cteroot = root;
while (levelsup-- > 0)
if (!cteroot) /* shouldn't happen */
elog(ERROR, "bad levelsup for CTE \"%s\"", rte->ctename);
}
- if (cteroot->wt_param_id < 0) /* shouldn't happen */
+ if (cteroot->wt_param_id < 0) /* shouldn't happen */
elog(ERROR, "could not find param ID for CTE \"%s\"", rte->ctename);
/* Sort clauses into best execution order */
NestLoop *join_plan;
/*
- * If the inner path is a nestloop inner indexscan, it might be using
- * some of the join quals as index quals, in which case we don't have
- * to check them again at the join node. Remove any join quals that
- * are redundant.
+ * If the inner path is a nestloop inner indexscan, it might be using some
+ * of the join quals as index quals, in which case we don't have to check
+ * them again at the join node. Remove any join quals that are redundant.
*/
joinrestrictclauses =
select_nonredundant_join_clauses(root,
disuse_physical_tlist(outer_plan, best_path->jpath.outerjoinpath);
/*
- * If there is a single join clause and we can identify the outer
- * variable as a simple column reference, supply its identity for
- * possible use in skew optimization. (Note: in principle we could
- * do skew optimization with multiple join clauses, but we'd have to
- * be able to determine the most common combinations of outer values,
- * which we don't currently have enough stats for.)
+ * If there is a single join clause and we can identify the outer variable
+ * as a simple column reference, supply its identity for possible use in
+ * skew optimization. (Note: in principle we could do skew optimization
+ * with multiple join clauses, but we'd have to be able to determine the
+ * most common combinations of outer values, which we don't currently have
+ * enough stats for.)
*/
if (list_length(hashclauses) == 1)
{
node = (Node *) ((RelabelType *) node)->arg;
if (IsA(node, Var))
{
- Var *var = (Var *) node;
+ Var *var = (Var *) node;
RangeTblEntry *rte;
rte = root->simple_rte_array[var->varno];
/* Never need to commute... */
/*
- * Determine which index attribute this is and change the
- * indexkey operand as needed.
+ * Determine which index attribute this is and change the indexkey
+ * operand as needed.
*/
linitial(saop->args) = fix_indexqual_operand(linitial(saop->args),
index);
int ctePlanId,
int cteParam)
{
- CteScan *node = makeNode(CteScan);
+ CteScan *node = makeNode(CteScan);
Plan *plan = &node->scan.plan;
/* cost should be inserted by caller */
{
WindowAgg *node = makeNode(WindowAgg);
Plan *plan = &node->plan;
- Path windowagg_path; /* dummy for result of cost_windowagg */
+ Path windowagg_path; /* dummy for result of cost_windowagg */
QualCost qual_cost;
node->winref = winref;
node->ordOperators = ordOperators;
node->frameOptions = frameOptions;
- copy_plan_costsize(plan, lefttree); /* only care about copying size */
+ copy_plan_costsize(plan, lefttree); /* only care about copying size */
cost_windowagg(&windowagg_path, root,
numWindowFuncs, partNumCols, ordNumCols,
lefttree->startup_cost,
*/
foreach(l, (List *) f->quals)
{
- Node *qual = (Node *) lfirst(l);
+ Node *qual = (Node *) lfirst(l);
distribute_qual_to_rels(root, qual,
false, below_outer_join, JOIN_INNER,
* we mustn't add it to join_info_list just yet, because we don't want
* distribute_qual_to_rels to think it is an outer join below us.
*
- * Semijoins are a bit of a hybrid: we build a SpecialJoinInfo,
- * but we want ojscope = NULL for distribute_qual_to_rels.
+ * Semijoins are a bit of a hybrid: we build a SpecialJoinInfo, but we
+ * want ojscope = NULL for distribute_qual_to_rels.
*/
if (j->jointype != JOIN_INNER)
{
/* Process the qual clauses */
foreach(l, (List *) j->quals)
{
- Node *qual = (Node *) lfirst(l);
+ Node *qual = (Node *) lfirst(l);
distribute_qual_to_rels(root, qual,
false, below_outer_join, j->jointype,
* min_lefthand. (We must use its full syntactic relset, not just its
* min_lefthand + min_righthand. This is because there might be other
* OJs below this one that this one can commute with, but we cannot
- * commute with them if we don't with this one.) Also, if the
- * current join is an antijoin, we must preserve ordering regardless
- * of strictness.
+ * commute with them if we don't with this one.) Also, if the current
+ * join is an antijoin, we must preserve ordering regardless of
+ * strictness.
*
* Note: I believe we have to insist on being strict for at least one
* rel in the lower OJ's min_righthand, not its whole syn_righthand.
* We can't use such a clause to deduce equivalence (the left and
* right sides might be unequal above the join because one of them has
* gone to NULL) ... but we might be able to use it for more limited
- * deductions, if it is mergejoinable. So consider adding it to the
+ * deductions, if it is mergejoinable. So consider adding it to the
* lists of set-aside outer-join clauses.
*/
is_pushed_down = false;
/*
* It's possible that this is an IS NULL clause that's redundant
* with a lower antijoin; if so we can just discard it. We need
- * not test in any of the other cases, because this will only
- * be possible for pushed-down, delayed clauses.
+ * not test in any of the other cases, because this will only be
+ * possible for pushed-down, delayed clauses.
*/
if (check_redundant_nullability_qual(root, clause))
return;
*/
static bool
check_outerjoin_delay(PlannerInfo *root,
- Relids *relids_p, /* in/out parameter */
- Relids *nullable_relids_p, /* output parameter */
+ Relids *relids_p, /* in/out parameter */
+ Relids *nullable_relids_p, /* output parameter */
bool is_pushed_down)
{
Relids relids;
forced_null_rel = forced_null_var->varno;
/*
- * If the Var comes from the nullable side of a lower antijoin, the
- * IS NULL condition is necessarily true.
+ * If the Var comes from the nullable side of a lower antijoin, the IS
+ * NULL condition is necessarily true.
*/
foreach(lc, root->join_info_list)
{
true, /* is_pushed_down */
false, /* outerjoin_delayed */
false, /* pseudoconstant */
- qualscope, /* required_relids */
+ qualscope, /* required_relids */
NULL); /* nullable_relids */
/* Set mergejoinability info always, and hashjoinability if enabled */
* Reject unoptimizable cases.
*
* We don't handle GROUP BY or windowing, because our current
- * implementations of grouping require looking at all the rows anyway,
- * and so there's not much point in optimizing MIN/MAX.
+ * implementations of grouping require looking at all the rows anyway, and
+ * so there's not much point in optimizing MIN/MAX.
*/
if (parse->groupClause || parse->hasWindowFuncs)
return NULL;
&aggs_list);
/*
- * We have to replace Aggrefs with Params in equivalence classes too,
- * else ORDER BY or DISTINCT on an optimized aggregate will fail.
+ * We have to replace Aggrefs with Params in equivalence classes too, else
+ * ORDER BY or DISTINCT on an optimized aggregate will fail.
*
- * Note: at some point it might become necessary to mutate other
- * data structures too, such as the query's sortClause or distinctClause.
- * Right now, those won't be examined after this point.
+ * Note: at some point it might become necessary to mutate other data
+ * structures too, such as the query's sortClause or distinctClause. Right
+ * now, those won't be examined after this point.
*/
mutate_eclass_expressions(root,
replace_aggs_with_params_mutator,
/*
* If both GROUP BY and ORDER BY are specified, we will need two
* levels of sort --- and, therefore, certainly need to read all the
- * tuples --- unless ORDER BY is a subset of GROUP BY. Likewise if
- * we have both DISTINCT and GROUP BY, or if we have a window
+ * tuples --- unless ORDER BY is a subset of GROUP BY. Likewise if we
+ * have both DISTINCT and GROUP BY, or if we have a window
* specification not compatible with the GROUP BY.
*/
if (!pathkeys_contained_in(root->sort_pathkeys, root->group_pathkeys) ||
!pathkeys_contained_in(root->distinct_pathkeys, root->group_pathkeys) ||
- !pathkeys_contained_in(root->window_pathkeys, root->group_pathkeys))
+ !pathkeys_contained_in(root->window_pathkeys, root->group_pathkeys))
tuple_fraction = 0.0;
}
else if (parse->hasAggs || root->hasHavingQual)
/* GUC parameter */
-double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION;
+double cursor_tuple_fraction = DEFAULT_CURSOR_TUPLE_FRACTION;
/* Hook for plugins to get control in planner() */
planner_hook_type planner_hook = NULL;
static List *postprocess_setop_tlist(List *new_tlist, List *orig_tlist);
static List *select_active_windows(PlannerInfo *root, WindowFuncLists *wflists);
static List *add_volatile_sort_exprs(List *window_tlist, List *tlist,
- List *activeWindows);
+ List *activeWindows);
static List *make_pathkeys_for_window(PlannerInfo *root, WindowClause *wc,
- List *tlist, bool canonicalize);
+ List *tlist, bool canonicalize);
static void get_column_info_for_window(PlannerInfo *root, WindowClause *wc,
- List *tlist,
- int numSortCols, AttrNumber *sortColIdx,
- int *partNumCols,
- AttrNumber **partColIdx,
- Oid **partOperators,
- int *ordNumCols,
- AttrNumber **ordColIdx,
- Oid **ordOperators);
+ List *tlist,
+ int numSortCols, AttrNumber *sortColIdx,
+ int *partNumCols,
+ AttrNumber **partColIdx,
+ Oid **partOperators,
+ int *ordNumCols,
+ AttrNumber **ordColIdx,
+ Oid **ordOperators);
/*****************************************************************************
tuple_fraction = cursor_tuple_fraction;
/*
- * We document cursor_tuple_fraction as simply being a fraction,
- * which means the edge cases 0 and 1 have to be treated specially
- * here. We convert 1 to 0 ("all the tuples") and 0 to a very small
- * fraction.
+ * We document cursor_tuple_fraction as simply being a fraction, which
+ * means the edge cases 0 and 1 have to be treated specially here. We
+ * convert 1 to 0 ("all the tuples") and 0 to a very small fraction.
*/
if (tuple_fraction >= 1.0)
tuple_fraction = 0.0;
root->non_recursive_plan = NULL;
/*
- * If there is a WITH list, process each WITH query and build an
- * initplan SubPlan structure for it.
+ * If there is a WITH list, process each WITH query and build an initplan
+ * SubPlan structure for it.
*/
if (parse->cteList)
SS_process_ctes(root);
pull_up_sublinks(root);
/*
- * Scan the rangetable for set-returning functions, and inline them
- * if possible (producing subqueries that might get pulled up next).
+ * Scan the rangetable for set-returning functions, and inline them if
+ * possible (producing subqueries that might get pulled up next).
* Recursion issues here are handled in the same way as for SubLinks.
*/
inline_set_returning_functions(root);
/*
* Detect whether any rangetable entries are RTE_JOIN kind; if not, we can
* avoid the expense of doing flatten_join_alias_vars(). Also check for
- * outer joins --- if none, we can skip reduce_outer_joins().
- * This must be done after we have done pull_up_subqueries, of course.
+ * outer joins --- if none, we can skip reduce_outer_joins(). This must be
+ * done after we have done pull_up_subqueries, of course.
*/
root->hasJoinRTEs = false;
hasOuterJoins = false;
* Simplify constant expressions.
*
* Note: one essential effect here is to insert the current actual values
- * of any default arguments for functions. To ensure that happens, we
+ * of any default arguments for functions. To ensure that happens, we
* *must* process all expressions here. Previous PG versions sometimes
* skipped const-simplification if it didn't seem worth the trouble, but
* we can't do that anymore.
/*
* If there's a top-level ORDER BY, assume we have to fetch all the
* tuples. This might be too simplistic given all the hackery below
- * to possibly avoid the sort; but the odds of accurate estimates
- * here are pretty low anyway.
+ * to possibly avoid the sort; but the odds of accurate estimates here
+ * are pretty low anyway.
*/
if (parse->sortClause)
tuple_fraction = 0.0;
/*
* Calculate pathkeys that represent grouping/ordering requirements.
* Stash them in PlannerInfo so that query_planner can canonicalize
- * them after EquivalenceClasses have been formed. The sortClause
- * is certainly sort-able, but GROUP BY and DISTINCT might not be,
- * in which case we just leave their pathkeys empty.
+ * them after EquivalenceClasses have been formed. The sortClause is
+ * certainly sort-able, but GROUP BY and DISTINCT might not be, in
+ * which case we just leave their pathkeys empty.
*/
if (parse->groupClause &&
grouping_is_sortable(parse->groupClause))
* Note: if we have both ORDER BY and GROUP BY, and ORDER BY is a
* superset of GROUP BY, it would be tempting to request sort by ORDER
* BY --- but that might just leave us failing to exploit an available
- * sort order at all. Needs more thought. The choice for DISTINCT
+ * sort order at all. Needs more thought. The choice for DISTINCT
* versus ORDER BY is much easier, since we know that the parser
* ensured that one is a superset of the other.
*/
*/
if (parse->groupClause)
{
- bool can_hash;
- bool can_sort;
+ bool can_hash;
+ bool can_sort;
/*
* Executor doesn't support hashed aggregation with DISTINCT
- * aggregates. (Doing so would imply storing *all* the input
+ * aggregates. (Doing so would imply storing *all* the input
* values in the hash table, which seems like a certain loser.)
*/
can_hash = (agg_counts.numDistinctAggs == 0 &&
* Normal case --- create a plan according to query_planner's
* results.
*/
- bool need_sort_for_grouping = false;
+ bool need_sort_for_grouping = false;
result_plan = create_plan(root, best_path);
current_pathkeys = best_path->pathkeys;
/* Detect if we'll need an explicit sort for grouping */
if (parse->groupClause && !use_hashed_grouping &&
- !pathkeys_contained_in(root->group_pathkeys, current_pathkeys))
+ !pathkeys_contained_in(root->group_pathkeys, current_pathkeys))
{
need_sort_for_grouping = true;
+
/*
* Always override query_planner's tlist, so that we don't
* sort useless data from a "physical" tlist.
} /* end of non-minmax-aggregate case */
/*
- * Since each window function could require a different sort order,
- * we stack up a WindowAgg node for each window, with sort steps
- * between them as needed.
+ * Since each window function could require a different sort order, we
+ * stack up a WindowAgg node for each window, with sort steps between
+ * them as needed.
*/
if (activeWindows)
{
/*
* If the top-level plan node is one that cannot do expression
- * evaluation, we must insert a Result node to project the
- * desired tlist. (In some cases this might not really be
- * required, but it's not worth trying to avoid it.) Note that
- * on second and subsequent passes through the following loop,
- * the top-level node will be a WindowAgg which we know can
- * project; so we only need to check once.
+ * evaluation, we must insert a Result node to project the desired
+ * tlist. (In some cases this might not really be required, but
+ * it's not worth trying to avoid it.) Note that on second and
+ * subsequent passes through the following loop, the top-level
+ * node will be a WindowAgg which we know can project; so we only
+ * need to check once.
*/
if (!is_projection_capable_plan(result_plan))
{
}
/*
- * The "base" targetlist for all steps of the windowing process
- * is a flat tlist of all Vars and Aggs needed in the result.
- * (In some cases we wouldn't need to propagate all of these
- * all the way to the top, since they might only be needed as
- * inputs to WindowFuncs. It's probably not worth trying to
- * optimize that though.) We also need any volatile sort
- * expressions, because make_sort_from_pathkeys won't add those
- * on its own, and anyway we want them evaluated only once at
- * the bottom of the stack. As we climb up the stack, we add
- * outputs for the WindowFuncs computed at each level. Also,
- * each input tlist has to present all the columns needed to
- * sort the data for the next WindowAgg step. That's handled
- * internally by make_sort_from_pathkeys, but we need the
- * copyObject steps here to ensure that each plan node has
- * a separately modifiable tlist.
+ * The "base" targetlist for all steps of the windowing process is
+ * a flat tlist of all Vars and Aggs needed in the result. (In
+ * some cases we wouldn't need to propagate all of these all the
+ * way to the top, since they might only be needed as inputs to
+ * WindowFuncs. It's probably not worth trying to optimize that
+ * though.) We also need any volatile sort expressions, because
+ * make_sort_from_pathkeys won't add those on its own, and anyway
+ * we want them evaluated only once at the bottom of the stack.
+ * As we climb up the stack, we add outputs for the WindowFuncs
+ * computed at each level. Also, each input tlist has to present
+ * all the columns needed to sort the data for the next WindowAgg
+ * step. That's handled internally by make_sort_from_pathkeys,
+ * but we need the copyObject steps here to ensure that each plan
+ * node has a separately modifiable tlist.
*/
window_tlist = flatten_tlist(tlist);
if (parse->hasAggs)
{
/* Add the current WindowFuncs to the running tlist */
window_tlist = add_to_flat_tlist(window_tlist,
- wflists->windowFuncs[wc->winref]);
+ wflists->windowFuncs[wc->winref]);
}
else
{
result_plan = (Plan *)
make_windowagg(root,
(List *) copyObject(window_tlist),
- list_length(wflists->windowFuncs[wc->winref]),
+ list_length(wflists->windowFuncs[wc->winref]),
wc->winref,
partNumCols,
partColIdx,
*/
if (parse->distinctClause)
{
- double dNumDistinctRows;
- long numDistinctRows;
- bool use_hashed_distinct;
- bool can_sort;
- bool can_hash;
+ double dNumDistinctRows;
+ long numDistinctRows;
+ bool use_hashed_distinct;
+ bool can_sort;
+ bool can_hash;
/*
* If there was grouping or aggregation, use the current number of
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("could not implement DISTINCT"),
errdetail("Some of the datatypes only support hashing, while others only support sorting.")));
- use_hashed_distinct = false; /* keep compiler quiet */
+ use_hashed_distinct = false; /* keep compiler quiet */
}
}
result_plan->targetlist,
NIL,
AGG_HASHED,
- list_length(parse->distinctClause),
- extract_grouping_cols(parse->distinctClause,
- result_plan->targetlist),
- extract_grouping_ops(parse->distinctClause),
+ list_length(parse->distinctClause),
+ extract_grouping_cols(parse->distinctClause,
+ result_plan->targetlist),
+ extract_grouping_ops(parse->distinctClause),
numDistinctRows,
0,
result_plan);
* rigorous of DISTINCT and ORDER BY, to avoid a second sort
* below. However, for regular DISTINCT, don't sort now if we
* don't have to --- sorting afterwards will likely be cheaper,
- * and also has the possibility of optimizing via LIMIT. But
- * for DISTINCT ON, we *must* force the final sort now, else
- * it won't have the desired behavior.
+ * and also has the possibility of optimizing via LIMIT. But for
+ * DISTINCT ON, we *must* force the final sort now, else it won't
+ * have the desired behavior.
*/
- List *needed_pathkeys;
+ List *needed_pathkeys;
if (parse->hasDistinctOn &&
list_length(root->distinct_pathkeys) <
result_plan = (Plan *) make_sort_from_pathkeys(root,
result_plan,
- current_pathkeys,
+ current_pathkeys,
-1.0);
}
{
result_plan = (Plan *) make_sort_from_pathkeys(root,
result_plan,
- root->sort_pathkeys,
+ root->sort_pathkeys,
limit_tuples);
current_pathkeys = root->sort_pathkeys;
}
return;
/*
- * Add any remaining GROUP BY items to the new list, but only if we
- * were able to make a complete match. In other words, we only
- * rearrange the GROUP BY list if the result is that one list is a
- * prefix of the other --- otherwise there's no possibility of a
- * common sort. Also, give up if there are any non-sortable GROUP BY
- * items, since then there's no hope anyway.
+ * Add any remaining GROUP BY items to the new list, but only if we were
+ * able to make a complete match. In other words, we only rearrange the
+ * GROUP BY list if the result is that one list is a prefix of the other
+ * --- otherwise there's no possibility of a common sort. Also, give up
+ * if there are any non-sortable GROUP BY items, since then there's no
+ * hope anyway.
*/
foreach(gl, parse->groupClause)
{
/*
* When we have both GROUP BY and DISTINCT, use the more-rigorous of
- * DISTINCT and ORDER BY as the assumed required output sort order.
- * This is an oversimplification because the DISTINCT might get
- * implemented via hashing, but it's not clear that the case is common
- * enough (or that our estimates are good enough) to justify trying to
- * solve it exactly.
+ * DISTINCT and ORDER BY as the assumed required output sort order. This
+ * is an oversimplification because the DISTINCT might get implemented via
+ * hashing, but it's not clear that the case is common enough (or that our
+ * estimates are good enough) to justify trying to solve it exactly.
*/
if (list_length(root->distinct_pathkeys) >
list_length(root->sort_pathkeys))
* differences that it doesn't seem worth trying to unify the two functions.
*
* But note that making the two choices independently is a bit bogus in
- * itself. If the two could be combined into a single choice operation
+ * itself. If the two could be combined into a single choice operation
* it'd probably be better, but that seems far too unwieldy to be practical,
* especially considering that the combination of GROUP BY and DISTINCT
* isn't very common in real queries. By separating them, we are giving
* comparison.
*
* We need to consider input_plan + hashagg [+ final sort] versus
- * input_plan [+ sort] + group [+ final sort] where brackets indicate
- * a step that may not be needed.
+ * input_plan [+ sort] + group [+ final sort] where brackets indicate a
+ * step that may not be needed.
*
* These path variables are dummies that just hold cost fields; we don't
* make actual Paths for these steps.
numDistinctCols, dNumDistinctRows,
input_plan->startup_cost, input_plan->total_cost,
input_plan->plan_rows);
+
/*
- * Result of hashed agg is always unsorted, so if ORDER BY is present
- * we need to charge for the final sort.
+ * Result of hashed agg is always unsorted, so if ORDER BY is present we
+ * need to charge for the final sort.
*/
if (root->parse->sortClause)
cost_sort(&hashed_p, root, root->sort_pathkeys, hashed_p.total_cost,
dNumDistinctRows, input_plan->plan_width, limit_tuples);
/*
- * Now for the GROUP case. See comments in grouping_planner about the
+ * Now for the GROUP case. See comments in grouping_planner about the
* sorting choices here --- this code should match that code.
*/
sorted_p.startup_cost = input_plan->startup_cost;
* are otherwise distinct (eg, different names or framing clauses).
*
* There is room to be much smarter here, for example detecting whether
- * one window's sort keys are a prefix of another's (so that sorting
- * for the latter would do for the former), or putting windows first
- * that match a sort order available for the underlying query. For the
- * moment we are content with meeting the spec.
+ * one window's sort keys are a prefix of another's (so that sorting for
+ * the latter would do for the former), or putting windows first that
+ * match a sort order available for the underlying query. For the moment
+ * we are content with meeting the spec.
*/
result = NIL;
while (actives != NIL)
}
/*
- * Now scan the original tlist to find the referenced expressions.
- * Any that are volatile must be added to window_tlist.
+ * Now scan the original tlist to find the referenced expressions. Any
+ * that are volatile must be added to window_tlist.
*
- * Note: we know that the input window_tlist contains no items marked
- * with ressortgrouprefs, so we don't have to worry about collisions
- * of the reference numbers.
+ * Note: we know that the input window_tlist contains no items marked with
+ * ressortgrouprefs, so we don't have to worry about collisions of the
+ * reference numbers.
*/
foreach(lc, tlist)
{
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("could not implement window ORDER BY"),
- errdetail("Window ordering columns must be of sortable datatypes.")));
+ errdetail("Window ordering columns must be of sortable datatypes.")));
/* Okay, make the combined pathkeys */
window_sortclauses = list_concat(list_copy(wc->partitionClause),
* This depends on the behavior of make_pathkeys_for_window()!
*
* We are given the target WindowClause and an array of the input column
- * numbers associated with the resulting pathkeys. In the easy case, there
+ * numbers associated with the resulting pathkeys. In the easy case, there
* are the same number of pathkey columns as partitioning + ordering columns
* and we just have to copy some data around. However, it's possible that
* some of the original partitioning + ordering columns were eliminated as
* though the parser gets rid of obvious duplicates. A typical scenario is a
* window specification "PARTITION BY x ORDER BY y" coupled with a clause
* "WHERE x = y" that causes the two sort columns to be recognized as
- * redundant.) In that unusual case, we have to work a lot harder to
+ * redundant.) In that unusual case, we have to work a lot harder to
* determine which keys are significant.
*
* The method used here is a bit brute-force: add the sort columns to a list
- * one at a time and note when the resulting pathkey list gets longer. But
+ * one at a time and note when the resulting pathkey list gets longer. But
* it's a sufficiently uncommon case that a faster way doesn't seem worth
* the amount of code refactoring that'd be needed.
*----------
* Currently, we disallow sublinks in standalone expressions, so there's no
* real "planning" involved here. (That might not always be true though.)
* What we must do is run eval_const_expressions to ensure that any function
- * default arguments get inserted. The fact that constant subexpressions
+ * default arguments get inserted. The fact that constant subexpressions
* get simplified is a side-effect that is useful when the expression will
* get evaluated more than once. Also, we must fix operator function IDs.
*
fix_upper_expr_context *context);
static bool fix_opfuncids_walker(Node *node, void *context);
static bool extract_query_dependencies_walker(Node *node,
- PlannerGlobal *context);
+ PlannerGlobal *context);
/*****************************************************************************
break;
case T_CteScan:
{
- CteScan *splan = (CteScan *) plan;
+ CteScan *splan = (CteScan *) plan;
splan->scan.scanrelid += rtoffset;
splan->scan.plan.targetlist =
{
set_sa_opfuncid((ScalarArrayOpExpr *) node);
record_plan_function_dependency(glob,
- ((ScalarArrayOpExpr *) node)->opfuncid);
+ ((ScalarArrayOpExpr *) node)->opfuncid);
}
else if (IsA(node, ArrayCoerceExpr))
{
if (OidIsValid(((ArrayCoerceExpr *) node)->elemfuncid))
record_plan_function_dependency(glob,
- ((ArrayCoerceExpr *) node)->elemfuncid);
+ ((ArrayCoerceExpr *) node)->elemfuncid);
}
else if (IsA(node, Const))
{
* If rtoffset == 0, we don't need to change any Vars, and if there
* are no placeholders anywhere we won't need to remove them. Then
* it's OK to just scribble on the input node tree instead of copying
- * (since the only change, filling in any unset opfuncid fields,
- * is harmless). This saves just enough cycles to be noticeable on
+ * (since the only change, filling in any unset opfuncid fields, is
+ * harmless). This saves just enough cycles to be noticeable on
* trivial queries.
*/
(void) fix_scan_expr_walker(node, &context);
* entries, while leaving result-rel Vars as-is.
*
* PlaceHolderVars will also be sought in the targetlist, but no
- * more-complex expressions will be. Note that it is not possible for
- * a PlaceHolderVar to refer to the result relation, since the result
- * is never below an outer join. If that case could happen, we'd have
- * to be prepared to pick apart the PlaceHolderVar and evaluate its
- * contained expression instead.
+ * more-complex expressions will be. Note that it is not possible for a
+ * PlaceHolderVar to refer to the result relation, since the result is
+ * never below an outer join. If that case could happen, we'd have to be
+ * prepared to pick apart the PlaceHolderVar and evaluate its contained
+ * expression instead.
*/
itlist = build_tlist_index_other_vars(topplan->targetlist, resultRelation);
* we just assume they'll never change (or at least not in ways that'd
* invalidate plans using them). For this purpose we can consider a
* built-in function to be one with OID less than FirstBootstrapObjectId.
- * Note that the OID generator guarantees never to generate such an
- * OID after startup, even at OID wraparound.
+ * Note that the OID generator guarantees never to generate such an OID
+ * after startup, even at OID wraparound.
*/
if (funcid >= (Oid) FirstBootstrapObjectId)
{
SubLinkType subLinkType, Node *testexpr,
bool adjust_testexpr, bool unknownEqFalse);
static List *generate_subquery_params(PlannerInfo *root, List *tlist,
- List **paramIds);
+ List **paramIds);
static List *generate_subquery_vars(PlannerInfo *root, List *tlist,
- Index varno);
+ Index varno);
static Node *convert_testexpr(PlannerInfo *root,
Node *testexpr,
List *subst_nodes);
* path/costsize.c.
*
* XXX If an ANY subplan is uncorrelated, build_subplan may decide to hash
- * its output. In that case it would've been better to specify full
+ * its output. In that case it would've been better to specify full
* retrieval. At present, however, we can only check hashability after
* we've made the subplan :-(. (Determining whether it'll fit in work_mem
* is the really hard part.) Therefore, we don't want to be too
/*
* If it's a correlated EXISTS with an unimportant targetlist, we might be
* able to transform it to the equivalent of an IN and then implement it
- * by hashing. We don't have enough information yet to tell which way
- * is likely to be better (it depends on the expected number of executions
- * of the EXISTS qual, and we are much too early in planning the outer
- * query to be able to guess that). So we generate both plans, if
- * possible, and leave it to the executor to decide which to use.
+ * by hashing. We don't have enough information yet to tell which way is
+ * likely to be better (it depends on the expected number of executions of
+ * the EXISTS qual, and we are much too early in planning the outer query
+ * to be able to guess that). So we generate both plans, if possible, and
+ * leave it to the executor to decide which to use.
*/
if (simple_exists && IsA(result, SubPlan))
{
/* Now we can check if it'll fit in work_mem */
if (subplan_is_hashable(plan))
{
- SubPlan *hashplan;
+ SubPlan *hashplan;
AlternativeSubPlan *asplan;
/* OK, convert to SubPlan format. */
if (pitem->abslevel == root->query_level)
{
- Node *arg;
+ Node *arg;
/*
* The Var or Aggref has already been adjusted to have the correct
arg = copyObject(pitem->item);
/*
- * If it's an Aggref, its arguments might contain SubLinks,
- * which have not yet been processed. Do that now.
+ * If it's an Aggref, its arguments might contain SubLinks, which
+ * have not yet been processed. Do that now.
*/
if (IsA(arg, Aggref))
arg = SS_process_sublinks(root, arg, false);
/*
* convert_testexpr: convert the testexpr given by the parser into
* actually executable form. This entails replacing PARAM_SUBLINK Params
- * with Params or Vars representing the results of the sub-select. The
+ * with Params or Vars representing the results of the sub-select. The
* nodes to be substituted are passed in as the List result from
* generate_subquery_params or generate_subquery_vars.
*
testexpr_is_hashable(Node *testexpr)
{
/*
- * The testexpr must be a single OpExpr, or an AND-clause containing
- * only OpExprs.
+ * The testexpr must be a single OpExpr, or an AND-clause containing only
+ * OpExprs.
*
* The combining operators must be hashable and strict. The need for
* hashability is obvious, since we want to use hashing. Without
}
/*
- * Copy the source Query node. Probably not necessary, but let's
- * keep this similar to make_subplan.
+ * Copy the source Query node. Probably not necessary, but let's keep
+ * this similar to make_subplan.
*/
subquery = (Query *) copyObject(cte->ctequery);
&subroot);
/*
- * Make a SubPlan node for it. This is just enough unlike
+ * Make a SubPlan node for it. This is just enough unlike
* build_subplan that we can't share code.
*
* Note plan_id, plan_name, and cost fields are set further down.
/*
* Make parParam and args lists of param IDs and expressions that
- * current query level will pass to this child plan. Even though
- * this is an initplan, there could be side-references to earlier
+ * current query level will pass to this child plan. Even though this
+ * is an initplan, there could be side-references to earlier
* initplan's outputs, specifically their CTE output parameters.
*/
tmpset = bms_copy(plan->extParam);
bms_free(tmpset);
/*
- * Assign a param to represent the query output. We only really
- * care about reserving a parameter ID number.
+ * Assign a param to represent the query output. We only really care
+ * about reserving a parameter ID number.
*/
prm = generate_new_param(root, INTERNALOID, -1);
splan->setParam = list_make1_int(prm->paramid);
return NULL;
/*
- * The test expression must contain some Vars of the parent query,
- * else it's not gonna be a join. (Note that it won't have Vars
- * referring to the subquery, rather Params.)
+ * The test expression must contain some Vars of the parent query, else
+ * it's not gonna be a join. (Note that it won't have Vars referring to
+ * the subquery, rather Params.)
*/
upper_varnos = pull_varnos(sublink->testexpr);
if (bms_is_empty(upper_varnos))
subselect = (Query *) copyObject(subselect);
/*
- * See if the subquery can be simplified based on the knowledge that
- * it's being used in EXISTS(). If we aren't able to get rid of its
- * targetlist, we have to fail, because the pullup operation leaves
- * us with noplace to evaluate the targetlist.
+ * See if the subquery can be simplified based on the knowledge that it's
+ * being used in EXISTS(). If we aren't able to get rid of its
+ * targetlist, we have to fail, because the pullup operation leaves us
+ * with noplace to evaluate the targetlist.
*/
if (!simplify_EXISTS_query(subselect))
return NULL;
* to the inner (necessarily true). Therefore this is a lot easier than
* what pull_up_subqueries has to go through.
*
- * In fact, it's even easier than what convert_ANY_sublink_to_join has
- * to do. The machinations of simplify_EXISTS_query ensured that there
- * is nothing interesting in the subquery except an rtable and jointree,
- * and even the jointree FromExpr no longer has quals. So we can just
- * append the rtable to our own and use the FromExpr in our jointree.
- * But first, adjust all level-zero varnos in the subquery to account
- * for the rtable merger.
+ * In fact, it's even easier than what convert_ANY_sublink_to_join has to
+ * do. The machinations of simplify_EXISTS_query ensured that there is
+ * nothing interesting in the subquery except an rtable and jointree, and
+ * even the jointree FromExpr no longer has quals. So we can just append
+ * the rtable to our own and use the FromExpr in our jointree. But first,
+ * adjust all level-zero varnos in the subquery to account for the rtable
+ * merger.
*/
rtoffset = list_length(parse->rtable);
OffsetVarNodes((Node *) subselect, rtoffset, 0);
/*
* Now that the WHERE clause is adjusted to match the parent query
* environment, we can easily identify all the level-zero rels it uses.
- * The ones <= rtoffset belong to the upper query; the ones > rtoffset
- * do not.
+ * The ones <= rtoffset belong to the upper query; the ones > rtoffset do
+ * not.
*/
clause_varnos = pull_varnos(whereClause);
upper_varnos = NULL;
Assert(!bms_is_empty(upper_varnos));
/*
- * Now that we've got the set of upper-level varnos, we can make the
- * last check: only available_rels can be referenced.
+ * Now that we've got the set of upper-level varnos, we can make the last
+ * check: only available_rels can be referenced.
*/
if (!bms_is_subset(upper_varnos, available_rels))
return NULL;
*
* On success, the modified subselect is returned, and we store a suitable
* upper-level test expression at *testexpr, plus a list of the subselect's
- * output Params at *paramIds. (The test expression is already Param-ified
+ * output Params at *paramIds. (The test expression is already Param-ified
* and hence need not go through convert_testexpr, which is why we have to
* deal with the Param IDs specially.)
*
/*
* Clean up the WHERE clause by doing const-simplification etc on it.
* Aside from simplifying the processing we're about to do, this is
- * important for being able to pull chunks of the WHERE clause up into
- * the parent query. Since we are invoked partway through the parent's
+ * important for being able to pull chunks of the WHERE clause up into the
+ * parent query. Since we are invoked partway through the parent's
* preprocess_expression() work, earlier steps of preprocess_expression()
- * wouldn't get applied to the pulled-up stuff unless we do them here.
- * For the parts of the WHERE clause that get put back into the child
- * query, this work is partially duplicative, but it shouldn't hurt.
+ * wouldn't get applied to the pulled-up stuff unless we do them here. For
+ * the parts of the WHERE clause that get put back into the child query,
+ * this work is partially duplicative, but it shouldn't hurt.
*
- * Note: we do not run flatten_join_alias_vars. This is OK because
- * any parent aliases were flattened already, and we're not going to
- * pull any child Vars (of any description) into the parent.
+ * Note: we do not run flatten_join_alias_vars. This is OK because any
+ * parent aliases were flattened already, and we're not going to pull any
+ * child Vars (of any description) into the parent.
*
- * Note: passing the parent's root to eval_const_expressions is technically
- * wrong, but we can get away with it since only the boundParams (if any)
- * are used, and those would be the same in a subroot.
+ * Note: passing the parent's root to eval_const_expressions is
+ * technically wrong, but we can get away with it since only the
+ * boundParams (if any) are used, and those would be the same in a
+ * subroot.
*/
whereClause = eval_const_expressions(root, whereClause);
whereClause = (Node *) canonicalize_qual((Expr *) whereClause);
whereClause = (Node *) make_ands_implicit((Expr *) whereClause);
/*
- * We now have a flattened implicit-AND list of clauses, which we
- * try to break apart into "outervar = innervar" hash clauses.
- * Anything that can't be broken apart just goes back into the
- * newWhere list. Note that we aren't trying hard yet to ensure
- * that we have only outer or only inner on each side; we'll check
- * that if we get to the end.
+ * We now have a flattened implicit-AND list of clauses, which we try to
+ * break apart into "outervar = innervar" hash clauses. Anything that
+ * can't be broken apart just goes back into the newWhere list. Note that
+ * we aren't trying hard yet to ensure that we have only outer or only
+ * inner on each side; we'll check that if we get to the end.
*/
leftargs = rightargs = opids = newWhere = NIL;
foreach(lc, (List *) whereClause)
if (IsA(expr, OpExpr) &&
hash_ok_operator(expr))
{
- Node *leftarg = (Node *) linitial(expr->args);
- Node *rightarg = (Node *) lsecond(expr->args);
+ Node *leftarg = (Node *) linitial(expr->args);
+ Node *rightarg = (Node *) lsecond(expr->args);
if (contain_vars_of_level(leftarg, 1))
{
/*
* And there can't be any child Vars in the stuff we intend to pull up.
- * (Note: we'd need to check for child Aggs too, except we know the
- * child has no aggs at all because of simplify_EXISTS_query's check.
- * The same goes for window functions.)
+ * (Note: we'd need to check for child Aggs too, except we know the child
+ * has no aggs at all because of simplify_EXISTS_query's check. The same
+ * goes for window functions.)
*/
if (contain_vars_of_level((Node *) leftargs, 0))
return NULL;
/*
- * Also reject sublinks in the stuff we intend to pull up. (It might be
+ * Also reject sublinks in the stuff we intend to pull up. (It might be
* possible to support this, but doesn't seem worth the complication.)
*/
if (contain_subplans((Node *) leftargs))
subselect->jointree->quals = (Node *) make_ands_explicit(newWhere);
/*
- * Build a new targetlist for the child that emits the expressions
- * we need. Concurrently, build a testexpr for the parent using
- * Params to reference the child outputs. (Since we generate Params
- * directly here, there will be no need to convert the testexpr in
- * build_subplan.)
+ * Build a new targetlist for the child that emits the expressions we
+ * need. Concurrently, build a testexpr for the parent using Params to
+ * reference the child outputs. (Since we generate Params directly here,
+ * there will be no need to convert the testexpr in build_subplan.)
*/
tlist = testlist = paramids = NIL;
resno = 1;
}
/*
- * Don't recurse into the arguments of an outer aggregate here.
- * Any SubLinks in the arguments have to be dealt with at the outer
- * query level; they'll be handled when build_subplan collects the
- * Aggref into the arguments to be passed down to the current subplan.
+ * Don't recurse into the arguments of an outer aggregate here. Any
+ * SubLinks in the arguments have to be dealt with at the outer query
+ * level; they'll be handled when build_subplan collects the Aggref into
+ * the arguments to be passed down to the current subplan.
*/
if (IsA(node, Aggref))
{
* is needed for a bare List.)
*
* Anywhere within the top-level AND/OR clause structure, we can tell
- * make_subplan() that NULL and FALSE are interchangeable. So isTopQual
+ * make_subplan() that NULL and FALSE are interchangeable. So isTopQual
* propagates down in both cases. (Note that this is unlike the meaning
* of "top level qual" used in most other places in Postgres.)
*/
}
/*
- * If we recurse down through anything other than an AND or OR node,
- * we are definitely not at top qual level anymore.
+ * If we recurse down through anything other than an AND or OR node, we
+ * are definitely not at top qual level anymore.
*/
locContext.isTopQual = false;
/*
* Now determine the set of params that are validly referenceable in this
* query level; to wit, those available from outer query levels plus the
- * output parameters of any initPlans. (We do not include output
- * parameters of regular subplans. Those should only appear within the
+ * output parameters of any initPlans. (We do not include output
+ * parameters of regular subplans. Those should only appear within the
* testexpr of SubPlan nodes, and are taken care of locally within
* finalize_primnode.)
*
if (attach_initplans)
{
plan->initPlan = root->init_plans;
- root->init_plans = NIL; /* make sure they're not attached twice */
+ root->init_plans = NIL; /* make sure they're not attached twice */
/* allParam must include all these params */
plan->allParam = bms_add_members(plan->allParam, initExtParam);
/*
* Note: by definition, extParam and allParam should have the same value
- * in any plan node that doesn't have child initPlans. We set them
- * equal here, and later SS_finalize_plan will update them properly
- * in node(s) that it attaches initPlans to.
+ * in any plan node that doesn't have child initPlans. We set them equal
+ * here, and later SS_finalize_plan will update them properly in node(s)
+ * that it attaches initPlans to.
*
* For speed at execution time, make sure extParam/allParam are actually
* NULL if they are empty sets.
/*
* Remove any param IDs of output parameters of the subplan that were
- * referenced in the testexpr. These are not interesting for
+ * referenced in the testexpr. These are not interesting for
* parameter change signaling since we always re-evaluate the subplan.
* Note that this wouldn't work too well if there might be uses of the
* same param IDs elsewhere in the plan, but that can't happen because
root->parse->rtable);
/*
- * Create a SubPlan node and add it to the outer list of InitPlans.
- * Note it has to appear after any other InitPlans it might depend on
- * (see comments in ExecReScan).
+ * Create a SubPlan node and add it to the outer list of InitPlans. Note
+ * it has to appear after any other InitPlans it might depend on (see
+ * comments in ExecReScan).
*/
node = makeNode(SubPlan);
node->subLinkType = EXPR_SUBLINK;
static Node *pull_up_simple_union_all(PlannerInfo *root, Node *jtnode,
RangeTblEntry *rte);
static void pull_up_union_leaf_queries(Node *setOp, PlannerInfo *root,
- int parentRTindex, Query *setOpQuery,
- int childRToffset);
+ int parentRTindex, Query *setOpQuery,
+ int childRToffset);
static void make_setop_translation_list(Query *query, Index newvarno,
- List **translated_vars);
+ List **translated_vars);
static bool is_simple_subquery(Query *subquery);
static bool is_simple_union_all(Query *subquery);
static bool is_simple_union_all_recurse(Node *setOp, Query *setOpQuery,
List *colTypes);
static List *insert_targetlist_placeholders(PlannerInfo *root, List *tlist,
- int varno, bool wrap_non_vars);
+ int varno, bool wrap_non_vars);
static bool is_safe_append_member(Query *subquery);
static void resolvenew_in_jointree(Node *jtnode, int varno, RangeTblEntry *rte,
List *subtlist, List *subtlist_with_phvs,
List *nonnullable_vars,
List *forced_null_vars);
static void substitute_multiple_relids(Node *node,
- int varno, Relids subrelids);
+ int varno, Relids subrelids);
static void fix_append_rel_relids(List *append_rel_list, int varno,
Relids subrelids);
static Node *find_jointree_node_for_rel(Node *jtnode, int relid);
*
* A clause "foo op ANY (sub-SELECT)" can be processed by pulling the
* sub-SELECT up to become a rangetable entry and treating the implied
- * comparisons as quals of a semijoin. However, this optimization *only*
+ * comparisons as quals of a semijoin. However, this optimization *only*
* works at the top level of WHERE or a JOIN/ON clause, because we cannot
* distinguish whether the ANY ought to return FALSE or NULL in cases
* involving NULL inputs. Also, in an outer join's ON clause we can only
* transformations if any are found.
*
* This routine has to run before preprocess_expression(), so the quals
- * clauses are not yet reduced to implicit-AND format. That means we need
+ * clauses are not yet reduced to implicit-AND format. That means we need
* to recursively search through explicit AND clauses, which are
* probably only binary ANDs. We stop as soon as we hit a non-AND item.
*/
/* First, recurse to process children and collect their relids */
foreach(l, f->fromlist)
{
- Node *newchild;
- Relids childrelids;
+ Node *newchild;
+ Relids childrelids;
newchild = pull_up_sublinks_jointree_recurse(root,
lfirst(l),
/*
* Note that the result will be either newf, or a stack of JoinExprs
- * with newf at the base. We rely on subsequent optimization steps
- * to flatten this and rearrange the joins as needed.
+ * with newf at the base. We rely on subsequent optimization steps to
+ * flatten this and rearrange the joins as needed.
*
* Although we could include the pulled-up subqueries in the returned
* relids, there's no need since upper quals couldn't refer to their
Node *jtlink;
/*
- * Make a modifiable copy of join node, but don't bother copying
- * its subnodes (yet).
+ * Make a modifiable copy of join node, but don't bother copying its
+ * subnodes (yet).
*/
j = (JoinExpr *) palloc(sizeof(JoinExpr));
memcpy(j, jtnode, sizeof(JoinExpr));
/*
* Now process qual, showing appropriate child relids as available,
- * and attach any pulled-up jointree items at the right place.
- * In the inner-join case we put new JoinExprs above the existing one
- * (much as for a FromExpr-style join). In outer-join cases the
- * new JoinExprs must go into the nullable side of the outer join.
- * The point of the available_rels machinations is to ensure that we
- * only pull up quals for which that's okay.
+ * and attach any pulled-up jointree items at the right place. In the
+ * inner-join case we put new JoinExprs above the existing one (much
+ * as for a FromExpr-style join). In outer-join cases the new
+ * JoinExprs must go into the nullable side of the outer join. The
+ * point of the available_rels machinations is to ensure that we only
+ * pull up quals for which that's okay.
*
* XXX for the moment, we refrain from pulling up IN/EXISTS clauses
- * appearing in LEFT or RIGHT join conditions. Although it is
+ * appearing in LEFT or RIGHT join conditions. Although it is
* semantically valid to do so under the above conditions, we end up
* with a query in which the semijoin or antijoin must be evaluated
- * below the outer join, which could perform far worse than leaving
- * it as a sublink that is executed only for row pairs that meet the
+ * below the outer join, which could perform far worse than leaving it
+ * as a sublink that is executed only for row pairs that meet the
* other join conditions. Fixing this seems to require considerable
* restructuring of the executor, but maybe someday it can happen.
*
case JOIN_INNER:
j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
bms_union(leftrelids,
- rightrelids),
+ rightrelids),
&jtlink);
break;
case JOIN_LEFT:
/*
* Although we could include the pulled-up subqueries in the returned
* relids, there's no need since upper quals couldn't refer to their
- * outputs anyway. But we *do* need to include the join's own rtindex
+ * outputs anyway. But we *do* need to include the join's own rtindex
* because we haven't yet collapsed join alias variables, so upper
* levels would mistakenly think they couldn't use references to this
* join.
if (rte->rtekind == RTE_FUNCTION)
{
- Query *funcquery;
+ Query *funcquery;
/* Check safety of expansion, and expand if possible */
funcquery = inline_set_returning_function(root, rte);
* Alternatively, is it a simple UNION ALL subquery? If so, flatten
* into an "append relation".
*
- * It's safe to do this regardless of whether this query is
- * itself an appendrel member. (If you're thinking we should try to
- * flatten the two levels of appendrel together, you're right; but we
- * handle that in set_append_rel_pathlist, not here.)
+ * It's safe to do this regardless of whether this query is itself an
+ * appendrel member. (If you're thinking we should try to flatten the
+ * two levels of appendrel together, you're right; but we handle that
+ * in set_append_rel_pathlist, not here.)
*/
if (rte->rtekind == RTE_SUBQUERY &&
is_simple_union_all(rte->subquery))
* pull_up_subqueries' processing is complete for its jointree and
* rangetable.
*
- * Note: we should pass NULL for containing-join info even if we are within
- * an outer join in the upper query; the lower query starts with a clean
- * slate for outer-join semantics. Likewise, we say we aren't handling an
- * appendrel member.
+ * Note: we should pass NULL for containing-join info even if we are
+ * within an outer join in the upper query; the lower query starts with a
+ * clean slate for outer-join semantics. Likewise, we say we aren't
+ * handling an appendrel member.
*/
subquery->jointree = (FromExpr *)
pull_up_subqueries(subroot, (Node *) subquery->jointree, NULL, NULL);
/*
* Adjust level-0 varnos in subquery so that we can append its rangetable
- * to upper query's. We have to fix the subquery's append_rel_list
- * as well.
+ * to upper query's. We have to fix the subquery's append_rel_list as
+ * well.
*/
rtoffset = list_length(parse->rtable);
OffsetVarNodes((Node *) subquery, rtoffset, 0);
* The subquery's targetlist items are now in the appropriate form to
* insert into the top query, but if we are under an outer join then
* non-nullable items may have to be turned into PlaceHolderVars. If we
- * are dealing with an appendrel member then anything that's not a
- * simple Var has to be turned into a PlaceHolderVar.
+ * are dealing with an appendrel member then anything that's not a simple
+ * Var has to be turned into a PlaceHolderVar.
*/
subtlist = subquery->targetList;
if (lowest_outer_join != NULL || containing_appendrel != NULL)
subtlist_with_phvs = insert_targetlist_placeholders(root,
subtlist,
varno,
- containing_appendrel != NULL);
+ containing_appendrel != NULL);
else
subtlist_with_phvs = subtlist;
* replace any of the jointree structure. (This'd be a lot cleaner if we
* could use query_tree_mutator.) We have to use PHVs in the targetList,
* returningList, and havingQual, since those are certainly above any
- * outer join. resolvenew_in_jointree tracks its location in the jointree
+ * outer join. resolvenew_in_jointree tracks its location in the jointree
* and uses PHVs or not appropriately.
*/
parse->targetList = (List *)
subtlist_with_phvs, CMD_SELECT, 0);
/*
- * Replace references in the translated_vars lists of appendrels.
- * When pulling up an appendrel member, we do not need PHVs in the list
- * of the parent appendrel --- there isn't any outer join between.
- * Elsewhere, use PHVs for safety. (This analysis could be made tighter
- * but it seems unlikely to be worth much trouble.)
+ * Replace references in the translated_vars lists of appendrels. When
+ * pulling up an appendrel member, we do not need PHVs in the list of the
+ * parent appendrel --- there isn't any outer join between. Elsewhere, use
+ * PHVs for safety. (This analysis could be made tighter but it seems
+ * unlikely to be worth much trouble.)
*/
foreach(lc, root->append_rel_list)
{
*
* You might think that we could avoid using PHVs for alias vars of joins
* below lowest_outer_join, but that doesn't work because the alias vars
- * could be referenced above that join; we need the PHVs to be present
- * in such references after the alias vars get flattened. (It might be
- * worth trying to be smarter here, someday.)
+ * could be referenced above that join; we need the PHVs to be present in
+ * such references after the alias vars get flattened. (It might be worth
+ * trying to be smarter here, someday.)
*/
foreach(lc, parse->rtable)
{
* will be adjusted, so having created them with the subquery's varno is
* correct.
*
- * Likewise, relids appearing in AppendRelInfo nodes have to be fixed.
- * We already checked that this won't require introducing multiple
- * subrelids into the single-slot AppendRelInfo structs.
+ * Likewise, relids appearing in AppendRelInfo nodes have to be fixed. We
+ * already checked that this won't require introducing multiple subrelids
+ * into the single-slot AppendRelInfo structs.
*/
if (parse->hasSubLinks || root->glob->lastPHId != 0 ||
root->append_rel_list)
* Miscellaneous housekeeping.
*/
parse->hasSubLinks |= subquery->hasSubLinks;
+
/*
- * subquery won't be pulled up if it hasAggs or hasWindowFuncs, so no
- * work needed on those flags
+ * subquery won't be pulled up if it hasAggs or hasWindowFuncs, so no work
+ * needed on those flags
*/
/*
/*
* Append child RTEs to parent rtable.
*
- * Upper-level vars in subquery are now one level closer to their
- * parent than before. We don't have to worry about offsetting
- * varnos, though, because any such vars must refer to stuff above the
- * level of the query we are pulling into.
+ * Upper-level vars in subquery are now one level closer to their parent
+ * than before. We don't have to worry about offsetting varnos, though,
+ * because any such vars must refer to stuff above the level of the query
+ * we are pulling into.
*/
rtable = copyObject(subquery->rtable);
IncrementVarSublevelsUp_rtable(rtable, -1, 1);
* query_planner() will correctly generate a Result plan for a jointree
* that's totally empty, but I don't think the right things happen if an
* empty FromExpr appears lower down in a jointree. It would pose a
- * problem for the PlaceHolderVar mechanism too, since we'd have no
- * way to identify where to evaluate a PHV coming out of the subquery.
- * Not worth working hard on this, just to collapse SubqueryScan/Result
- * into Result; especially since the SubqueryScan can often be optimized
- * away by setrefs.c anyway.
+ * problem for the PlaceHolderVar mechanism too, since we'd have no way to
+ * identify where to evaluate a PHV coming out of the subquery. Not worth
+ * working hard on this, just to collapse SubqueryScan/Result into Result;
+ * especially since the SubqueryScan can often be optimized away by
+ * setrefs.c anyway.
*/
if (subquery->jointree->fromlist == NIL)
return false;
}
/*
- * Simple Vars always escape being wrapped. This is common enough
- * to deserve a fast path even if we aren't doing wrap_non_vars.
+ * Simple Vars always escape being wrapped. This is common enough to
+ * deserve a fast path even if we aren't doing wrap_non_vars.
*/
if (tle->expr && IsA(tle->expr, Var) &&
((Var *) tle->expr)->varlevelsup == 0)
if (!wrap_non_vars)
{
/*
- * If it contains a Var of current level, and does not contain
- * any non-strict constructs, then it's certainly nullable and we
+ * If it contains a Var of current level, and does not contain any
+ * non-strict constructs, then it's certainly nullable and we
* don't need to insert a PlaceHolderVar. (Note: in future maybe
* we should insert PlaceHolderVars anyway, when a tlist item is
* expensive to evaluate?
* but there's no other way...
*
* If we are above lowest_outer_join then use subtlist_with_phvs; at or
- * below it, use subtlist. (When no outer joins are in the picture,
+ * below it, use subtlist. (When no outer joins are in the picture,
* these will be the same list.)
*/
static void
* SELECT ... FROM a LEFT JOIN b ON (a.x = b.y) WHERE b.y IS NULL;
* If the join clause is strict for b.y, then only null-extended rows could
* pass the upper WHERE, and we can conclude that what the query is really
- * specifying is an anti-semijoin. We change the join type from JOIN_LEFT
+ * specifying is an anti-semijoin. We change the join type from JOIN_LEFT
* to JOIN_ANTI. The IS NULL clause then becomes redundant, and must be
* removed to prevent bogus selectivity calculations, but we leave it to
* distribute_qual_to_rels to get rid of such clauses.
break;
case JOIN_SEMI:
case JOIN_ANTI:
+
/*
* These could only have been introduced by pull_up_sublinks,
* so there's no way that upper quals could refer to their
}
/*
- * See if we can reduce JOIN_LEFT to JOIN_ANTI. This is the case
- * if the join's own quals are strict for any var that was forced
- * null by higher qual levels. NOTE: there are other ways that we
- * could detect an anti-join, in particular if we were to check
- * whether Vars coming from the RHS must be non-null because of
- * table constraints. That seems complicated and expensive though
- * (in particular, one would have to be wary of lower outer joins).
- * For the moment this seems sufficient.
+ * See if we can reduce JOIN_LEFT to JOIN_ANTI. This is the case if
+ * the join's own quals are strict for any var that was forced null by
+ * higher qual levels. NOTE: there are other ways that we could
+ * detect an anti-join, in particular if we were to check whether Vars
+ * coming from the RHS must be non-null because of table constraints.
+ * That seems complicated and expensive though (in particular, one
+ * would have to be wary of lower outer joins). For the moment this
+ * seems sufficient.
*/
if (jointype == JOIN_LEFT)
{
computed_local_nonnullable_vars = true;
/*
- * It's not sufficient to check whether local_nonnullable_vars
- * and forced_null_vars overlap: we need to know if the overlap
+ * It's not sufficient to check whether local_nonnullable_vars and
+ * forced_null_vars overlap: we need to know if the overlap
* includes any RHS variables.
*/
overlap = list_intersection(local_nonnullable_vars,
* side, because an outer join never eliminates any rows from its
* non-nullable side. Also, there is no point in passing upper
* constraints into the nullable side, since if there were any
- * we'd have been able to reduce the join. (In the case of
- * upper forced-null constraints, we *must not* pass them into
- * the nullable side --- they either applied here, or not.)
- * The upshot is that we pass either the local or the upper
- * constraints, never both, to the children of an outer join.
+ * we'd have been able to reduce the join. (In the case of upper
+ * forced-null constraints, we *must not* pass them into the
+ * nullable side --- they either applied here, or not.) The upshot
+ * is that we pass either the local or the upper constraints,
+ * never both, to the children of an outer join.
*
* At a FULL join we just punt and pass nothing down --- is it
* possible to be smarter?
{
/* OK to merge upper and local constraints */
local_nonnullable_rels = bms_add_members(local_nonnullable_rels,
- nonnullable_rels);
+ nonnullable_rels);
local_nonnullable_vars = list_concat(local_nonnullable_vars,
nonnullable_vars);
local_forced_null_vars = list_concat(local_forced_null_vars,
pass_nonnullable_vars = local_nonnullable_vars;
pass_forced_null_vars = local_forced_null_vars;
}
- else if (jointype != JOIN_FULL) /* ie, LEFT/SEMI/ANTI */
+ else if (jointype != JOIN_FULL) /* ie, LEFT/SEMI/ANTI */
{
/* can't pass local constraints to non-nullable side */
pass_nonnullable_rels = nonnullable_rels;
* top query could (yet) contain such a reference.
*
* NOTE: although this has the form of a walker, we cheat and modify the
- * nodes in-place. This should be OK since the tree was copied by ResolveNew
+ * nodes in-place. This should be OK since the tree was copied by ResolveNew
* earlier. Avoid scribbling on the original values of the bitmapsets, though,
* because expression_tree_mutator doesn't copy those.
*/
Index newvarno,
List **translated_vars);
static Bitmapset *translate_col_privs(const Bitmapset *parent_privs,
- List *translated_vars);
+ List *translated_vars);
static Node *adjust_appendrel_attrs_mutator(Node *node,
AppendRelInfo *context);
static Relids adjust_relid_set(Relids relids, Index oldrelid, Index newrelid);
&subroot);
/*
- * Estimate number of groups if caller wants it. If the subquery
- * used grouping or aggregation, its output is probably mostly
- * unique anyway; otherwise do statistical estimation.
+ * Estimate number of groups if caller wants it. If the subquery used
+ * grouping or aggregation, its output is probably mostly unique
+ * anyway; otherwise do statistical estimation.
*/
if (pNumGroups)
{
*pNumGroups = subplan->plan_rows;
else
*pNumGroups = estimate_num_groups(subroot,
- get_tlist_exprs(subquery->targetList, false),
+ get_tlist_exprs(subquery->targetList, false),
subplan->plan_rows);
}
}
else
{
- double dNumGroups;
+ double dNumGroups;
/* Identify the grouping semantics */
groupList = generate_setop_grouplist(setOp, tlist);
errdetail("All column datatypes must be hashable.")));
/*
- * For the moment, take the number of distinct groups as equal to
- * the total input size, ie, the worst case.
+ * For the moment, take the number of distinct groups as equal to the
+ * total input size, ie, the worst case.
*/
dNumGroups = lplan->plan_rows + rplan->plan_rows * 10;
plan = make_union_unique(op, plan, root, tuple_fraction, sortClauses);
/*
- * Estimate number of groups if caller wants it. For now we just
- * assume the output is unique --- this is certainly true for the
- * UNION case, and we want worst-case estimates anyway.
+ * Estimate number of groups if caller wants it. For now we just assume
+ * the output is unique --- this is certainly true for the UNION case, and
+ * we want worst-case estimates anyway.
*/
if (pNumGroups)
*pNumGroups = plan->plan_rows;
* Estimate number of distinct groups that we'll need hashtable entries
* for; this is the size of the left-hand input for EXCEPT, or the smaller
* input for INTERSECT. Also estimate the number of eventual output rows.
- * In non-ALL cases, we estimate each group produces one output row;
- * in ALL cases use the relevant relation size. These are worst-case
+ * In non-ALL cases, we estimate each group produces one output row; in
+ * ALL cases use the relevant relation size. These are worst-case
* estimates, of course, but we need to be conservative.
*/
if (op->op == SETOP_EXCEPT)
*/
use_hash = choose_hashed_setop(root, groupList, plan,
dNumGroups, dNumOutputRows, tuple_fraction,
- (op->op == SETOP_INTERSECT) ? "INTERSECT" : "EXCEPT");
+ (op->op == SETOP_INTERSECT) ? "INTERSECT" : "EXCEPT");
if (!use_hash)
plan = (Plan *) make_sort_from_sortclauses(root, groupList, plan);
}
/*
- * XXX for the moment, take the number of distinct groups as equal to
- * the total input size, ie, the worst case. This is too conservative,
- * but we don't want to risk having the hashtable overrun memory; also,
- * it's not clear how to get a decent estimate of the true size. One
- * should note as well the propensity of novices to write UNION rather
- * than UNION ALL even when they don't expect any duplicates...
+ * XXX for the moment, take the number of distinct groups as equal to the
+ * total input size, ie, the worst case. This is too conservative, but we
+ * don't want to risk having the hashtable overrun memory; also, it's not
+ * clear how to get a decent estimate of the true size. One should note
+ * as well the propensity of novices to write UNION rather than UNION ALL
+ * even when they don't expect any duplicates...
*/
dNumGroups = plan->plan_rows;
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s is UNION, INTERSECT, or EXCEPT */
+ /* translator: %s is UNION, INTERSECT, or EXCEPT */
errmsg("could not implement %s", construct),
errdetail("Some of the datatypes only support hashing, while others only support sorting.")));
appinfos = lappend(appinfos, appinfo);
/*
- * Translate the column permissions bitmaps to the child's attnums
- * (we have to build the translated_vars list before we can do this).
- * But if this is the parent table, leave copyObject's result alone.
+ * Translate the column permissions bitmaps to the child's attnums (we
+ * have to build the translated_vars list before we can do this). But
+ * if this is the parent table, leave copyObject's result alone.
*/
if (childOID != parentOID)
{
childrte->selectedCols = translate_col_privs(rte->selectedCols,
- appinfo->translated_vars);
+ appinfo->translated_vars);
childrte->modifiedCols = translate_col_privs(rte->modifiedCols,
- appinfo->translated_vars);
+ appinfo->translated_vars);
}
/*
* parent rel's attribute numbering to the child's.
*
* The only surprise here is that we don't translate a parent whole-row
- * reference into a child whole-row reference. That would mean requiring
+ * reference into a child whole-row reference. That would mean requiring
* permissions on all child columns, which is overly strict, since the
* query is really only going to reference the inherited columns. Instead
* we set the per-column bits for all inherited columns.
ListCell *lc;
/* System attributes have the same numbers in all tables */
- for (attno = FirstLowInvalidHeapAttributeNumber+1; attno < 0; attno++)
+ for (attno = FirstLowInvalidHeapAttributeNumber + 1; attno < 0; attno++)
{
if (bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
parent_privs))
child_privs = bms_add_member(child_privs,
- attno - FirstLowInvalidHeapAttributeNumber);
+ attno - FirstLowInvalidHeapAttributeNumber);
}
/* Check if parent has whole-row reference */
attno = InvalidAttrNumber;
foreach(lc, translated_vars)
{
- Var *var = (Var *) lfirst(lc);
+ Var *var = (Var *) lfirst(lc);
attno++;
if (var == NULL) /* ignore dropped columns */
bms_is_member(attno - FirstLowInvalidHeapAttributeNumber,
parent_privs))
child_privs = bms_add_member(child_privs,
- var->varattno - FirstLowInvalidHeapAttributeNumber);
+ var->varattno - FirstLowInvalidHeapAttributeNumber);
}
return child_privs;
bool allow_inline,
eval_const_expressions_context *context);
static List *add_function_defaults(List *args, Oid result_type,
- HeapTuple func_tuple,
- eval_const_expressions_context *context);
+ HeapTuple func_tuple,
+ eval_const_expressions_context *context);
static Expr *evaluate_function(Oid funcid,
Oid result_type, int32 result_typmod, List *args,
HeapTuple func_tuple,
static void sql_inline_error_callback(void *arg);
static Expr *evaluate_expr(Expr *expr, Oid result_type, int32 result_typmod);
static Query *substitute_actual_srf_parameters(Query *expr,
- int nargs, List *args);
+ int nargs, List *args);
static Node *substitute_actual_srf_parameters_mutator(Node *node,
- substitute_actual_srf_parameters_context *context);
+ substitute_actual_srf_parameters_context *context);
static bool tlist_matches_coltypelist(List *tlist, List *coltypelist);
lists->numWindowFuncs++;
/*
- * Complain if the window function's arguments contain window functions
+ * Complain if the window function's arguments contain window
+ * functions
*/
if (contain_window_function((Node *) wfunc->args))
ereport(ERROR,
/*
* We don't bother considering the OR case, because it's fairly
- * unlikely anyone would write "v1 IS NULL OR v1 IS NULL".
- * Likewise, the NOT case isn't worth expending code on.
+ * unlikely anyone would write "v1 IS NULL OR v1 IS NULL". Likewise,
+ * the NOT case isn't worth expending code on.
*/
if (expr->boolop == AND_EXPR)
{
if (expr->nulltesttype == IS_NULL)
{
- Var *var = (Var *) expr->arg;
+ Var *var = (Var *) expr->arg;
if (var && IsA(var, Var) &&
var->varlevelsup == 0)
if (expr->booltesttype == IS_UNKNOWN)
{
- Var *var = (Var *) expr->arg;
+ Var *var = (Var *) expr->arg;
if (var && IsA(var, Var) &&
var->varlevelsup == 0)
if (root)
{
context.boundParams = root->glob->boundParams; /* bound Params */
- context.glob = root->glob; /* for inlined-function dependencies */
+ context.glob = root->glob; /* for inlined-function dependencies */
}
else
{
/*
* CoerceViaIO represents calling the source type's output function
- * then the result type's input function. So, try to simplify it
- * as though it were a stack of two such function calls. First we
- * need to know what the functions are.
+ * then the result type's input function. So, try to simplify it as
+ * though it were a stack of two such function calls. First we need
+ * to know what the functions are.
*/
getTypeOutputInfo(exprType((Node *) arg), &outfunc, &outtypisvarlena);
getTypeInputInfo(expr->resulttype, &infunc, &intypioparam);
ArrayCoerceExpr *newexpr;
/*
- * Reduce constants in the ArrayCoerceExpr's argument, then build
- * a new ArrayCoerceExpr.
+ * Reduce constants in the ArrayCoerceExpr's argument, then build a
+ * new ArrayCoerceExpr.
*/
arg = (Expr *) eval_const_expressions_mutator((Node *) expr->arg,
context);
newbtest->booltesttype = btest->booltesttype;
return (Node *) newbtest;
}
- if (IsA(node, PlaceHolderVar) && context->estimate)
+ if (IsA(node, PlaceHolderVar) &&context->estimate)
{
/*
* In estimation mode, just strip the PlaceHolderVar node altogether;
*
* It is possible for some of the defaulted arguments to be polymorphic;
* therefore we can't assume that the default expressions have the correct
- * data types already. We have to re-resolve polymorphics and do coercion
+ * data types already. We have to re-resolve polymorphics and do coercion
* just like the parser did.
*/
static List *
/*
* Make sure the function (still) returns what it's declared to. This
* will raise an error if wrong, but that's okay since the function would
- * fail at runtime anyway. Note that check_sql_fn_retval will also insert
+ * fail at runtime anyway. Note that check_sql_fn_retval will also insert
* a RelabelType if needed to make the tlist expression match the declared
* type of the function.
*
MemoryContextDelete(mycxt);
/*
- * Since there is now no trace of the function in the plan tree, we
- * must explicitly record the plan's dependency on the function.
+ * Since there is now no trace of the function in the plan tree, we must
+ * explicitly record the plan's dependency on the function.
*/
if (context->glob)
record_plan_function_dependency(context->glob, funcid);
fix_opfuncids((Node *) expr);
/*
- * Prepare expr for execution. (Note: we can't use ExecPrepareExpr
+ * Prepare expr for execution. (Note: we can't use ExecPrepareExpr
* because it'd result in recursively invoking eval_const_expressions.)
*/
exprstate = ExecInitExpr(expr, NULL);
Assert(rte->rtekind == RTE_FUNCTION);
/*
- * It doesn't make a lot of sense for a SQL SRF to refer to itself
- * in its own FROM clause, since that must cause infinite recursion
- * at runtime. It will cause this code to recurse too, so check
- * for stack overflow. (There's no need to do more.)
+ * It doesn't make a lot of sense for a SQL SRF to refer to itself in its
+ * own FROM clause, since that must cause infinite recursion at runtime.
+ * It will cause this code to recurse too, so check for stack overflow.
+ * (There's no need to do more.)
*/
check_stack_depth();
/*
* The function must be declared to return a set, else inlining would
- * change the results if the contained SELECT didn't return exactly
- * one row.
+ * change the results if the contained SELECT didn't return exactly one
+ * row.
*/
if (!fexpr->funcretset)
return NULL;
* Refuse to inline if the arguments contain any volatile functions or
* sub-selects. Volatile functions are rejected because inlining may
* result in the arguments being evaluated multiple times, risking a
- * change in behavior. Sub-selects are rejected partly for implementation
+ * change in behavior. Sub-selects are rejected partly for implementation
* reasons (pushing them down another level might change their behavior)
* and partly because they're likely to be expensive and so multiple
* evaluation would be bad.
/*
* Forget it if the function is not SQL-language or has other showstopper
- * properties. In particular it mustn't be declared STRICT, since we
+ * properties. In particular it mustn't be declared STRICT, since we
* couldn't enforce that. It also mustn't be VOLATILE, because that is
* supposed to cause it to be executed with its own snapshot, rather than
* sharing the snapshot of the calling query. (The nargs check is just
src = TextDatumGetCString(tmp);
/*
- * Parse, analyze, and rewrite (unlike inline_function(), we can't
- * skip rewriting here). We can fail as soon as we find more than
- * one query, though.
+ * Parse, analyze, and rewrite (unlike inline_function(), we can't skip
+ * rewriting here). We can fail as soon as we find more than one query,
+ * though.
*/
raw_parsetree_list = pg_parse_query(src);
if (list_length(raw_parsetree_list) != 1)
goto fail;
querytree_list = pg_analyze_and_rewrite(linitial(raw_parsetree_list), src,
- argtypes, funcform->pronargs);
+ argtypes, funcform->pronargs);
if (list_length(querytree_list) != 1)
goto fail;
querytree = linitial(querytree_list);
/*
* Make sure the function (still) returns what it's declared to. This
* will raise an error if wrong, but that's okay since the function would
- * fail at runtime anyway. Note that check_sql_fn_retval will also insert
+ * fail at runtime anyway. Note that check_sql_fn_retval will also insert
* RelabelType(s) if needed to make the tlist expression(s) match the
* declared type of the function.
*
- * If the function returns a composite type, don't inline unless the
- * check shows it's returning a whole tuple result; otherwise what
- * it's returning is a single composite column which is not what we need.
+ * If the function returns a composite type, don't inline unless the check
+ * shows it's returning a whole tuple result; otherwise what it's
+ * returning is a single composite column which is not what we need.
*/
if (!check_sql_fn_retval(fexpr->funcid, fexpr->funcresulttype,
querytree_list,
fexpr->args);
/*
- * Copy the modified query out of the temporary memory context,
- * and clean up.
+ * Copy the modified query out of the temporary memory context, and clean
+ * up.
*/
MemoryContextSwitchTo(oldcxt);
ReleaseSysCache(func_tuple);
/*
- * Since there is now no trace of the function in the plan tree, we
- * must explicitly record the plan's dependency on the function.
+ * Since there is now no trace of the function in the plan tree, we must
+ * explicitly record the plan's dependency on the function.
*/
record_plan_function_dependency(root->glob, fexpr->funcid);
static Node *
substitute_actual_srf_parameters_mutator(Node *node,
- substitute_actual_srf_parameters_context *context)
+ substitute_actual_srf_parameters_context *context)
{
- Node *result;
+ Node *result;
if (node == NULL)
return NULL;
{
context->sublevels_up++;
result = (Node *) query_tree_mutator((Query *) node,
- substitute_actual_srf_parameters_mutator,
+ substitute_actual_srf_parameters_mutator,
(void *) context,
0);
context->sublevels_up--;
elog(ERROR, "invalid paramid: %d", param->paramid);
/*
- * Since the parameter is being inserted into a subquery,
- * we must adjust levels.
+ * Since the parameter is being inserted into a subquery, we must
+ * adjust levels.
*/
result = copyObject(list_nth(context->args, param->paramid - 1));
IncrementVarSublevelsUp(result, context->sublevels_up, 0);
in_operators = NIL;
uniq_exprs = NIL;
all_btree = true;
- all_hash = enable_hashagg; /* don't consider hash if not enabled */
+ all_hash = enable_hashagg; /* don't consider hash if not enabled */
foreach(lc, sjinfo->join_quals)
{
OpExpr *op = (OpExpr *) lfirst(lc);
goto no_unique_path;
/*
- * If we get here, we can unique-ify using at least one of sorting
- * and hashing. Start building the result Path object.
+ * If we get here, we can unique-ify using at least one of sorting and
+ * hashing. Start building the result Path object.
*/
pathnode = makeNode(UniquePath);
-1.0);
/*
- * Charge one cpu_operator_cost per comparison per input tuple.
- * We assume all columns get compared at most of the tuples. (XXX
+ * Charge one cpu_operator_cost per comparison per input tuple. We
+ * assume all columns get compared at most of the tuples. (XXX
* probably this is an overestimate.) This should agree with
* make_unique.
*/
return pathnode;
-no_unique_path: /* failure exit */
+no_unique_path: /* failure exit */
/* Mark the SpecialJoinInfo as not unique-able */
sjinfo->join_quals = NIL;
* selected as the input of a mergejoin, and they don't support
* mark/restore at present.
*
- * Note: Sort supports mark/restore, so no materialize is really needed
- * in that case; but one may be desirable anyway to optimize the sort.
- * However, since we aren't representing the sort step separately in
- * the Path tree, we can't explicitly represent the materialize either.
- * So that case is not handled here. Instead, cost_mergejoin has to
- * factor in the cost and create_mergejoin_plan has to add the plan node.
+ * Note: Sort supports mark/restore, so no materialize is really needed in
+ * that case; but one may be desirable anyway to optimize the sort.
+ * However, since we aren't representing the sort step separately in the
+ * Path tree, we can't explicitly represent the materialize either. So
+ * that case is not handled here. Instead, cost_mergejoin has to factor
+ * in the cost and create_mergejoin_plan has to add the plan node.
*/
if (innersortkeys == NIL &&
!ExecSupportsMarkRestore(inner_path->pathtype))
{
- Path *mpath;
+ Path *mpath;
mpath = (Path *) create_material_path(inner_path->parent, inner_path);
/*
- * We expect the materialize won't spill to disk (it could only do
- * so if there were a whole lot of duplicate tuples, which is a case
- * cost_mergejoin will avoid choosing anyway). Therefore
- * cost_material's cost estimate is bogus and we should charge
- * just cpu_tuple_cost per tuple. (Keep this estimate in sync with
- * similar ones in cost_mergejoin and create_mergejoin_plan.)
+ * We expect the materialize won't spill to disk (it could only do so
+ * if there were a whole lot of duplicate tuples, which is a case
+ * cost_mergejoin will avoid choosing anyway). Therefore
+ * cost_material's cost estimate is bogus and we should charge just
+ * cpu_tuple_cost per tuple. (Keep this estimate in sync with similar
+ * ones in cost_mergejoin and create_mergejoin_plan.)
*/
mpath->startup_cost = inner_path->startup_cost;
mpath->total_cost = inner_path->total_cost;
pathnode->jpath.outerjoinpath = outer_path;
pathnode->jpath.innerjoinpath = inner_path;
pathnode->jpath.joinrestrictinfo = restrict_clauses;
+
/*
* A hashjoin never has pathkeys, since its output ordering is
- * unpredictable due to possible batching. XXX If the inner relation is
+ * unpredictable due to possible batching. XXX If the inner relation is
* small enough, we could instruct the executor that it must not batch,
* and then we could assume that the output inherits the outer relation's
- * ordering, which might save a sort step. However there is considerable
- * downside if our estimate of the inner relation size is badly off.
- * For the moment we don't risk it. (Note also that if we wanted to take
- * this seriously, joinpath.c would have to consider many more paths for
- * the outer rel than it does now.)
+ * ordering, which might save a sort step. However there is considerable
+ * downside if our estimate of the inner relation size is badly off. For
+ * the moment we don't risk it. (Note also that if we wanted to take this
+ * seriously, joinpath.c would have to consider many more paths for the
+ * outer rel than it does now.)
*/
pathnode->jpath.path.pathkeys = NIL;
pathnode->path_hashclauses = hashclauses;
phinfo->ph_var = copyObject(phv);
phinfo->ph_eval_at = pull_varnos((Node *) phv);
/* ph_eval_at may change later, see fix_placeholder_eval_levels */
- phinfo->ph_needed = NULL; /* initially it's unused */
+ phinfo->ph_needed = NULL; /* initially it's unused */
/* for the moment, estimate width using just the datatype info */
phinfo->ph_width = get_typavgwidth(exprType((Node *) phv->phexpr),
exprTypmod((Node *) phv->phexpr));
*
* The initial eval_at level set by find_placeholder_info was the set of
* rels used in the placeholder's expression (or the whole subselect if
- * the expr is variable-free). If the subselect contains any outer joins
+ * the expr is variable-free). If the subselect contains any outer joins
* that can null any of those rels, we must delay evaluation to above those
* joins.
*
/*
* Now that we know where to evaluate the placeholder, make sure that
* any vars or placeholders it uses will be available at that join
- * level. NOTE: this could cause more PlaceHolderInfos to be added
- * to placeholder_list. That is okay because we'll process them
- * before falling out of the foreach loop. Also, it could cause
- * the ph_needed sets of existing list entries to expand, which
- * is also okay because this loop doesn't examine those.
+ * level. NOTE: this could cause more PlaceHolderInfos to be added to
+ * placeholder_list. That is okay because we'll process them before
+ * falling out of the foreach loop. Also, it could cause the
+ * ph_needed sets of existing list entries to expand, which is also
+ * okay because this loop doesn't examine those.
*/
if (bms_membership(eval_at) == BMS_MULTIPLE)
{
* Now, if any placeholder can be computed at a base rel and is needed
* above it, add it to that rel's targetlist. (This is essentially the
* same logic as in add_placeholders_to_joinrel, but we can't do that part
- * until joinrels are formed.) We have to do this as a separate step
+ * until joinrels are formed.) We have to do this as a separate step
* because the ph_needed values aren't stable until the previous loop
* finishes.
*/
/* Add NOT NULL constraints in expression form, if requested */
if (include_notnull && constr->has_not_null)
{
- int natts = relation->rd_att->natts;
+ int natts = relation->rd_att->natts;
for (i = 1; i <= natts; i++)
{
if (att->attnotnull && !att->attisdropped)
{
- NullTest *ntest = makeNode(NullTest);
+ NullTest *ntest = makeNode(NullTest);
ntest->arg = (Expr *) makeVar(varno,
i,
return false;
/*
- * OK to fetch the constraint expressions. Include "col IS NOT NULL"
+ * OK to fetch the constraint expressions. Include "col IS NOT NULL"
* expressions for attnotnull columns, in case we can refute those.
*/
constraint_pred = get_relation_constraints(root, rte->relid, rel, true);
/*
* Note: ignore partial indexes, since they don't allow us to conclude
* that all attr values are distinct, *unless* they are marked predOK
- * which means we know the index's predicate is satisfied by the query.
- * We don't take any interest in expressional indexes either. Also, a
- * multicolumn unique index doesn't allow us to conclude that just the
- * specified attr is unique.
+ * which means we know the index's predicate is satisfied by the
+ * query. We don't take any interest in expressional indexes either.
+ * Also, a multicolumn unique index doesn't allow us to conclude that
+ * just the specified attr is unique.
*/
if (index->unique &&
index->ncolumns == 1 &&
static bool list_member_strip(List *list, Expr *datum);
static bool btree_predicate_proof(Expr *predicate, Node *clause,
bool refute_it);
-static Oid get_btree_test_op(Oid pred_op, Oid clause_op, bool refute_it);
+static Oid get_btree_test_op(Oid pred_op, Oid clause_op, bool refute_it);
static void InvalidateOprProofCacheCallBack(Datum arg, int cacheid, ItemPointer tuplePtr);
/*
* If either input is a single-element list, replace it with its lone
- * member; this avoids one useless level of AND-recursion. We only need
+ * member; this avoids one useless level of AND-recursion. We only need
* to worry about this at top level, since eval_const_expressions should
* have gotten rid of any trivial ANDs or ORs below that.
*/
/*
* If either input is a single-element list, replace it with its lone
- * member; this avoids one useless level of AND-recursion. We only need
+ * member; this avoids one useless level of AND-recursion. We only need
* to worry about this at top level, since eval_const_expressions should
* have gotten rid of any trivial ANDs or ORs below that.
*/
case CLASS_ATOM:
#ifdef NOT_USED
+
/*
* If A is a NOT-clause, A R=> B if B => A's arg
*
* Unfortunately not: this would only prove that B is not-TRUE,
* not that it's not NULL either. Keep this code as a comment
- * because it would be useful if we ever had a need for the
- * weak form of refutation.
+ * because it would be useful if we ever had a need for the weak
+ * form of refutation.
*/
not_arg = extract_not_arg(clause);
if (not_arg &&
* This function also implements enforcement of MAX_SAOP_ARRAY_SIZE: if a
* ScalarArrayOpExpr's array has too many elements, we just classify it as an
* atom. (This will result in its being passed as-is to the simple_clause
- * functions, which will fail to prove anything about it.) Note that we
+ * functions, which will fail to prove anything about it.) Note that we
* cannot just stop after considering MAX_SAOP_ARRAY_SIZE elements; in general
* that would result in wrong proofs, rather than failing to prove anything.
*/
bool have_implic; /* do we know the implication result? */
bool have_refute; /* do we know the refutation result? */
- Oid implic_test_op; /* OID of the operator, or 0 if none */
- Oid refute_test_op; /* OID of the operator, or 0 if none */
+ Oid implic_test_op; /* OID of the operator, or 0 if none */
+ Oid refute_test_op; /* OID of the operator, or 0 if none */
} OprProofCacheEntry;
static HTAB *OprProofCacheHash = NULL;
int ndx;
/*
- * Ignore PlaceHolderVars in the input tlists; we'll make our
- * own decisions about whether to copy them.
+ * Ignore PlaceHolderVars in the input tlists; we'll make our own
+ * decisions about whether to copy them.
*/
if (IsA(origvar, PlaceHolderVar))
continue;
* OK because we're only trying to prove we can dispense with some
* join quals; failing to prove that doesn't result in an incorrect
* plan. It's quite unlikely that a join qual could be proven
- * redundant by an index predicate anyway. (Also, if we did manage
- * to prove it, we'd have to have a special case for update targets;
- * see notes about EvalPlanQual testing in create_indexscan_plan().)
+ * redundant by an index predicate anyway. (Also, if we did manage to
+ * prove it, we'd have to have a special case for update targets; see
+ * notes about EvalPlanQual testing in create_indexscan_plan().)
*/
BitmapHeapPath *innerpath = (BitmapHeapPath *) inner_path;
}
/*
- * XXX the inner path of a nestloop could also be an append relation
- * whose elements use join quals. However, they might each use different
- * quals; we could only remove join quals that are enforced by all the
- * appendrel members. For the moment we don't bother to try.
+ * XXX the inner path of a nestloop could also be an append relation whose
+ * elements use join quals. However, they might each use different quals;
+ * we could only remove join quals that are enforced by all the appendrel
+ * members. For the moment we don't bother to try.
*/
return restrictinfo_list;
static bool contain_var_clause_walker(Node *node, void *context);
static bool contain_vars_of_level_walker(Node *node, int *sublevels_up);
static bool locate_var_of_level_walker(Node *node,
- locate_var_of_level_context *context);
+ locate_var_of_level_context *context);
static bool locate_var_of_relation_walker(Node *node,
- locate_var_of_relation_context *context);
+ locate_var_of_relation_context *context);
static bool find_minimum_var_level_walker(Node *node,
find_minimum_var_level_context *context);
static bool pull_var_clause_walker(Node *node,
* Find the parse location of any Var of the specified query level.
*
* Returns -1 if no such Var is in the querytree, or if they all have
- * unknown parse location. (The former case is probably caller error,
+ * unknown parse location. (The former case is probably caller error,
* but we don't bother to distinguish it from the latter case.)
*
* Will recurse into sublinks. Also, may be invoked directly on a Query.
{
locate_var_of_level_context context;
- context.var_location = -1; /* in case we find nothing */
+ context.var_location = -1; /* in case we find nothing */
context.sublevels_up = levelsup;
(void) query_or_expression_tree_walker(node,
return false;
if (IsA(node, Var))
{
- Var *var = (Var *) node;
+ Var *var = (Var *) node;
if (var->varlevelsup == context->sublevels_up &&
var->location >= 0)
{
locate_var_of_relation_context context;
- context.var_location = -1; /* in case we find nothing */
+ context.var_location = -1; /* in case we find nothing */
context.relid = relid;
context.sublevels_up = levelsup;
return false;
if (IsA(node, Var))
{
- Var *var = (Var *) node;
+ Var *var = (Var *) node;
if (var->varno == context->relid &&
var->varlevelsup == context->sublevels_up &&
* Upper-level vars (with varlevelsup > 0) are not included.
* (These probably represent errors too, but we don't complain.)
*
- * Returns list of nodes found. Note the nodes themselves are not
+ * Returns list of nodes found. Note the nodes themselves are not
* copied, only referenced.
*
* Does not examine subqueries, therefore must only be used after reduction
static Query *transformValuesClause(ParseState *pstate, SelectStmt *stmt);
static Query *transformSetOperationStmt(ParseState *pstate, SelectStmt *stmt);
static Node *transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
- List **colInfo);
+ List **colInfo);
static void applyColumnNames(List *dst, List *src);
static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
static List *transformReturningList(ParseState *pstate, List *returningList);
static Query *transformExplainStmt(ParseState *pstate,
ExplainStmt *stmt);
static void transformLockingClause(ParseState *pstate,
- Query *qry, LockingClause *lc);
+ Query *qry, LockingClause *lc);
static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
ParseState *pstate = make_parsestate(NULL);
Query *query;
- Assert(sourceText != NULL); /* required as of 8.4 */
+ Assert(sourceText != NULL); /* required as of 8.4 */
pstate->p_sourcetext = sourceText;
pstate->p_paramtypes = paramTypes;
ParseState *pstate = make_parsestate(NULL);
Query *query;
- Assert(sourceText != NULL); /* required as of 8.4 */
+ Assert(sourceText != NULL); /* required as of 8.4 */
pstate->p_sourcetext = sourceText;
pstate->p_paramtypes = *paramTypes;
break;
case T_ExplainStmt:
+
/*
* We only need a snapshot in varparams case, but it doesn't seem
* worth complicating this function's API to distinguish that.
* bugs of just that nature...)
*/
sub_pstate->p_rtable = sub_rtable;
- sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */
+ sub_pstate->p_joinexprs = NIL; /* sub_rtable has no joins */
sub_pstate->p_relnamespace = sub_relnamespace;
sub_pstate->p_varnamespace = sub_varnamespace;
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("INSERT ... SELECT cannot specify INTO"),
parser_errposition(pstate,
- exprLocation((Node *) selectQuery->intoClause))));
+ exprLocation((Node *) selectQuery->intoClause))));
/*
* Make the source be a subquery in the INSERT's rangetable, and add
expr = tle->expr;
else
{
- Var *var = makeVar(rtr->rtindex,
- tle->resno,
- exprType((Node *) tle->expr),
- exprTypmod((Node *) tle->expr),
- 0);
+ Var *var = makeVar(rtr->rtindex,
+ tle->resno,
+ exprType((Node *) tle->expr),
+ exprTypmod((Node *) tle->expr),
+ 0);
+
var->location = exprLocation((Node *) tle->expr);
expr = (Expr *) var;
}
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("VALUES must not contain table references"),
parser_errposition(pstate,
- locate_var_of_level((Node *) exprsLists, 0))));
+ locate_var_of_level((Node *) exprsLists, 0))));
/*
* Another thing we can't currently support is NEW/OLD references in
errmsg("VALUES must not contain OLD or NEW references"),
errhint("Use SELECT ... UNION ALL ... instead."),
parser_errposition(pstate,
- locate_var_of_level((Node *) exprsLists, 0))));
+ locate_var_of_level((Node *) exprsLists, 0))));
/*
* Generate the VALUES RTE
qry->targetList = lappend(qry->targetList, tle);
rte->modifiedCols = bms_add_member(rte->modifiedCols,
- attr_num - FirstLowInvalidHeapAttributeNumber);
+ attr_num - FirstLowInvalidHeapAttributeNumber);
icols = lnext(icols);
attnos = lnext(attnos);
errmsg("INSERT has more expressions than target columns"),
parser_errposition(pstate,
exprLocation(list_nth(exprlist,
- list_length(icolumns))))));
+ list_length(icolumns))))));
if (stmtcols != NIL &&
list_length(exprlist) < list_length(icolumns))
ereport(ERROR,
errmsg("INSERT has more target columns than expressions"),
parser_errposition(pstate,
exprLocation(list_nth(icolumns,
- list_length(exprlist))))));
+ list_length(exprlist))))));
/*
* Prepare columns for assignment to target table.
/*
* Transform sorting/grouping stuff. Do ORDER BY first because both
- * transformGroupClause and transformDistinctClause need the results.
- * Note that these functions can also change the targetList, so it's
- * passed to them by reference.
+ * transformGroupClause and transformDistinctClause need the results. Note
+ * that these functions can also change the targetList, so it's passed to
+ * them by reference.
*/
qry->sortClause = transformSortClause(pstate,
stmt->sortClause,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("VALUES must not contain table references"),
parser_errposition(pstate,
- locate_var_of_level((Node *) newExprsLists, 0))));
+ locate_var_of_level((Node *) newExprsLists, 0))));
/*
* Another thing we can't currently support is NEW/OLD references in rules
errmsg("VALUES must not contain OLD or NEW references"),
errhint("Use SELECT ... UNION ALL ... instead."),
parser_errposition(pstate,
- locate_var_of_level((Node *) newExprsLists, 0))));
+ locate_var_of_level((Node *) newExprsLists, 0))));
qry->rtable = pstate->p_rtable;
qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("cannot use aggregate function in VALUES"),
parser_errposition(pstate,
- locate_agg_of_level((Node *) newExprsLists, 0))));
+ locate_agg_of_level((Node *) newExprsLists, 0))));
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("cannot use window function in VALUES"),
parser_errposition(pstate,
- locate_windowfunc((Node *) newExprsLists))));
+ locate_windowfunc((Node *) newExprsLists))));
return qry;
}
errdetail("Only result column names can be used, not expressions or functions."),
errhint("Add the expression/function to every SELECT, or move the UNION into a FROM clause."),
parser_errposition(pstate,
- exprLocation(list_nth(qry->targetList, tllen)))));
+ exprLocation(list_nth(qry->targetList, tllen)))));
qry->limitOffset = transformLimitClause(pstate, limitOffset,
"OFFSET");
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"),
parser_errposition(pstate,
- exprLocation((Node *) stmt->intoClause))));
+ exprLocation((Node *) stmt->intoClause))));
/* We don't support FOR UPDATE/SHARE with set ops at the moment. */
if (stmt->lockingClause)
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
parser_errposition(pstate,
- locate_var_of_level((Node *) selectQuery, 1))));
+ locate_var_of_level((Node *) selectQuery, 1))));
}
/*
/* no new relation references please */
if (list_length(pstate->p_rtable) != length_rtable)
{
- int vlocation = -1;
- int relid;
+ int vlocation = -1;
+ int relid;
/* try to locate such a reference to point to */
for (relid = length_rtable + 1; relid <= list_length(pstate->p_rtable); relid++)
}
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("RETURNING cannot contain references to other relations"),
+ errmsg("RETURNING cannot contain references to other relations"),
parser_errposition(pstate, vlocation)));
}
(errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
errmsg("DECLARE CURSOR cannot specify INTO"),
parser_errposition(pstate,
- exprLocation((Node *) result->intoClause))));
+ exprLocation((Node *) result->intoClause))));
/* FOR UPDATE and WITH HOLD are not compatible */
if (result->rowMarks != NIL && (stmt->options & CURSOR_OPT_HOLD))
{
/*
* We allow FOR UPDATE/SHARE of a WITH query to be
- * propagated into the WITH, but it doesn't seem
- * very sane to allow this for a reference to an
- * outer-level WITH. And it definitely wouldn't
- * work for a self-reference, since we're not done
+ * propagated into the WITH, but it doesn't seem very
+ * sane to allow this for a reference to an
+ * outer-level WITH. And it definitely wouldn't work
+ * for a self-reference, since we're not done
* analyzing the CTE anyway.
*/
CommonTableExpr *cte;
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE/SHARE cannot be applied to a join"),
- parser_errposition(pstate, thisrel->location)));
+ parser_errposition(pstate, thisrel->location)));
break;
case RTE_SPECIAL:
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE/SHARE cannot be applied to NEW or OLD"),
- parser_errposition(pstate, thisrel->location)));
+ parser_errposition(pstate, thisrel->location)));
break;
case RTE_FUNCTION:
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE/SHARE cannot be applied to a function"),
- parser_errposition(pstate, thisrel->location)));
+ parser_errposition(pstate, thisrel->location)));
break;
case RTE_VALUES:
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("SELECT FOR UPDATE/SHARE cannot be applied to VALUES"),
- parser_errposition(pstate, thisrel->location)));
+ parser_errposition(pstate, thisrel->location)));
break;
case RTE_CTE:
{
if (rte->ctelevelsup > 0 || rte->self_reference)
ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("SELECT FOR UPDATE/SHARE cannot be applied to an outer-level WITH query"),
- parser_errposition(pstate, thisrel->location)));
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("SELECT FOR UPDATE/SHARE cannot be applied to an outer-level WITH query"),
+ parser_errposition(pstate, thisrel->location)));
cte = GetCTEForRTE(pstate, rte, -1);
/* should be analyzed by now */
Assert(IsA(cte->ctequery, Query));
transformLockingClause(pstate,
- (Query *) cte->ctequery,
+ (Query *) cte->ctequery,
allrels);
}
break;
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregate function calls cannot be nested"),
parser_errposition(pstate,
- locate_agg_of_level((Node *) agg->args, 0))));
+ locate_agg_of_level((Node *) agg->args, 0))));
}
/* It can't contain window functions either */
WindowDef *windef)
{
/*
- * A window function call can't contain another one (but aggs are OK).
- * XXX is this required by spec, or just an unimplemented feature?
+ * A window function call can't contain another one (but aggs are OK). XXX
+ * is this required by spec, or just an unimplemented feature?
*/
if (pstate->p_hasWindowFuncs &&
checkExprHasWindowFuncs((Node *) wfunc->args))
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window function calls cannot be nested"),
parser_errposition(pstate,
- locate_windowfunc((Node *) wfunc->args))));
+ locate_windowfunc((Node *) wfunc->args))));
/*
- * If the OVER clause just specifies a window name, find that
- * WINDOW clause (which had better be present). Otherwise, try to
- * match all the properties of the OVER clause, and make a new entry
- * in the p_windowdefs list if no luck.
+ * If the OVER clause just specifies a window name, find that WINDOW
+ * clause (which had better be present). Otherwise, try to match all the
+ * properties of the OVER clause, and make a new entry in the p_windowdefs
+ * list if no luck.
*/
if (windef->name)
{
foreach(lc, pstate->p_windowdefs)
{
- WindowDef *refwin = (WindowDef *) lfirst(lc);
+ WindowDef *refwin = (WindowDef *) lfirst(lc);
winref++;
if (refwin->name && strcmp(refwin->name, windef->name) == 0)
foreach(lc, pstate->p_windowdefs)
{
- WindowDef *refwin = (WindowDef *) lfirst(lc);
+ WindowDef *refwin = (WindowDef *) lfirst(lc);
winref++;
if (refwin->refname && windef->refname &&
strcmp(refwin->refname, windef->refname) == 0)
- /* matched on refname */ ;
+ /* matched on refname */ ;
else if (!refwin->refname && !windef->refname)
- /* matched, no refname */ ;
+ /* matched, no refname */ ;
else
continue;
if (equal(refwin->partitionClause, windef->partitionClause) &&
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregates not allowed in WHERE clause"),
parser_errposition(pstate,
- locate_agg_of_level(qry->jointree->quals, 0))));
+ locate_agg_of_level(qry->jointree->quals, 0))));
if (checkExprHasAggs((Node *) qry->jointree->fromlist))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
errmsg("aggregates not allowed in JOIN conditions"),
parser_errposition(pstate,
- locate_agg_of_level((Node *) qry->jointree->fromlist, 0))));
+ locate_agg_of_level((Node *) qry->jointree->fromlist, 0))));
/*
* No aggregates allowed in GROUP BY clauses, either.
* If there are join alias vars involved, we have to flatten them to the
* underlying vars, so that aliased and unaliased vars will be correctly
* taken as equal. We can skip the expense of doing this if no rangetable
- * entries are RTE_JOIN kind.
- * We use the planner's flatten_join_alias_vars routine to do the
- * flattening; it wants a PlannerInfo root node, which fortunately can be
- * mostly dummy.
+ * entries are RTE_JOIN kind. We use the planner's flatten_join_alias_vars
+ * routine to do the flattening; it wants a PlannerInfo root node, which
+ * fortunately can be mostly dummy.
*/
if (hasJoinRTEs)
{
*
* Note: because we check resjunk tlist elements as well as regular ones,
* this will also find ungrouped variables that came from ORDER BY and
- * WINDOW clauses. For that matter, it's also going to examine the
+ * WINDOW clauses. For that matter, it's also going to examine the
* grouping expressions themselves --- but they'll all pass the test ...
*/
clause = (Node *) qry->targetList;
* Check for window functions where they shouldn't be.
*
* We have to forbid window functions in WHERE, JOIN/ON, HAVING, GROUP BY,
- * and window specifications. (Other clauses, such as RETURNING and LIMIT,
+ * and window specifications. (Other clauses, such as RETURNING and LIMIT,
* have already been checked.) Transformation of all these clauses must
* be completed already.
*/
void
parseCheckWindowFuncs(ParseState *pstate, Query *qry)
{
- ListCell *l;
+ ListCell *l;
/* This should only be called if we found window functions */
Assert(pstate->p_hasWindowFuncs);
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in WHERE clause"),
parser_errposition(pstate,
- locate_windowfunc(qry->jointree->quals))));
+ locate_windowfunc(qry->jointree->quals))));
if (checkExprHasWindowFuncs((Node *) qry->jointree->fromlist))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
errmsg("window functions not allowed in JOIN conditions"),
parser_errposition(pstate,
- locate_windowfunc((Node *) qry->jointree->fromlist))));
+ locate_windowfunc((Node *) qry->jointree->fromlist))));
if (checkExprHasWindowFuncs(qry->havingQual))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("window functions not allowed in GROUP BY clause"),
+ errmsg("window functions not allowed in GROUP BY clause"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
foreach(l, qry->windowClause)
{
- WindowClause *wc = (WindowClause *) lfirst(l);
+ WindowClause *wc = (WindowClause *) lfirst(l);
ListCell *l2;
foreach(l2, wc->partitionClause)
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("window functions not allowed in window definition"),
+ errmsg("window functions not allowed in window definition"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
if (checkExprHasWindowFuncs(expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("window functions not allowed in window definition"),
+ errmsg("window functions not allowed in window definition"),
parser_errposition(pstate,
locate_windowfunc(expr))));
}
#define DISTINCT_ON_CLAUSE 2
#define PARTITION_CLAUSE 3
-static const char * const clauseText[] = {
+static const char *const clauseText[] = {
"ORDER BY",
"GROUP BY",
"DISTINCT ON",
Var *l_colvar, Var *r_colvar);
static TargetEntry *findTargetlistEntry(ParseState *pstate, Node *node,
List **tlist, int clause);
-static int get_matching_location(int sortgroupref,
- List *sortgrouprefs, List *exprs);
+static int get_matching_location(int sortgroupref,
+ List *sortgrouprefs, List *exprs);
static List *addTargetToSortList(ParseState *pstate, TargetEntry *tle,
List *sortlist, List *targetlist, SortBy *sortby,
bool resolveUnknown);
errmsg("JOIN/ON clause refers to \"%s\", which is not part of JOIN",
rt_fetch(varno, pstate->p_rtable)->eref->aliasname),
parser_errposition(pstate,
- locate_var_of_relation(result, varno, 0))));
+ locate_var_of_relation(result, varno, 0))));
}
bms_free(clause_varnos);
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("subquery in FROM cannot have SELECT INTO"),
parser_errposition(pstate,
- exprLocation((Node *) query->intoClause))));
+ exprLocation((Node *) query->intoClause))));
/*
* The subquery cannot make use of any variables from FROM items created
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg("subquery in FROM cannot refer to other relations of same query level"),
parser_errposition(pstate,
- locate_var_of_level((Node *) query, 1))));
+ locate_var_of_level((Node *) query, 1))));
}
/*
checkExprHasWindowFuncs(funcexpr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot use window function in function expression in FROM"),
+ errmsg("cannot use window function in function expression in FROM"),
parser_errposition(pstate,
locate_windowfunc(funcexpr))));
if (IsA(n, RangeVar))
{
/* Plain relation reference, or perhaps a CTE reference */
- RangeVar *rv = (RangeVar *) n;
+ RangeVar *rv = (RangeVar *) n;
RangeTblRef *rtr;
RangeTblEntry *rte = NULL;
int rtindex;
if (!rv->schemaname)
{
CommonTableExpr *cte;
- Index levelsup;
+ Index levelsup;
cte = scanNameSpaceForCTE(pstate, rv->relname, &levelsup);
if (cte)
* info from the (first) matching ORDER BY item. This means that if
* you write something like "GROUP BY foo ORDER BY foo USING <<<", the
* GROUP BY operation silently takes on the equality semantics implied
- * by the ORDER BY. There are two reasons to do this: it improves
- * the odds that we can implement both GROUP BY and ORDER BY with a
- * single sort step, and it allows the user to choose the equality
- * semantics used by GROUP BY, should she be working with a datatype
- * that has more than one equality operator.
+ * by the ORDER BY. There are two reasons to do this: it improves the
+ * odds that we can implement both GROUP BY and ORDER BY with a single
+ * sort step, and it allows the user to choose the equality semantics
+ * used by GROUP BY, should she be working with a datatype that has
+ * more than one equality operator.
*/
if (tle->ressortgroupref > 0)
{
}
/*
- * If no match in ORDER BY, just add it to the result using
- * default sort/group semantics.
+ * If no match in ORDER BY, just add it to the result using default
+ * sort/group semantics.
*/
if (!found)
result = addTargetToGroupList(pstate, tle,
foreach(lc, windowdefs)
{
- WindowDef *windef = (WindowDef *) lfirst(lc);
+ WindowDef *windef = (WindowDef *) lfirst(lc);
WindowClause *refwc = NULL;
- List *partitionClause;
- List *orderClause;
+ List *partitionClause;
+ List *orderClause;
WindowClause *wc;
winref++;
/*
* Transform PARTITION and ORDER specs, if any. These are treated
- * exactly like top-level GROUP BY and ORDER BY clauses, including
- * the special handling of nondefault operator semantics.
+ * exactly like top-level GROUP BY and ORDER BY clauses, including the
+ * special handling of nondefault operator semantics.
*/
orderClause = transformSortClause(pstate,
windef->orderClause,
/*
* Per spec, a windowdef that references a previous one copies the
* previous partition clause (and mustn't specify its own). It can
- * specify its own ordering clause. but only if the previous one
- * had none. It always specifies its own frame clause, and the
- * previous one must not have a frame clause. (Yeah, it's bizarre
- * that each of these cases works differently, but SQL:2008 says so;
- * see 7.11 <window clause> syntax rule 10 and general rule 1.)
+ * specify its own ordering clause. but only if the previous one had
+ * none. It always specifies its own frame clause, and the previous
+ * one must not have a frame clause. (Yeah, it's bizarre that each of
+ * these cases works differently, but SQL:2008 says so; see 7.11
+ * <window clause> syntax rule 10 and general rule 1.)
*/
if (refwc)
{
if (partitionClause)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot override PARTITION BY clause of window \"%s\"",
- windef->refname),
+ errmsg("cannot override PARTITION BY clause of window \"%s\"",
+ windef->refname),
parser_errposition(pstate, windef->location)));
wc->partitionClause = copyObject(refwc->partitionClause);
}
if (orderClause && refwc->orderClause)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot override ORDER BY clause of window \"%s\"",
- windef->refname),
+ errmsg("cannot override ORDER BY clause of window \"%s\"",
+ windef->refname),
parser_errposition(pstate, windef->location)));
if (orderClause)
{
ListCell *tlitem;
/*
- * The distinctClause should consist of all ORDER BY items followed
- * by all other non-resjunk targetlist items. There must not be any
- * resjunk ORDER BY items --- that would imply that we are sorting
- * by a value that isn't necessarily unique within a DISTINCT group,
- * so the results wouldn't be well-defined. This construction
- * ensures we follow the rule that sortClause and distinctClause match;
- * in fact the sortClause will always be a prefix of distinctClause.
+ * The distinctClause should consist of all ORDER BY items followed by all
+ * other non-resjunk targetlist items. There must not be any resjunk
+ * ORDER BY items --- that would imply that we are sorting by a value that
+ * isn't necessarily unique within a DISTINCT group, so the results
+ * wouldn't be well-defined. This construction ensures we follow the rule
+ * that sortClause and distinctClause match; in fact the sortClause will
+ * always be a prefix of distinctClause.
*
- * Note a corner case: the same TLE could be in the ORDER BY list
- * multiple times with different sortops. We have to include it in
- * the distinctClause the same way to preserve the prefix property.
- * The net effect will be that the TLE value will be made unique
- * according to both sortops.
+ * Note a corner case: the same TLE could be in the ORDER BY list multiple
+ * times with different sortops. We have to include it in the
+ * distinctClause the same way to preserve the prefix property. The net
+ * effect will be that the TLE value will be made unique according to both
+ * sortops.
*/
foreach(slitem, sortClause)
{
}
/*
- * Now add any remaining non-resjunk tlist items, using default
- * sort/group semantics for their data types.
+ * Now add any remaining non-resjunk tlist items, using default sort/group
+ * semantics for their data types.
*/
foreach(tlitem, *targetlist)
{
/*
* Add all the DISTINCT ON expressions to the tlist (if not already
- * present, they are added as resjunk items). Assign sortgroupref
- * numbers to them, and make a list of these numbers. (NB: we rely
- * below on the sortgrouprefs list being one-for-one with the original
- * distinctlist. Also notice that we could have duplicate DISTINCT ON
- * expressions and hence duplicate entries in sortgrouprefs.)
+ * present, they are added as resjunk items). Assign sortgroupref numbers
+ * to them, and make a list of these numbers. (NB: we rely below on the
+ * sortgrouprefs list being one-for-one with the original distinctlist.
+ * Also notice that we could have duplicate DISTINCT ON expressions and
+ * hence duplicate entries in sortgrouprefs.)
*/
foreach(lc, distinctlist)
{
}
/*
- * If the user writes both DISTINCT ON and ORDER BY, adopt the
- * sorting semantics from ORDER BY items that match DISTINCT ON
- * items, and also adopt their column sort order. We insist that
- * the distinctClause and sortClause match, so throw error if we
- * find the need to add any more distinctClause items after we've
- * skipped an ORDER BY item that wasn't in DISTINCT ON.
+ * If the user writes both DISTINCT ON and ORDER BY, adopt the sorting
+ * semantics from ORDER BY items that match DISTINCT ON items, and also
+ * adopt their column sort order. We insist that the distinctClause and
+ * sortClause match, so throw error if we find the need to add any more
+ * distinctClause items after we've skipped an ORDER BY item that wasn't
+ * in DISTINCT ON.
*/
skipped_sortitem = false;
foreach(lc, sortClause)
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg("SELECT DISTINCT ON expressions must match initial ORDER BY expressions"),
parser_errposition(pstate,
- get_matching_location(scl->tleSortGroupRef,
- sortgrouprefs,
- distinctlist))));
+ get_matching_location(scl->tleSortGroupRef,
+ sortgrouprefs,
+ distinctlist))));
else
result = lappend(result, copyObject(scl));
}
/*
* Now add any remaining DISTINCT ON items, using default sort/group
- * semantics for their data types. (Note: this is pretty questionable;
- * if the ORDER BY list doesn't include all the DISTINCT ON items and more
+ * semantics for their data types. (Note: this is pretty questionable; if
+ * the ORDER BY list doesn't include all the DISTINCT ON items and more
* besides, you certainly aren't using DISTINCT ON in the intended way,
* and you probably aren't going to get consistent results. It might be
* better to throw an error or warning here. But historically we've
* Rather than clutter the API of get_sort_group_operators and the other
* functions we're about to use, make use of error context callback to
* mark any error reports with a parse position. We point to the operator
- * location if present, else to the expression being sorted. (NB: use
- * the original untransformed expression here; the TLE entry might well
- * point at a duplicate expression in the regular SELECT list.)
+ * location if present, else to the expression being sorted. (NB: use the
+ * original untransformed expression here; the TLE entry might well point
+ * at a duplicate expression in the regular SELECT list.)
*/
location = sortby->location;
if (location < 0)
* For most types we pass typmod -1 to the input routine, because
* existing input routines follow implicit-coercion semantics for
* length checks, which is not always what we want here. Any length
- * constraint will be applied later by our caller. An exception
+ * constraint will be applied later by our caller. An exception
* however is the INTERVAL type, for which we *must* pass the typmod
- * or it won't be able to obey the bizarre SQL-spec input rules.
- * (Ugly as sin, but so is this part of the spec...)
+ * or it won't be able to obey the bizarre SQL-spec input rules. (Ugly
+ * as sin, but so is this part of the spec...)
*/
if (baseTypeId == INTERVALOID)
inputTypeMod = baseTypeMod;
newcon->location = location;
/*
- * Set up to point at the constant's text if the input routine
- * throws an error.
+ * Set up to point at the constant's text if the input routine throws
+ * an error.
*/
setup_parser_errposition_callback(&pcbstate, pstate, con->location);
continue;
#ifdef NOT_USED /* not implemented yet */
+
/*
- * If input is record[] and target is a composite array type,
- * assume we can coerce (may need tighter checking here)
+ * If input is record[] and target is a composite array type, assume
+ * we can coerce (may need tighter checking here)
*/
if (inputTypeId == RECORDARRAYOID &&
is_complex_array(targetTypeId))
if (inputTypeId != BOOLOID)
{
- Node *newnode;
+ Node *newnode;
newnode = coerce_to_target_type(pstate, node, inputTypeId,
BOOLOID, -1,
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
/* translator: first %s is name of a SQL construct, eg WHERE */
- errmsg("argument of %s must be type boolean, not type %s",
- constructName, format_type_be(inputTypeId)),
+ errmsg("argument of %s must be type boolean, not type %s",
+ constructName, format_type_be(inputTypeId)),
parser_errposition(pstate, exprLocation(node))));
node = newnode;
}
if (inputTypeId != targetTypeId)
{
- Node *newnode;
+ Node *newnode;
newnode = coerce_to_target_type(pstate, node, inputTypeId,
targetTypeId, -1,
{
Node *pexpr;
Oid ptype;
- TYPCATEGORY pcategory;
+ TYPCATEGORY pcategory;
bool pispreferred;
ListCell *lc;
{
for_each_cell(lc, lc)
{
- Node *nexpr = (Node *) lfirst(lc);
- Oid ntype = exprType(nexpr);
+ Node *nexpr = (Node *) lfirst(lc);
+ Oid ntype = exprType(nexpr);
if (ntype != ptype)
break;
}
/*
- * Nope, so set up for the full algorithm. Note that at this point,
- * lc points to the first list item with type different from pexpr's;
- * we need not re-examine any items the previous loop advanced over.
+ * Nope, so set up for the full algorithm. Note that at this point, lc
+ * points to the first list item with type different from pexpr's; we need
+ * not re-examine any items the previous loop advanced over.
*/
ptype = getBaseType(ptype);
get_type_category_preferred(ptype, &pcategory, &pispreferred);
/* move on to next one if no new information... */
if (ntype != UNKNOWNOID && ntype != ptype)
{
- TYPCATEGORY ncategory;
+ TYPCATEGORY ncategory;
bool nispreferred;
get_type_category_preferred(ntype, &ncategory, &nispreferred);
*
* When allow_poly is false, we are not expecting any of the actual_arg_types
* to be polymorphic, and we should not return a polymorphic result type
- * either. When allow_poly is true, it is okay to have polymorphic "actual"
+ * either. When allow_poly is true, it is okay to have polymorphic "actual"
* arg types, and we can return ANYARRAY or ANYELEMENT as the result. (This
* case is currently used only to check compatibility of an aggregate's
* declaration with the underlying transfn.)
*
* A special case is that we could see ANYARRAY as an actual_arg_type even
* when allow_poly is false (this is possible only because pg_statistic has
- * columns shown as anyarray in the catalogs). We allow this to match a
+ * columns shown as anyarray in the catalogs). We allow this to match a
* declared ANYARRAY argument, but only if there is no ANYELEMENT argument
* or result (since we can't determine a specific element type to match to
* ANYELEMENT). Note this means that functions taking ANYARRAY had better
/*
* If we still haven't found a possibility, consider automatic casting
- * using I/O functions. We allow assignment casts to string types
- * and explicit casts from string types to be handled this way. (The
+ * using I/O functions. We allow assignment casts to string types and
+ * explicit casts from string types to be handled this way. (The
* CoerceViaIO mechanism is a lot more general than that, but this is
* all we want to allow in the absence of a pg_cast entry.) It would
* probably be better to insist on explicit casts in both directions,
typedef enum
{
RECURSION_OK,
- RECURSION_NONRECURSIVETERM, /* inside the left-hand term */
+ RECURSION_NONRECURSIVETERM, /* inside the left-hand term */
RECURSION_SUBLINK, /* inside a sublink */
RECURSION_OUTERJOIN, /* inside nullable side of an outer join */
RECURSION_INTERSECT, /* underneath INTERSECT (ALL) */
} RecursionContext;
/* Associated error messages --- each must have one %s for CTE name */
-static const char * const recursion_errormsgs[] = {
+static const char *const recursion_errormsgs[] = {
/* RECURSION_OK */
NULL,
/* RECURSION_NONRECURSIVETERM */
*/
typedef struct CteItem
{
- CommonTableExpr *cte; /* One CTE to examine */
- int id; /* Its ID number for dependencies */
- Node *non_recursive_term; /* Its nonrecursive part, if identified */
- Bitmapset *depends_on; /* CTEs depended on (not including self) */
+ CommonTableExpr *cte; /* One CTE to examine */
+ int id; /* Its ID number for dependencies */
+ Node *non_recursive_term; /* Its nonrecursive part, if
+ * identified */
+ Bitmapset *depends_on; /* CTEs depended on (not including self) */
} CteItem;
/* CteState is what we need to pass around in the tree walkers */
{
/* global state: */
ParseState *pstate; /* global parse state */
- CteItem *items; /* array of CTEs and extra data */
+ CteItem *items; /* array of CTEs and extra data */
int numitems; /* number of CTEs */
/* working state during a tree walk: */
int curitem; /* index of item currently being examined */
/*
* transformWithClause -
- * Transform the list of WITH clause "common table expressions" into
- * Query nodes.
+ * Transform the list of WITH clause "common table expressions" into
+ * Query nodes.
*
* The result is the list of transformed CTEs to be put into the output
* Query. (This is in fact the same as the ending value of p_ctenamespace,
Assert(pstate->p_future_ctes == NIL);
/*
- * For either type of WITH, there must not be duplicate CTE names in
- * the list. Check this right away so we needn't worry later.
+ * For either type of WITH, there must not be duplicate CTE names in the
+ * list. Check this right away so we needn't worry later.
*
- * Also, tentatively mark each CTE as non-recursive, and initialize
- * its reference count to zero.
+ * Also, tentatively mark each CTE as non-recursive, and initialize its
+ * reference count to zero.
*/
foreach(lc, withClause->ctes)
{
if (strcmp(cte->ctename, cte2->ctename) == 0)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_ALIAS),
- errmsg("WITH query name \"%s\" specified more than once",
- cte2->ctename),
+ errmsg("WITH query name \"%s\" specified more than once",
+ cte2->ctename),
parser_errposition(pstate, cte2->location)));
}
if (withClause->recursive)
{
/*
- * For WITH RECURSIVE, we rearrange the list elements if needed
- * to eliminate forward references. First, build a work array
- * and set up the data structure needed by the tree walkers.
+ * For WITH RECURSIVE, we rearrange the list elements if needed to
+ * eliminate forward references. First, build a work array and set up
+ * the data structure needed by the tree walkers.
*/
- CteState cstate;
- int i;
+ CteState cstate;
+ int i;
cstate.pstate = pstate;
cstate.numitems = list_length(withClause->ctes);
checkWellFormedRecursion(&cstate);
/*
- * Set up the ctenamespace for parse analysis. Per spec, all
- * the WITH items are visible to all others, so stuff them all in
- * before parse analysis. We build the list in safe processing
- * order so that the planner can process the queries in sequence.
+ * Set up the ctenamespace for parse analysis. Per spec, all the WITH
+ * items are visible to all others, so stuff them all in before parse
+ * analysis. We build the list in safe processing order so that the
+ * planner can process the queries in sequence.
*/
for (i = 0; i < cstate.numitems; i++)
{
CommonTableExpr *cte = cstate.items[i].cte;
/*
- * If it's recursive, we have to do a throwaway parse analysis
- * of the non-recursive term in order to determine the set of
- * output columns for the recursive CTE.
+ * If it's recursive, we have to do a throwaway parse analysis of
+ * the non-recursive term in order to determine the set of output
+ * columns for the recursive CTE.
*/
if (cte->cterecursive)
{
- Node *nrt;
- Query *nrq;
+ Node *nrt;
+ Query *nrq;
if (!cstate.items[i].non_recursive_term)
elog(ERROR, "could not find non-recursive term for %s",
{
/*
* For non-recursive WITH, just analyze each CTE in sequence and then
- * add it to the ctenamespace. This corresponds to the spec's
- * definition of the scope of each WITH name. However, to allow
- * error reports to be aware of the possibility of an erroneous
- * reference, we maintain a list in p_future_ctes of the
- * not-yet-visible CTEs.
+ * add it to the ctenamespace. This corresponds to the spec's
+ * definition of the scope of each WITH name. However, to allow error
+ * reports to be aware of the possibility of an erroneous reference,
+ * we maintain a list in p_future_ctes of the not-yet-visible CTEs.
*/
pstate->p_future_ctes = list_copy(withClause->ctes);
pstate->p_ctenamespace = lappend(pstate->p_ctenamespace, cte);
pstate->p_future_ctes = list_delete_first(pstate->p_future_ctes);
}
- }
+ }
return pstate->p_ctenamespace;
}
static void
analyzeCTE(ParseState *pstate, CommonTableExpr *cte)
{
- Query *query;
+ Query *query;
/* Analysis not done already */
Assert(IsA(cte->ctequery, SelectStmt));
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("subquery in WITH cannot have SELECT INTO"),
parser_errposition(pstate,
- exprLocation((Node *) query->intoClause))));
+ exprLocation((Node *) query->intoClause))));
if (!cte->cterecursive)
{
{
/*
* Verify that the previously determined output column types match
- * what the query really produced. We have to check this because
- * the recursive term could have overridden the non-recursive term,
- * and we don't have any easy way to fix that.
+ * what the query really produced. We have to check this because the
+ * recursive term could have overridden the non-recursive term, and we
+ * don't have any easy way to fix that.
*/
ListCell *lctlist,
*lctyp,
foreach(lctlist, query->targetList)
{
TargetEntry *te = (TargetEntry *) lfirst(lctlist);
- Node *texpr;
+ Node *texpr;
if (te->resjunk)
continue;
errmsg("recursive query \"%s\" column %d has type %s in non-recursive term but type %s overall",
cte->ctename, varattno,
format_type_with_typemod(lfirst_oid(lctyp),
- lfirst_int(lctypmod)),
+ lfirst_int(lctypmod)),
format_type_with_typemod(exprType(texpr),
exprTypmod(texpr))),
errhint("Cast the output of the non-recursive term to the correct type."),
lctyp = lnext(lctyp);
lctypmod = lnext(lctypmod);
}
- if (lctyp != NULL || lctypmod != NULL) /* shouldn't happen */
+ if (lctyp != NULL || lctypmod != NULL) /* shouldn't happen */
elog(ERROR, "wrong number of output columns in WITH");
}
}
/*
* We need to determine column names and types. The alias column names
- * override anything coming from the query itself. (Note: the SQL spec
- * says that the alias list must be empty or exactly as long as the
- * output column set; but we allow it to be shorter for consistency
- * with Alias handling.)
+ * override anything coming from the query itself. (Note: the SQL spec
+ * says that the alias list must be empty or exactly as long as the output
+ * column set; but we allow it to be shorter for consistency with Alias
+ * handling.)
*/
cte->ctecolnames = copyObject(cte->aliascolnames);
cte->ctecoltypes = cte->ctecoltypmods = NIL;
}
coltype = exprType((Node *) te->expr);
coltypmod = exprTypmod((Node *) te->expr);
+
/*
* If the CTE is recursive, force the exposed column type of any
- * "unknown" column to "text". This corresponds to the fact that
- * SELECT 'foo' UNION SELECT 'bar' will ultimately produce text.
- * We might see "unknown" as a result of an untyped literal in
- * the non-recursive term's select list, and if we don't convert
- * to text then we'll have a mismatch against the UNION result.
+ * "unknown" column to "text". This corresponds to the fact that
+ * SELECT 'foo' UNION SELECT 'bar' will ultimately produce text. We
+ * might see "unknown" as a result of an untyped literal in the
+ * non-recursive term's select list, and if we don't convert to text
+ * then we'll have a mismatch against the UNION result.
*/
if (cte->cterecursive && coltype == UNKNOWNOID)
{
/* If unqualified name, might be a CTE reference */
if (!rv->schemaname)
{
- ListCell *lc;
- int i;
+ ListCell *lc;
+ int i;
/* ... but first see if it's captured by an inner WITH */
foreach(lc, cstate->innerwiths)
{
- List *withlist = (List *) lfirst(lc);
- ListCell *lc2;
+ List *withlist = (List *) lfirst(lc);
+ ListCell *lc2;
foreach(lc2, withlist)
{
CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc2);
if (strcmp(rv->relname, cte->ctename) == 0)
- return false; /* yes, so bail out */
+ return false; /* yes, so bail out */
}
}
if (strcmp(rv->relname, cte->ctename) == 0)
{
- int myindex = cstate->curitem;
+ int myindex = cstate->curitem;
if (i != myindex)
{
if (IsA(node, SelectStmt))
{
SelectStmt *stmt = (SelectStmt *) node;
- ListCell *lc;
+ ListCell *lc;
if (stmt->withClause)
{
{
/*
* In the RECURSIVE case, all query names of the WITH are
- * visible to all WITH items as well as the main query.
- * So push them all on, process, pop them all off.
+ * visible to all WITH items as well as the main query. So
+ * push them all on, process, pop them all off.
*/
cstate->innerwiths = lcons(stmt->withClause->ctes,
cstate->innerwiths);
else
{
/*
- * In the non-RECURSIVE case, query names are visible to
- * the WITH items after them and to the main query.
+ * In the non-RECURSIVE case, query names are visible to the
+ * WITH items after them and to the main query.
*/
ListCell *cell1;
if (IsA(node, WithClause))
{
/*
- * Prevent raw_expression_tree_walker from recursing directly into
- * a WITH clause. We need that to happen only under the control
- * of the code above.
+ * Prevent raw_expression_tree_walker from recursing directly into a
+ * WITH clause. We need that to happen only under the control of the
+ * code above.
*/
return false;
}
static void
TopologicalSort(ParseState *pstate, CteItem *items, int numitems)
{
- int i, j;
+ int i,
+ j;
/* for each position in sequence ... */
for (i = 0; i < numitems; i++)
if (j >= numitems)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("mutual recursion between WITH items is not implemented"),
+ errmsg("mutual recursion between WITH items is not implemented"),
parser_errposition(pstate, items[i].cte->location)));
/*
- * Found one. Move it to front and remove it from every other
- * item's dependencies.
+ * Found one. Move it to front and remove it from every other item's
+ * dependencies.
*/
if (i != j)
{
- CteItem tmp;
-
+ CteItem tmp;
+
tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
+
/*
- * Items up through i are known to have no dependencies left,
- * so we can skip them in this loop.
+ * Items up through i are known to have no dependencies left, so we
+ * can skip them in this loop.
*/
for (j = i + 1; j < numitems; j++)
{
for (i = 0; i < cstate->numitems; i++)
{
CommonTableExpr *cte = cstate->items[i].cte;
- SelectStmt *stmt = (SelectStmt *) cte->ctequery;
+ SelectStmt *stmt = (SelectStmt *) cte->ctequery;
- Assert(IsA(stmt, SelectStmt)); /* not analyzed yet */
+ Assert(IsA(stmt, SelectStmt)); /* not analyzed yet */
/* Ignore items that weren't found to be recursive */
if (!cte->cterecursive)
cstate->context = RECURSION_OK;
checkWellFormedRecursionWalker((Node *) stmt->rarg, cstate);
Assert(cstate->innerwiths == NIL);
- if (cstate->selfrefcount != 1) /* shouldn't happen */
+ if (cstate->selfrefcount != 1) /* shouldn't happen */
elog(ERROR, "missing recursive reference");
/*
- * Disallow ORDER BY and similar decoration atop the UNION.
- * These don't make sense because it's impossible to figure out what
- * they mean when we have only part of the recursive query's results.
- * (If we did allow them, we'd have to check for recursive references
+ * Disallow ORDER BY and similar decoration atop the UNION. These
+ * don't make sense because it's impossible to figure out what they
+ * mean when we have only part of the recursive query's results. (If
+ * we did allow them, we'd have to check for recursive references
* inside these subtrees.)
*/
if (stmt->sortClause)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("ORDER BY in a recursive query is not implemented"),
+ errmsg("ORDER BY in a recursive query is not implemented"),
parser_errposition(cstate->pstate,
- exprLocation((Node *) stmt->sortClause))));
+ exprLocation((Node *) stmt->sortClause))));
if (stmt->limitOffset)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("FOR UPDATE/SHARE in a recursive query is not implemented"),
parser_errposition(cstate->pstate,
- exprLocation((Node *) stmt->lockingClause))));
+ exprLocation((Node *) stmt->lockingClause))));
/*
* Save non_recursive_term.
/* If unqualified name, might be a CTE reference */
if (!rv->schemaname)
{
- ListCell *lc;
+ ListCell *lc;
CommonTableExpr *mycte;
/* ... but first see if it's captured by an inner WITH */
foreach(lc, cstate->innerwiths)
{
- List *withlist = (List *) lfirst(lc);
- ListCell *lc2;
+ List *withlist = (List *) lfirst(lc);
+ ListCell *lc2;
foreach(lc2, withlist)
{
CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc2);
if (strcmp(rv->relname, cte->ctename) == 0)
- return false; /* yes, so bail out */
+ return false; /* yes, so bail out */
}
}
if (IsA(node, SelectStmt))
{
SelectStmt *stmt = (SelectStmt *) node;
- ListCell *lc;
+ ListCell *lc;
if (stmt->withClause)
{
{
/*
* In the RECURSIVE case, all query names of the WITH are
- * visible to all WITH items as well as the main query.
- * So push them all on, process, pop them all off.
+ * visible to all WITH items as well as the main query. So
+ * push them all on, process, pop them all off.
*/
cstate->innerwiths = lcons(stmt->withClause->ctes,
cstate->innerwiths);
else
{
/*
- * In the non-RECURSIVE case, query names are visible to
- * the WITH items after them and to the main query.
+ * In the non-RECURSIVE case, query names are visible to the
+ * WITH items after them and to the main query.
*/
ListCell *cell1;
}
}
else
- checkWellFormedSelectStmt(stmt, cstate);
+ checkWellFormedSelectStmt(stmt, cstate);
/* We're done examining the SelectStmt */
return false;
}
if (IsA(node, WithClause))
{
/*
- * Prevent raw_expression_tree_walker from recursing directly into
- * a WITH clause. We need that to happen only under the control
- * of the code above.
+ * Prevent raw_expression_tree_walker from recursing directly into a
+ * WITH clause. We need that to happen only under the control of the
+ * code above.
*/
return false;
}
if (IsA(node, JoinExpr))
{
- JoinExpr *j = (JoinExpr *) node;
+ JoinExpr *j = (JoinExpr *) node;
switch (j->jointype)
{
}
if (IsA(node, SubLink))
{
- SubLink *sl = (SubLink *) node;
+ SubLink *sl = (SubLink *) node;
/*
* we intentionally override outer context, since subquery is
TypeCast *tc = (TypeCast *) expr;
/*
- * If the subject of the typecast is an ARRAY[] construct
- * and the target type is an array type, we invoke
- * transformArrayExpr() directly so that we can pass down
- * the type information. This avoids some cases where
+ * If the subject of the typecast is an ARRAY[] construct and
+ * the target type is an array type, we invoke
+ * transformArrayExpr() directly so that we can pass down the
+ * type information. This avoids some cases where
* transformArrayExpr() might not infer the correct type.
*/
if (IsA(tc->arg, A_ArrayExpr))
}
/*
- * Corner case: ARRAY[] cast to a non-array type.
- * Fall through to do it the standard way.
+ * Corner case: ARRAY[] cast to a non-array type. Fall
+ * through to do it the standard way.
*/
}
* We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
* possible if the inputs are all scalars (no RowExprs) and there is a
* suitable array type available. If not, we fall back to a boolean
- * condition tree with multiple copies of the lefthand expression.
- * Also, any IN-list items that contain Vars are handled as separate
- * boolean conditions, because that gives the planner more scope for
- * optimization on such clauses.
+ * condition tree with multiple copies of the lefthand expression. Also,
+ * any IN-list items that contain Vars are handled as separate boolean
+ * conditions, because that gives the planner more scope for optimization
+ * on such clauses.
*
* First step: transform all the inputs, and detect whether any are
* RowExprs or contain Vars.
}
/*
- * ScalarArrayOpExpr is only going to be useful if there's more than
- * one non-Var righthand item. Also, it won't work for RowExprs.
+ * ScalarArrayOpExpr is only going to be useful if there's more than one
+ * non-Var righthand item. Also, it won't work for RowExprs.
*/
if (!haveRowExpr && list_length(rnonvars) > 1)
{
Oid array_type;
/*
- * Try to select a common type for the array elements. Note that
+ * Try to select a common type for the array elements. Note that
* since the LHS' type is first in the list, it will be preferred when
* there is doubt (eg, when all the RHS items are unknown literals).
*
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("subquery cannot have SELECT INTO"),
parser_errposition(pstate,
- exprLocation((Node *) qtree->intoClause))));
+ exprLocation((Node *) qtree->intoClause))));
sublink->subselect = (Node *) qtree;
Oid coerce_type;
bool coerce_hard;
- /*
- * Transform the element expressions
+ /*
+ * Transform the element expressions
*
- * Assume that the array is one-dimensional unless we find an
- * array-type element expression.
- */
+ * Assume that the array is one-dimensional unless we find an array-type
+ * element expression.
+ */
newa->multidims = false;
foreach(element, a->elements)
{
Node *newe;
/*
- * If an element is itself an A_ArrayExpr, recurse directly so that
- * we can pass down any target type we were given.
+ * If an element is itself an A_ArrayExpr, recurse directly so that we
+ * can pass down any target type we were given.
*/
if (IsA(e, A_ArrayExpr))
{
else
{
newe = transformExpr(pstate, e);
+
/*
- * Check for sub-array expressions, if we haven't already
- * found one.
+ * Check for sub-array expressions, if we haven't already found
+ * one.
*/
if (!newa->multidims && type_is_array(exprType(newe)))
newa->multidims = true;
newelems = lappend(newelems, newe);
}
- /*
+ /*
* Select a target type for the elements.
*
* If we haven't been given a target array type, we must try to deduce a
if (!OidIsValid(element_type))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("could not find element type for data type %s",
- format_type_be(array_type)),
+ errmsg("could not find element type for data type %s",
+ format_type_be(array_type)),
parser_errposition(pstate, a->location)));
}
else
}
/*
- * Coerce elements to target type
+ * Coerce elements to target type
*
* If the array has been explicitly cast, then the elements are in turn
* explicitly coerced.
* If the array's type was merely derived from the common type of its
* elements, then the elements are implicitly coerced to the common type.
* This is consistent with other uses of select_common_type().
- */
+ */
foreach(element, newelems)
{
Node *e = (Node *) lfirst(element);
if (coerce_hard)
{
- newe = coerce_to_target_type(pstate, e,
+ newe = coerce_to_target_type(pstate, e,
exprType(e),
- coerce_type,
+ coerce_type,
typmod,
COERCION_EXPLICIT,
COERCE_EXPLICIT_CAST,
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
x->op == IS_XMLELEMENT
- ? errmsg("unnamed XML attribute value must be a column reference")
- : errmsg("unnamed XML element value must be a column reference"),
+ ? errmsg("unnamed XML attribute value must be a column reference")
+ : errmsg("unnamed XML element value must be a column reference"),
parser_errposition(pstate, r->location)));
argname = NULL; /* keep compiler quiet */
}
if (strcmp(argname, strVal(lfirst(lc2))) == 0)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("XML attribute name \"%s\" appears more than once",
- argname),
+ errmsg("XML attribute name \"%s\" appears more than once",
+ argname),
parser_errposition(pstate, r->location)));
}
}
if (list_length(fargs) > FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
- errmsg_plural("cannot pass more than %d argument to a function",
- "cannot pass more than %d arguments to a function",
- FUNC_MAX_ARGS,
- FUNC_MAX_ARGS),
+ errmsg_plural("cannot pass more than %d argument to a function",
+ "cannot pass more than %d arguments to a function",
+ FUNC_MAX_ARGS,
+ FUNC_MAX_ARGS),
parser_errposition(pstate, location)));
/*
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("OVER specified, but %s is not a window function nor an aggregate function",
- NameListToString(funcname)),
+ NameListToString(funcname)),
parser_errposition(pstate, location)));
}
else if (!(fdresult == FUNCDETAIL_AGGREGATE ||
* If there are default arguments, we have to include their types in
* actual_arg_types for the purpose of checking generic type consistency.
* However, we do NOT put them into the generated parse node, because
- * their actual values might change before the query gets run. The
+ * their actual values might change before the query gets run. The
* planner has to insert the up-to-date values at plan time.
*/
nargsplusdefs = nargs;
foreach(l, argdefaults)
{
- Node *expr = (Node *) lfirst(l);
+ Node *expr = (Node *) lfirst(l);
/* probably shouldn't happen ... */
if (nargsplusdefs >= FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
- errmsg_plural("cannot pass more than %d argument to a function",
- "cannot pass more than %d arguments to a function",
- FUNC_MAX_ARGS,
- FUNC_MAX_ARGS),
+ errmsg_plural("cannot pass more than %d argument to a function",
+ "cannot pass more than %d arguments to a function",
+ FUNC_MAX_ARGS,
+ FUNC_MAX_ARGS),
parser_errposition(pstate, location)));
actual_arg_types[nargsplusdefs++] = exprType(expr);
*/
if (nvargs > 0 && declared_arg_types[nargs - 1] != ANYOID)
{
- ArrayExpr *newa = makeNode(ArrayExpr);
- int non_var_args = nargs - nvargs;
- List *vargs;
+ ArrayExpr *newa = makeNode(ArrayExpr);
+ int non_var_args = nargs - nvargs;
+ List *vargs;
Assert(non_var_args >= 0);
vargs = list_copy_tail(fargs, non_var_args);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("could not find array type for data type %s",
format_type_be(newa->element_typeid)),
- parser_errposition(pstate, exprLocation((Node *) vargs))));
+ parser_errposition(pstate, exprLocation((Node *) vargs))));
newa->multidims = false;
newa->location = exprLocation((Node *) vargs);
if (agg_distinct)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("DISTINCT is not implemented for window functions"),
+ errmsg("DISTINCT is not implemented for window functions"),
parser_errposition(pstate, location)));
/*
int nbestMatch,
nmatch;
Oid input_base_typeids[FUNC_MAX_ARGS];
- TYPCATEGORY slot_category[FUNC_MAX_ARGS],
+ TYPCATEGORY slot_category[FUNC_MAX_ARGS],
current_category;
bool current_is_preferred;
bool slot_has_preferred_type[FUNC_MAX_ARGS];
if (nargs > FUNC_MAX_ARGS)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
- errmsg_plural("cannot pass more than %d argument to a function",
- "cannot pass more than %d arguments to a function",
- FUNC_MAX_ARGS,
- FUNC_MAX_ARGS)));
+ errmsg_plural("cannot pass more than %d argument to a function",
+ "cannot pass more than %d arguments to a function",
+ FUNC_MAX_ARGS,
+ FUNC_MAX_ARGS)));
/*
* If any input types are domains, reduce them to their base types. This
*nvargs = 0;
*true_typeids = NULL;
if (argdefaults)
- *argdefaults = NIL;
+ *argdefaults = NIL;
/* Get list of possible candidates from namespace search */
raw_candidates = FuncnameGetCandidates(funcname, nargs,
/*
* If expanding variadics or defaults, the "best candidate" might
- * represent multiple equivalently good functions; treat this case
- * as ambiguous.
+ * represent multiple equivalently good functions; treat this case as
+ * ambiguous.
*/
if (!OidIsValid(best_candidate->oid))
return FUNCDETAIL_MULTIPLE;
* Sometimes the parser calls functions that aren't part of the parser
* subsystem and can't reasonably be passed a ParseState; yet we would
* like any errors thrown in those functions to be tagged with a parse
- * error location. Use this function to set up an error context stack
+ * error location. Use this function to set up an error context stack
* entry that will accomplish that. Usage pattern:
*
* declare a local variable "ParseCallbackState pcbstate"
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("array subscript must have type integer"),
- parser_errposition(pstate, exprLocation(ai->lidx))));
+ parser_errposition(pstate, exprLocation(ai->lidx))));
}
else
{
" but expression is of type %s",
format_type_be(typeneeded),
format_type_be(typesource)),
- errhint("You will need to rewrite or cast the expression."),
+ errhint("You will need to rewrite or cast the expression."),
parser_errposition(pstate, exprLocation(assignFrom))));
assignFrom = newFrom;
}
typeid = INT8OID;
typelen = sizeof(int64);
- typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
+ typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
}
}
else
typedef struct OprCacheEntry
{
/* the hash lookup key MUST BE FIRST */
- OprCacheKey key;
+ OprCacheKey key;
Oid opr_oid; /* OID of the resolved operator */
} OprCacheEntry;
Oid arg1, Oid arg2,
FuncDetailCode fdresult, int location);
static bool make_oper_cache_key(OprCacheKey *key, List *opname,
- Oid ltypeId, Oid rtypeId);
+ Oid ltypeId, Oid rtypeId);
static Oid find_oper_cache_entry(OprCacheKey *key);
static void make_oper_cache_entry(OprCacheKey *key, Oid opr_oid);
static void InvalidateOprCacheCallBack(Datum arg, int cacheid, ItemPointer tuplePtr);
* are consistent, ie all from the same opclass.
*/
typentry = lookup_type_cache(argtype,
- TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR);
+ TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR);
lt_opr = typentry->lt_opr;
eq_opr = typentry->eq_opr;
gt_opr = typentry->gt_opr;
/*
* If the datatype is an array, then we can use array_lt and friends ...
* but only if there are suitable operators for the element type. (This
- * check is not in the raw typcache.c code ... should it be?) Testing
- * all three operator IDs here should be redundant.
+ * check is not in the raw typcache.c code ... should it be?) Testing all
+ * three operator IDs here should be redundant.
*/
if (lt_opr == ARRAY_LT_OP ||
eq_opr == ARRAY_EQ_OP ||
if (OidIsValid(elem_type))
{
typentry = lookup_type_cache(elem_type,
- TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR);
+ TYPECACHE_LT_OPR | TYPECACHE_EQ_OPR | TYPECACHE_GT_OPR);
if (!OidIsValid(typentry->lt_opr))
lt_opr = InvalidOid; /* element type has no "<" */
if (!OidIsValid(typentry->eq_opr))
gt_opr = InvalidOid; /* element type has no ">" */
}
else
- lt_opr = eq_opr = gt_opr = InvalidOid; /* bogus array type? */
+ lt_opr = eq_opr = gt_opr = InvalidOid; /* bogus array type? */
}
/* Report errors if needed */
bool noError, int location)
{
Oid operOid;
- OprCacheKey key;
+ OprCacheKey key;
bool key_ok;
FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;
HeapTuple tup = NULL;
right_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
{
Oid operOid;
- OprCacheKey key;
+ OprCacheKey key;
bool key_ok;
FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;
HeapTuple tup = NULL;
left_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location)
{
Oid operOid;
- OprCacheKey key;
+ OprCacheKey key;
bool key_ok;
FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;
HeapTuple tup = NULL;
* mapping is pretty expensive to compute, especially for ambiguous operators;
* this is mainly because there are a *lot* of instances of popular operator
* names such as "=", and we have to check each one to see which is the
- * best match. So once we have identified the correct mapping, we save it
+ * best match. So once we have identified the correct mapping, we save it
* in a cache that need only be flushed on pg_operator or pg_cast change.
* (pg_cast must be considered because changes in the set of implicit casts
* affect the set of applicable operators for any given input datatype.)
{
/* get the active search path */
if (fetch_search_path_array(key->search_path,
- MAX_CACHED_PATH_LEN) > MAX_CACHED_PATH_LEN)
+ MAX_CACHED_PATH_LEN) > MAX_CACHED_PATH_LEN)
return false; /* oops, didn't fit */
}
ctl.entrysize = sizeof(OprCacheEntry);
ctl.hash = tag_hash;
OprCacheHash = hash_create("Operator lookup cache", 256,
- &ctl, HASH_ELEM | HASH_FUNCTION);
+ &ctl, HASH_ELEM | HASH_FUNCTION);
/* Arrange to flush cache on pg_operator and pg_cast changes */
CacheRegisterSyscacheCallback(OPERNAMENSP,
static RangeTblEntry *scanNameSpaceForRefname(ParseState *pstate,
const char *refname, int location);
static RangeTblEntry *scanNameSpaceForRelid(ParseState *pstate, Oid relid,
- int location);
+ int location);
static void markRTEForSelectPriv(ParseState *pstate, RangeTblEntry *rte,
- int rtindex, AttrNumber col);
+ int rtindex, AttrNumber col);
static bool isLockedRel(ParseState *pstate, char *refname);
static void expandRelation(Oid relid, Alias *eref,
int rtindex, int sublevels_up,
scanNameSpaceForCTE(ParseState *pstate, const char *refname,
Index *ctelevelsup)
{
- Index levelsup;
+ Index levelsup;
for (levelsup = 0;
pstate != NULL;
pstate = pstate->parentParseState, levelsup++)
{
- ListCell *lc;
+ ListCell *lc;
foreach(lc, pstate->p_ctenamespace)
{
{
for (; pstate != NULL; pstate = pstate->parentParseState)
{
- ListCell *lc;
+ ListCell *lc;
foreach(lc, pstate->p_future_ctes)
{
Index levelsup;
/*
- * If it's an unqualified name, check for possible CTE matches.
- * A CTE hides any real relation matches. If no CTE, look for
- * a matching relation.
+ * If it's an unqualified name, check for possible CTE matches. A CTE
+ * hides any real relation matches. If no CTE, look for a matching
+ * relation.
*/
if (!relation->schemaname)
cte = scanNameSpaceForCTE(pstate, refname, &ctelevelsup);
rte->requiredPerms |= ACL_SELECT;
/* Must offset the attnum to fit in a bitmapset */
rte->selectedCols = bms_add_member(rte->selectedCols,
- col - FirstLowInvalidHeapAttributeNumber);
+ col - FirstLowInvalidHeapAttributeNumber);
}
else if (rte->rtekind == RTE_JOIN)
{
if (col == InvalidAttrNumber)
{
/*
- * A whole-row reference to a join has to be treated as
- * whole-row references to the two inputs.
+ * A whole-row reference to a join has to be treated as whole-row
+ * references to the two inputs.
*/
JoinExpr *j;
/* Note: we can't see FromExpr here */
if (IsA(j->larg, RangeTblRef))
{
- int varno = ((RangeTblRef *) j->larg)->rtindex;
+ int varno = ((RangeTblRef *) j->larg)->rtindex;
markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
}
else if (IsA(j->larg, JoinExpr))
{
- int varno = ((JoinExpr *) j->larg)->rtindex;
+ int varno = ((JoinExpr *) j->larg)->rtindex;
markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
}
(int) nodeTag(j->larg));
if (IsA(j->rarg, RangeTblRef))
{
- int varno = ((RangeTblRef *) j->rarg)->rtindex;
+ int varno = ((RangeTblRef *) j->rarg)->rtindex;
markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
}
else if (IsA(j->rarg, JoinExpr))
{
- int varno = ((JoinExpr *) j->rarg)->rtindex;
+ int varno = ((JoinExpr *) j->rarg)->rtindex;
markRTEForSelectPriv(pstate, NULL, varno, InvalidAttrNumber);
}
* The aliasvar could be either a Var or a COALESCE expression,
* but in the latter case we should already have marked the two
* referent variables as being selected, due to their use in the
- * JOIN clause. So we need only be concerned with the simple
- * Var case.
+ * JOIN clause. So we need only be concerned with the simple Var
+ * case.
*/
- Var *aliasvar;
+ Var *aliasvar;
Assert(col > 0 && col <= list_length(rte->joinaliasvars));
aliasvar = (Var *) list_nth(rte->joinaliasvars, col - 1);
void
markVarForSelectPriv(ParseState *pstate, Var *var, RangeTblEntry *rte)
{
- Index lv;
+ Index lv;
Assert(IsA(var, Var));
/* Find the appropriate pstate if it's an uplevel Var */
int numaliases;
/*
- * Fail if join has too many columns --- we must be able to reference
- * any of the columns with an AttrNumber.
+ * Fail if join has too many columns --- we must be able to reference any
+ * of the columns with an AttrNumber.
*/
if (list_length(aliasvars) > MaxAttrNumber)
ereport(ERROR,
varattno = 0;
forboth(lct, rte->ctecoltypes, lcm, rte->ctecoltypmods)
{
- Oid coltype = lfirst_oid(lct);
- int32 coltypmod = lfirst_int(lcm);
+ Oid coltype = lfirst_oid(lct);
+ int32 coltypmod = lfirst_int(lcm);
varattno++;
markVarForSelectPriv(pstate, varnode, rte);
}
- Assert(name == NULL && var == NULL); /* lists not the same length? */
+ Assert(name == NULL && var == NULL); /* lists not the same length? */
return te_list;
}
if (rte)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
- errmsg("invalid reference to FROM-clause entry for table \"%s\"",
- relation->relname),
+ errmsg("invalid reference to FROM-clause entry for table \"%s\"",
+ relation->relname),
(badAlias ?
errhint("Perhaps you meant to reference the table alias \"%s\".",
badAlias) :
/* not a simple relation, leave it unmarked */
break;
case RTE_CTE:
+
/*
- * CTE reference: copy up from the subquery, if possible.
- * If the RTE is a recursive self-reference then we can't do
- * anything because we haven't finished analyzing it yet.
- * However, it's no big loss because we must be down inside
- * the recursive term of a recursive CTE, and so any markings
- * on the current targetlist are not going to affect the results
- * anyway.
+ * CTE reference: copy up from the subquery, if possible. If the
+ * RTE is a recursive self-reference then we can't do anything
+ * because we haven't finished analyzing it yet. However, it's no
+ * big loss because we must be down inside the recursive term of a
+ * recursive CTE, and so any markings on the current targetlist
+ * are not going to affect the results anyway.
*/
if (attnum != InvalidAttrNumber && !rte->self_reference)
{
*
* Note: location points at the target column name (SET target or INSERT
* column name list entry), and must therefore be -1 in an INSERT that
- * omits the column name list. So we should usually prefer to use
+ * omits the column name list. So we should usually prefer to use
* exprLocation(expr) for errors that can happen in a default INSERT.
*/
Expr *
* For normal non-qualified target column, do type checking and
* coercion.
*/
- Node *orig_expr = (Node *) expr;
+ Node *orig_expr = (Node *) expr;
expr = (Expr *)
coerce_to_target_type(pstate,
/* Require read access to each column */
foreach(l, vars)
{
- Var *var = (Var *) lfirst(l);
+ Var *var = (Var *) lfirst(l);
markVarForSelectPriv(pstate, var, rte);
}
typioparam, atttypmod);
#ifdef RANDOMIZE_ALLOCATED_MEMORY
+
/*
* For pass-by-reference data types, repeat the conversion to see if the
* input function leaves any uninitialized bytes in the result. We can
- * only detect that reliably if RANDOMIZE_ALLOCATED_MEMORY is enabled,
- * so we don't bother testing otherwise. The reason we don't want any
+ * only detect that reliably if RANDOMIZE_ALLOCATED_MEMORY is enabled, so
+ * we don't bother testing otherwise. The reason we don't want any
* instability in the input function is that comparison of Const nodes
* relies on bytewise comparison of the datums, so if the input function
* leaves garbage then subexpressions that should be identical may not get
- * recognized as such. See pgsql-hackers discussion of 2008-04-04.
+ * recognized as such. See pgsql-hackers discussion of 2008-04-04.
*/
if (string && !typform->typbyval)
{
}
/*
- * We have to reject "serial[]" explicitly, because once we've
- * set typeid, LookupTypeName won't notice arrayBounds. We don't
- * need any special coding for serial(typmod) though.
+ * We have to reject "serial[]" explicitly, because once we've set
+ * typeid, LookupTypeName won't notice arrayBounds. We don't need any
+ * special coding for serial(typmod) though.
*/
if (is_serial && column->typename->arrayBounds != NIL)
ereport(ERROR,
index->idxname = NULL;
/*
- * If the index is marked PRIMARY, it's certainly from a constraint;
- * else, if it's not marked UNIQUE, it certainly isn't; else, we have
- * to search pg_depend to see if there's an associated unique constraint.
+ * If the index is marked PRIMARY, it's certainly from a constraint; else,
+ * if it's not marked UNIQUE, it certainly isn't; else, we have to search
+ * pg_depend to see if there's an associated unique constraint.
*/
if (index->primary)
index->isconstraint = true;
if (amrec->amcanorder)
{
/*
- * If it supports sort ordering, copy DESC and NULLS opts.
- * Don't set non-default settings unnecessarily, though,
- * so as to improve the chance of recognizing equivalence
- * to constraint indexes.
+ * If it supports sort ordering, copy DESC and NULLS opts. Don't
+ * set non-default settings unnecessarily, though, so as to
+ * improve the chance of recognizing equivalence to constraint
+ * indexes.
*/
if (opt & INDOPTION_DESC)
{
strcmp(index->accessMethod, priorindex->accessMethod) == 0)
{
priorindex->unique |= index->unique;
+
/*
* If the prior index is as yet unnamed, and this one is
* named, then transfer the name to the prior index. This
if (pstate->p_hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- errmsg("cannot use window function in rule WHERE condition")));
+ errmsg("cannot use window function in rule WHERE condition")));
/*
* 'instead nothing' rules with a qualification need a query rangetable so
char *
pg_parse_string_token(const char *token)
{
- int ctoken;
+ int ctoken;
scanner_init(token);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* only needed in OS X 10.1 and possibly early 10.2 releases */
#include <AvailabilityMacros.h>
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* Dummy file used for nothing at this point
*
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef PORT_PROTOS_H
#define PORT_PROTOS_H
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#include "postgres.h"
int errStatus;
/*
- * See notes in sysv_sema.c's implementation of PGSemaphoreLock.
- * Just as that code does for semop(), we handle both the case where
- * sem_wait() returns errno == EINTR after a signal, and the case
- * where it just keeps waiting.
+ * See notes in sysv_sema.c's implementation of PGSemaphoreLock. Just as
+ * that code does for semop(), we handle both the case where sem_wait()
+ * returns errno == EINTR after a signal, and the case where it just keeps
+ * waiting.
*/
do
{
* from the operation prematurely because we were sent a signal. So we
* try and lock the semaphore again.
*
- * Each time around the loop, we check for a cancel/die interrupt. On
- * some platforms, if such an interrupt comes in while we are waiting,
- * it will cause the semop() call to exit with errno == EINTR, allowing
- * us to service the interrupt (if not in a critical section already)
- * during the next loop iteration.
+ * Each time around the loop, we check for a cancel/die interrupt. On
+ * some platforms, if such an interrupt comes in while we are waiting, it
+ * will cause the semop() call to exit with errno == EINTR, allowing us to
+ * service the interrupt (if not in a critical section already) during the
+ * next loop iteration.
*
* Once we acquire the lock, we do NOT check for an interrupt before
* returning. The caller needs to be able to record ownership of the lock
*
* On some platforms, signals marked SA_RESTART (which is most, for us)
* will not interrupt the semop(); it will just keep waiting. Therefore
- * it's necessary for cancel/die interrupts to be serviced directly by
- * the signal handler. On these platforms the behavior is really the same
+ * it's necessary for cancel/die interrupts to be serviced directly by the
+ * signal handler. On these platforms the behavior is really the same
* whether the signal arrives just before the semop() begins, or while it
- * is waiting. The loop on EINTR is thus important only for other types
+ * is waiting. The loop on EINTR is thus important only for other types
* of interrupts.
*/
do
* kernel32.dll·
*/
typedef
-BOOL(WINAPI * __RegisterWaitForSingleObject)
-(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, ULONG, ULONG);
+BOOL (WINAPI * __RegisterWaitForSingleObject)
+ (PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, ULONG, ULONG);
static __RegisterWaitForSingleObject _RegisterWaitForSingleObject = NULL;
BOOL WINAPI
r = WSASend(writefds->fd_array[i], &buf, 1, &sent, 0, NULL, NULL);
if (r == 0) /* Completed - means things are fine! */
- FD_SET(writefds->fd_array[i], &outwritefds);
+ FD_SET (writefds->fd_array[i], &outwritefds);
+
else
{ /* Not completed */
if (WSAGetLastError() != WSAEWOULDBLOCK)
* Not completed, and not just "would block", so an error
* occured
*/
- FD_SET(writefds->fd_array[i], &outwritefds);
+ FD_SET (writefds->fd_array[i], &outwritefds);
}
}
if (outwritefds.fd_count > 0)
(resEvents.lNetworkEvents & FD_ACCEPT) ||
(resEvents.lNetworkEvents & FD_CLOSE))
{
- FD_SET(sockets[i], &outreadfds);
+ FD_SET (sockets[i], &outreadfds);
+
nummatches++;
}
}
if ((resEvents.lNetworkEvents & FD_WRITE) ||
(resEvents.lNetworkEvents & FD_CLOSE))
{
- FD_SET(sockets[i], &outwritefds);
+ FD_SET (sockets[i], &outwritefds);
+
nummatches++;
}
}
struct itimerval value;
HANDLE event;
CRITICAL_SECTION crit_sec;
-} timerCA;
+} timerCA;
static timerCA timerCommArea;
static HANDLE timerThreadHandle = INVALID_HANDLE_VALUE;
wh[1] = pgwin32_signal_event;
/*
- * As in other implementations of PGSemaphoreLock, we need to check
- * for cancel/die interrupts each time through the loop. But here,
- * there is no hidden magic about whether the syscall will internally
- * service a signal --- we do that ourselves.
+ * As in other implementations of PGSemaphoreLock, we need to check for
+ * cancel/die interrupts each time through the loop. But here, there is
+ * no hidden magic about whether the syscall will internally service a
+ * signal --- we do that ourselves.
*/
do
{
elog(FATAL, "could not generate full pathname for datadir %s: %lu",
DataDir, GetLastError());
- /*
+ /*
* XXX: Intentionally overwriting the Global\ part here. This was not the
* original approach, but putting it in the actual Global\ namespace
- * causes permission errors in a lot of cases, so we leave it in
- * the default namespace for now.
+ * causes permission errors in a lot of cases, so we leave it in the
+ * default namespace for now.
*/
for (cp = retptr; *cp; cp++)
if (*cp == '\\')
/*
* When recycling a shared memory segment, it may take a short while
* before it gets dropped from the global namespace. So re-try after
- * sleeping for a second, and continue retrying 10 times.
- * (both the 1 second time and the 10 retries are completely arbitrary)
+ * sleeping for a second, and continue retrying 10 times. (both the 1
+ * second time and the 10 retries are completely arbitrary)
*/
for (i = 0; i < 10; i++)
{
- /* In case CreateFileMapping() doesn't set the error code to 0 on success */
+ /*
+ * In case CreateFileMapping() doesn't set the error code to 0 on
+ * success
+ */
SetLastError(0);
- hmap = CreateFileMapping((HANDLE) 0xFFFFFFFF, /* Use the pagefile */
- NULL, /* Default security attrs */
- PAGE_READWRITE, /* Memory is Read/Write */
+ hmap = CreateFileMapping((HANDLE) 0xFFFFFFFF, /* Use the pagefile */
+ NULL, /* Default security attrs */
+ PAGE_READWRITE, /* Memory is Read/Write */
0L, /* Size Upper 32 Bits */
- (DWORD) size, /* Size Lower 32 bits */
+ (DWORD) size, /* Size Lower 32 bits */
szShareMem);
if (!hmap)
*/
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
- CloseHandle(hmap); /* Close the handle, since we got a valid
- * one to the previous segment. */
+ CloseHandle(hmap); /* Close the handle, since we got a valid one
+ * to the previous segment. */
hmap = NULL;
Sleep(1000);
continue;
*/
if (!hmap)
ereport(FATAL,
- (errmsg("pre-existing shared memory block is still in use"),
- errhint("Check if there are any old server processes still running, and terminate them.")));
+ (errmsg("pre-existing shared memory block is still in use"),
+ errhint("Check if there are any old server processes still running, and terminate them.")));
free(szShareMem);
#define STATS_READ_DELAY 1000
/* the minimum allowed time between two awakenings of the launcher */
-#define MIN_AUTOVAC_SLEEPTIME 100.0 /* milliseconds */
+#define MIN_AUTOVAC_SLEEPTIME 100.0 /* milliseconds */
/* Flags to tell if we are in an autovacuum process */
static bool am_autovacuum_launcher = false;
Oid ar_toastrelid; /* hash key - must be first */
Oid ar_relid;
bool ar_hasrelopts;
- AutoVacOpts ar_reloptions; /* copy of AutoVacOpts from the main table's
- reloptions, or NULL if none */
+ AutoVacOpts ar_reloptions; /* copy of AutoVacOpts from the main table's
+ * reloptions, or NULL if none */
} av_relation;
/* struct to keep track of tables to vacuum and/or analyze, after rechecking */
{
case -1:
ereport(LOG,
- (errmsg("could not fork autovacuum launcher process: %m")));
+ (errmsg("could not fork autovacuum launcher process: %m")));
return 0;
#ifndef EXEC_BACKEND
qsort(dbary, nelems, sizeof(avl_dbase), db_comparator);
/*
- * Determine the time interval between databases in the schedule.
- * If we see that the configured naptime would take us to sleep times
+ * Determine the time interval between databases in the schedule. If
+ * we see that the configured naptime would take us to sleep times
* lower than our min sleep time (which launcher_determine_sleep is
* coded not to allow), silently use a larger naptime (but don't touch
* the GUC variable).
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
- * should ensure the postmaster sees this as a crash, too, but no harm
- * in being doubly sure.)
+ * should ensure the postmaster sees this as a crash, too, but no harm in
+ * being doubly sure.)
*/
exit(2);
}
PgStat_StatDBEntry *shared;
PgStat_StatDBEntry *dbentry;
BufferAccessStrategy bstrategy;
- ScanKeyData key;
+ ScanKeyData key;
TupleDesc pg_class_desc;
/*
pgstat_vacuum_stat();
/*
- * Find the pg_database entry and select the default freeze ages. We
- * use zero in template and nonconnectable databases, else the system-wide
+ * Find the pg_database entry and select the default freeze ages. We use
+ * zero in template and nonconnectable databases, else the system-wide
* default.
*/
tuple = SearchSysCache(DATABASEOID,
/*
* Scan pg_class to determine which tables to vacuum.
*
- * We do this in two passes: on the first one we collect the list of
- * plain relations, and on the second one we collect TOAST tables.
- * The reason for doing the second pass is that during it we want to use
- * the main relation's pg_class.reloptions entry if the TOAST table does
- * not have any, and we cannot obtain it unless we know beforehand what's
- * the main table OID.
+ * We do this in two passes: on the first one we collect the list of plain
+ * relations, and on the second one we collect TOAST tables. The reason
+ * for doing the second pass is that during it we want to use the main
+ * relation's pg_class.reloptions entry if the TOAST table does not have
+ * any, and we cannot obtain it unless we know beforehand what's the main
+ * table OID.
*
* We need to check TOAST tables separately because in cases with short,
* wide tables there might be proportionally much more activity in the
relScan = heap_beginscan(classRel, SnapshotNow, 1, &key);
/*
- * On the first pass, we collect main tables to vacuum, and also the
- * main table relid to TOAST relid mapping.
+ * On the first pass, we collect main tables to vacuum, and also the main
+ * table relid to TOAST relid mapping.
*/
while ((tuple = heap_getnext(relScan, ForwardScanDirection)) != NULL)
{
ereport(LOG,
(errmsg("autovacuum: dropping orphan temp table \"%s\".\"%s\" in database \"%s\"",
- get_namespace_name(classForm->relnamespace),
+ get_namespace_name(classForm->relnamespace),
NameStr(classForm->relname),
get_database_name(MyDatabaseId))));
object.classId = RelationRelationId;
{
ereport(LOG,
(errmsg("autovacuum: found orphan temp table \"%s\".\"%s\" in database \"%s\"",
- get_namespace_name(classForm->relnamespace),
+ get_namespace_name(classForm->relnamespace),
NameStr(classForm->relname),
get_database_name(MyDatabaseId))));
}
{
Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple);
PgStat_StatTabEntry *tabentry;
- Oid relid;
+ Oid relid;
AutoVacOpts *relopts = NULL;
bool dovacuum;
bool doanalyze;
relid = HeapTupleGetOid(tuple);
/*
- * fetch reloptions -- if this toast table does not have them,
- * try the main rel
+ * fetch reloptions -- if this toast table does not have them, try the
+ * main rel
*/
relopts = extract_autovac_opts(tuple, pg_class_desc);
if (relopts == NULL)
{
- av_relation *hentry;
- bool found;
+ av_relation *hentry;
+ bool found;
hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found);
if (found && hentry->ar_hasrelopts)
* It could have changed if something else processed the table while
* we weren't looking.
*
- * Note: we have a special case in pgstat code to ensure that the stats
- * we read are as up-to-date as possible, to avoid the problem that
- * somebody just finished vacuuming this table. The window to the race
- * condition is not closed but it is very small.
+ * Note: we have a special case in pgstat code to ensure that the
+ * stats we read are as up-to-date as possible, to avoid the problem
+ * that somebody just finished vacuuming this table. The window to
+ * the race condition is not closed but it is very small.
*/
MemoryContextSwitchTo(AutovacMemCxt);
tab = table_recheck_autovac(relid, table_toast_map, pg_class_desc);
/*
* Save the relation name for a possible error message, to avoid a
- * catalog lookup in case of an error. If any of these return NULL,
+ * catalog lookup in case of an error. If any of these return NULL,
* then the relation has been dropped since last we checked; skip it.
* Note: they must live in a long-lived memory context because we call
* vacuum and analyze in different transactions.
}
/*
- * We leak table_toast_map here (among other things), but since we're going
- * away soon, it's not a problem.
+ * We leak table_toast_map here (among other things), but since we're
+ * going away soon, it's not a problem.
*/
/*
relopts = extractRelOptions(tup, pg_class_desc, InvalidOid);
if (relopts == NULL)
return NULL;
-
+
av = palloc(sizeof(AutoVacOpts));
memcpy(av, &(((StdRdOptions *) relopts)->autovacuum), sizeof(AutoVacOpts));
pfree(relopts);
PgStat_StatDBEntry *shared;
PgStat_StatDBEntry *dbentry;
bool wraparound;
- AutoVacOpts *avopts;
+ AutoVacOpts *avopts;
/* use fresh stats */
autovac_refresh_stats();
return NULL;
classForm = (Form_pg_class) GETSTRUCT(classTup);
- /*
+ /*
* Get the applicable reloptions. If it is a TOAST table, try to get the
* main table reloptions if the toast table itself doesn't have.
*/
avopts = extract_autovac_opts(classTup, pg_class_desc);
- if (classForm->relkind == RELKIND_TOASTVALUE &&
+ if (classForm->relkind == RELKIND_TOASTVALUE &&
avopts == NULL && table_toast_map != NULL)
{
- av_relation *hentry;
- bool found;
+ av_relation *hentry;
+ bool found;
hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found);
if (found && hentry->ar_hasrelopts)
*
* A table whose autovacuum_enabled option is false is
* automatically skipped (unless we have to vacuum it due to freeze_max_age).
- * Thus autovacuum can be disabled for specific tables. Also, when the stats
+ * Thus autovacuum can be disabled for specific tables. Also, when the stats
* collector does not have data about a table, it will be skipped.
*
* A table whose vac_base_thresh value is < 0 takes the base value from the
autovac_report_activity(autovac_table *tab)
{
#define MAX_AUTOVAC_ACTIV_LEN (NAMEDATALEN * 2 + 56)
- char activity[MAX_AUTOVAC_ACTIV_LEN];
- int len;
+ char activity[MAX_AUTOVAC_ACTIV_LEN];
+ int len;
/* Report the command and possible options */
if (tab->at_dovacuum)
snprintf(activity + len, MAX_AUTOVAC_ACTIV_LEN - len,
" %s.%s%s", tab->at_nspname, tab->at_relname,
- tab->at_wraparound ? " (to prevent wraparound)" : "");
+ tab->at_wraparound ? " (to prevent wraparound)" : "");
/* Set statement_timestamp() to current time for pg_stat_activity */
SetCurrentStatementStartTimestamp();
typedef struct
{
RelFileNode rnode;
- ForkNumber forknum;
+ ForkNumber forknum;
BlockNumber segno; /* see md.c for special values */
/* might add a real request-type field later; not needed yet */
} BgWriterRequest;
*/
if (do_checkpoint)
{
- bool ckpt_performed = false;
- bool do_restartpoint;
+ bool ckpt_performed = false;
+ bool do_restartpoint;
/* use volatile pointer to prevent code rearrangement */
volatile BgWriterShmemStruct *bgs = BgWriterShmem;
/*
- * Check if we should perform a checkpoint or a restartpoint.
- * As a side-effect, RecoveryInProgress() initializes
- * TimeLineID if it's not set yet.
+ * Check if we should perform a checkpoint or a restartpoint. As a
+ * side-effect, RecoveryInProgress() initializes TimeLineID if
+ * it's not set yet.
*/
do_restartpoint = RecoveryInProgress();
elapsed_secs < CheckPointWarning)
ereport(LOG,
(errmsg_plural("checkpoints are occurring too frequently (%d second apart)",
- "checkpoints are occurring too frequently (%d seconds apart)",
+ "checkpoints are occurring too frequently (%d seconds apart)",
elapsed_secs,
elapsed_secs),
errhint("Consider increasing the configuration parameter \"checkpoint_segments\".")));
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
- * should ensure the postmaster sees this as a crash, too, but no harm
- * in being doubly sure.)
+ * should ensure the postmaster sees this as a crash, too, but no harm in
+ * being doubly sure.)
*/
exit(2);
}
/*
* Send signal to request checkpoint. It's possible that the bgwriter
- * hasn't started yet, or is in process of restarting, so we will retry
- * a few times if needed. Also, if not told to wait for the checkpoint
- * to occur, we consider failure to send the signal to be nonfatal and
- * merely LOG it.
+ * hasn't started yet, or is in process of restarting, so we will retry a
+ * few times if needed. Also, if not told to wait for the checkpoint to
+ * occur, we consider failure to send the signal to be nonfatal and merely
+ * LOG it.
*/
- for (ntries = 0; ; ntries++)
+ for (ntries = 0;; ntries++)
{
if (BgWriterShmem->bgwriter_pid == 0)
{
- if (ntries >= 20) /* max wait 2.0 sec */
+ if (ntries >= 20) /* max wait 2.0 sec */
{
elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
- "could not request checkpoint because bgwriter not running");
+ "could not request checkpoint because bgwriter not running");
break;
}
}
else if (kill(BgWriterShmem->bgwriter_pid, SIGINT) != 0)
{
- if (ntries >= 20) /* max wait 2.0 sec */
+ if (ntries >= 20) /* max wait 2.0 sec */
{
elog((flags & CHECKPOINT_WAIT) ? ERROR : LOG,
"could not signal for checkpoint: %m");
* If we've gotten SIGTERM, we normally just sit and do nothing until
* SIGUSR2 arrives. However, that means a random SIGTERM would
* disable archiving indefinitely, which doesn't seem like a good
- * idea. If more than 60 seconds pass since SIGTERM, exit anyway,
- * so that the postmaster can start a new archiver if needed.
+ * idea. If more than 60 seconds pass since SIGTERM, exit anyway, so
+ * that the postmaster can start a new archiver if needed.
*/
if (got_SIGTERM)
{
{
/*
* Do not initiate any more archive commands after receiving
- * SIGTERM, nor after the postmaster has died unexpectedly.
- * The first condition is to try to keep from having init
- * SIGKILL the command, and the second is to avoid conflicts
- * with another archiver spawned by a newer postmaster.
+ * SIGTERM, nor after the postmaster has died unexpectedly. The
+ * first condition is to try to keep from having init SIGKILL the
+ * command, and the second is to avoid conflicts with another
+ * archiver spawned by a newer postmaster.
*/
if (got_SIGTERM || !PostmasterIsAlive(true))
return;
* Per the Single Unix Spec, shells report exit status > 128 when a
* called command died on a signal.
*/
- int lev = (WIFSIGNALED(rc) || WEXITSTATUS(rc) > 128) ? FATAL : LOG;
+ int lev = (WIFSIGNALED(rc) || WEXITSTATUS(rc) > 128) ? FATAL : LOG;
if (WIFEXITED(rc))
{
{
#if defined(WIN32)
ereport(lev,
- (errmsg("archive command was terminated by exception 0x%X",
- WTERMSIG(rc)),
- errhint("See C include file \"ntstatus.h\" for a description of the hexadecimal value."),
- errdetail("The failed archive command was: %s",
- xlogarchcmd)));
+ (errmsg("archive command was terminated by exception 0x%X",
+ WTERMSIG(rc)),
+ errhint("See C include file \"ntstatus.h\" for a description of the hexadecimal value."),
+ errdetail("The failed archive command was: %s",
+ xlogarchcmd)));
#elif defined(HAVE_DECL_SYS_SIGLIST) && HAVE_DECL_SYS_SIGLIST
ereport(lev,
(errmsg("archive command was terminated by signal %d: %s",
WTERMSIG(rc),
- WTERMSIG(rc) < NSIG ? sys_siglist[WTERMSIG(rc)] : "(unknown)"),
+ WTERMSIG(rc) < NSIG ? sys_siglist[WTERMSIG(rc)] : "(unknown)"),
errdetail("The failed archive command was: %s",
xlogarchcmd)));
#else
else
{
ereport(lev,
- (errmsg("archive command exited with unrecognized status %d",
- rc),
- errdetail("The failed archive command was: %s",
- xlogarchcmd)));
+ (errmsg("archive command exited with unrecognized status %d",
+ rc),
+ errdetail("The failed archive command was: %s",
+ xlogarchcmd)));
}
snprintf(activitymsg, sizeof(activitymsg), "failed on %s", xlog);
/* Last time the collector successfully wrote the stats file */
static TimestampTz last_statwrite;
+
/* Latest statistics request time from backends */
static TimestampTz last_statrequest;
for (;;) /* need a loop to handle EINTR */
{
FD_ZERO(&rset);
- FD_SET(pgStatSock, &rset);
+ FD_SET (pgStatSock, &rset);
+
tv.tv_sec = 0;
tv.tv_usec = 500000;
sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
return;
/*
- * Unlike VACUUM, ANALYZE might be running inside a transaction that
- * has already inserted and/or deleted rows in the target table.
- * ANALYZE will have counted such rows as live or dead respectively.
- * Because we will report our counts of such rows at transaction end,
- * we should subtract off these counts from what we send to the collector
- * now, else they'll be double-counted after commit. (This approach also
- * ensures that the collector ends up with the right numbers if we abort
- * instead of committing.)
+ * Unlike VACUUM, ANALYZE might be running inside a transaction that has
+ * already inserted and/or deleted rows in the target table. ANALYZE will
+ * have counted such rows as live or dead respectively. Because we will
+ * report our counts of such rows at transaction end, we should subtract
+ * off these counts from what we send to the collector now, else they'll
+ * be double-counted after commit. (This approach also ensures that the
+ * collector ends up with the right numbers if we abort instead of
+ * committing.)
*/
if (rel->pgstat_info != NULL)
{
pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
msg.m_tableoid = RelationGetRelid(rel);
- msg.m_autovacuum = IsAutoVacuumWorkerProcess(); /* is this autovacuum? */
+ msg.m_autovacuum = IsAutoVacuumWorkerProcess(); /* is this autovacuum? */
msg.m_analyzetime = GetCurrentTimestamp();
msg.m_live_tuples = livetuples;
msg.m_dead_tuples = deadtuples;
PgStat_FunctionCallUsage *fcu)
{
PgStat_BackendFunctionEntry *htabent;
- bool found;
+ bool found;
if (pgstat_track_functions <= fcinfo->flinfo->fn_stats)
{
* Compute the new total f_time as the total elapsed time added to the
* pre-call value of f_time. This is necessary to avoid double-counting
* any time taken by recursive calls of myself. (We do not need any
- * similar kluge for self time, since that already excludes any
- * recursive calls.)
+ * similar kluge for self time, since that already excludes any recursive
+ * calls.)
*/
INSTR_TIME_ADD(f_total, fcu->save_f_time);
static PgBackendStatus *BackendStatusArray = NULL;
static PgBackendStatus *MyBEEntry = NULL;
-static char *BackendActivityBuffer = NULL;
+static char *BackendActivityBuffer = NULL;
/*
/* Create or attach to the shared activity buffer */
size = mul_size(pgstat_track_activity_query_size, MaxBackends);
- BackendActivityBuffer = (char*)
+ BackendActivityBuffer = (char *)
ShmemInitStruct("Backend Activity Buffer", size, &found);
if (!found)
/* Initialize st_activity pointers. */
buffer = BackendActivityBuffer;
- for (i = 0; i < MaxBackends; i++) {
+ for (i = 0; i < MaxBackends; i++)
+ {
BackendStatusArray[i].st_activity = buffer;
buffer += pgstat_track_activity_query_size;
}
volatile PgBackendStatus *beentry;
PgBackendStatus *localtable;
PgBackendStatus *localentry;
- char *localactivity;
+ char *localactivity;
int i;
Assert(!pgStatRunningInCollector);
if (localentry->st_procpid > 0)
{
memcpy(localentry, (char *) beentry, sizeof(PgBackendStatus));
+
/*
* strcpy is safe even if the string is modified concurrently,
* because there's always a \0 at the end of the buffer.
* pgstat_get_backend_current_activity() -
*
* Return a string representing the current activity of the backend with
- * the specified PID. This looks directly at the BackendStatusArray,
+ * the specified PID. This looks directly at the BackendStatusArray,
* and so will provide current information regardless of the age of our
* transaction's snapshot of the status array.
*
* It is the caller's responsibility to invoke this only for backends whose
- * state is expected to remain stable while the result is in use. The
+ * state is expected to remain stable while the result is in use. The
* only current use is in deadlock reporting, where we can expect that
* the target backend is blocked on a lock. (There are corner cases
* where the target's wait could get aborted while we are looking at it,
* must follow the protocol of retrying if st_changecount changes
* while we examine the entry, or if it's odd. (This might be
* unnecessary, since fetching or storing an int is almost certainly
- * atomic, but let's play it safe.) We use a volatile pointer here
- * to ensure the compiler doesn't try to get cute.
+ * atomic, but let's play it safe.) We use a volatile pointer here to
+ * ensure the compiler doesn't try to get cute.
*/
volatile PgBackendStatus *vbeentry = beentry;
- bool found;
+ bool found;
for (;;)
{
*
* For performance reasons, we don't want to do a PostmasterIsAlive() test
* after every message; instead, do it only when select()/poll() is
- * interrupted by timeout. In essence, we'll stay alive as long as
+ * interrupted by timeout. In essence, we'll stay alive as long as
* backends keep sending us stuff often, even if the postmaster is gone.
*/
for (;;)
got_data = (input_fd.revents != 0);
#else /* !HAVE_POLL */
- FD_SET(pgStatSock, &rfds);
+ FD_SET (pgStatSock, &rfds);
/*
* timeout struct is modified by select() on some operating systems,
pgstat_recv_bgwriter((PgStat_MsgBgWriter *) &msg, len);
break;
- case PGSTAT_MTYPE_FUNCSTAT:
- pgstat_recv_funcstat((PgStat_MsgFuncstat *) &msg, len);
- break;
+ case PGSTAT_MTYPE_FUNCSTAT:
+ pgstat_recv_funcstat((PgStat_MsgFuncstat *) &msg, len);
+ break;
case PGSTAT_MTYPE_FUNCPURGE:
pgstat_recv_funcpurge((PgStat_MsgFuncpurge *) &msg, len);
PgStat_StatFuncEntry *funcentry;
FILE *fpout;
int32 format_id;
- const char *tmpfile = permanent?PGSTAT_STAT_PERMANENT_TMPFILE:pgstat_stat_tmpname;
- const char *statfile = permanent?PGSTAT_STAT_PERMANENT_FILENAME:pgstat_stat_filename;
+ const char *tmpfile = permanent ? PGSTAT_STAT_PERMANENT_TMPFILE : pgstat_stat_tmpname;
+ const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
/*
* Open the statistics temp file to write out the current values.
{
/*
* Write out the DB entry including the number of live backends. We
- * don't write the tables or functions pointers, since they're of
- * no use to any other process.
+ * don't write the tables or functions pointers, since they're of no
+ * use to any other process.
*/
fputc('D', fpout);
fwrite(dbentry, offsetof(PgStat_StatDBEntry, tables), 1, fpout);
FILE *fpin;
int32 format_id;
bool found;
- const char *statfile = permanent?PGSTAT_STAT_PERMANENT_FILENAME:pgstat_stat_filename;
+ const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
/*
* The tables will live in pgStatLocalContext.
PGSTAT_FUNCTION_HASH_SIZE,
&hash_ctl,
HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
+
/*
* Arrange that following records add entries to this
* database's hash tables.
break;
funcentry = (PgStat_StatFuncEntry *) hash_search(funchash,
- (void *) &funcbuf.functionid,
+ (void *) &funcbuf.functionid,
HASH_ENTER, &found);
if (found)
PgStat_GlobalStats myGlobalStats;
FILE *fpin;
int32 format_id;
- const char *statfile = permanent?PGSTAT_STAT_PERMANENT_FILENAME:pgstat_stat_filename;
+ const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
/*
* Try to open the status file.
/*
* We set the minimum acceptable timestamp to PGSTAT_STAT_INTERVAL msec
- * before now. This indirectly ensures that the collector needn't write
+ * before now. This indirectly ensures that the collector needn't write
* the file more often than PGSTAT_STAT_INTERVAL. In an autovacuum
* worker, however, we want a lower delay to avoid using stale data, so we
* use PGSTAT_RETRY_DELAY (since the number of worker is low, this
* shouldn't be a problem).
*
* Note that we don't recompute min_ts after sleeping; so we might end up
- * accepting a file a bit older than PGSTAT_STAT_INTERVAL. In practice
+ * accepting a file a bit older than PGSTAT_STAT_INTERVAL. In practice
* that shouldn't happen, though, as long as the sleep time is less than
* PGSTAT_STAT_INTERVAL; and we don't want to lie to the collector about
* what our cutoff time really is.
/*
* Loop until fresh enough stats file is available or we ran out of time.
- * The stats inquiry message is sent repeatedly in case collector drops it.
+ * The stats inquiry message is sent repeatedly in case collector drops
+ * it.
*/
for (count = 0; count < PGSTAT_POLL_LOOP_COUNT; count++)
{
for (i = 0; i < msg->m_nentries; i++, funcmsg++)
{
funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
- (void *) &(funcmsg->f_id),
- HASH_ENTER, &found);
+ (void *) &(funcmsg->f_id),
+ HASH_ENTER, &found);
if (!found)
{
static int Shutdown = NoShutdown;
static bool FatalError = false; /* T if recovering from backend crash */
-static bool RecoveryError = false; /* T if WAL recovery failed */
+static bool RecoveryError = false; /* T if WAL recovery failed */
/*
* We use a simple state machine to control startup, shutdown, and
* reading the control file and other preliminary initialization steps. When
* it's ready to start WAL redo, it signals postmaster, and we switch to
* PM_RECOVERY phase. The background writer is launched, while the startup
- * process continues applying WAL.
- *
+ * process continues applying WAL.
+ *
* After reaching a consistent point in WAL redo, startup process signals
* us again, and we switch to PM_RECOVERY_CONSISTENT phase. There's currently
* no difference between PM_RECOVERY and PM_RECOVERY_CONSISTENT, but we
HANDLE waitHandle;
HANDLE procHandle;
DWORD procId;
-} win32_deadchild_waitinfo;
+} win32_deadchild_waitinfo;
HANDLE PostmasterHandle;
#endif
SOCKET origsocket; /* Original socket value, or -1 if not a
* socket */
WSAPROTOCOL_INFO wsainfo;
-} InheritableSocket;
+} InheritableSocket;
#else
typedef int InheritableSocket;
#endif
char ExtraOptions[MAXPGPATH];
char lc_collate[NAMEDATALEN];
char lc_ctype[NAMEDATALEN];
-} BackendParameters;
+} BackendParameters;
static void read_backend_variables(char *id, Port *port);
-static void restore_backend_variables(BackendParameters * param, Port *port);
+static void restore_backend_variables(BackendParameters *param, Port *port);
#ifndef WIN32
-static bool save_backend_variables(BackendParameters * param, Port *port);
+static bool save_backend_variables(BackendParameters *param, Port *port);
#else
-static bool save_backend_variables(BackendParameters * param, Port *port,
+static bool save_backend_variables(BackendParameters *param, Port *port,
HANDLE childProcess, pid_t childPid);
#endif
*/
if (!load_hba())
{
- /*
- * It makes no sense continue if we fail to load the HBA file, since
+ /*
+ * It makes no sense continue if we fail to load the HBA file, since
* there is no way to connect to the database in this case.
*/
ereport(FATAL,
get_pkglib_path(my_exec_path, pkglib_path);
/*
- * Verify that there's a readable directory there; otherwise the
- * Postgres installation is incomplete or corrupt. (A typical cause
- * of this failure is that the postgres executable has been moved or
- * hardlinked to some directory that's not a sibling of the installation
- * lib/ directory.)
+ * Verify that there's a readable directory there; otherwise the Postgres
+ * installation is incomplete or corrupt. (A typical cause of this
+ * failure is that the postgres executable has been moved or hardlinked to
+ * some directory that's not a sibling of the installation lib/
+ * directory.)
*/
pdir = AllocateDir(pkglib_path);
if (pdir == NULL)
FreeDir(pdir);
/*
- * XXX is it worth similarly checking the share/ directory? If the
- * lib/ directory is there, then share/ probably is too.
+ * XXX is it worth similarly checking the share/ directory? If the lib/
+ * directory is there, then share/ probably is too.
*/
}
* fails, we'll just try again later.
*/
if (BgWriterPID == 0 &&
- (pmState == PM_RUN || pmState == PM_RECOVERY ||
+ (pmState == PM_RUN || pmState == PM_RECOVERY ||
pmState == PM_RECOVERY_CONSISTENT))
BgWriterPID = StartBackgroundWriter();
if (fd == -1)
break;
- FD_SET(fd, rmask);
+ FD_SET (fd, rmask);
+
if (fd > maxsock)
maxsock = fd;
}
if (pmState != PM_RUN)
{
if (pmState == PM_WAIT_BACKUP)
- return CAC_WAITBACKUP; /* allow superusers only */
+ return CAC_WAITBACKUP; /* allow superusers only */
if (Shutdown > NoShutdown)
return CAC_SHUTDOWN; /* shutdown is pending */
if (!FatalError &&
}
/*
- * Now wait for online backup mode to end and
- * backends to exit. If that is already the case,
- * PostmasterStateMachine will take the next step.
+ * Now wait for online backup mode to end and backends to exit.
+ * If that is already the case, PostmasterStateMachine will take
+ * the next step.
*/
PostmasterStateMachine();
break;
/*
* Unexpected exit of startup process (including FATAL exit)
- * during PM_STARTUP is treated as catastrophic. There is no
- * other processes running yet, so we can just exit.
+ * during PM_STARTUP is treated as catastrophic. There is no other
+ * processes running yet, so we can just exit.
*/
if (pmState == PM_STARTUP && !EXIT_STATUS_0(exitstatus))
{
(errmsg("aborting startup due to startup process failure")));
ExitPostmaster(1);
}
+
/*
- * Startup process exited in response to a shutdown request (or
- * it completed normally regardless of the shutdown request).
+ * Startup process exited in response to a shutdown request (or it
+ * completed normally regardless of the shutdown request).
*/
if (Shutdown > NoShutdown &&
(EXIT_STATUS_0(exitstatus) || EXIT_STATUS_1(exitstatus)))
/* PostmasterStateMachine logic does the rest */
continue;
}
+
/*
* Any unexpected exit (including FATAL exit) of the startup
- * process is treated as a crash, except that we don't want
- * to reinitialize.
+ * process is treated as a crash, except that we don't want to
+ * reinitialize.
*/
if (!EXIT_STATUS_0(exitstatus))
{
if (!ReleasePostmasterChildSlot(bp->child_slot))
{
/*
- * Uh-oh, the child failed to clean itself up. Treat
- * as a crash after all.
+ * Uh-oh, the child failed to clean itself up. Treat as a
+ * crash after all.
*/
HandleChildCrash(pid, exitstatus, _("server process"));
return;
pmState = PM_WAIT_DEAD_END;
/*
- * We already SIGQUIT'd the archiver and stats processes,
- * if any, when we entered FatalError state.
+ * We already SIGQUIT'd the archiver and stats processes, if
+ * any, when we entered FatalError state.
*/
}
else
else
{
/*
- * Terminate backup mode to avoid recovery after a
- * clean fast shutdown.
+ * Terminate backup mode to avoid recovery after a clean fast
+ * shutdown.
*/
CancelBackup();
}
/*
- * If recovery failed, wait for all non-syslogger children to exit,
- * and then exit postmaster. We don't try to reinitialize when recovery
- * fails, because more than likely it will just fail again and we will
- * keep trying forever.
+ * If recovery failed, wait for all non-syslogger children to exit, and
+ * then exit postmaster. We don't try to reinitialize when recovery fails,
+ * because more than likely it will just fail again and we will keep
+ * trying forever.
*/
if (RecoveryError && pmState == PM_NO_CHILDREN)
- ExitPostmaster(1);
+ ExitPostmaster(1);
/*
- * If we need to recover from a crash, wait for all non-syslogger
- * children to exit, then reset shmem and StartupDataBase.
+ * If we need to recover from a crash, wait for all non-syslogger children
+ * to exit, then reset shmem and StartupDataBase.
*/
if (FatalError && pmState == PM_NO_CHILDREN)
{
pid_t pid;
/*
- * Create backend data structure. Better before the fork() so we
- * can handle failure cleanly.
+ * Create backend data structure. Better before the fork() so we can
+ * handle failure cleanly.
*/
bn = (Backend *) malloc(sizeof(Backend));
if (!bn)
if (!load_hba())
{
- /*
- * It makes no sense continue if we fail to load the HBA file, since
+ /*
+ * It makes no sense continue if we fail to load the HBA file, since
* there is no way to connect to the database in this case.
*/
ereport(FATAL,
read_nondefault_variables();
/*
- * Reload any libraries that were preloaded by the postmaster. Since
- * we exec'd this process, those libraries didn't come along with us;
- * but we should load them into all child processes to be consistent
- * with the non-EXEC_BACKEND behavior.
+ * Reload any libraries that were preloaded by the postmaster. Since we
+ * exec'd this process, those libraries didn't come along with us; but we
+ * should load them into all child processes to be consistent with the
+ * non-EXEC_BACKEND behavior.
*/
process_shared_preload_libraries();
FatalError = false;
/*
- * Crank up the background writer. It doesn't matter if this
- * fails, we'll just try again later.
+ * Crank up the background writer. It doesn't matter if this fails,
+ * we'll just try again later.
*/
Assert(BgWriterPID == 0);
BgWriterPID = StartBackgroundWriter();
/*
* Load the flat authorization file into postmaster's cache. The
* startup process won't have recomputed this from the database yet,
- * so we it may change following recovery.
+ * so we it may change following recovery.
*/
load_role();
if (bn)
{
/*
- * Compute the cancel key that will be assigned to this session. We
- * probably don't need cancel keys for autovac workers, but we'd
- * better have something random in the field to prevent unfriendly
- * people from sending cancels to them.
+ * Compute the cancel key that will be assigned to this session.
+ * We probably don't need cancel keys for autovac workers, but
+ * we'd better have something random in the field to prevent
+ * unfriendly people from sending cancels to them.
*/
MyCancelKey = PostmasterRandom();
bn->cancel_key = MyCancelKey;
* This reports the number of entries needed in per-child-process arrays
* (the PMChildFlags array, and if EXEC_BACKEND the ShmemBackendArray).
* These arrays include regular backends and autovac workers, but not special
- * children nor dead_end children. This allows the arrays to have a fixed
+ * children nor dead_end children. This allows the arrays to have a fixed
* maximum size, to wit the same too-many-children limit enforced by
- * canAcceptConnections(). The exact value isn't too critical as long as
+ * canAcceptConnections(). The exact value isn't too critical as long as
* it's more than MaxBackends.
*/
int
#define write_inheritable_socket(dest, src, childpid) (*(dest) = (src))
#define read_inheritable_socket(dest, src) (*(dest) = *(src))
#else
-static void write_duplicated_handle(HANDLE * dest, HANDLE src, HANDLE child);
-static void write_inheritable_socket(InheritableSocket * dest, SOCKET src,
+static void write_duplicated_handle(HANDLE *dest, HANDLE src, HANDLE child);
+static void write_inheritable_socket(InheritableSocket *dest, SOCKET src,
pid_t childPid);
-static void read_inheritable_socket(SOCKET * dest, InheritableSocket * src);
+static void read_inheritable_socket(SOCKET *dest, InheritableSocket *src);
#endif
/* Save critical backend variables into the BackendParameters struct */
#ifndef WIN32
static bool
-save_backend_variables(BackendParameters * param, Port *port)
+save_backend_variables(BackendParameters *param, Port *port)
#else
static bool
-save_backend_variables(BackendParameters * param, Port *port,
+save_backend_variables(BackendParameters *param, Port *port,
HANDLE childProcess, pid_t childPid)
#endif
{
* process instance of the handle to the parameter file.
*/
static void
-write_duplicated_handle(HANDLE * dest, HANDLE src, HANDLE childProcess)
+write_duplicated_handle(HANDLE *dest, HANDLE src, HANDLE childProcess)
{
HANDLE hChild = INVALID_HANDLE_VALUE;
* straight socket inheritance.
*/
static void
-write_inheritable_socket(InheritableSocket * dest, SOCKET src, pid_t childpid)
+write_inheritable_socket(InheritableSocket *dest, SOCKET src, pid_t childpid)
{
dest->origsocket = src;
if (src != 0 && src != -1)
* Read a duplicate socket structure back, and get the socket descriptor.
*/
static void
-read_inheritable_socket(SOCKET * dest, InheritableSocket * src)
+read_inheritable_socket(SOCKET *dest, InheritableSocket *src)
{
SOCKET s;
/* Restore critical backend variables from the BackendParameters struct */
static void
-restore_backend_variables(BackendParameters * param, Port *port)
+restore_backend_variables(BackendParameters *param, Port *port)
{
memcpy(port, ¶m->port, sizeof(Port));
read_inheritable_socket(&port->sock, ¶m->portsocket);
/* Mark the slot as empty */
ShmemBackendArray[i].pid = 0;
}
-
#endif /* EXEC_BACKEND */
* Wait for some data, timing out after 1 second
*/
FD_ZERO(&rfds);
- FD_SET(syslogPipe[0], &rfds);
+ FD_SET (syslogPipe[0], &rfds);
+
timeout.tv_sec = 1;
timeout.tv_usec = 0;
/* treat it as a strftime pattern */
pg_strftime(filename + len, MAXPGPATH - len, Log_filename,
- pg_localtime(×tamp, log_timezone));
+ pg_localtime(×tamp, log_timezone));
if (suffix != NULL)
{
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
- * should ensure the postmaster sees this as a crash, too, but no harm
- * in being doubly sure.)
+ * should ensure the postmaster sees this as a crash, too, but no harm in
+ * being doubly sure.)
*/
exit(2);
}
/*
* string constants to interpolate as expansions of things like \d
*/
-static const chr backd[] = { /* \d */
+static const chr backd[] = { /* \d */
CHR('['), CHR('['), CHR(':'),
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
CHR(':'), CHR(']'), CHR(']')
};
-static const chr backD[] = { /* \D */
+static const chr backD[] = { /* \D */
CHR('['), CHR('^'), CHR('['), CHR(':'),
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
CHR(':'), CHR(']'), CHR(']')
};
-static const chr brbackd[] = { /* \d within brackets */
+static const chr brbackd[] = { /* \d within brackets */
CHR('['), CHR(':'),
CHR('d'), CHR('i'), CHR('g'), CHR('i'), CHR('t'),
CHR(':'), CHR(']')
};
-static const chr backs[] = { /* \s */
+static const chr backs[] = { /* \s */
CHR('['), CHR('['), CHR(':'),
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
CHR(':'), CHR(']'), CHR(']')
};
-static const chr backS[] = { /* \S */
+static const chr backS[] = { /* \S */
CHR('['), CHR('^'), CHR('['), CHR(':'),
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
CHR(':'), CHR(']'), CHR(']')
};
-static const chr brbacks[] = { /* \s within brackets */
+static const chr brbacks[] = { /* \s within brackets */
CHR('['), CHR(':'),
CHR('s'), CHR('p'), CHR('a'), CHR('c'), CHR('e'),
CHR(':'), CHR(']')
};
-static const chr backw[] = { /* \w */
+static const chr backw[] = { /* \w */
CHR('['), CHR('['), CHR(':'),
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
CHR(':'), CHR(']'), CHR('_'), CHR(']')
};
-static const chr backW[] = { /* \W */
+static const chr backW[] = { /* \W */
CHR('['), CHR('^'), CHR('['), CHR(':'),
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
CHR(':'), CHR(']'), CHR('_'), CHR(']')
};
-static const chr brbackw[] = { /* \w within brackets */
+static const chr brbackw[] = { /* \w within brackets */
CHR('['), CHR(':'),
CHR('a'), CHR('l'), CHR('n'), CHR('u'), CHR('m'),
CHR(':'), CHR(']'), CHR('_')
* TooManyStates - checks if the max states exceeds the compile-time value
*/
static int
-TooManyStates(struct nfa *nfa)
+TooManyStates(struct nfa * nfa)
{
struct nfa *parent = nfa->parent;
size_t sz = nfa->size;
* IncrementSize - increases the tracked size of the NFA and its parents.
*/
static void
-IncrementSize(struct nfa *nfa)
+IncrementSize(struct nfa * nfa)
{
struct nfa *parent = nfa->parent;
* DecrementSize - decreases the tracked size of the NFA and its parents.
*/
static void
-DecrementSize(struct nfa *nfa)
+DecrementSize(struct nfa * nfa)
{
struct nfa *parent = nfa->parent;
/*
* DGP 2007-11-15: Cloning a state with a circular constraint on its list
- * of outs can lead to trouble [Tcl Bug 1810038], so get rid of them first.
+ * of outs can lead to trouble [Tcl Bug 1810038], so get rid of them
+ * first.
*/
for (a = from->outs; a != NULL; a = nexta)
{
}
/*
- * DGP 2007-11-15: Here we duplicate the same protections as appear
- * in pull() above to avoid troubles with cloning a state with a
- * circular constraint on its list of ins. It is not clear whether
- * this is necessary, or is protecting against a "can't happen".
- * Any test case that actually leads to a freearc() call here would
- * be a welcome addition to the test suite.
+ * DGP 2007-11-15: Here we duplicate the same protections as appear in
+ * pull() above to avoid troubles with cloning a state with a circular
+ * constraint on its list of ins. It is not clear whether this is
+ * necessary, or is protecting against a "can't happen". Any test case
+ * that actually leads to a freearc() call here would be a welcome
+ * addition to the test suite.
*/
for (a = to->ins; a != NULL; a = nexta)
{
{
progress = 0;
for (s = nfa->states; s != NULL && !NISERR() &&
- s->no != FREESTATE; s = nexts)
+ s->no != FREESTATE; s = nexts)
{
nexts = s->next;
for (a = s->outs; a != NULL && !NISERR(); a = nexta)
replaces[Anum_pg_rewrite_ev_action - 1] = true;
tup = heap_modify_tuple(oldtup, RelationGetDescr(pg_rewrite_desc),
- values, nulls, replaces);
+ values, nulls, replaces);
simple_heap_update(pg_rewrite_desc, &tup->t_self, tup);
*
* If so, check that the relation is empty because the storage for the
* relation is going to be deleted. Also insist that the rel not have
- * any triggers, indexes, or child tables. (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
+ * any triggers, indexes, or child tables. (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
* loading ancient pg_dump files.)
*/
break;
}
if (sub_action->hasSubLinks)
- break; /* no need to keep scanning rtable */
+ break; /* no need to keep scanning rtable */
}
}
*/
if (parsetree->hasSubLinks && !rule_action->hasSubLinks)
rule_action->hasSubLinks =
- checkExprHasSubLink((Node *) rule_action->returningList);
+ checkExprHasSubLink((Node *) rule_action->returningList);
}
return rule_action;
if (strcmp(cte->ctename, rte->ctename) == 0)
break;
}
- if (lc == NULL) /* shouldn't happen */
+ if (lc == NULL) /* shouldn't happen */
elog(ERROR, "could not find CTE \"%s\"", rte->ctename);
/* should be analyzed by now */
Assert(IsA(cte->ctequery, Query));
} locate_windowfunc_context;
static bool contain_aggs_of_level_walker(Node *node,
- contain_aggs_of_level_context *context);
+ contain_aggs_of_level_context *context);
static bool locate_agg_of_level_walker(Node *node,
- locate_agg_of_level_context *context);
+ locate_agg_of_level_context *context);
static bool contain_windowfuncs_walker(Node *node, void *context);
static bool locate_windowfunc_walker(Node *node,
- locate_windowfunc_context *context);
+ locate_windowfunc_context *context);
static bool checkExprHasSubLink_walker(Node *node, void *context);
static Relids offset_relid_set(Relids relids, int offset);
static Relids adjust_relid_set(Relids relids, int oldrelid, int newrelid);
* specified query level.
*
* The objective of this routine is to detect whether there are aggregates
- * belonging to the given query level. Aggregates belonging to subqueries
+ * belonging to the given query level. Aggregates belonging to subqueries
* or outer queries do NOT cause a true result. We must recurse into
* subqueries to detect outer-reference aggregates that logically belong to
* the specified query level.
* Find the parse location of any aggregate of the specified query level.
*
* Returns -1 if no such agg is in the querytree, or if they all have
- * unknown parse location. (The former case is probably caller error,
+ * unknown parse location. (The former case is probably caller error,
* but we don't bother to distinguish it from the latter case.)
*
* Note: it might seem appropriate to merge this functionality into
{
locate_agg_of_level_context context;
- context.agg_location = -1; /* in case we find nothing */
+ context.agg_location = -1; /* in case we find nothing */
context.sublevels_up = levelsup;
/*
if (node == NULL)
return false;
if (IsA(node, WindowFunc))
- return true; /* abort the tree traversal and return true */
+ return true; /* abort the tree traversal and return true */
/* Mustn't recurse into subselects */
return expression_tree_walker(node, contain_windowfuncs_walker,
(void *) context);
* Find the parse location of any windowfunc of the current query level.
*
* Returns -1 if no such windowfunc is in the querytree, or if they all have
- * unknown parse location. (The former case is probably caller error,
+ * unknown parse location. (The former case is probably caller error,
* but we don't bother to distinguish it from the latter case.)
*
* Note: it might seem appropriate to merge this functionality into
{
locate_windowfunc_context context;
- context.win_location = -1; /* in case we find nothing */
+ context.win_location = -1; /* in case we find nothing */
/*
* Must be prepared to start with a Query or a bare expression tree; if
* If generating an expansion for a var of a named rowtype
* (ie, this is a plain relation RTE), then we must include
* dummy items for dropped columns. If the var is RECORD (ie,
- * this is a JOIN), then omit dropped columns. Either way,
+ * this is a JOIN), then omit dropped columns. Either way,
* attach column names to the RowExpr for use of ruleutils.c.
*/
expandRTE(context->target_rte,
elog(ERROR, "could not find tuple for rule %u", ruleOid);
/*
- * We had better grab AccessExclusiveLock to ensure that no queries
- * are going on that might depend on this rule. (Note: a weaker lock
- * would suffice if it's not an ON SELECT rule.)
+ * We had better grab AccessExclusiveLock to ensure that no queries are
+ * going on that might depend on this rule. (Note: a weaker lock would
+ * suffice if it's not an ON SELECT rule.)
*/
eventRelationOid = ((Form_pg_rewrite) GETSTRUCT(tuple))->ev_class;
event_relation = heap_open(eventRelationOid, AccessExclusiveLock);
static Buffer ReadBuffer_common(SMgrRelation reln, bool isLocalBuf,
- ForkNumber forkNum, BlockNumber blockNum,
- ReadBufferMode mode , BufferAccessStrategy strategy,
- bool *hit);
+ ForkNumber forkNum, BlockNumber blockNum,
+ ReadBufferMode mode, BufferAccessStrategy strategy,
+ bool *hit);
static bool PinBuffer(volatile BufferDesc *buf, BufferAccessStrategy strategy);
static void PinBuffer_Locked(volatile BufferDesc *buf);
static void UnpinBuffer(volatile BufferDesc *buf, bool fixOwner);
* PrefetchBuffer -- initiate asynchronous read of a block of a relation
*
* This is named by analogy to ReadBuffer but doesn't actually allocate a
- * buffer. Instead it tries to ensure that a future ReadBuffer for the given
+ * buffer. Instead it tries to ensure that a future ReadBuffer for the given
* block will not be delayed by the I/O. Prefetching is optional.
* No-op if prefetching isn't compiled in.
*/
if (RELATION_IS_OTHER_TEMP(reln))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot access temporary tables of other sessions")));
+ errmsg("cannot access temporary tables of other sessions")));
/* pass it off to localbuf.c */
LocalPrefetchBuffer(reln->rd_smgr, forkNum, blockNum);
}
else
{
- BufferTag newTag; /* identity of requested block */
- uint32 newHash; /* hash value for newTag */
- LWLockId newPartitionLock; /* buffer partition lock for it */
+ BufferTag newTag; /* identity of requested block */
+ uint32 newHash; /* hash value for newTag */
+ LWLockId newPartitionLock; /* buffer partition lock for it */
int buf_id;
/* create a tag so we can lookup the buffer */
/*
* If the block *is* in buffers, we do nothing. This is not really
- * ideal: the block might be just about to be evicted, which would
- * be stupid since we know we are going to need it soon. But the
- * only easy answer is to bump the usage_count, which does not seem
- * like a great solution: when the caller does ultimately touch the
- * block, usage_count would get bumped again, resulting in too much
- * favoritism for blocks that are involved in a prefetch sequence.
- * A real fix would involve some additional per-buffer state, and
- * it's not clear that there's enough of a problem to justify that.
+ * ideal: the block might be just about to be evicted, which would be
+ * stupid since we know we are going to need it soon. But the only
+ * easy answer is to bump the usage_count, which does not seem like a
+ * great solution: when the caller does ultimately touch the block,
+ * usage_count would get bumped again, resulting in too much
+ * favoritism for blocks that are involved in a prefetch sequence. A
+ * real fix would involve some additional per-buffer state, and it's
+ * not clear that there's enough of a problem to justify that.
*/
}
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
* for non-critical data, where the caller is prepared to repair errors.
*
* In RBM_ZERO mode, if the page isn't in buffer cache already, it's filled
- * with zeros instead of reading it from disk. Useful when the caller is
+ * with zeros instead of reading it from disk. Useful when the caller is
* going to fill the page from scratch, since this saves I/O and avoids
* unnecessary failure if the page-on-disk has corrupt page headers.
* Caution: do not use this mode to read a page that is beyond the relation's
ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum,
ReadBufferMode mode, BufferAccessStrategy strategy)
{
- bool hit;
- Buffer buf;
+ bool hit;
+ Buffer buf;
/* Open it at the smgr level if not already done */
RelationOpenSmgr(reln);
/*
- * Reject attempts to read non-local temporary relations; we would
- * be likely to get wrong data since we have no visibility into the
- * owning session's local buffers.
+ * Reject attempts to read non-local temporary relations; we would be
+ * likely to get wrong data since we have no visibility into the owning
+ * session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(reln))
ereport(ERROR,
errmsg("cannot access temporary tables of other sessions")));
/*
- * Read the buffer, and update pgstat counters to reflect a cache
- * hit or miss.
+ * Read the buffer, and update pgstat counters to reflect a cache hit or
+ * miss.
*/
pgstat_count_buffer_read(reln);
buf = ReadBuffer_common(reln->rd_smgr, reln->rd_istemp, forkNum, blockNum,
ForkNumber forkNum, BlockNumber blockNum,
ReadBufferMode mode, BufferAccessStrategy strategy)
{
- bool hit;
+ bool hit;
SMgrRelation smgr = smgropen(rnode);
+
return ReadBuffer_common(smgr, isTemp, forkNum, blockNum, mode, strategy,
&hit);
}
bufBlock = isLocalBuf ? LocalBufHdrGetBlock(bufHdr) : BufHdrGetBlock(bufHdr);
if (!PageIsNew((Page) bufBlock))
ereport(ERROR,
- (errmsg("unexpected data beyond EOF in block %u of relation %s",
- blockNum, relpath(smgr->smgr_rnode, forkNum)),
- errhint("This has been seen to occur with buggy kernels; consider updating your system.")));
+ (errmsg("unexpected data beyond EOF in block %u of relation %s",
+ blockNum, relpath(smgr->smgr_rnode, forkNum)),
+ errhint("This has been seen to occur with buggy kernels; consider updating your system.")));
/*
* We *must* do smgrextend before succeeding, else the page will not
else
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
- errmsg("invalid page header in block %u of relation %s",
- blockNum,
- relpath(smgr->smgr_rnode, forkNum))));
+ errmsg("invalid page header in block %u of relation %s",
+ blockNum,
+ relpath(smgr->smgr_rnode, forkNum))));
}
}
}
/* OK, do the I/O */
TRACE_POSTGRESQL_BUFFER_WRITE_DIRTY_START(forkNum, blockNum,
- smgr->smgr_rnode.spcNode,
- smgr->smgr_rnode.dbNode,
- smgr->smgr_rnode.relNode);
+ smgr->smgr_rnode.spcNode,
+ smgr->smgr_rnode.dbNode,
+ smgr->smgr_rnode.relNode);
FlushBuffer(buf, NULL);
LWLockRelease(buf->content_lock);
TRACE_POSTGRESQL_BUFFER_WRITE_DIRTY_DONE(forkNum, blockNum,
- smgr->smgr_rnode.spcNode,
+ smgr->smgr_rnode.spcNode,
smgr->smgr_rnode.dbNode,
- smgr->smgr_rnode.relNode);
+ smgr->smgr_rnode.relNode);
}
else
{
Relation relation,
BlockNumber blockNum)
{
- ForkNumber forkNum = MAIN_FORKNUM;
+ ForkNumber forkNum = MAIN_FORKNUM;
volatile BufferDesc *bufHdr;
if (BufferIsValid(buffer))
if (sv_flags & BM_IO_ERROR)
{
/* Buffer is pinned, so we can read tag without spinlock */
- char *path = relpath(buf->tag.rnode, buf->tag.forkNum);
+ char *path = relpath(buf->tag.rnode, buf->tag.forkNum);
+
ereport(WARNING,
(errcode(ERRCODE_IO_ERROR),
errmsg("could not write block %u of %s",
/* Buffer is pinned, so we can read the tag without locking the spinlock */
if (bufHdr != NULL)
{
- char *path = relpath(bufHdr->tag.rnode, bufHdr->tag.forkNum);
+ char *path = relpath(bufHdr->tag.rnode, bufHdr->tag.forkNum);
+
errcontext("writing block %u of relation %s",
bufHdr->tag.blockNum, path);
pfree(path);
/* Not in buffers, so initiate prefetch */
smgrprefetch(smgr, forkNum, blockNum);
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
#ifdef LBDEBUG
fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n",
- smgr->smgr_rnode.relNode, forkNum, blockNum, -nextFreeLocalBuf - 1);
+ smgr->smgr_rnode.relNode, forkNum, blockNum, -nextFreeLocalBuf - 1);
#endif
/*
file->files = (File *) repalloc(file->files,
(file->numFiles + 1) * sizeof(File));
file->offsets = (off_t *) repalloc(file->offsets,
- (file->numFiles + 1) * sizeof(off_t));
+ (file->numFiles + 1) * sizeof(off_t));
file->files[file->numFiles] = pfile;
file->offsets[file->numFiles] = 0L;
file->numFiles++;
* Flag to tell whether it's worth scanning VfdCache looking for temp files to
* close
*/
-static bool have_xact_temporary_files = false;
+static bool have_xact_temporary_files = false;
typedef struct vfd
{
int fd; /* current FD, or VFD_CLOSED if none */
unsigned short fdstate; /* bitflags for VFD's state */
- SubTransactionId create_subid; /* for TEMPORARY fds, creating subxact */
+ SubTransactionId create_subid; /* for TEMPORARY fds, creating subxact */
File nextFree; /* link to next free VFD, if in freelist */
File lruMoreRecently; /* doubly linked recency-of-use list */
File lruLessRecently;
int used = 0;
int highestfd = 0;
int j;
+
#ifdef HAVE_GETRLIMIT
struct rlimit rlim;
int getrlimit_status;
fd = (int *) palloc(size * sizeof(int));
#ifdef HAVE_GETRLIMIT
-# ifdef RLIMIT_NOFILE /* most platforms use RLIMIT_NOFILE */
+#ifdef RLIMIT_NOFILE /* most platforms use RLIMIT_NOFILE */
getrlimit_status = getrlimit(RLIMIT_NOFILE, &rlim);
-# else /* but BSD doesn't ... */
+#else /* but BSD doesn't ... */
getrlimit_status = getrlimit(RLIMIT_OFILE, &rlim);
-# endif /* RLIMIT_NOFILE */
+#endif /* RLIMIT_NOFILE */
if (getrlimit_status != 0)
ereport(WARNING, (errmsg("getrlimit failed: %m")));
-#endif /* HAVE_GETRLIMIT */
+#endif /* HAVE_GETRLIMIT */
/* dup until failure or probe limit reached */
for (;;)
int thisfd;
#ifdef HAVE_GETRLIMIT
- /* don't go beyond RLIMIT_NOFILE; causes irritating kernel logs on some platforms */
+
+ /*
+ * don't go beyond RLIMIT_NOFILE; causes irritating kernel logs on
+ * some platforms
+ */
if (getrlimit_status == 0 && highestfd >= rlim.rlim_cur - 1)
break;
#endif
int returnCode;
Assert(FileIsValid(file));
-
+
DO_DB(elog(LOG, "FilePrefetch: %d (%s) " INT64_FORMAT " %d",
file, VfdCache[file].fileName,
(int64) offset, amount));
*
* NOTES:
*
- * Free Space Map keeps track of the amount of free space on pages, and
- * allows quickly searching for a page with enough free space. The FSM is
- * stored in a dedicated relation fork of all heap relations, and those
- * index access methods that need it (see also indexfsm.c). See README for
- * more information.
+ * Free Space Map keeps track of the amount of free space on pages, and
+ * allows quickly searching for a page with enough free space. The FSM is
+ * stored in a dedicated relation fork of all heap relations, and those
+ * index access methods that need it (see also indexfsm.c). See README for
+ * more information.
*
*-------------------------------------------------------------------------
*/
* look like this
*
*
- * Range Category
- * 0 - 31 0
- * 32 - 63 1
- * ... ... ...
+ * Range Category
+ * 0 - 31 0
+ * 32 - 63 1
+ * ... ... ...
* 8096 - 8127 253
* 8128 - 8163 254
* 8164 - 8192 255
*/
typedef struct
{
- int level; /* level */
- int logpageno; /* page number within the level */
+ int level; /* level */
+ int logpageno; /* page number within the level */
} FSMAddress;
/* Address of the root page. */
-static const FSMAddress FSM_ROOT_ADDRESS = { FSM_ROOT_LEVEL, 0 };
+static const FSMAddress FSM_ROOT_ADDRESS = {FSM_ROOT_LEVEL, 0};
/* functions to navigate the tree */
static FSMAddress fsm_get_child(FSMAddress parent, uint16 slot);
/* functions to convert amount of free space to a FSM category */
static uint8 fsm_space_avail_to_cat(Size avail);
static uint8 fsm_space_needed_to_cat(Size needed);
-static Size fsm_space_cat_to_avail(uint8 cat);
+static Size fsm_space_cat_to_avail(uint8 cat);
/* workhorse functions for various operations */
static int fsm_set_and_search(Relation rel, FSMAddress addr, uint16 slot,
- uint8 newValue, uint8 minValue);
+ uint8 newValue, uint8 minValue);
static BlockNumber fsm_search(Relation rel, uint8 min_cat);
static uint8 fsm_vacuum_page(Relation rel, FSMAddress addr, bool *eof);
BlockNumber
GetPageWithFreeSpace(Relation rel, Size spaceNeeded)
{
- uint8 min_cat = fsm_space_needed_to_cat(spaceNeeded);
+ uint8 min_cat = fsm_space_needed_to_cat(spaceNeeded);
+
return fsm_search(rel, min_cat);
}
void
FreeSpaceMapTruncateRel(Relation rel, BlockNumber nblocks)
{
- BlockNumber new_nfsmblocks;
+ BlockNumber new_nfsmblocks;
FSMAddress first_removed_address;
uint16 first_removed_slot;
Buffer buf;
/*
* Zero out the tail of the last remaining FSM page. If the slot
- * representing the first removed heap block is at a page boundary, as
- * the first slot on the FSM page that first_removed_address points to,
- * we can just truncate that page altogether.
+ * representing the first removed heap block is at a page boundary, as the
+ * first slot on the FSM page that first_removed_address points to, we can
+ * just truncate that page altogether.
*/
if (first_removed_slot > 0)
{
buf = fsm_readbuf(rel, first_removed_address, false);
if (!BufferIsValid(buf))
- return; /* nothing to do; the FSM was already smaller */
+ return; /* nothing to do; the FSM was already smaller */
LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
fsm_truncate_avail(BufferGetPage(buf), first_removed_slot);
MarkBufferDirty(buf);
{
new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM) <= new_nfsmblocks)
- return; /* nothing to do; the FSM was already smaller */
+ return; /* nothing to do; the FSM was already smaller */
}
/* Truncate the unused FSM pages */
smgrtruncate(rel->rd_smgr, FSM_FORKNUM, new_nfsmblocks, rel->rd_istemp);
/*
- * Need to invalidate the relcache entry, because rd_fsm_nblocks
- * seen by other backends is no longer valid.
+ * Need to invalidate the relcache entry, because rd_fsm_nblocks seen by
+ * other backends is no longer valid.
*/
if (!InRecovery)
CacheInvalidateRelcache(rel);
void
FreeSpaceMapVacuum(Relation rel)
{
- bool dummy;
+ bool dummy;
/*
* Traverse the tree in depth-first order. The tree is stored physically
static uint8
fsm_space_avail_to_cat(Size avail)
{
- int cat;
+ int cat;
Assert(avail < BLCKSZ);
static uint8
fsm_space_needed_to_cat(Size needed)
{
- int cat;
+ int cat;
/* Can't ask for more space than the highest category represents */
if (needed > MaxFSMRequestSize)
- elog(ERROR, "invalid FSM request size %lu",
- (unsigned long) needed);
+ elog(ERROR, "invalid FSM request size %lu",
+ (unsigned long) needed);
if (needed == 0)
return 1;
fsm_logical_to_physical(FSMAddress addr)
{
BlockNumber pages;
- int leafno;
- int l;
+ int leafno;
+ int l;
/*
* Calculate the logical page number of the first leaf page below the
}
/*
- * If the page we were asked for wasn't at the bottom level, subtract
- * the additional lower level pages we counted above.
+ * If the page we were asked for wasn't at the bottom level, subtract the
+ * additional lower level pages we counted above.
*/
pages -= addr.level;
static FSMAddress
fsm_get_location(BlockNumber heapblk, uint16 *slot)
{
- FSMAddress addr;
+ FSMAddress addr;
addr.level = FSM_BOTTOM_LEVEL;
addr.logpageno = heapblk / SlotsPerFSMPage;
static FSMAddress
fsm_get_parent(FSMAddress child, uint16 *slot)
{
- FSMAddress parent;
+ FSMAddress parent;
Assert(child.level < FSM_ROOT_LEVEL);
static FSMAddress
fsm_get_child(FSMAddress parent, uint16 slot)
{
- FSMAddress child;
+ FSMAddress child;
Assert(parent.level > FSM_BOTTOM_LEVEL);
fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
{
BlockNumber blkno = fsm_logical_to_physical(addr);
- Buffer buf;
+ Buffer buf;
RelationOpenSmgr(rel);
fsm_extend(Relation rel, BlockNumber fsm_nblocks)
{
BlockNumber fsm_nblocks_now;
- Page pg;
+ Page pg;
pg = (Page) palloc(BLCKSZ);
PageInit(pg, BLCKSZ, 0);
/*
- * We use the relation extension lock to lock out other backends
- * trying to extend the FSM at the same time. It also locks out
- * extension of the main fork, unnecessarily, but extending the
- * FSM happens seldom enough that it doesn't seem worthwhile to
- * have a separate lock tag type for it.
+ * We use the relation extension lock to lock out other backends trying to
+ * extend the FSM at the same time. It also locks out extension of the
+ * main fork, unnecessarily, but extending the FSM happens seldom enough
+ * that it doesn't seem worthwhile to have a separate lock tag type for
+ * it.
*
- * Note that another backend might have extended or created the
- * relation before we get the lock.
+ * Note that another backend might have extended or created the relation
+ * before we get the lock.
*/
LockRelationForExtension(rel, ExclusiveLock);
static BlockNumber
fsm_search(Relation rel, uint8 min_cat)
{
- int restarts = 0;
- FSMAddress addr = FSM_ROOT_ADDRESS;
+ int restarts = 0;
+ FSMAddress addr = FSM_ROOT_ADDRESS;
for (;;)
{
- int slot;
- Buffer buf;
- uint8 max_avail = 0;
+ int slot;
+ Buffer buf;
+ uint8 max_avail = 0;
/* Read the FSM page. */
buf = fsm_readbuf(rel, addr, false);
}
else
{
- uint16 parentslot;
- FSMAddress parent;
+ uint16 parentslot;
+ FSMAddress parent;
/*
* At lower level, failure can happen if the value in the upper-
fsm_set_and_search(rel, parent, parentslot, max_avail, 0);
/*
- * If the upper pages are badly out of date, we might need to
- * loop quite a few times, updating them as we go. Any
- * inconsistencies should eventually be corrected and the loop
- * should end. Looping indefinitely is nevertheless scary, so
- * provide an emergency valve.
+ * If the upper pages are badly out of date, we might need to loop
+ * quite a few times, updating them as we go. Any inconsistencies
+ * should eventually be corrected and the loop should end. Looping
+ * indefinitely is nevertheless scary, so provide an emergency
+ * valve.
*/
if (restarts++ > 10000)
return InvalidBlockNumber;
static uint8
fsm_vacuum_page(Relation rel, FSMAddress addr, bool *eof_p)
{
- Buffer buf;
- Page page;
- uint8 max_avail;
+ Buffer buf;
+ Page page;
+ uint8 max_avail;
/* Read the page if it exists, or return EOF */
buf = fsm_readbuf(rel, addr, false);
page = BufferGetPage(buf);
/*
- * Recurse into children, and fix the information stored about them
- * at this level.
+ * Recurse into children, and fix the information stored about them at
+ * this level.
*/
if (addr.level > FSM_BOTTOM_LEVEL)
{
- int slot;
- bool eof = false;
+ int slot;
+ bool eof = false;
for (slot = 0; slot < SlotsPerFSMPage; slot++)
{
- int child_avail;
+ int child_avail;
/* After we hit end-of-file, just clear the rest of the slots */
if (!eof)
*
* NOTES:
*
- * The public functions in this file form an API that hides the internal
- * structure of a FSM page. This allows freespace.c to treat each FSM page
- * as a black box with SlotsPerPage "slots". fsm_set_avail() and
- * fsm_get_avail() let you get/set the value of a slot, and
- * fsm_search_avail() lets you search for a slot with value >= X.
+ * The public functions in this file form an API that hides the internal
+ * structure of a FSM page. This allows freespace.c to treat each FSM page
+ * as a black box with SlotsPerPage "slots". fsm_set_avail() and
+ * fsm_get_avail() let you get/set the value of a slot, and
+ * fsm_search_avail() lets you search for a slot with value >= X.
*
*-------------------------------------------------------------------------
*/
x++;
/*
- * Check if we stepped to the leftmost node at next level, and correct
- * if so. The leftmost nodes at each level are numbered x = 2^level - 1,
- * so check if (x + 1) is a power of two, using a standard
+ * Check if we stepped to the leftmost node at next level, and correct if
+ * so. The leftmost nodes at each level are numbered x = 2^level - 1, so
+ * check if (x + 1) is a power of two, using a standard
* twos-complement-arithmetic trick.
*/
if (((x + 1) & x) == 0)
bool
fsm_set_avail(Page page, int slot, uint8 value)
{
- int nodeno = NonLeafNodesPerPage + slot;
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
- uint8 oldvalue;
+ int nodeno = NonLeafNodesPerPage + slot;
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ uint8 oldvalue;
Assert(slot < LeafNodesPerPage);
fsmpage->fp_nodes[nodeno] = value;
/*
- * Propagate up, until we hit the root or a node that doesn't
- * need to be updated.
+ * Propagate up, until we hit the root or a node that doesn't need to be
+ * updated.
*/
do
{
- uint8 newvalue = 0;
- int lchild;
- int rchild;
+ uint8 newvalue = 0;
+ int lchild;
+ int rchild;
nodeno = parentof(nodeno);
lchild = leftchild(nodeno);
} while (nodeno > 0);
/*
- * sanity check: if the new value is (still) higher than the value
- * at the top, the tree is corrupt. If so, rebuild.
+ * sanity check: if the new value is (still) higher than the value at the
+ * top, the tree is corrupt. If so, rebuild.
*/
if (value > fsmpage->fp_nodes[0])
fsm_rebuild_page(page);
uint8
fsm_get_avail(Page page, int slot)
{
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
Assert(slot < LeafNodesPerPage);
uint8
fsm_get_max_avail(Page page)
{
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
return fsmpage->fp_nodes[0];
}
fsm_search_avail(Buffer buf, uint8 minvalue, bool advancenext,
bool exclusive_lock_held)
{
- Page page = BufferGetPage(buf);
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
- int nodeno;
- int target;
- uint16 slot;
+ Page page = BufferGetPage(buf);
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ int nodeno;
+ int target;
+ uint16 slot;
+
+restart:
- restart:
/*
- * Check the root first, and exit quickly if there's no leaf with
- * enough free space
+ * Check the root first, and exit quickly if there's no leaf with enough
+ * free space
*/
if (fsmpage->fp_nodes[0] < minvalue)
return -1;
/*----------
* Start the search from the target slot. At every step, move one
- * node to the right, then climb up to the parent. Stop when we reach
+ * node to the right, then climb up to the parent. Stop when we reach
* a node with enough free space (as we must, since the root has enough
* space).
*
* The idea is to gradually expand our "search triangle", that is, all
* nodes covered by the current node, and to be sure we search to the
- * right from the start point. At the first step, only the target slot
+ * right from the start point. At the first step, only the target slot
* is examined. When we move up from a left child to its parent, we are
* adding the right-hand subtree of that parent to the search triangle.
* When we move right then up from a right child, we are dropping the
*
* For example, consider this tree:
*
- * 7
- * 7 6
- * 5 7 6 5
- * 4 5 5 7 2 6 5 2
- * T
+ * 7
+ * 7 6
+ * 5 7 6 5
+ * 4 5 5 7 2 6 5 2
+ * T
*
* Assume that the target node is the node indicated by the letter T,
* and we're searching for a node with value of 6 or higher. The search
break;
/*
- * Move to the right, wrapping around on same level if necessary,
- * then climb up.
+ * Move to the right, wrapping around on same level if necessary, then
+ * climb up.
*/
nodeno = parentof(rightneighbor(nodeno));
}
*/
while (nodeno < NonLeafNodesPerPage)
{
- int childnodeno = leftchild(nodeno);
+ int childnodeno = leftchild(nodeno);
if (childnodeno < NodesPerPage &&
fsmpage->fp_nodes[childnodeno] >= minvalue)
else
{
/*
- * Oops. The parent node promised that either left or right
- * child has enough space, but neither actually did. This can
- * happen in case of a "torn page", IOW if we crashed earlier
- * while writing the page to disk, and only part of the page
- * made it to disk.
+ * Oops. The parent node promised that either left or right child
+ * has enough space, but neither actually did. This can happen in
+ * case of a "torn page", IOW if we crashed earlier while writing
+ * the page to disk, and only part of the page made it to disk.
*
* Fix the corruption and restart.
*/
- RelFileNode rnode;
+ RelFileNode rnode;
ForkNumber forknum;
- BlockNumber blknum;
+ BlockNumber blknum;
BufferGetTag(buf, &rnode, &forknum, &blknum);
elog(DEBUG1, "fixing corrupt FSM block %u, relation %u/%u/%u",
bool
fsm_truncate_avail(Page page, int nslots)
{
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
- uint8 *ptr;
- bool changed = false;
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ uint8 *ptr;
+ bool changed = false;
Assert(nslots >= 0 && nslots < LeafNodesPerPage);
bool
fsm_rebuild_page(Page page)
{
- FSMPage fsmpage = (FSMPage) PageGetContents(page);
- bool changed = false;
- int nodeno;
+ FSMPage fsmpage = (FSMPage) PageGetContents(page);
+ bool changed = false;
+ int nodeno;
/*
* Start from the lowest non-leaf level, at last node, working our way
*/
for (nodeno = NonLeafNodesPerPage - 1; nodeno >= 0; nodeno--)
{
- int lchild = leftchild(nodeno);
- int rchild = lchild + 1;
- uint8 newvalue = 0;
+ int lchild = leftchild(nodeno);
+ int rchild = lchild + 1;
+ uint8 newvalue = 0;
/* The first few nodes we examine might have zero or one child. */
if (lchild < NodesPerPage)
*
* NOTES:
*
- * This is similar to the FSM used for heap, in freespace.c, but instead
- * of tracking the amount of free space on pages, we only track whether
- * pages are completely free or in-use. We use the same FSM implementation
- * as for heaps, using BLCKSZ - 1 to denote used pages, and 0 for unused.
+ * This is similar to the FSM used for heap, in freespace.c, but instead
+ * of tracking the amount of free space on pages, we only track whether
+ * pages are completely free or in-use. We use the same FSM implementation
+ * as for heaps, using BLCKSZ - 1 to denote used pages, and 0 for unused.
*
*-------------------------------------------------------------------------
*/
BlockNumber
GetFreeIndexPage(Relation rel)
{
- BlockNumber blkno = GetPageWithFreeSpace(rel, BLCKSZ/2);
+ BlockNumber blkno = GetPageWithFreeSpace(rel, BLCKSZ / 2);
if (blkno != InvalidBlockNumber)
RecordUsedIndexPage(rel, blkno);
* -cim 2/6/90
*
* Unfortunately, we can't really guarantee that add-on code
- * obeys the rule of not calling exit() directly. So, while
+ * obeys the rule of not calling exit() directly. So, while
* this is the preferred way out of the system, we also register
* an atexit callback that will make sure cleanup happens.
* ----------------------------------------------------------------
*
* Note that we do this here instead of in an on_proc_exit() callback
* because we want to ensure that this code executes last - we don't
- * want to interfere with any other on_proc_exit() callback. For
- * the same reason, we do not include it in proc_exit_prepare ...
- * so if you are exiting in the "wrong way" you won't drop your profile
- * in a nice place.
+ * want to interfere with any other on_proc_exit() callback. For the
+ * same reason, we do not include it in proc_exit_prepare ... so if
+ * you are exiting in the "wrong way" you won't drop your profile in a
+ * nice place.
*/
char gprofDirName[32];
/* ... too bad we don't know the real exit code ... */
proc_exit_prepare(-1);
}
-
-#else /* assume we have on_exit instead */
+#else /* assume we have on_exit instead */
static void
atexit_callback(int exitstatus, void *arg)
/* Clean up everything that must be cleaned up */
proc_exit_prepare(exitstatus);
}
-
-#endif /* HAVE_ATEXIT */
+#endif /* HAVE_ATEXIT */
/* ----------------------------------------------------------------
* on_proc_exit
* have three possible states: UNUSED, ASSIGNED, ACTIVE. An UNUSED slot is
* available for assignment. An ASSIGNED slot is associated with a postmaster
* child process, but either the process has not touched shared memory yet,
- * or it has successfully cleaned up after itself. A ACTIVE slot means the
+ * or it has successfully cleaned up after itself. A ACTIVE slot means the
* process is actively using shared memory. The slots are assigned to
* child processes at random, and postmaster.c is responsible for tracking
* which one goes with which PID.
/* per-reason flags */
sig_atomic_t PMSignalFlags[NUM_PMSIGNALS];
/* per-child-process flags */
- int num_child_flags; /* # of entries in PMChildFlags[] */
- int next_child_flag; /* next slot to try to assign */
+ int num_child_flags; /* # of entries in PMChildFlags[] */
+ int next_child_flag; /* next slot to try to assign */
sig_atomic_t PMChildFlags[1]; /* VARIABLE LENGTH ARRAY */
};
Assert(slot > 0 && slot <= PMSignalState->num_child_flags);
slot--;
+
/*
* Note: the slot state might already be unused, because the logic in
* postmaster.c is such that this might get called twice when a child
snapshot->curcid = GetCurrentCommandId(false);
/*
- * This is a new snapshot, so set both refcounts are zero, and mark it
- * as not copied in persistent memory.
+ * This is a new snapshot, so set both refcounts are zero, and mark it as
+ * not copied in persistent memory.
*/
snapshot->active_count = 0;
snapshot->regd_count = 0;
* some snapshot we have. Since we examine the procarray with only shared
* lock, there are race conditions: a backend could set its xmin just after
* we look. Indeed, on multiprocessors with weak memory ordering, the
- * other backend could have set its xmin *before* we look. We know however
+ * other backend could have set its xmin *before* we look. We know however
* that such a backend must have held shared ProcArrayLock overlapping our
* own hold of ProcArrayLock, else we would see its xmin update. Therefore,
* any snapshot the other backend is taking concurrently with our scan cannot
*
* If someone just decremented numProcs, 'proc' could also point to a
* PGPROC entry that's no longer in the array. It still points to a
- * PGPROC struct, though, because freed PGPPROC entries just go to
- * the free list and are recycled. Its contents are nonsense in that
- * case, but that's acceptable for this function.
+ * PGPROC struct, though, because freed PGPPROC entries just go to the
+ * free list and are recycled. Its contents are nonsense in that case,
+ * but that's acceptable for this function.
*/
if (proc != NULL)
continue;
CountOtherDBBackends(Oid databaseId, int *nbackends, int *nprepared)
{
ProcArrayStruct *arrayP = procArray;
-#define MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */
+
+#define MAXAUTOVACPIDS 10 /* max autovacs to SIGTERM per iteration */
int autovac_pids[MAXAUTOVACPIDS];
int tries;
return false; /* no conflicting backends, so done */
/*
- * Send SIGTERM to any conflicting autovacuums before sleeping.
- * We postpone this step until after the loop because we don't
- * want to hold ProcArrayLock while issuing kill().
- * We have no idea what might block kill() inside the kernel...
+ * Send SIGTERM to any conflicting autovacuums before sleeping. We
+ * postpone this step until after the loop because we don't want to
+ * hold ProcArrayLock while issuing kill(). We have no idea what might
+ * block kill() inside the kernel...
*/
for (index = 0; index < nautovacs; index++)
(void) kill(autovac_pids[index], SIGTERM); /* ignore any error */
* NOTE: it is entirely possible for this routine to be invoked recursively
* as a consequence of processing inside the invalFunction or resetFunction.
* Furthermore, such a recursive call must guarantee that all outstanding
- * inval messages have been processed before it exits. This is the reason
+ * inval messages have been processed before it exits. This is the reason
* for the strange-looking choice to use a statically allocated buffer array
* and counters; it's so that a recursive call can process messages already
* sucked out of sinvaladt.c.
{
#define MAXINVALMSGS 32
static SharedInvalidationMessage messages[MAXINVALMSGS];
+
/*
- * We use volatile here to prevent bugs if a compiler doesn't realize
- * that recursion is a possibility ...
+ * We use volatile here to prevent bugs if a compiler doesn't realize that
+ * recursion is a possibility ...
*/
static volatile int nextmsg = 0;
static volatile int nummsgs = 0;
}
/*
- * We only need to loop if the last SIGetDataEntries call (which
- * might have been within a recursive call) returned a full buffer.
+ * We only need to loop if the last SIGetDataEntries call (which might
+ * have been within a recursive call) returned a full buffer.
*/
} while (nummsgs == MAXINVALMSGS);
/*
* We are now caught up. If we received a catchup signal, reset that
- * flag, and call SICleanupQueue(). This is not so much because we
- * need to flush dead messages right now, as that we want to pass on
- * the catchup signal to the next slowest backend. "Daisy chaining" the
- * catchup signal this way avoids creating spikes in system load for
- * what should be just a background maintenance activity.
+ * flag, and call SICleanupQueue(). This is not so much because we need
+ * to flush dead messages right now, as that we want to pass on the
+ * catchup signal to the next slowest backend. "Daisy chaining" the
+ * catchup signal this way avoids creating spikes in system load for what
+ * should be just a background maintenance activity.
*/
if (catchupInterruptOccurred)
{
* normal behavior is that at most one such interrupt is in flight at a time;
* when a backend completes processing a catchup interrupt, it executes
* SICleanupQueue, which will signal the next-furthest-behind backend if
- * needed. This avoids undue contention from multiple backends all trying
+ * needed. This avoids undue contention from multiple backends all trying
* to catch up at once. However, the furthest-back backend might be stuck
* in a state where it can't catch up. Eventually it will get reset, so it
* won't cause any more problems for anyone but itself. But we don't want
* the writer wants to change maxMsgNum while readers need to read it.
* We deal with that by having a spinlock that readers must take for just
* long enough to read maxMsgNum, while writers take it for just long enough
- * to write maxMsgNum. (The exact rule is that you need the spinlock to
+ * to write maxMsgNum. (The exact rule is that you need the spinlock to
* read maxMsgNum if you are not holding SInvalWriteLock, and you need the
* spinlock to write maxMsgNum unless you are holding both locks.)
*
/*
* Next LocalTransactionId to use for each idle backend slot. We keep
* this here because it is indexed by BackendId and it is convenient to
- * copy the value to and from local memory when MyBackendId is set.
- * It's meaningless in an active ProcState entry.
+ * copy the value to and from local memory when MyBackendId is set. It's
+ * meaningless in an active ProcState entry.
*/
LocalTransactionId nextLXID;
} ProcState;
/* Mark all backends inactive, and initialize nextLXID */
for (i = 0; i < shmInvalBuffer->maxBackends; i++)
{
- shmInvalBuffer->procState[i].procPid = 0; /* inactive */
- shmInvalBuffer->procState[i].nextMsgNum = 0; /* meaningless */
+ shmInvalBuffer->procState[i].procPid = 0; /* inactive */
+ shmInvalBuffer->procState[i].nextMsgNum = 0; /* meaningless */
shmInvalBuffer->procState[i].resetState = false;
shmInvalBuffer->procState[i].signaled = false;
shmInvalBuffer->procState[i].nextLXID = InvalidLocalTransactionId;
SISeg *segP = shmInvalBuffer;
/*
- * This can run in parallel with read operations, and for that matter
- * with write operations; but not in parallel with additions and removals
- * of backends, nor in parallel with SICleanupQueue. It doesn't seem
- * worth having a third lock, so we choose to use SInvalWriteLock to
- * serialize additions/removals.
+ * This can run in parallel with read operations, and for that matter with
+ * write operations; but not in parallel with additions and removals of
+ * backends, nor in parallel with SICleanupQueue. It doesn't seem worth
+ * having a third lock, so we choose to use SInvalWriteLock to serialize
+ * additions/removals.
*/
LWLockAcquire(SInvalWriteLock, LW_EXCLUSIVE);
SISeg *segP = shmInvalBuffer;
/*
- * N can be arbitrarily large. We divide the work into groups of no more
+ * N can be arbitrarily large. We divide the work into groups of no more
* than WRITE_QUANTUM messages, to be sure that we don't hold the lock for
* an unreasonably long time. (This is not so much because we care about
* letting in other writers, as that some just-caught-up backend might be
*/
while (n > 0)
{
- int nthistime = Min(n, WRITE_QUANTUM);
- int numMsgs;
- int max;
+ int nthistime = Min(n, WRITE_QUANTUM);
+ int numMsgs;
+ int max;
n -= nthistime;
* If the buffer is full, we *must* acquire some space. Clean the
* queue and reset anyone who is preventing space from being freed.
* Otherwise, clean the queue only when it's exceeded the next
- * fullness threshold. We have to loop and recheck the buffer state
+ * fullness threshold. We have to loop and recheck the buffer state
* after any call of SICleanupQueue.
*/
for (;;)
* get next SI message(s) for current backend, if there are any
*
* Possible return values:
- * 0: no SI message available
+ * 0: no SI message available
* n>0: next n SI messages have been extracted into data[]
- * -1: SI reset message extracted
+ * -1: SI reset message extracted
*
* If the return value is less than the array size "datasize", the caller
* can assume that there are no more SI messages after the one(s) returned.
* executing on behalf of other backends, since each instance will modify only
* fields of its own backend's ProcState, and no instance will look at fields
* of other backends' ProcStates. We express this by grabbing SInvalReadLock
- * in shared mode. Note that this is not exactly the normal (read-only)
+ * in shared mode. Note that this is not exactly the normal (read-only)
* interpretation of a shared lock! Look closely at the interactions before
* allowing SInvalReadLock to be grabbed in shared mode for any other reason!
*
- * NB: this can also run in parallel with SIInsertDataEntries. It is not
+ * NB: this can also run in parallel with SIInsertDataEntries. It is not
* guaranteed that we will return any messages added after the routine is
* entered.
*
ProcState *stateP;
int max;
int n;
-
+
LWLockAcquire(SInvalReadLock, LW_SHARED);
segP = shmInvalBuffer;
*
* Caution: because we transiently release write lock when we have to signal
* some other backend, it is NOT guaranteed that there are still minFree
- * free message slots at exit. Caller must recheck and perhaps retry.
+ * free message slots at exit. Caller must recheck and perhaps retry.
*/
void
SICleanupQueue(bool callerHasWriteLock, int minFree)
LWLockAcquire(SInvalReadLock, LW_EXCLUSIVE);
/*
- * Recompute minMsgNum = minimum of all backends' nextMsgNum, identify
- * the furthest-back backend that needs signaling (if any), and reset
- * any backends that are too far back.
+ * Recompute minMsgNum = minimum of all backends' nextMsgNum, identify the
+ * furthest-back backend that needs signaling (if any), and reset any
+ * backends that are too far back.
*/
min = segP->maxMsgNum;
minsig = min - SIG_THRESHOLD;
for (i = 0; i < segP->lastBackend; i++)
{
ProcState *stateP = &segP->procState[i];
- int n = stateP->nextMsgNum;
+ int n = stateP->nextMsgNum;
/* Ignore if inactive or already in reset state */
if (stateP->procPid == 0 || stateP->resetState)
continue;
/*
- * If we must free some space and this backend is preventing it,
- * force him into reset state and then ignore until he catches up.
+ * If we must free some space and this backend is preventing it, force
+ * him into reset state and then ignore until he catches up.
*/
if (n < lowbound)
{
/*
* When minMsgNum gets really large, decrement all message counters so as
- * to forestall overflow of the counters. This happens seldom enough
- * that folding it into the previous loop would be a loser.
+ * to forestall overflow of the counters. This happens seldom enough that
+ * folding it into the previous loop would be a loser.
*/
if (min >= MSGNUMWRAPAROUND)
{
*/
if (needSig)
{
- pid_t his_pid = needSig->procPid;
+ pid_t his_pid = needSig->procPid;
needSig->signaled = true;
LWLockRelease(SInvalReadLock);
else if (flags & INV_READ)
{
/*
- * We must register the snapshot in TopTransaction's resowner,
- * because it must stay alive until the LO is closed rather than until
- * the current portal shuts down.
+ * We must register the snapshot in TopTransaction's resowner, because
+ * it must stay alive until the LO is closed rather than until the
+ * current portal shuts down.
*/
retval->snapshot = RegisterSnapshotOnOwner(GetActiveSnapshot(),
- TopTransactionResourceOwner);
+ TopTransactionResourceOwner);
retval->flags = IFS_RDLOCK;
}
else
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
replace[Anum_pg_largeobject_data - 1] = true;
newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
- values, nulls, replace);
+ values, nulls, replace);
simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
CatalogIndexInsert(indstate, newtup);
heap_freetuple(newtup);
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
replace[Anum_pg_largeobject_data - 1] = true;
newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
- values, nulls, replace);
+ values, nulls, replace);
simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
CatalogIndexInsert(indstate, newtup);
heap_freetuple(newtup);
appendStringInfo(&logbuf,
_("Process %d: %s"),
info->pid,
- pgstat_get_backend_current_activity(info->pid, false));
+ pgstat_get_backend_current_activity(info->pid, false));
}
ereport(ERROR,
{
LOCKMETHODID lockmethodid = LOCALLOCK_LOCKMETHOD(*locallock);
LockMethod lockMethodTable = LockMethods[lockmethodid];
- char * volatile new_status = NULL;
+ char *volatile new_status = NULL;
LOCK_PRINT("WaitOnLock: sleeping on lock",
locallock->lock, locallock->tag.mode);
* the locktable state must fully reflect the fact that we own the lock;
* we can't do additional work on return.
*
- * We can and do use a PG_TRY block to try to clean up after failure,
- * but this still has a major limitation: elog(FATAL) can occur while
- * waiting (eg, a "die" interrupt), and then control won't come back here.
- * So all cleanup of essential state should happen in LockWaitCancel,
- * not here. We can use PG_TRY to clear the "waiting" status flags,
- * since doing that is unimportant if the process exits.
+ * We can and do use a PG_TRY block to try to clean up after failure, but
+ * this still has a major limitation: elog(FATAL) can occur while waiting
+ * (eg, a "die" interrupt), and then control won't come back here. So all
+ * cleanup of essential state should happen in LockWaitCancel, not here.
+ * We can use PG_TRY to clear the "waiting" status flags, since doing that
+ * is unimportant if the process exits.
*/
PG_TRY();
{
if (ProcSleep(locallock, lockMethodTable) != STATUS_OK)
{
/*
- * We failed as a result of a deadlock, see CheckDeadLock().
- * Quit now.
+ * We failed as a result of a deadlock, see CheckDeadLock(). Quit
+ * now.
*/
awaitedLock = NULL;
LOCK_PRINT("WaitOnLock: aborting on lock",
/*
* Now that we have a PGPROC, mark ourselves as an active postmaster
- * child; this is so that the postmaster can detect it if we exit
- * without cleaning up.
+ * child; this is so that the postmaster can detect it if we exit without
+ * cleaning up.
*/
if (IsUnderPostmaster)
MarkPostmasterChildActive();
* Check to see if we've been awoken by anyone in the interim.
*
* If we have, we can return and resume our transaction -- happy day.
- * Before we are awoken the process releasing the lock grants it to us
- * so we know that we don't have to wait anymore.
+ * Before we are awoken the process releasing the lock grants it to us so
+ * we know that we don't have to wait anymore.
*
* We check by looking to see if we've been unlinked from the wait queue.
* This is quicker than checking our semaphore's state, since no kernel
typedef struct
{
RelFileNode rnode; /* the targeted relation */
- ForkNumber forknum;
+ ForkNumber forknum;
BlockNumber segno; /* which segment */
} PendingOperationTag;
} ExtensionBehavior;
/* local routines */
-static MdfdVec *mdopen(SMgrRelation reln, ForkNumber forknum,
- ExtensionBehavior behavior);
+static MdfdVec *mdopen(SMgrRelation reln, ForkNumber forknum,
+ ExtensionBehavior behavior);
static void register_dirty_segment(SMgrRelation reln, ForkNumber forknum,
- MdfdVec *seg);
+ MdfdVec *seg);
static void register_unlink(RelFileNode rnode);
static MdfdVec *_fdvec_alloc(void);
static MdfdVec *_mdfd_openseg(SMgrRelation reln, ForkNumber forkno,
- BlockNumber segno, int oflags);
+ BlockNumber segno, int oflags);
static MdfdVec *_mdfd_getseg(SMgrRelation reln, ForkNumber forkno,
BlockNumber blkno, bool isTemp, ExtensionBehavior behavior);
static BlockNumber _mdnblocks(SMgrRelation reln, ForkNumber forknum,
- MdfdVec *seg);
+ MdfdVec *seg);
/*
}
/*
- * mdexists() -- Does the physical file exist?
+ * mdexists() -- Does the physical file exist?
*
* Note: this will return true for lingering files, with pending deletions
*/
mdexists(SMgrRelation reln, ForkNumber forkNum)
{
/*
- * Close it first, to ensure that we notice if the fork has been
- * unlinked since we opened it.
+ * Close it first, to ensure that we notice if the fork has been unlinked
+ * since we opened it.
*/
mdclose(reln, forkNum);
if (errno != ENOENT)
ereport(WARNING,
(errcode_for_file_access(),
- errmsg("could not remove segment %u of relation %s: %m",
- segno, path)));
+ errmsg("could not remove segment %u of relation %s: %m",
+ segno, path)));
break;
}
}
v = _mdfd_getseg(reln, forknum, blocknum, isTemp, EXTENSION_CREATE);
- seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
/*
if (v == NULL)
return;
- reln->md_fd[forknum] = NULL; /* prevent dangling pointer after error */
+ reln->md_fd[forknum] = NULL; /* prevent dangling pointer after error */
while (v != NULL)
{
v = _mdfd_getseg(reln, forknum, blocknum, false, EXTENSION_FAIL);
- seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
(void) FilePrefetch(v->mdfd_vfd, seekpos, BLCKSZ);
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
v = _mdfd_getseg(reln, forknum, blocknum, false, EXTENSION_FAIL);
- seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
if (nbytes < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read block %u of relation %s: %m",
- blocknum, relpath(reln->smgr_rnode, forknum))));
+ errmsg("could not read block %u of relation %s: %m",
+ blocknum, relpath(reln->smgr_rnode, forknum))));
/*
* Short read: we are at or past EOF, or we read a partial block at
v = _mdfd_getseg(reln, forknum, blocknum, isTemp, EXTENSION_FAIL);
- seekpos = (off_t) BLCKSZ * (blocknum % ((BlockNumber) RELSEG_SIZE));
+ seekpos = (off_t) BLCKSZ *(blocknum % ((BlockNumber) RELSEG_SIZE));
+
Assert(seekpos < (off_t) BLCKSZ * RELSEG_SIZE);
if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
if (nbytes < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not write block %u of relation %s: %m",
- blocknum, relpath(reln->smgr_rnode, forknum))));
+ errmsg("could not write block %u of relation %s: %m",
+ blocknum, relpath(reln->smgr_rnode, forknum))));
/* short write: complain appropriately */
ereport(ERROR,
(errcode(ERRCODE_DISK_FULL),
if (v->mdfd_chain == NULL)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not open segment %u of relation %s: %m",
- segno,
- relpath(reln->smgr_rnode, forknum))));
+ errmsg("could not open segment %u of relation %s: %m",
+ segno,
+ relpath(reln->smgr_rnode, forknum))));
}
v = v->mdfd_chain;
if (FileTruncate(v->mdfd_vfd, 0) < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not truncate relation %s to %u blocks: %m",
- relpath(reln->smgr_rnode, forknum),
- nblocks)));
+ errmsg("could not truncate relation %s to %u blocks: %m",
+ relpath(reln->smgr_rnode, forknum),
+ nblocks)));
if (!isTemp)
register_dirty_segment(reln, forknum, v);
v = v->mdfd_chain;
- Assert(ov != reln->md_fd[forknum]); /* we never drop the 1st segment */
+ Assert(ov != reln->md_fd[forknum]); /* we never drop the 1st
+ * segment */
pfree(ov);
}
else if (priorblocks + ((BlockNumber) RELSEG_SIZE) > nblocks)
if (FileTruncate(v->mdfd_vfd, (off_t) lastsegblocks * BLCKSZ) < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not truncate relation %s to %u blocks: %m",
- relpath(reln->smgr_rnode, forknum),
- nblocks)));
+ errmsg("could not truncate relation %s to %u blocks: %m",
+ relpath(reln->smgr_rnode, forknum),
+ nblocks)));
if (!isTemp)
register_dirty_segment(reln, forknum, v);
v = v->mdfd_chain;
failures > 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not fsync segment %u of relation %s: %m",
- entry->tag.segno, path)));
+ errmsg("could not fsync segment %u of relation %s: %m",
+ entry->tag.segno, path)));
else
ereport(DEBUG1,
(errcode_for_file_access(),
hash_seq_init(&hstat, pendingOpsTable);
while ((entry = (PendingOperationEntry *) hash_seq_search(&hstat)) != NULL)
{
- if (RelFileNodeEquals(entry->tag.rnode, rnode) &&
+ if (RelFileNodeEquals(entry->tag.rnode, rnode) &&
entry->tag.forknum == forknum)
{
/* Okay, cancel this entry */
/* Remove any pending requests for the entire database */
HASH_SEQ_STATUS hstat;
PendingOperationEntry *entry;
- ListCell *cell,
+ ListCell *cell,
*prev,
*next;
entry->canceled = true;
}
}
-
+
/* Remove unlink requests */
prev = NULL;
for (cell = list_head(pendingUnlinks); cell; cell = next)
PendingUnlinkEntry *entry = (PendingUnlinkEntry *) lfirst(cell);
next = lnext(cell);
- if (entry->rnode.dbNode == rnode.dbNode)
+ if (entry->rnode.dbNode == rnode.dbNode)
{
pendingUnlinks = list_delete_cell(pendingUnlinks, cell, prev);
pfree(entry);
if (len < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek to end of segment %u of relation %s: %m",
- seg->mdfd_segno, relpath(reln->smgr_rnode, forknum))));
+ errmsg("could not seek to end of segment %u of relation %s: %m",
+ seg->mdfd_segno, relpath(reln->smgr_rnode, forknum))));
/* note that this calculation will ignore any partial block at EOF */
return (BlockNumber) (len / BLCKSZ);
}
void (*smgr_shutdown) (void); /* may be NULL */
void (*smgr_close) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_create) (SMgrRelation reln, ForkNumber forknum,
- bool isRedo);
+ bool isRedo);
bool (*smgr_exists) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_unlink) (RelFileNode rnode, ForkNumber forknum,
- bool isRedo);
+ bool isRedo);
void (*smgr_extend) (SMgrRelation reln, ForkNumber forknum,
BlockNumber blocknum, char *buffer, bool isTemp);
void (*smgr_prefetch) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum);
+ BlockNumber blocknum);
void (*smgr_read) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer);
- void (*smgr_write) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer, bool isTemp);
+ BlockNumber blocknum, char *buffer);
+ void (*smgr_write) (SMgrRelation reln, ForkNumber forknum,
+ BlockNumber blocknum, char *buffer, bool isTemp);
BlockNumber (*smgr_nblocks) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_truncate) (SMgrRelation reln, ForkNumber forknum,
- BlockNumber nblocks, bool isTemp);
+ BlockNumber nblocks, bool isTemp);
void (*smgr_immedsync) (SMgrRelation reln, ForkNumber forknum);
void (*smgr_pre_ckpt) (void); /* may be NULL */
void (*smgr_sync) (void); /* may be NULL */
/* local function prototypes */
static void smgrshutdown(int code, Datum arg);
-static void smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
- int which, bool isTemp, bool isRedo);
+static void smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
+ int which, bool isTemp, bool isRedo);
/*
/* Initialize it if not present before */
if (!found)
{
- int forknum;
+ int forknum;
/* hash_search already filled in the lookup key */
reln->smgr_owner = NULL;
reln->smgr_which = 0; /* we only have md.c at present */
/* mark it not open */
- for(forknum = 0; forknum <= MAX_FORKNUM; forknum++)
+ for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
reln->md_fd[forknum] = NULL;
}
smgrclose(SMgrRelation reln)
{
SMgrRelation *owner;
- ForkNumber forknum;
+ ForkNumber forknum;
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
(*(smgrsw[reln->smgr_which].smgr_close)) (reln, forknum);
smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
{
/*
- * Exit quickly in WAL replay mode if we've already opened the file.
- * If it's open, it surely must exist.
- */
+ * Exit quickly in WAL replay mode if we've already opened the file. If
+ * it's open, it surely must exist.
+ */
if (isRedo && reln->md_fd[forknum] != NULL)
return;
* Shared subroutine that actually does the unlink ...
*/
static void
-smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
+smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
int which, bool isTemp, bool isRedo)
{
/*
* causes intervening file space to become filled with zeroes.
*/
void
-smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
+smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer, bool isTemp)
{
(*(smgrsw[reln->smgr_which].smgr_extend)) (reln, forknum, blocknum,
* return pages in the format that POSTGRES expects.
*/
void
-smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
+smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer)
{
(*(smgrsw[reln->smgr_which].smgr_read)) (reln, forknum, blocknum, buffer);
* made to fsync the write before checkpointing.
*/
void
-smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
+smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
char *buffer, bool isTemp)
{
(*(smgrsw[reln->smgr_which].smgr_write)) (reln, forknum, blocknum,
(*(smgrsw[i].smgr_post_ckpt)) ();
}
}
-
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state. (The "dead man switch" mechanism in pmsignal.c
- * should ensure the postmaster sees this as a crash, too, but no harm
- * in being doubly sure.)
+ * should ensure the postmaster sees this as a crash, too, but no harm in
+ * being doubly sure.)
*/
exit(2);
}
qd->operation = plannedstmt->commandType; /* operation */
qd->plannedstmt = plannedstmt; /* plan */
qd->utilitystmt = plannedstmt->utilityStmt; /* in case DECLARE CURSOR */
- qd->sourceText = sourceText; /* query text */
+ qd->sourceText = sourceText; /* query text */
qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */
/* RI check snapshot */
qd->crosscheck_snapshot = RegisterSnapshot(crosscheck_snapshot);
qd->operation = CMD_UTILITY; /* operation */
qd->plannedstmt = NULL;
qd->utilitystmt = utilitystmt; /* utility command */
- qd->sourceText = sourceText; /* query text */
+ qd->sourceText = sourceText; /* query text */
qd->snapshot = RegisterSnapshot(snapshot); /* snapshot */
qd->crosscheck_snapshot = InvalidSnapshot; /* RI check snapshot */
qd->dest = dest; /* output dest */
if (log_executor_stats && portal->strategy != PORTAL_MULTI_QUERY)
ShowUsage("EXECUTOR STATISTICS");
-
+
TRACE_POSTGRESQL_QUERY_EXECUTE_DONE();
return result;
PortalRunUtility(Portal portal, Node *utilityStmt, bool isTopLevel,
DestReceiver *dest, char *completionTag)
{
- bool active_snapshot_set;
+ bool active_snapshot_set;
elog(DEBUG3, "ProcessUtility");
/*
* Some utility commands may pop the ActiveSnapshot stack from under us,
- * so we only pop the stack if we actually see a snapshot set. Note that
+ * so we only pop the stack if we actually see a snapshot set. Note that
* the set of utility commands that do this must be the same set
* disallowed to run inside a transaction; otherwise, we could be popping
* a snapshot that belongs to some other operation.
/*
* Note: Commands that need to do more complicated checking are handled
- * elsewhere, in particular COPY and plannable statements do their
- * own checking.
+ * elsewhere, in particular COPY and plannable statements do their own
+ * checking.
*/
switch (nodeTag(parsetree))
DestReceiver *dest,
char *completionTag)
{
- Assert(queryString != NULL); /* required as of 8.4 */
+ Assert(queryString != NULL); /* required as of 8.4 */
check_xact_readonly(parsetree);
if (IsA(stmt, CreateStmt))
{
- Datum toast_options;
- static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
+ Datum toast_options;
+ static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
/* Create the table itself */
relOid = DefineRelation((CreateStmt *) stmt,
/* parse and validate reloptions for the toast table */
toast_options = transformRelOptions((Datum) 0,
- ((CreateStmt *)stmt)->options,
+ ((CreateStmt *) stmt)->options,
"toast",
validnsps,
true, false);
break;
case T_LockStmt:
+
/*
* Since the lock would just get dropped immediately, LOCK TABLE
* outside a transaction block is presumed to be user error.
if (state == RS_IN_WAIT)
{
if (t_isalpha(c))
- /* okay */ ;
+ /* okay */ ;
else if (t_iseq(c, '['))
state = RS_IN_ONEOF;
else
else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)
{
if (t_isalpha(c))
- /* okay */ ;
+ /* okay */ ;
else if (t_iseq(c, ']'))
state = RS_IN_WAIT;
else
ptr->type = RSF_ONEOF;
state = RS_IN_ONEOF;
}
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else if (state == RS_IN_ONEOF)
ptr->len = pg_mblen(c);
state = RS_IN_ONEOF_IN;
}
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else if (state == RS_IN_ONEOF_IN || state == RS_IN_NONEOF)
}
else if (t_iseq(c, ']'))
state = RS_IN_WAIT;
- else /* shouldn't get here */
+ else /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
}
else
c += pg_mblen(c);
}
- if (state != RS_IN_WAIT) /* shouldn't get here */
+ if (state != RS_IN_WAIT) /* shouldn't get here */
elog(ERROR, "invalid regis pattern: \"%s\"", str);
ptr = r->node;
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("multibyte flag character is not allowed")));
- Conf->flagval[*(unsigned char*) s] = (unsigned char) val;
+ Conf->flagval[*(unsigned char *) s] = (unsigned char) val;
Conf->usecompound = true;
}
ptr = repl + (ptr - prepl) + 1;
while (*ptr)
{
- aflg |= Conf->flagval[*(unsigned char*) ptr];
+ aflg |= Conf->flagval[*(unsigned char *) ptr];
ptr++;
}
}
if (*s && pg_mblen(s) == 1)
{
- Conf->flagval[*(unsigned char*) s] = FF_COMPOUNDFLAG;
+ Conf->flagval[*(unsigned char *) s] = FF_COMPOUNDFLAG;
Conf->usecompound = true;
}
oldformat = true;
(errcode(ERRCODE_CONFIG_FILE_ERROR),
errmsg("multibyte flag character is not allowed")));
- flag = *(unsigned char*) s;
+ flag = *(unsigned char *) s;
goto nextline;
}
if (STRNCMP(recoded, "COMPOUNDFLAG") == 0 || STRNCMP(recoded, "COMPOUNDMIN") == 0 ||
while (str && *str)
{
- flag |= Conf->flagval[*(unsigned char*) str];
+ flag |= Conf->flagval[*(unsigned char *) str];
str++;
}
if (forms == cur || strcmp(word, *(cur - 1)) != 0)
{
*cur = pstrdup(word);
- *(cur+1) = NULL;
+ *(cur + 1) = NULL;
return 1;
}
static void
AddStem(SplitVar *v, char *word)
{
- if ( v->nstem >= v->lenstem )
+ if (v->nstem >= v->lenstem)
{
v->lenstem *= 2;
v->stem = (char **) repalloc(v->stem, sizeof(char *) * v->lenstem);
if (level + lenaff - 1 <= minpos)
continue;
- if ( lenaff >= MAXNORMLEN )
- continue; /* skip too big value */
+ if (lenaff >= MAXNORMLEN)
+ continue; /* skip too big value */
if (lenaff > 0)
memcpy(buf, word + startpos, lenaff);
buf[lenaff] = '\0';
while (*sptr)
{
- AddStem( new, *sptr );
+ AddStem(new, *sptr);
sptr++;
}
pfree(subres);
if (wordlen == level + 1)
{
/* well, it was last word */
- AddStem( var, pnstrdup(word + startpos, wordlen - startpos) );
+ AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
pfree(notprobed);
return var;
}
ptr->next = SplitToVariants(Conf, node, var, word, wordlen, startpos, level);
/* we can find next word */
level++;
- AddStem( var, pnstrdup(word + startpos, level - startpos) );
+ AddStem(var, pnstrdup(word + startpos, level - startpos));
node = Conf->Dictionary;
startpos = level;
continue;
level++;
}
- AddStem( var, pnstrdup(word + startpos, wordlen - startpos) );
+ AddStem(var, pnstrdup(word + startpos, wordlen - startpos));
pfree(notprobed);
return var;
}
static void
-addNorm( TSLexeme **lres, TSLexeme **lcur, char *word, int flags, uint16 NVariant)
+addNorm(TSLexeme **lres, TSLexeme **lcur, char *word, int flags, uint16 NVariant)
{
- if ( *lres == NULL )
+ if (*lres == NULL)
*lcur = *lres = (TSLexeme *) palloc(MAX_NORM * sizeof(TSLexeme));
- if ( *lcur - *lres < MAX_NORM-1 ) {
+ if (*lcur - *lres < MAX_NORM - 1)
+ {
(*lcur)->lexeme = word;
(*lcur)->flags = flags;
(*lcur)->nvariant = NVariant;
{
char **ptr = res;
- while (*ptr && (lcur-lres) < MAX_NORM)
+ while (*ptr && (lcur - lres) < MAX_NORM)
{
- addNorm( &lres, &lcur, *ptr, 0, NVariant++);
+ addNorm(&lres, &lcur, *ptr, 0, NVariant++);
ptr++;
}
pfree(res);
{
for (i = 0; i < var->nstem - 1; i++)
{
- addNorm( &lres, &lcur, (subptr == subres) ? var->stem[i] : pstrdup(var->stem[i]), 0, NVariant);
+ addNorm(&lres, &lcur, (subptr == subres) ? var->stem[i] : pstrdup(var->stem[i]), 0, NVariant);
}
- addNorm( &lres, &lcur, *subptr, 0, NVariant);
+ addNorm(&lres, &lcur, *subptr, 0, NVariant);
subptr++;
NVariant++;
}
static int
compareWORD(const void *a, const void *b)
{
- int res;
+ int res;
res = tsCompareString(
- ((ParsedWord *) a)->word, ((ParsedWord *) a)->len,
- ((ParsedWord *) b)->word, ((ParsedWord *) b)->len,
- false );
-
+ ((ParsedWord *) a)->word, ((ParsedWord *) a)->len,
+ ((ParsedWord *) b)->word, ((ParsedWord *) b)->len,
+ false);
+
if (res == 0)
{
if (((ParsedWord *) a)->pos.pos == ((ParsedWord *) b)->pos.pos)
if (lenstr > MAXSTRPOS)
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("string is too long for tsvector (%d bytes, max %d bytes)", lenstr, MAXSTRPOS)));
+ errmsg("string is too long for tsvector (%d bytes, max %d bytes)", lenstr, MAXSTRPOS)));
totallen = CALCDATASIZE(prs->curwords, lenstr);
in = (TSVector) palloc0(totallen);
while (count < prs.curwords && pos == prs.words[count].pos.pos && variant == prs.words[count].nvariant)
{
- pushValue(state, prs.words[count].word, prs.words[count].len, weight,
- ( (prs.words[count].flags & TSL_PREFIX) || prefix ) ? true : false );
+ pushValue(state, prs.words[count].word, prs.words[count].len, weight,
+ ((prs.words[count].flags & TSL_PREFIX) || prefix) ? true : false);
pfree(prs.words[count].word);
if (cnt)
pushOperator(state, OP_AND);
}
memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(QueryItem));
- if ( len != query->size ) {
- char *oldoperand = GETOPERAND(query);
- int4 lenoperand = VARSIZE(query) - (oldoperand - (char*)query);
+ if (len != query->size)
+ {
+ char *oldoperand = GETOPERAND(query);
+ int4 lenoperand = VARSIZE(query) - (oldoperand - (char *) query);
- Assert( len < query->size );
+ Assert(len < query->size);
query->size = len;
- memcpy((void *) GETOPERAND(query), oldoperand, VARSIZE(query) - (oldoperand - (char*)query) );
- SET_VARSIZE(query, COMPUTESIZE( len, lenoperand ));
+ memcpy((void *) GETOPERAND(query), oldoperand, VARSIZE(query) - (oldoperand - (char *) query));
+ SET_VARSIZE(query, COMPUTESIZE(len, lenoperand));
}
pfree(res);
}
memcpy((void *) GETQUERY(query), (void *) res, len * sizeof(QueryItem));
- if ( len != query->size ) {
- char *oldoperand = GETOPERAND(query);
- int4 lenoperand = VARSIZE(query) - (oldoperand - (char*)query);
+ if (len != query->size)
+ {
+ char *oldoperand = GETOPERAND(query);
+ int4 lenoperand = VARSIZE(query) - (oldoperand - (char *) query);
- Assert( len < query->size );
+ Assert(len < query->size);
query->size = len;
- memcpy((void *) GETOPERAND(query), oldoperand, lenoperand );
- SET_VARSIZE(query, COMPUTESIZE( len, lenoperand ));
+ memcpy((void *) GETOPERAND(query), oldoperand, lenoperand);
+ SET_VARSIZE(query, COMPUTESIZE(len, lenoperand));
}
pfree(res);
/*
- * Set up to read a file using tsearch_readline(). This facility is
+ * Set up to read a file using tsearch_readline(). This facility is
* better than just reading the file directly because it provides error
* context pointing to the specific line where a problem is detected.
*
/*
* We can't include the text of the config line for errors that occur
- * during t_readline() itself. This is only partly a consequence of
- * our arms-length use of that routine: the major cause of such
- * errors is encoding violations, and we daren't try to print error
- * messages containing badly-encoded data.
+ * during t_readline() itself. This is only partly a consequence of our
+ * arms-length use of that routine: the major cause of such errors is
+ * encoding violations, and we daren't try to print error messages
+ * containing badly-encoded data.
*/
if (stp->curline)
errcontext("line %d of configuration file \"%s\": \"%s\"",
if (wlen < 0)
ereport(ERROR,
(errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
- errmsg("conversion from wchar_t to server encoding failed: %m")));
+ errmsg("conversion from wchar_t to server encoding failed: %m")));
Assert(wlen < len);
}
else
for (i = 0; i < query->size; i++)
{
if (item->type == QI_VAL &&
- tsCompareString( GETOPERAND(query) + item->operand.distance, item->operand.length,
- buf, buflen, item->operand.prefix ) == 0 )
+ tsCompareString(GETOPERAND(query) + item->operand.distance, item->operand.length,
+ buf, buflen, item->operand.prefix) == 0)
{
if (word->item)
{
{
text *out;
char *ptr;
- int len = 128;
- int numfragments = 0;
- int2 infrag = 0;
+ int len = 128;
+ int numfragments = 0;
+ int2 infrag = 0;
HeadlineWordEntry *wrd = prs->words;
/* start of a new fragment */
infrag = 1;
- numfragments ++;
- /* add a fragment delimitor if this is after the first one */
+ numfragments++;
+ /* add a fragment delimitor if this is after the first one */
if (numfragments > 1)
{
memcpy(ptr, prs->fragdelim, prs->fragdelimlen);
ptr += prs->fragdelimlen;
- }
+ }
- }
+ }
if (wrd->replace)
{
*ptr = ' ';
if (infrag)
infrag = 0;
pfree(wrd->word);
- }
+ }
wrd++;
}
/* lookup table type for binary searching through MCELEMs */
typedef struct
{
- text *element;
- float4 frequency;
+ text *element;
+ float4 frequency;
} TextFreq;
/* type of keys for bsearch'ing through an array of TextFreqs */
typedef struct
{
- char *lexeme;
- int length;
+ char *lexeme;
+ int length;
} LexemeKey;
static Selectivity tsquerysel(VariableStatData *vardata, Datum constval);
static Selectivity mcelem_tsquery_selec(TSQuery query,
- Datum *mcelem, int nmcelem,
- float4 *numbers, int nnumbers);
+ Datum *mcelem, int nmcelem,
+ float4 *numbers, int nnumbers);
static Selectivity tsquery_opr_selec(QueryItem *item, char *operand,
- TextFreq *lookup, int length, float4 minfreq);
+ TextFreq *lookup, int length, float4 minfreq);
static int compare_lexeme_textfreq(const void *e1, const void *e2);
tsmatchsel(PG_FUNCTION_ARGS)
{
PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
+
#ifdef NOT_USED
Oid operator = PG_GETARG_OID(1);
#endif
VariableStatData vardata;
Node *other;
bool varonleft;
- Selectivity selec;
+ Selectivity selec;
/*
* If expression is not variable = something or something = variable, then
static Selectivity
tsquerysel(VariableStatData *vardata, Datum constval)
{
- Selectivity selec;
- TSQuery query;
+ Selectivity selec;
+ TSQuery query;
/* The caller made sure the const is a TSQuery, so get it now */
query = DatumGetTSQuery(constval);
if (HeapTupleIsValid(vardata->statsTuple))
{
- Form_pg_statistic stats;
- Datum *values;
- int nvalues;
- float4 *numbers;
- int nnumbers;
+ Form_pg_statistic stats;
+ Datum *values;
+ int nvalues;
+ float4 *numbers;
+ int nnumbers;
stats = (Form_pg_statistic) GETSTRUCT(vardata->statsTuple);
mcelem_tsquery_selec(TSQuery query, Datum *mcelem, int nmcelem,
float4 *numbers, int nnumbers)
{
- float4 minfreq;
- TextFreq *lookup;
- Selectivity selec;
- int i;
+ float4 minfreq;
+ TextFreq *lookup;
+ Selectivity selec;
+ int i;
/*
* There should be two more Numbers than Values, because the last two
for (i = 0; i < nmcelem; i++)
{
/*
- * The text Datums came from an array, so it cannot be compressed
- * or stored out-of-line -- it's safe to use VARSIZE_ANY*.
+ * The text Datums came from an array, so it cannot be compressed or
+ * stored out-of-line -- it's safe to use VARSIZE_ANY*.
*/
Assert(!VARATT_IS_COMPRESSED(mcelem[i]) && !VARATT_IS_EXTERNAL(mcelem[i]));
lookup[i].element = (text *) DatumGetPointer(mcelem[i]);
/*
* Traverse the tsquery in preorder, calculating selectivity as:
*
- * selec(left_oper) * selec(right_oper) in AND nodes,
+ * selec(left_oper) * selec(right_oper) in AND nodes,
*
- * selec(left_oper) + selec(right_oper) -
- * selec(left_oper) * selec(right_oper) in OR nodes,
+ * selec(left_oper) + selec(right_oper) -
+ * selec(left_oper) * selec(right_oper) in OR nodes,
*
- * 1 - select(oper) in NOT nodes
+ * 1 - select(oper) in NOT nodes
*
- * freq[val] in VAL nodes, if the value is in MCELEM
- * min(freq[MCELEM]) / 2 in VAL nodes, if it is not
+ * freq[val] in VAL nodes, if the value is in MCELEM
+ * min(freq[MCELEM]) / 2 in VAL nodes, if it is not
*
*
* The MCELEM array is already sorted (see ts_typanalyze.c), so we can use
TextFreq *lookup, int length, float4 minfreq)
{
LexemeKey key;
- TextFreq *searchres;
- Selectivity selec, s1, s2;
+ TextFreq *searchres;
+ Selectivity selec,
+ s1,
+ s2;
/* since this function recurses, it could be driven to stack overflow */
check_stack_depth();
switch (item->operator.oper)
{
case OP_NOT:
- selec = 1.0 - tsquery_opr_selec(item + 1, operand,
- lookup, length, minfreq);
+ selec = 1.0 - tsquery_opr_selec(item + 1, operand,
+ lookup, length, minfreq);
break;
case OP_AND:
s1 = tsquery_opr_selec(item + 1, operand,
- lookup, length, minfreq);
+ lookup, length, minfreq);
s2 = tsquery_opr_selec(item + item->operator.left, operand,
lookup, length, minfreq);
selec = s1 * s2;
static int
compare_lexeme_textfreq(const void *e1, const void *e2)
{
- const LexemeKey *key = (const LexemeKey *) e1;
- const TextFreq *t = (const TextFreq *) e2;
- int len1,
- len2;
+ const LexemeKey *key = (const LexemeKey *) e1;
+ const TextFreq *t = (const TextFreq *) e2;
+ int len1,
+ len2;
len1 = key->length;
len2 = VARSIZE_ANY_EXHDR(t->element);
/* A hash table entry for the Lossy Counting algorithm */
typedef struct
{
- LexemeHashKey key; /* This is 'e' from the LC algorithm. */
- int frequency; /* This is 'f'. */
- int delta; /* And this is 'delta'. */
+ LexemeHashKey key; /* This is 'e' from the LC algorithm. */
+ int frequency; /* This is 'f'. */
+ int delta; /* And this is 'delta'. */
} TrackItem;
static void compute_tsvector_stats(VacAttrStats *stats,
- AnalyzeAttrFetchFunc fetchfunc,
- int samplerows,
- double totalrows);
+ AnalyzeAttrFetchFunc fetchfunc,
+ int samplerows,
+ double totalrows);
static void prune_lexemes_hashtable(HTAB *lexemes_tab, int b_current);
static uint32 lexeme_hash(const void *key, Size keysize);
-static int lexeme_match(const void *key1, const void *key2, Size keysize);
-static int lexeme_compare(const void *key1, const void *key2);
-static int trackitem_compare_frequencies_desc(const void *e1, const void *e2);
-static int trackitem_compare_lexemes(const void *e1, const void *e2);
+static int lexeme_match(const void *key1, const void *key2, Size keysize);
+static int lexeme_compare(const void *key1, const void *key2);
+static int trackitem_compare_frequencies_desc(const void *e1, const void *e2);
+static int trackitem_compare_lexemes(const void *e1, const void *e2);
/*
* The Lossy Counting (aka LC) algorithm goes like this:
* Let D be a set of triples (e, f, d), where e is an element value, f is
* that element's frequency (occurrence count) and d is the maximum error in
- * f. We start with D empty and process the elements in batches of size
+ * f. We start with D empty and process the elements in batches of size
* w. (The batch size is also known as "bucket size".) Let the current batch
* number be b_current, starting with 1. For each element e we either
* increment its f count, if it's already in D, or insert a new triple into D
int samplerows,
double totalrows)
{
- int num_mcelem;
- int null_cnt = 0;
- double total_width = 0;
+ int num_mcelem;
+ int null_cnt = 0;
+ double total_width = 0;
+
/* This is D from the LC algorithm. */
- HTAB *lexemes_tab;
- HASHCTL hash_ctl;
- HASH_SEQ_STATUS scan_status;
+ HTAB *lexemes_tab;
+ HASHCTL hash_ctl;
+ HASH_SEQ_STATUS scan_status;
+
/* This is the current bucket number from the LC algorithm */
- int b_current;
+ int b_current;
+
/* This is 'w' from the LC algorithm */
- int bucket_width;
- int vector_no,
- lexeme_no;
- LexemeHashKey hash_key;
- TrackItem *item;
+ int bucket_width;
+ int vector_no,
+ lexeme_no;
+ LexemeHashKey hash_key;
+ TrackItem *item;
/* We want statistics_target * 10 lexemes in the MCELEM array */
num_mcelem = stats->attr->attstattarget * 10;
/*
- * We set bucket width equal to the target number of result lexemes.
- * This is probably about right but perhaps might need to be scaled
- * up or down a bit?
+ * We set bucket width equal to the target number of result lexemes. This
+ * is probably about right but perhaps might need to be scaled up or down
+ * a bit?
*/
bucket_width = num_mcelem;
lexemes_tab = hash_create("Analyzed lexemes table",
bucket_width * 4,
&hash_ctl,
- HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
+ HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT);
/* Initialize counters. */
b_current = 1;
{
Datum value;
bool isnull;
- TSVector vector;
- WordEntry *curentryptr;
- char *lexemesptr;
+ TSVector vector;
+ WordEntry *curentryptr;
+ char *lexemesptr;
int j;
vacuum_delay_point();
/*
* We loop through the lexemes in the tsvector and add them to our
- * tracking hashtable. Note: the hashtable entries will point into
+ * tracking hashtable. Note: the hashtable entries will point into
* the (detoasted) tsvector value, therefore we cannot free that
* storage until we're done.
*/
curentryptr = ARRPTR(vector);
for (j = 0; j < vector->size; j++)
{
- bool found;
+ bool found;
/* Construct a hash key */
hash_key.lexeme = lexemesptr + curentryptr->pos;
{
int nonnull_cnt = samplerows - null_cnt;
int i;
- TrackItem **sort_table;
+ TrackItem **sort_table;
int track_len;
- int minfreq, maxfreq;
+ int minfreq,
+ maxfreq;
stats->stats_valid = true;
/* Do the simple null-frac and average width stats */
/* Suppress any single-occurrence items */
while (track_len > 0)
{
- if (sort_table[track_len-1]->frequency > 1)
+ if (sort_table[track_len - 1]->frequency > 1)
break;
track_len--;
}
/* Generate MCELEM slot entry */
if (num_mcelem > 0)
{
- MemoryContext old_context;
- Datum *mcelem_values;
- float4 *mcelem_freqs;
+ MemoryContext old_context;
+ Datum *mcelem_values;
+ float4 *mcelem_freqs;
/* Grab the minimal and maximal frequencies that will get stored */
minfreq = sort_table[num_mcelem - 1]->frequency;
* We want to store statistics sorted on the lexeme value using
* first length, then byte-for-byte comparison. The reason for
* doing length comparison first is that we don't care about the
- * ordering so long as it's consistent, and comparing lengths first
- * gives us a chance to avoid a strncmp() call.
+ * ordering so long as it's consistent, and comparing lengths
+ * first gives us a chance to avoid a strncmp() call.
*
- * This is different from what we do with scalar statistics -- they
- * get sorted on frequencies. The rationale is that we usually
- * search through most common elements looking for a specific
- * value, so we can grab its frequency. When values are presorted
- * we can employ binary search for that. See ts_selfuncs.c for a
- * real usage scenario.
+ * This is different from what we do with scalar statistics --
+ * they get sorted on frequencies. The rationale is that we
+ * usually search through most common elements looking for a
+ * specific value, so we can grab its frequency. When values are
+ * presorted we can employ binary search for that. See
+ * ts_selfuncs.c for a real usage scenario.
*/
qsort(sort_table, num_mcelem, sizeof(TrackItem *),
trackitem_compare_lexemes);
for (i = 0; i < num_mcelem; i++)
{
- TrackItem *item = sort_table[i];
+ TrackItem *item = sort_table[i];
mcelem_values[i] =
PointerGetDatum(cstring_to_text_with_len(item->key.lexeme,
- item->key.length));
+ item->key.length));
mcelem_freqs[i] = (double) item->frequency / (double) nonnull_cnt;
}
mcelem_freqs[i++] = (double) minfreq / (double) nonnull_cnt;
stats->numvalues[0] = num_mcelem;
/* We are storing text values */
stats->statypid[0] = TEXTOID;
- stats->statyplen[0] = -1; /* typlen, -1 for varlena */
+ stats->statyplen[0] = -1; /* typlen, -1 for varlena */
stats->statypbyval[0] = false;
stats->statypalign[0] = 'i';
}
/* We found only nulls; assume the column is entirely null */
stats->stats_valid = true;
stats->stanullfrac = 1.0;
- stats->stawidth = 0; /* "unknown" */
- stats->stadistinct = 0.0; /* "unknown" */
+ stats->stawidth = 0; /* "unknown" */
+ stats->stadistinct = 0.0; /* "unknown" */
}
/*
- * We don't need to bother cleaning up any of our temporary palloc's.
- * The hashtable should also go away, as it used a child memory context.
+ * We don't need to bother cleaning up any of our temporary palloc's. The
+ * hashtable should also go away, as it used a child memory context.
*/
}
static void
prune_lexemes_hashtable(HTAB *lexemes_tab, int b_current)
{
- HASH_SEQ_STATUS scan_status;
- TrackItem *item;
+ HASH_SEQ_STATUS scan_status;
+ TrackItem *item;
hash_seq_init(&scan_status, lexemes_tab);
while ((item = (TrackItem *) hash_seq_search(&scan_status)) != NULL)
static int
lexeme_compare(const void *key1, const void *key2)
{
- const LexemeHashKey *d1 = (const LexemeHashKey *) key1;
- const LexemeHashKey *d2 = (const LexemeHashKey *) key2;
+ const LexemeHashKey *d1 = (const LexemeHashKey *) key1;
+ const LexemeHashKey *d2 = (const LexemeHashKey *) key2;
/* First, compare by length */
if (d1->length > d2->length)
static int
trackitem_compare_frequencies_desc(const void *e1, const void *e2)
{
- const TrackItem * const *t1 = (const TrackItem * const *) e1;
- const TrackItem * const *t2 = (const TrackItem * const *) e2;
+ const TrackItem *const * t1 = (const TrackItem *const *) e1;
+ const TrackItem *const * t2 = (const TrackItem *const *) e2;
return (*t2)->frequency - (*t1)->frequency;
}
static int
trackitem_compare_lexemes(const void *e1, const void *e2)
{
- const TrackItem * const *t1 = (const TrackItem * const *) e1;
- const TrackItem * const *t2 = (const TrackItem * const *) e2;
+ const TrackItem *const * t1 = (const TrackItem *const *) e1;
+ const TrackItem *const * t2 = (const TrackItem *const *) e2;
return lexeme_compare(&(*t1)->key, &(*t2)->key);
}
prsobj = lookup_ts_parser_cache(cfg->prsId);
if (!OidIsValid(prsobj->headlineOid))
- ereport(ERROR,
+ ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("text search parser does not support headline creation")));
+ errmsg("text search parser does not support headline creation")));
memset(&prs, 0, sizeof(HeadlineParsedText));
prs.lenwords = 32;
static AclMode convert_priv_string(text *priv_type_text);
static AclMode convert_any_priv_string(text *priv_type_text,
- const priv_map *privileges);
+ const priv_map *privileges);
static Oid convert_table_name(text *tablename);
static AclMode convert_table_priv_string(text *priv_type_text);
Acl *
aclcopy(const Acl *orig_acl)
{
- Acl *result_acl;
+ Acl *result_acl;
result_acl = allocacl(ACL_NUM(orig_acl));
Acl *
aclconcat(const Acl *left_acl, const Acl *right_acl)
{
- Acl *result_acl;
+ Acl *result_acl;
result_acl = allocacl(ACL_NUM(left_acl) + ACL_NUM(right_acl));
convert_table_priv_string(text *priv_type_text)
{
static const priv_map table_priv_map[] = {
- { "SELECT", ACL_SELECT },
- { "SELECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_SELECT) },
- { "INSERT", ACL_INSERT },
- { "INSERT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_INSERT) },
- { "UPDATE", ACL_UPDATE },
- { "UPDATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_UPDATE) },
- { "DELETE", ACL_DELETE },
- { "DELETE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_DELETE) },
- { "TRUNCATE", ACL_TRUNCATE },
- { "TRUNCATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_TRUNCATE) },
- { "REFERENCES", ACL_REFERENCES },
- { "REFERENCES WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_REFERENCES) },
- { "TRIGGER", ACL_TRIGGER },
- { "TRIGGER WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_TRIGGER) },
- { "RULE", 0 }, /* ignore old RULE privileges */
- { "RULE WITH GRANT OPTION", 0 },
- { NULL, 0 }
+ {"SELECT", ACL_SELECT},
+ {"SELECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_SELECT)},
+ {"INSERT", ACL_INSERT},
+ {"INSERT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_INSERT)},
+ {"UPDATE", ACL_UPDATE},
+ {"UPDATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_UPDATE)},
+ {"DELETE", ACL_DELETE},
+ {"DELETE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_DELETE)},
+ {"TRUNCATE", ACL_TRUNCATE},
+ {"TRUNCATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_TRUNCATE)},
+ {"REFERENCES", ACL_REFERENCES},
+ {"REFERENCES WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_REFERENCES)},
+ {"TRIGGER", ACL_TRIGGER},
+ {"TRIGGER WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_TRIGGER)},
+ {"RULE", 0}, /* ignore old RULE privileges */
+ {"RULE WITH GRANT OPTION", 0},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, table_priv_map);
* existence of the pg_class row before risking calling pg_class_aclcheck.
* Note: it might seem there's a race condition against concurrent DROP,
* but really it's safe because there will be no syscache flush between
- * here and there. So if we see the row in the syscache, so will
+ * here and there. So if we see the row in the syscache, so will
* pg_class_aclcheck.
*/
if (!SearchSysCacheExists(RELOID,
convert_column_priv_string(text *priv_type_text)
{
static const priv_map column_priv_map[] = {
- { "SELECT", ACL_SELECT },
- { "SELECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_SELECT) },
- { "INSERT", ACL_INSERT },
- { "INSERT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_INSERT) },
- { "UPDATE", ACL_UPDATE },
- { "UPDATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_UPDATE) },
- { "REFERENCES", ACL_REFERENCES },
- { "REFERENCES WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_REFERENCES) },
- { NULL, 0 }
+ {"SELECT", ACL_SELECT},
+ {"SELECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_SELECT)},
+ {"INSERT", ACL_INSERT},
+ {"INSERT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_INSERT)},
+ {"UPDATE", ACL_UPDATE},
+ {"UPDATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_UPDATE)},
+ {"REFERENCES", ACL_REFERENCES},
+ {"REFERENCES WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_REFERENCES)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, column_priv_map);
convert_database_priv_string(text *priv_type_text)
{
static const priv_map database_priv_map[] = {
- { "CREATE", ACL_CREATE },
- { "CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { "TEMPORARY", ACL_CREATE_TEMP },
- { "TEMPORARY WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE_TEMP) },
- { "TEMP", ACL_CREATE_TEMP },
- { "TEMP WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE_TEMP) },
- { "CONNECT", ACL_CONNECT },
- { "CONNECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CONNECT) },
- { NULL, 0 }
+ {"CREATE", ACL_CREATE},
+ {"CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {"TEMPORARY", ACL_CREATE_TEMP},
+ {"TEMPORARY WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE_TEMP)},
+ {"TEMP", ACL_CREATE_TEMP},
+ {"TEMP WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE_TEMP)},
+ {"CONNECT", ACL_CONNECT},
+ {"CONNECT WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CONNECT)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, database_priv_map);
convert_foreign_data_wrapper_priv_string(text *priv_type_text)
{
static const priv_map foreign_data_wrapper_priv_map[] = {
- { "USAGE", ACL_USAGE },
- { "USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE) },
- { NULL, 0 }
+ {"USAGE", ACL_USAGE},
+ {"USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, foreign_data_wrapper_priv_map);
convert_function_priv_string(text *priv_type_text)
{
static const priv_map function_priv_map[] = {
- { "EXECUTE", ACL_EXECUTE },
- { "EXECUTE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_EXECUTE) },
- { NULL, 0 }
+ {"EXECUTE", ACL_EXECUTE},
+ {"EXECUTE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_EXECUTE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, function_priv_map);
convert_language_priv_string(text *priv_type_text)
{
static const priv_map language_priv_map[] = {
- { "USAGE", ACL_USAGE },
- { "USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE) },
- { NULL, 0 }
+ {"USAGE", ACL_USAGE},
+ {"USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, language_priv_map);
convert_schema_priv_string(text *priv_type_text)
{
static const priv_map schema_priv_map[] = {
- { "CREATE", ACL_CREATE },
- { "CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { "USAGE", ACL_USAGE },
- { "USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE) },
- { NULL, 0 }
+ {"CREATE", ACL_CREATE},
+ {"CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {"USAGE", ACL_USAGE},
+ {"USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, schema_priv_map);
convert_server_priv_string(text *priv_type_text)
{
static const priv_map server_priv_map[] = {
- { "USAGE", ACL_USAGE },
- { "USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE) },
- { NULL, 0 }
+ {"USAGE", ACL_USAGE},
+ {"USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_USAGE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, server_priv_map);
convert_tablespace_priv_string(text *priv_type_text)
{
static const priv_map tablespace_priv_map[] = {
- { "CREATE", ACL_CREATE },
- { "CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { NULL, 0 }
+ {"CREATE", ACL_CREATE},
+ {"CREATE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, tablespace_priv_map);
convert_role_priv_string(text *priv_type_text)
{
static const priv_map role_priv_map[] = {
- { "USAGE", ACL_USAGE },
- { "MEMBER", ACL_CREATE },
- { "USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { "USAGE WITH ADMIN OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { "MEMBER WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { "MEMBER WITH ADMIN OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE) },
- { NULL, 0 }
+ {"USAGE", ACL_USAGE},
+ {"MEMBER", ACL_CREATE},
+ {"USAGE WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {"USAGE WITH ADMIN OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {"MEMBER WITH GRANT OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {"MEMBER WITH ADMIN OPTION", ACL_GRANT_OPTION_FOR(ACL_CREATE)},
+ {NULL, 0}
};
return convert_any_priv_string(priv_type_text, role_priv_map);
Datum
array_agg_transfn(PG_FUNCTION_ARGS)
{
- Oid arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);
+ Oid arg1_typeid = get_fn_expr_argtype(fcinfo->flinfo, 1);
MemoryContext aggcontext;
ArrayBuildState *state;
Datum elem;
aggcontext);
/*
- * The transition type for array_agg() is declared to be "internal",
- * which is a pass-by-value type the same size as a pointer. So we
- * can safely pass the ArrayBuildState pointer through nodeAgg.c's
- * machinations.
+ * The transition type for array_agg() is declared to be "internal", which
+ * is a pass-by-value type the same size as a pointer. So we can safely
+ * pass the ArrayBuildState pointer through nodeAgg.c's machinations.
*/
PG_RETURN_POINTER(state);
}
int lbs[1];
/*
- * Test for null before Asserting we are in right context. This is
- * to avoid possible Assert failure in 8.4beta installations, where
- * it is possible for users to create NULL constants of type internal.
+ * Test for null before Asserting we are in right context. This is to
+ * avoid possible Assert failure in 8.4beta installations, where it is
+ * possible for users to create NULL constants of type internal.
*/
if (PG_ARGISNULL(0))
- PG_RETURN_NULL(); /* returns null iff no input values */
+ PG_RETURN_NULL(); /* returns null iff no input values */
/* cannot be called directly because of internal-type argument */
Assert(fcinfo->context &&
int typlen, bool typbyval, char typalign);
static int array_cmp(FunctionCallInfo fcinfo);
static ArrayType *create_array_envelope(int ndims, int *dimv, int *lbv, int nbytes,
- Oid elmtype, int dataoffset);
+ Oid elmtype, int dataoffset);
static ArrayType *array_fill_internal(ArrayType *dims, ArrayType *lbs,
- Datum value, bool isnull, Oid elmtype,
- FunctionCallInfo fcinfo);
+ Datum value, bool isnull, Oid elmtype,
+ FunctionCallInfo fcinfo);
/*
/*
* array_ndims :
- * returns the number of dimensions of the array pointed to by "v"
+ * returns the number of dimensions of the array pointed to by "v"
*/
Datum
array_ndims(PG_FUNCTION_ARGS)
typedef struct generate_subscripts_fctx
{
- int4 lower;
- int4 upper;
- bool reverse;
+ int4 lower;
+ int4 upper;
+ bool reverse;
} generate_subscripts_fctx;
/*
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL())
{
- ArrayType *v = PG_GETARG_ARRAYTYPE_P(0);
- int reqdim = PG_GETARG_INT32(1);
- int *lb,
- *dimv;
+ ArrayType *v = PG_GETARG_ARRAYTYPE_P(0);
+ int reqdim = PG_GETARG_INT32(1);
+ int *lb,
+ *dimv;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
Datum
array_fill_with_lower_bounds(PG_FUNCTION_ARGS)
{
- ArrayType *dims;
- ArrayType *lbs;
- ArrayType *result;
+ ArrayType *dims;
+ ArrayType *lbs;
+ ArrayType *result;
Oid elmtype;
- Datum value;
- bool isnull;
+ Datum value;
+ bool isnull;
if (PG_ARGISNULL(1) || PG_ARGISNULL(2))
ereport(ERROR,
- (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
- errmsg("dimension array or low bound array cannot be NULL")));
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("dimension array or low bound array cannot be NULL")));
dims = PG_GETARG_ARRAYTYPE_P(1);
- lbs = PG_GETARG_ARRAYTYPE_P(2);
+ lbs = PG_GETARG_ARRAYTYPE_P(2);
if (!PG_ARGISNULL(0))
{
Datum
array_fill(PG_FUNCTION_ARGS)
{
- ArrayType *dims;
- ArrayType *result;
+ ArrayType *dims;
+ ArrayType *result;
Oid elmtype;
- Datum value;
- bool isnull;
+ Datum value;
+ bool isnull;
if (PG_ARGISNULL(1))
ereport(ERROR,
- (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
- errmsg("dimension array or low bound array cannot be NULL")));
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("dimension array or low bound array cannot be NULL")));
dims = PG_GETARG_ARRAYTYPE_P(1);
create_array_envelope(int ndims, int *dimv, int *lbsv, int nbytes,
Oid elmtype, int dataoffset)
{
- ArrayType *result;
+ ArrayType *result;
result = (ArrayType *) palloc0(nbytes);
SET_VARSIZE(result, nbytes);
Datum value, bool isnull, Oid elmtype,
FunctionCallInfo fcinfo)
{
- ArrayType *result;
- int *dimv;
- int *lbsv;
- int ndims;
- int nitems;
- int deflbs[MAXDIM];
- int16 elmlen;
- bool elmbyval;
- char elmalign;
- ArrayMetaState *my_extra;
+ ArrayType *result;
+ int *dimv;
+ int *lbsv;
+ int ndims;
+ int nitems;
+ int deflbs[MAXDIM];
+ int16 elmlen;
+ bool elmbyval;
+ char elmalign;
+ ArrayMetaState *my_extra;
/*
* Params checks
*/
if (ARR_NDIM(dims) != 1)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("wrong number of array subscripts"),
- errdetail("Dimension array must be one dimensional.")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("wrong number of array subscripts"),
+ errdetail("Dimension array must be one dimensional.")));
if (ARR_LBOUND(dims)[0] != 1)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("wrong range of array subscripts"),
- errdetail("Lower bound of dimension array must be one.")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("wrong range of array subscripts"),
+ errdetail("Lower bound of dimension array must be one.")));
if (ARR_HASNULL(dims))
ereport(ERROR,
- (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
- errmsg("dimension values cannot be null")));
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("dimension values cannot be null")));
dimv = (int *) ARR_DATA_PTR(dims);
ndims = ARR_DIMS(dims)[0];
{
if (ARR_NDIM(lbs) != 1)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("wrong number of array subscripts"),
- errdetail("Dimension array must be one dimensional.")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("wrong number of array subscripts"),
+ errdetail("Dimension array must be one dimensional.")));
if (ARR_LBOUND(lbs)[0] != 1)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("wrong range of array subscripts"),
- errdetail("Lower bound of dimension array must be one.")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("wrong range of array subscripts"),
+ errdetail("Lower bound of dimension array must be one.")));
if (ARR_HASNULL(lbs))
ereport(ERROR,
- (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
- errmsg("dimension values cannot be null")));
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("dimension values cannot be null")));
if (ARR_DIMS(lbs)[0] != ndims)
ereport(ERROR,
- (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
- errmsg("wrong number of array subscripts"),
- errdetail("Low bound array has different size than dimensions array.")));
+ (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
+ errmsg("wrong number of array subscripts"),
+ errdetail("Low bound array has different size than dimensions array.")));
lbsv = (int *) ARR_DATA_PTR(lbs);
}
else
{
- int i;
+ int i;
for (i = 0; i < MAXDIM; i++)
deflbs[i] = 1;
/* compute required space */
if (!isnull)
{
- int i;
- char *p;
+ int i;
+ char *p;
int nbytes;
int totbytes;
}
else
{
- int nbytes;
- int dataoffset;
+ int nbytes;
+ int dataoffset;
dataoffset = ARR_OVERHEAD_WITHNULLS(ndims, nitems);
nbytes = dataoffset;
{
typedef struct
{
- ArrayType *arr;
- int nextelem;
- int numelems;
- char *elemdataptr; /* this moves with nextelem */
- bits8 *arraynullsptr; /* this does not */
- int16 elmlen;
- bool elmbyval;
- char elmalign;
+ ArrayType *arr;
+ int nextelem;
+ int numelems;
+ char *elemdataptr; /* this moves with nextelem */
+ bits8 *arraynullsptr; /* this does not */
+ int16 elmlen;
+ bool elmbyval;
+ char elmalign;
} array_unnest_fctx;
FuncCallContext *funcctx;
/*
* Get the array value and detoast if needed. We can't do this
- * earlier because if we have to detoast, we want the detoasted
- * copy to be in multi_call_memory_ctx, so it will go away when
- * we're done and not before. (If no detoast happens, we assume
- * the originally passed array will stick around till then.)
+ * earlier because if we have to detoast, we want the detoasted copy
+ * to be in multi_call_memory_ctx, so it will go away when we're done
+ * and not before. (If no detoast happens, we assume the originally
+ * passed array will stick around till then.)
*/
arr = PG_GETARG_ARRAYTYPE_P(0);
if (fctx->nextelem < fctx->numelems)
{
- int offset = fctx->nextelem++;
- Datum elem;
+ int offset = fctx->nextelem++;
+ Datum elem;
/*
* Check for NULL array element
/*
* OK, get the element
*/
- char *ptr = fctx->elemdataptr;
+ char *ptr = fctx->elemdataptr;
fcinfo->isnull = false;
elem = ArrayCast(ptr, fctx->elmbyval, fctx->elmlen);
}
if (result)
- *result = false; /* suppress compiler warning */
+ *result = false; /* suppress compiler warning */
return false;
}
count -= strlen(csymbol) - 1;
/*
- * If points == 0 and the number of digits % mon_group == 0,
- * the code above adds a trailing ssymbol on the far right,
- * so remove it.
+ * If points == 0 and the number of digits % mon_group == 0, the code
+ * above adds a trailing ssymbol on the far right, so remove it.
*/
if (buf[LAST_DIGIT] == ssymbol)
buf[LAST_DIGIT] = '\0';
/* Now treat as unsigned, to avoid trouble at INT_MIN */
val = (uint64) value;
- m0 = val % INT64CONST(100); /* cents */
- m1 = (val / INT64CONST(100)) % 1000; /* hundreds */
- m2 = (val / INT64CONST(100000)) % 1000; /* thousands */
- m3 = (val / INT64CONST(100000000)) % 1000; /* millions */
+ m0 = val % INT64CONST(100); /* cents */
+ m1 = (val / INT64CONST(100)) % 1000; /* hundreds */
+ m2 = (val / INT64CONST(100000)) % 1000; /* thousands */
+ m3 = (val / INT64CONST(100000000)) % 1000; /* millions */
m4 = (val / INT64CONST(100000000000)) % 1000; /* billions */
m5 = (val / INT64CONST(100000000000000)) % 1000; /* trillions */
- m6 = (val / INT64CONST(100000000000000000)) % 1000; /* quadrillions */
+ m6 = (val / INT64CONST(100000000000000000)) % 1000; /* quadrillions */
if (m6)
{
strcpy(str, EARLY);
else if (DATE_IS_NOEND(dt))
strcpy(str, LATE);
- else /* shouldn't happen */
+ else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialDate");
}
pg_tz *tzp;
/*
- * Look up the requested timezone. First we look in the date token table
+ * Look up the requested timezone. First we look in the date token table
* (to handle cases like "EST"), and if that fails, we look in the
* timezone database (to handle cases like "America/New_York"). (This
* matches the order in which timestamp input checks the cases; it's
int *tmask, struct pg_tm * tm, fsec_t *fsec);
static int DecodeTimezone(char *str, int *tzp);
static const datetkn *datebsearch(const char *key, const datetkn *base, int nel);
-static int DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
- struct pg_tm * tm);
-static int ValidateDate(int fmask, bool is2digits, bool bc,
- struct pg_tm * tm);
+static int DecodeDate(char *str, int fmask, int *tmask, bool *is2digits,
+ struct pg_tm * tm);
+static int ValidateDate(int fmask, bool is2digits, bool bc,
+ struct pg_tm * tm);
static void TrimTrailingZeros(char *str);
static void AppendSeconds(char *cp, int sec, fsec_t fsec,
- int precision, bool fillzeros);
+ int precision, bool fillzeros);
static void AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec,
- int scale);
+ int scale);
static void AdjustFractDays(double frac, struct pg_tm * tm, fsec_t *fsec,
- int scale);
+ int scale);
const int day_tab[2][13] =
static int
strtoi(const char *nptr, char **endptr, int base)
{
- long val;
+ long val;
val = strtol(nptr, endptr, base);
#ifdef HAVE_LONG_INT_64
AppendTimestampSeconds(char *cp, struct pg_tm * tm, fsec_t fsec)
{
/*
- * In float mode, don't print fractional seconds before 1 AD,
- * since it's unlikely there's any precision left ...
+ * In float mode, don't print fractional seconds before 1 AD, since it's
+ * unlikely there's any precision left ...
*/
#ifndef HAVE_INT64_TIMESTAMP
if (tm->tm_year <= 0)
static void
AdjustFractSeconds(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
{
- int sec;
+ int sec;
if (frac == 0)
return;
- frac *= scale;
- sec = (int) frac;
+ frac *= scale;
+ sec = (int) frac;
tm->tm_sec += sec;
- frac -= sec;
+ frac -= sec;
#ifdef HAVE_INT64_TIMESTAMP
- *fsec += rint(frac * 1000000);
+ *fsec += rint(frac * 1000000);
#else
- *fsec += frac;
+ *fsec += frac;
#endif
}
static void
AdjustFractDays(double frac, struct pg_tm * tm, fsec_t *fsec, int scale)
{
- int extra_days;
+ int extra_days;
if (frac == 0)
return;
- frac *= scale;
- extra_days = (int) frac;
+ frac *= scale;
+ extra_days = (int) frac;
tm->tm_mday += extra_days;
- frac -= extra_days;
+ frac -= extra_days;
AdjustFractSeconds(frac, tm, fsec, SECS_PER_DAY);
}
if (tmask & fmask)
return DTERR_BAD_FORMAT;
fmask |= tmask;
- } /* end loop over fields */
+ } /* end loop over fields */
/* do final checking/adjustment of Y/M/D fields */
dterr = ValidateDate(fmask, is2digits, bc, tm);
if (tmask & fmask)
return DTERR_BAD_FORMAT;
fmask |= tmask;
- } /* end loop over fields */
+ } /* end loop over fields */
/* do final checking/adjustment of Y/M/D fields */
dterr = ValidateDate(fmask, is2digits, bc, tm);
if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > 59 ||
tm->tm_sec < 0 || tm->tm_sec > 60 || tm->tm_hour > 24 ||
- /* test for > 24:00:00 */
+ /* test for > 24:00:00 */
(tm->tm_hour == 24 &&
(tm->tm_min > 0 || tm->tm_sec > 0 || *fsec > 0)) ||
#ifdef HAVE_INT64_TIMESTAMP
else if (is2digits)
{
/* process 1 or 2-digit input as 1970-2069 AD, allow '0' and '00' */
- if (tm->tm_year < 0) /* just paranoia */
+ if (tm->tm_year < 0) /* just paranoia */
return DTERR_FIELD_OVERFLOW;
if (tm->tm_year < 70)
tm->tm_year += 2000;
if ((cp = strchr(str, '.')) != NULL)
{
/*
- * Can we use ParseFractionalSecond here? Not clear whether
- * trailing junk should be rejected ...
+ * Can we use ParseFractionalSecond here? Not clear whether trailing
+ * junk should be rejected ...
*/
double frac;
*
* Zero out a pg_tm and associated fsec_t
*/
-static inline void
-ClearPgTm(struct pg_tm *tm, fsec_t *fsec)
+static inline void
+ClearPgTm(struct pg_tm * tm, fsec_t *fsec)
{
tm->tm_year = 0;
- tm->tm_mon = 0;
+ tm->tm_mon = 0;
tm->tm_mday = 0;
tm->tm_hour = 0;
- tm->tm_min = 0;
- tm->tm_sec = 0;
- *fsec = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ *fsec = 0;
}
*dtype = DTK_DELTA;
type = IGNORE_DTF;
- ClearPgTm(tm,fsec);
+ ClearPgTm(tm, fsec);
/* read through list backwards to pick up units before values */
for (i = nf - 1; i >= 0; i--)
case DTK_TZ:
/*
- * Timezone is a token with a leading sign character and
- * at least one digit; there could be ':', '.', '-'
- * embedded in it as well.
+ * Timezone is a token with a leading sign character and at
+ * least one digit; there could be ':', '.', '-' embedded in
+ * it as well.
*/
Assert(*field[i] == '-' || *field[i] == '+');
/*
* Try for hh:mm or hh:mm:ss. If not, fall through to
- * DTK_NUMBER case, which can handle signed float numbers
- * and signed year-month values.
+ * DTK_NUMBER case, which can handle signed float numbers and
+ * signed year-month values.
*/
if (strchr(field[i] + 1, ':') != NULL &&
DecodeTime(field[i] + 1, fmask, INTERVAL_FULL_RANGE,
if (*cp == '-')
{
/* SQL "years-months" syntax */
- int val2;
+ int val2;
val2 = strtoi(cp + 1, &cp, 10);
if (errno == ERANGE || val2 < 0 || val2 >= MONTHS_PER_YEAR)
tm->tm_hour += val;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_HOUR);
tmask = DTK_M(HOUR);
- type = DTK_DAY; /* set for next field */
+ type = DTK_DAY; /* set for next field */
break;
case DTK_DAY:
/*----------
* The SQL standard defines the interval literal
- * '-1 1:00:00'
+ * '-1 1:00:00'
* to mean "negative 1 days and negative 1 hours", while Postgres
* traditionally treats this as meaning "negative 1 days and positive
* 1 hours". In SQL_STANDARD intervalstyle, we apply the leading sign
* This protects us against misinterpreting postgres-style dump output,
* since the postgres-style output code has always put an explicit sign on
* all fields following a negative field. But note that SQL-spec output
- * is ambiguous and can be misinterpreted on load! (So it's best practice
+ * is ambiguous and can be misinterpreted on load! (So it's best practice
* to dump in postgres style, not SQL style.)
*----------
*/
if (IntervalStyle == INTSTYLE_SQL_STANDARD && *field[0] == '-')
{
/* Check for additional explicit signs */
- bool more_signs = false;
+ bool more_signs = false;
for (i = 1; i < nf; i++)
{
if (!more_signs)
{
/*
- * Rather than re-determining which field was field[0], just
- * force 'em all negative.
+ * Rather than re-determining which field was field[0], just force
+ * 'em all negative.
*/
if (*fsec > 0)
*fsec = -(*fsec);
/* DecodeISO8601Interval()
- * Decode an ISO 8601 time interval of the "format with designators"
- * (section 4.4.3.2) or "alternative format" (section 4.4.3.3)
- * Examples: P1D for 1 day
- * PT1H for 1 hour
- * P2Y6M7DT1H30M for 2 years, 6 months, 7 days 1 hour 30 min
- * P0002-06-07T01:30:00 the same value in alternative format
+ * Decode an ISO 8601 time interval of the "format with designators"
+ * (section 4.4.3.2) or "alternative format" (section 4.4.3.3)
+ * Examples: P1D for 1 day
+ * PT1H for 1 hour
+ * P2Y6M7DT1H30M for 2 years, 6 months, 7 days 1 hour 30 min
+ * P0002-06-07T01:30:00 the same value in alternative format
*
* Returns 0 if successful, DTERR code if bogus input detected.
* Note: error code should be DTERR_BAD_FORMAT if input doesn't look like
* ISO8601, otherwise this could cause unexpected error messages.
* dtype, tm, fsec are output parameters.
*
- * A couple exceptions from the spec:
- * - a week field ('W') may coexist with other units
- * - allows decimals in fields other than the least significant unit.
+ * A couple exceptions from the spec:
+ * - a week field ('W') may coexist with other units
+ * - allows decimals in fields other than the least significant unit.
*/
int
DecodeISO8601Interval(char *str,
int *dtype, struct pg_tm * tm, fsec_t *fsec)
{
- bool datepart = true;
- bool havefield = false;
+ bool datepart = true;
+ bool havefield = false;
*dtype = DTK_DELTA;
ClearPgTm(tm, fsec);
str++;
while (*str)
{
- char *fieldstart;
- int val;
- double fval;
- char unit;
- int dterr;
+ char *fieldstart;
+ int val;
+ double fval;
+ char unit;
+ int dterr;
- if (*str == 'T') /* T indicates the beginning of the time part */
+ if (*str == 'T') /* T indicates the beginning of the time part */
{
datepart = false;
havefield = false;
return dterr;
/*
- * Note: we could step off the end of the string here. Code below
+ * Note: we could step off the end of the string here. Code below
* *must* exit the loop if unit == '\0'.
*/
unit = *str++;
if (datepart)
{
- switch (unit) /* before T: Y M W D */
+ switch (unit) /* before T: Y M W D */
{
case 'Y':
tm->tm_year += val;
tm->tm_mday += val;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_DAY);
break;
- case 'T': /* ISO 8601 4.4.3.3 Alternative Format / Basic */
+ case 'T': /* ISO 8601 4.4.3.3 Alternative Format / Basic */
case '\0':
if (ISO8601IntegerWidth(fieldstart) == 8 && !havefield)
{
tm->tm_year += val / 10000;
- tm->tm_mon += (val / 100) % 100;
+ tm->tm_mon += (val / 100) % 100;
tm->tm_mday += val % 100;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_DAY);
if (unit == '\0')
continue;
}
/* Else fall through to extended alternative format */
- case '-': /* ISO 8601 4.4.3.3 Alternative Format, Extended */
+ case '-': /* ISO 8601 4.4.3.3 Alternative Format,
+ * Extended */
if (havefield)
return DTERR_BAD_FORMAT;
tm->tm_year += val;
- tm->tm_mon += (fval * 12);
+ tm->tm_mon += (fval * 12);
if (unit == '\0')
return 0;
if (unit == 'T')
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_mon += val;
+ tm->tm_mon += val;
AdjustFractDays(fval, tm, fsec, DAYS_PER_MONTH);
if (*str == '\0')
return 0;
if (*str != '-')
return DTERR_BAD_FORMAT;
str++;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
}
else
{
- switch (unit) /* after T: H M S */
+ switch (unit) /* after T: H M S */
{
case 'H':
tm->tm_hour += val;
tm->tm_sec += val;
AdjustFractSeconds(fval, tm, fsec, 1);
break;
- case '\0': /* ISO 8601 4.4.3.3 Alternative Format */
- if (ISO8601IntegerWidth(fieldstart) == 6 && !havefield)
+ case '\0': /* ISO 8601 4.4.3.3 Alternative Format */
+ if (ISO8601IntegerWidth(fieldstart) == 6 && !havefield)
{
tm->tm_hour += val / 10000;
- tm->tm_min += (val / 100) % 100;
- tm->tm_sec += val % 100;
+ tm->tm_min += (val / 100) % 100;
+ tm->tm_sec += val % 100;
AdjustFractSeconds(fval, tm, fsec, 1);
return 0;
}
/* Else fall through to extended alternative format */
- case ':': /* ISO 8601 4.4.3.3 Alternative Format, Extended */
+ case ':': /* ISO 8601 4.4.3.3 Alternative Format,
+ * Extended */
if (havefield)
return DTERR_BAD_FORMAT;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_HOUR);
if (unit == '\0')
return 0;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_min += val;
+ tm->tm_min += val;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_MINUTE);
if (*str == '\0')
return 0;
if (*str != ':')
return DTERR_BAD_FORMAT;
str++;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_sec += val;
+ tm->tm_sec += val;
AdjustFractSeconds(fval, tm, fsec, 1);
if (*str == '\0')
return 0;
value,
units,
(value != 1) ? "s" : "");
+
/*
- * Each nonzero field sets is_before for (only) the next one. This is
- * a tad bizarre but it's how it worked before...
+ * Each nonzero field sets is_before for (only) the next one. This is a
+ * tad bizarre but it's how it worked before...
*/
*is_before = (value < 0);
*is_zero = FALSE;
* Actually, afaik, ISO 8601 does specify formats for "time
* intervals...[of the]...format with time-unit designators", which
* are pretty ugly. The format looks something like
- * P1Y1M1DT1H1M1.12345S
+ * P1Y1M1DT1H1M1.12345S
* but useful for exchanging data with computers instead of humans.
* - ron 2003-07-14
*
{
char *cp = str;
int year = tm->tm_year;
- int mon = tm->tm_mon;
+ int mon = tm->tm_mon;
int mday = tm->tm_mday;
int hour = tm->tm_hour;
- int min = tm->tm_min;
- int sec = tm->tm_sec;
+ int min = tm->tm_min;
+ int sec = tm->tm_sec;
bool is_before = FALSE;
bool is_zero = TRUE;
*/
switch (style)
{
- /* SQL Standard interval format */
+ /* SQL Standard interval format */
case INTSTYLE_SQL_STANDARD:
{
- bool has_negative = year < 0 || mon < 0 ||
- mday < 0 || hour < 0 ||
- min < 0 || sec < 0 || fsec < 0;
- bool has_positive = year > 0 || mon > 0 ||
- mday > 0 || hour > 0 ||
- min > 0 || sec > 0 || fsec > 0;
- bool has_year_month = year != 0 || mon != 0;
- bool has_day_time = mday != 0 || hour != 0 ||
- min != 0 || sec != 0 || fsec != 0;
- bool has_day = mday != 0;
- bool sql_standard_value = !(has_negative && has_positive) &&
- !(has_year_month && has_day_time);
+ bool has_negative = year < 0 || mon < 0 ||
+ mday < 0 || hour < 0 ||
+ min < 0 || sec < 0 || fsec < 0;
+ bool has_positive = year > 0 || mon > 0 ||
+ mday > 0 || hour > 0 ||
+ min > 0 || sec > 0 || fsec > 0;
+ bool has_year_month = year != 0 || mon != 0;
+ bool has_day_time = mday != 0 || hour != 0 ||
+ min != 0 || sec != 0 || fsec != 0;
+ bool has_day = mday != 0;
+ bool sql_standard_value = !(has_negative && has_positive) &&
+ !(has_year_month && has_day_time);
/*
* SQL Standard wants only 1 "<sign>" preceding the whole
{
*cp++ = '-';
year = -year;
- mon = -mon;
+ mon = -mon;
mday = -mday;
hour = -hour;
- min = -min;
- sec = -sec;
+ min = -min;
+ sec = -sec;
fsec = -fsec;
}
else if (!sql_standard_value)
{
/*
- * For non sql-standard interval values,
- * force outputting the signs to avoid
- * ambiguities with intervals with mixed
- * sign components.
+ * For non sql-standard interval values, force outputting
+ * the signs to avoid ambiguities with intervals with
+ * mixed sign components.
*/
- char year_sign = (year < 0 || mon < 0) ? '-' : '+';
- char day_sign = (mday < 0) ? '-' : '+';
- char sec_sign = (hour < 0 || min < 0 ||
- sec < 0 || fsec < 0) ? '-' : '+';
+ char year_sign = (year < 0 || mon < 0) ? '-' : '+';
+ char day_sign = (mday < 0) ? '-' : '+';
+ char sec_sign = (hour < 0 || min < 0 ||
+ sec < 0 || fsec < 0) ? '-' : '+';
sprintf(cp, "%c%d-%d %c%d %c%d:%02d:",
year_sign, abs(year), abs(mon),
}
break;
- /* ISO 8601 "time-intervals by duration only" */
+ /* ISO 8601 "time-intervals by duration only" */
case INTSTYLE_ISO_8601:
/* special-case zero to avoid printing nothing */
if (year == 0 && mon == 0 && mday == 0 &&
- hour == 0 && min == 0 && sec == 0 && fsec == 0)
+ hour == 0 && min == 0 && sec == 0 && fsec == 0)
{
sprintf(cp, "PT0S");
break;
}
*cp++ = 'P';
cp = AddISO8601IntPart(cp, year, 'Y');
- cp = AddISO8601IntPart(cp, mon , 'M');
+ cp = AddISO8601IntPart(cp, mon, 'M');
cp = AddISO8601IntPart(cp, mday, 'D');
if (hour != 0 || min != 0 || sec != 0 || fsec != 0)
*cp++ = 'T';
cp = AddISO8601IntPart(cp, hour, 'H');
- cp = AddISO8601IntPart(cp, min , 'M');
+ cp = AddISO8601IntPart(cp, min, 'M');
if (sec != 0 || fsec != 0)
{
if (sec < 0 || fsec < 0)
}
break;
- /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
+ /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
case INTSTYLE_POSTGRES:
cp = AddPostgresIntPart(cp, year, "year", &is_zero, &is_before);
cp = AddPostgresIntPart(cp, mon, "mon", &is_zero, &is_before);
cp = AddPostgresIntPart(cp, mday, "day", &is_zero, &is_before);
if (is_zero || hour != 0 || min != 0 || sec != 0 || fsec != 0)
{
- bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
+ bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
sprintf(cp, "%s%s%02d:%02d:",
is_zero ? "" : " ",
}
break;
- /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
+ /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
case INTSTYLE_POSTGRES_VERBOSE:
default:
strcpy(cp, "@");
rel = relation_open(relOid, AccessShareLock);
size = calculate_relation_size(&(rel->rd_node),
- forkname_to_number(text_to_cstring(forkName)));
+ forkname_to_number(text_to_cstring(forkName)));
relation_close(rel, AccessShareLock);
/*
* The SQL spec requires that we emit a particular SQLSTATE error code for
- * certain error conditions. Specifically, we don't return a divide-by-zero
- * error code for 0 ^ -1.
+ * certain error conditions. Specifically, we don't return a
+ * divide-by-zero error code for 0 ^ -1.
*/
if (arg1 == 0 && arg2 < 0)
ereport(ERROR,
*/
typedef enum
{
- FROM_CHAR_DATE_NONE = 0, /* Value does not affect date mode. */
- FROM_CHAR_DATE_GREGORIAN, /* Gregorian (day, month, year) style date */
- FROM_CHAR_DATE_ISOWEEK /* ISO 8601 week date */
+ FROM_CHAR_DATE_NONE = 0, /* Value does not affect date mode. */
+ FROM_CHAR_DATE_GREGORIAN, /* Gregorian (day, month, year) style date */
+ FROM_CHAR_DATE_ISOWEEK /* ISO 8601 week date */
} FromCharDateMode;
typedef struct FormatNode FormatNode;
* Flags & Options:
* ----------
*/
-#define ONE_UPPER 1 /* Name */
-#define ALL_UPPER 2 /* NAME */
-#define ALL_LOWER 3 /* name */
+#define ONE_UPPER 1 /* Name */
+#define ALL_UPPER 2 /* NAME */
+#define ALL_LOWER 3 /* name */
#define FULL_SIZ 0
cc,
j,
us,
- yysz, /* is it YY or YYYY ? */
- clock; /* 12 or 24 hour clock? */
+ yysz, /* is it YY or YYYY ? */
+ clock; /* 12 or 24 hour clock? */
} TmFromChar;
#define ZERO_tmfc(_X) memset(_X, 0, sizeof(TmFromChar))
*/
static const KeyWord DCH_keywords[] = {
/* name, len, id, is_digit, date_mode */
- {"A.D.", 4, DCH_A_D, FALSE, FROM_CHAR_DATE_NONE}, /* A */
+ {"A.D.", 4, DCH_A_D, FALSE, FROM_CHAR_DATE_NONE}, /* A */
{"A.M.", 4, DCH_A_M, FALSE, FROM_CHAR_DATE_NONE},
{"AD", 2, DCH_AD, FALSE, FROM_CHAR_DATE_NONE},
{"AM", 2, DCH_AM, FALSE, FROM_CHAR_DATE_NONE},
- {"B.C.", 4, DCH_B_C, FALSE, FROM_CHAR_DATE_NONE}, /* B */
+ {"B.C.", 4, DCH_B_C, FALSE, FROM_CHAR_DATE_NONE}, /* B */
{"BC", 2, DCH_BC, FALSE, FROM_CHAR_DATE_NONE},
- {"CC", 2, DCH_CC, TRUE, FROM_CHAR_DATE_NONE}, /* C */
- {"DAY", 3, DCH_DAY, FALSE, FROM_CHAR_DATE_NONE}, /* D */
+ {"CC", 2, DCH_CC, TRUE, FROM_CHAR_DATE_NONE}, /* C */
+ {"DAY", 3, DCH_DAY, FALSE, FROM_CHAR_DATE_NONE}, /* D */
{"DDD", 3, DCH_DDD, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"DD", 2, DCH_DD, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"DY", 2, DCH_DY, FALSE, FROM_CHAR_DATE_NONE},
{"Day", 3, DCH_Day, FALSE, FROM_CHAR_DATE_NONE},
{"Dy", 2, DCH_Dy, FALSE, FROM_CHAR_DATE_NONE},
{"D", 1, DCH_D, TRUE, FROM_CHAR_DATE_GREGORIAN},
- {"FX", 2, DCH_FX, FALSE, FROM_CHAR_DATE_NONE}, /* F */
- {"HH24", 4, DCH_HH24, TRUE, FROM_CHAR_DATE_NONE}, /* H */
+ {"FX", 2, DCH_FX, FALSE, FROM_CHAR_DATE_NONE}, /* F */
+ {"HH24", 4, DCH_HH24, TRUE, FROM_CHAR_DATE_NONE}, /* H */
{"HH12", 4, DCH_HH12, TRUE, FROM_CHAR_DATE_NONE},
{"HH", 2, DCH_HH, TRUE, FROM_CHAR_DATE_NONE},
- {"IDDD", 4, DCH_IDDD, TRUE, FROM_CHAR_DATE_ISOWEEK}, /* I */
+ {"IDDD", 4, DCH_IDDD, TRUE, FROM_CHAR_DATE_ISOWEEK}, /* I */
{"ID", 2, DCH_ID, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"IW", 2, DCH_IW, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"IYYY", 4, DCH_IYYY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"IYY", 3, DCH_IYY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"IY", 2, DCH_IY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"I", 1, DCH_I, TRUE, FROM_CHAR_DATE_ISOWEEK},
- {"J", 1, DCH_J, TRUE, FROM_CHAR_DATE_NONE}, /* J */
- {"MI", 2, DCH_MI, TRUE, FROM_CHAR_DATE_NONE}, /* M */
+ {"J", 1, DCH_J, TRUE, FROM_CHAR_DATE_NONE}, /* J */
+ {"MI", 2, DCH_MI, TRUE, FROM_CHAR_DATE_NONE}, /* M */
{"MM", 2, DCH_MM, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"MONTH", 5, DCH_MONTH, FALSE, FROM_CHAR_DATE_GREGORIAN},
{"MON", 3, DCH_MON, FALSE, FROM_CHAR_DATE_GREGORIAN},
{"MS", 2, DCH_MS, TRUE, FROM_CHAR_DATE_NONE},
{"Month", 5, DCH_Month, FALSE, FROM_CHAR_DATE_GREGORIAN},
{"Mon", 3, DCH_Mon, FALSE, FROM_CHAR_DATE_GREGORIAN},
- {"P.M.", 4, DCH_P_M, FALSE, FROM_CHAR_DATE_NONE}, /* P */
+ {"P.M.", 4, DCH_P_M, FALSE, FROM_CHAR_DATE_NONE}, /* P */
{"PM", 2, DCH_PM, FALSE, FROM_CHAR_DATE_NONE},
- {"Q", 1, DCH_Q, TRUE, FROM_CHAR_DATE_NONE}, /* Q */
- {"RM", 2, DCH_RM, FALSE, FROM_CHAR_DATE_GREGORIAN}, /* R */
- {"SSSS", 4, DCH_SSSS, TRUE, FROM_CHAR_DATE_NONE}, /* S */
+ {"Q", 1, DCH_Q, TRUE, FROM_CHAR_DATE_NONE}, /* Q */
+ {"RM", 2, DCH_RM, FALSE, FROM_CHAR_DATE_GREGORIAN}, /* R */
+ {"SSSS", 4, DCH_SSSS, TRUE, FROM_CHAR_DATE_NONE}, /* S */
{"SS", 2, DCH_SS, TRUE, FROM_CHAR_DATE_NONE},
- {"TZ", 2, DCH_TZ, FALSE, FROM_CHAR_DATE_NONE}, /* T */
- {"US", 2, DCH_US, TRUE, FROM_CHAR_DATE_NONE}, /* U */
- {"WW", 2, DCH_WW, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* W */
+ {"TZ", 2, DCH_TZ, FALSE, FROM_CHAR_DATE_NONE}, /* T */
+ {"US", 2, DCH_US, TRUE, FROM_CHAR_DATE_NONE}, /* U */
+ {"WW", 2, DCH_WW, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* W */
{"W", 1, DCH_W, TRUE, FROM_CHAR_DATE_GREGORIAN},
- {"Y,YYY", 5, DCH_Y_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN},/* Y */
+ {"Y,YYY", 5, DCH_Y_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* Y */
{"YYYY", 4, DCH_YYYY, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"YYY", 3, DCH_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"YY", 2, DCH_YY, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"Y", 1, DCH_Y, TRUE, FROM_CHAR_DATE_GREGORIAN},
- {"a.d.", 4, DCH_a_d, FALSE, FROM_CHAR_DATE_NONE}, /* a */
+ {"a.d.", 4, DCH_a_d, FALSE, FROM_CHAR_DATE_NONE}, /* a */
{"a.m.", 4, DCH_a_m, FALSE, FROM_CHAR_DATE_NONE},
{"ad", 2, DCH_ad, FALSE, FROM_CHAR_DATE_NONE},
{"am", 2, DCH_am, FALSE, FROM_CHAR_DATE_NONE},
- {"b.c.", 4, DCH_b_c, FALSE, FROM_CHAR_DATE_NONE}, /* b */
+ {"b.c.", 4, DCH_b_c, FALSE, FROM_CHAR_DATE_NONE}, /* b */
{"bc", 2, DCH_bc, FALSE, FROM_CHAR_DATE_NONE},
- {"cc", 2, DCH_CC, TRUE, FROM_CHAR_DATE_NONE}, /* c */
- {"day", 3, DCH_day, FALSE, FROM_CHAR_DATE_NONE}, /* d */
+ {"cc", 2, DCH_CC, TRUE, FROM_CHAR_DATE_NONE}, /* c */
+ {"day", 3, DCH_day, FALSE, FROM_CHAR_DATE_NONE}, /* d */
{"ddd", 3, DCH_DDD, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"dd", 2, DCH_DD, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"dy", 2, DCH_dy, FALSE, FROM_CHAR_DATE_NONE},
{"d", 1, DCH_D, TRUE, FROM_CHAR_DATE_GREGORIAN},
- {"fx", 2, DCH_FX, FALSE, FROM_CHAR_DATE_NONE}, /* f */
- {"hh24", 4, DCH_HH24, TRUE, FROM_CHAR_DATE_NONE}, /* h */
+ {"fx", 2, DCH_FX, FALSE, FROM_CHAR_DATE_NONE}, /* f */
+ {"hh24", 4, DCH_HH24, TRUE, FROM_CHAR_DATE_NONE}, /* h */
{"hh12", 4, DCH_HH12, TRUE, FROM_CHAR_DATE_NONE},
{"hh", 2, DCH_HH, TRUE, FROM_CHAR_DATE_NONE},
- {"iddd", 4, DCH_IDDD, TRUE, FROM_CHAR_DATE_ISOWEEK}, /* i */
+ {"iddd", 4, DCH_IDDD, TRUE, FROM_CHAR_DATE_ISOWEEK}, /* i */
{"id", 2, DCH_ID, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"iw", 2, DCH_IW, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"iyyy", 4, DCH_IYYY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"iyy", 3, DCH_IYY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"iy", 2, DCH_IY, TRUE, FROM_CHAR_DATE_ISOWEEK},
{"i", 1, DCH_I, TRUE, FROM_CHAR_DATE_ISOWEEK},
- {"j", 1, DCH_J, TRUE, FROM_CHAR_DATE_NONE}, /* j */
- {"mi", 2, DCH_MI, TRUE, FROM_CHAR_DATE_NONE}, /* m */
+ {"j", 1, DCH_J, TRUE, FROM_CHAR_DATE_NONE}, /* j */
+ {"mi", 2, DCH_MI, TRUE, FROM_CHAR_DATE_NONE}, /* m */
{"mm", 2, DCH_MM, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"month", 5, DCH_month, FALSE, FROM_CHAR_DATE_GREGORIAN},
{"mon", 3, DCH_mon, FALSE, FROM_CHAR_DATE_GREGORIAN},
{"ms", 2, DCH_MS, TRUE, FROM_CHAR_DATE_NONE},
- {"p.m.", 4, DCH_p_m, FALSE, FROM_CHAR_DATE_NONE}, /* p */
+ {"p.m.", 4, DCH_p_m, FALSE, FROM_CHAR_DATE_NONE}, /* p */
{"pm", 2, DCH_pm, FALSE, FROM_CHAR_DATE_NONE},
- {"q", 1, DCH_Q, TRUE, FROM_CHAR_DATE_NONE}, /* q */
- {"rm", 2, DCH_rm, FALSE, FROM_CHAR_DATE_GREGORIAN}, /* r */
- {"ssss", 4, DCH_SSSS, TRUE, FROM_CHAR_DATE_NONE}, /* s */
+ {"q", 1, DCH_Q, TRUE, FROM_CHAR_DATE_NONE}, /* q */
+ {"rm", 2, DCH_rm, FALSE, FROM_CHAR_DATE_GREGORIAN}, /* r */
+ {"ssss", 4, DCH_SSSS, TRUE, FROM_CHAR_DATE_NONE}, /* s */
{"ss", 2, DCH_SS, TRUE, FROM_CHAR_DATE_NONE},
- {"tz", 2, DCH_tz, FALSE, FROM_CHAR_DATE_NONE}, /* t */
- {"us", 2, DCH_US, TRUE, FROM_CHAR_DATE_NONE}, /* u */
- {"ww", 2, DCH_WW, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* w */
+ {"tz", 2, DCH_tz, FALSE, FROM_CHAR_DATE_NONE}, /* t */
+ {"us", 2, DCH_US, TRUE, FROM_CHAR_DATE_NONE}, /* u */
+ {"ww", 2, DCH_WW, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* w */
{"w", 1, DCH_W, TRUE, FROM_CHAR_DATE_GREGORIAN},
- {"y,yyy", 5, DCH_Y_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN},/* y */
+ {"y,yyy", 5, DCH_Y_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN}, /* y */
{"yyyy", 4, DCH_YYYY, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"yyy", 3, DCH_YYY, TRUE, FROM_CHAR_DATE_GREGORIAN},
{"yy", 2, DCH_YY, TRUE, FROM_CHAR_DATE_GREGORIAN},
*/
static const KeyWord NUM_keywords[] = {
/* name, len, id is in Index */
- {",", 1, NUM_COMMA}, /* , */
- {".", 1, NUM_DEC}, /* . */
- {"0", 1, NUM_0}, /* 0 */
- {"9", 1, NUM_9}, /* 9 */
- {"B", 1, NUM_B}, /* B */
- {"C", 1, NUM_C}, /* C */
- {"D", 1, NUM_D}, /* D */
- {"E", 1, NUM_E}, /* E */
- {"FM", 2, NUM_FM}, /* F */
- {"G", 1, NUM_G}, /* G */
- {"L", 1, NUM_L}, /* L */
- {"MI", 2, NUM_MI}, /* M */
- {"PL", 2, NUM_PL}, /* P */
+ {",", 1, NUM_COMMA}, /* , */
+ {".", 1, NUM_DEC}, /* . */
+ {"0", 1, NUM_0}, /* 0 */
+ {"9", 1, NUM_9}, /* 9 */
+ {"B", 1, NUM_B}, /* B */
+ {"C", 1, NUM_C}, /* C */
+ {"D", 1, NUM_D}, /* D */
+ {"E", 1, NUM_E}, /* E */
+ {"FM", 2, NUM_FM}, /* F */
+ {"G", 1, NUM_G}, /* G */
+ {"L", 1, NUM_L}, /* L */
+ {"MI", 2, NUM_MI}, /* M */
+ {"PL", 2, NUM_PL}, /* P */
{"PR", 2, NUM_PR},
- {"RN", 2, NUM_RN}, /* R */
- {"SG", 2, NUM_SG}, /* S */
+ {"RN", 2, NUM_RN}, /* R */
+ {"SG", 2, NUM_SG}, /* S */
{"SP", 2, NUM_SP},
{"S", 1, NUM_S},
- {"TH", 2, NUM_TH}, /* T */
- {"V", 1, NUM_V}, /* V */
- {"b", 1, NUM_B}, /* b */
- {"c", 1, NUM_C}, /* c */
- {"d", 1, NUM_D}, /* d */
- {"e", 1, NUM_E}, /* e */
- {"fm", 2, NUM_FM}, /* f */
- {"g", 1, NUM_G}, /* g */
- {"l", 1, NUM_L}, /* l */
- {"mi", 2, NUM_MI}, /* m */
- {"pl", 2, NUM_PL}, /* p */
+ {"TH", 2, NUM_TH}, /* T */
+ {"V", 1, NUM_V}, /* V */
+ {"b", 1, NUM_B}, /* b */
+ {"c", 1, NUM_C}, /* c */
+ {"d", 1, NUM_D}, /* d */
+ {"e", 1, NUM_E}, /* e */
+ {"fm", 2, NUM_FM}, /* f */
+ {"g", 1, NUM_G}, /* g */
+ {"l", 1, NUM_L}, /* l */
+ {"mi", 2, NUM_MI}, /* m */
+ {"pl", 2, NUM_PL}, /* p */
{"pr", 2, NUM_PR},
- {"rn", 2, NUM_rn}, /* r */
- {"sg", 2, NUM_SG}, /* s */
+ {"rn", 2, NUM_rn}, /* r */
+ {"sg", 2, NUM_SG}, /* s */
{"sp", 2, NUM_SP},
{"s", 1, NUM_S},
- {"th", 2, NUM_th}, /* t */
- {"v", 1, NUM_V}, /* v */
+ {"th", 2, NUM_th}, /* t */
+ {"v", 1, NUM_V}, /* v */
/* last */
{NULL, 0, 0}
KeySuffix *suf, const int *index, int ver, NUMDesc *Num);
static void DCH_to_char(FormatNode *node, bool is_interval,
- TmToChar *in, char *out);
+ TmToChar *in, char *out);
static void DCH_from_char(FormatNode *node, char *in, TmFromChar *out);
#ifdef DEBUG_TO_FROM_CHAR
char *
str_tolower(const char *buff, size_t nbytes)
{
- char *result;
+ char *result;
if (!buff)
return NULL;
#ifdef USE_WIDE_UPPER_LOWER
if (pg_database_encoding_max_length() > 1 && !lc_ctype_is_c())
{
- wchar_t *workspace;
+ wchar_t *workspace;
size_t curr_char;
size_t result_size;
pfree(workspace);
}
else
-#endif /* USE_WIDE_UPPER_LOWER */
+#endif /* USE_WIDE_UPPER_LOWER */
{
- char *p;
+ char *p;
result = pnstrdup(buff, nbytes);
char *
str_toupper(const char *buff, size_t nbytes)
{
- char *result;
+ char *result;
if (!buff)
return NULL;
#ifdef USE_WIDE_UPPER_LOWER
if (pg_database_encoding_max_length() > 1 && !lc_ctype_is_c())
{
- wchar_t *workspace;
+ wchar_t *workspace;
size_t curr_char;
size_t result_size;
pfree(workspace);
}
else
-#endif /* USE_WIDE_UPPER_LOWER */
+#endif /* USE_WIDE_UPPER_LOWER */
{
- char *p;
+ char *p;
result = pnstrdup(buff, nbytes);
char *
str_initcap(const char *buff, size_t nbytes)
{
- char *result;
+ char *result;
int wasalnum = false;
if (!buff)
#ifdef USE_WIDE_UPPER_LOWER
if (pg_database_encoding_max_length() > 1 && !lc_ctype_is_c())
{
- wchar_t *workspace;
+ wchar_t *workspace;
size_t curr_char;
size_t result_size;
pfree(workspace);
}
else
-#endif /* USE_WIDE_UPPER_LOWER */
+#endif /* USE_WIDE_UPPER_LOWER */
{
- char *p;
+ char *p;
result = pnstrdup(buff, nbytes);
if (*dest != 0 && *dest != value)
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
- errmsg("conflicting values for \"%s\" field in formatting string",
- node->key->name),
+ errmsg("conflicting values for \"%s\" field in formatting string",
+ node->key->name),
errdetail("This value contradicts a previous setting for "
"the same field type.")));
*dest = value;
{
/*
* This node is in Fill Mode, or the next node is known to be a
- * non-digit value, so we just slurp as many characters as we
- * can get.
+ * non-digit value, so we just slurp as many characters as we can get.
*/
errno = 0;
result = strtol(init, src, 10);
* We need to pull exactly the number of characters given in 'len' out
* of the string, and convert those.
*/
- char *last;
+ char *last;
if (used < len)
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
- errmsg("source string too short for \"%s\" formatting field",
- node->key->name),
+ errmsg("source string too short for \"%s\" formatting field",
+ node->key->name),
errdetail("Field requires %d characters, but only %d "
"remain.",
len, used),
if (used > 0 && used < len)
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
- errmsg("invalid value \"%s\" for \"%s\"",
- copy, node->key->name),
+ errmsg("invalid value \"%s\" for \"%s\"",
+ copy, node->key->name),
errdetail("Field requires %d characters, but only %d "
- "could be parsed.", len, used),
+ "could be parsed.", len, used),
errhint("If your source string is not fixed-width, try "
- "using the \"FM\" modifier.")));
+ "using the \"FM\" modifier.")));
*src += used;
}
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
errmsg("invalid value \"%s\" for \"%s\"",
- copy, node->key->name),
+ copy, node->key->name),
errdetail("Value must be an integer.")));
if (errno == ERANGE || result < INT_MIN || result > INT_MAX)
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("value for \"%s\" in source string is out of range",
- node->key->name),
+ node->key->name),
errdetail("Value must be in the range %d to %d.",
INT_MIN, INT_MAX)));
/*
* Perform a sequential search in 'array' for text matching the first 'max'
- * characters of the source string.
+ * characters of the source string.
*
* If a match is found, copy the array index of the match into the integer
* pointed to by 'dest', advance 'src' to the end of the part of the string
* If the string doesn't match, throw an error.
*/
static int
-from_char_seq_search(int *dest, char **src, char **array, int type, int max,
+from_char_seq_search(int *dest, char **src, char **array, int type, int max,
FormatNode *node)
{
- int len;
+ int len;
*dest = seq_search(*src, array, type, max, &len);
if (len <= 0)
{
- char copy[DCH_MAX_ITEM_SIZ + 1];
+ char copy[DCH_MAX_ITEM_SIZ + 1];
Assert(max <= DCH_MAX_ITEM_SIZ);
strlcpy(copy, *src, max + 1);
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
errmsg("invalid value \"%s\" for \"%s\"",
- copy, node->key->name),
+ copy, node->key->name),
errdetail("The given value did not match any of the allowed "
- "values for this field.")));
+ "values for this field.")));
}
*src += len;
return len;
str_numth(s, s, S_TH_TYPE(n->suffix));
s += strlen(s);
break;
- case DCH_MS: /* millisecond */
+ case DCH_MS: /* millisecond */
#ifdef HAVE_INT64_TIMESTAMP
sprintf(s, "%03d", (int) (in->fsec / INT64CONST(1000)));
#else
str_numth(s, s, S_TH_TYPE(n->suffix));
s += strlen(s);
break;
- case DCH_US: /* microsecond */
+ case DCH_US: /* microsecond */
#ifdef HAVE_INT64_TIMESTAMP
sprintf(s, "%06d", (int) in->fsec);
#else
strcpy(s, str_toupper_z(localized_full_days[tm->tm_wday]));
else
sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
- str_toupper_z(days[tm->tm_wday]));
+ str_toupper_z(days[tm->tm_wday]));
s += strlen(s);
break;
case DCH_Day:
sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 3,
(n->key->id == DCH_DDD) ?
tm->tm_yday :
- date2isoyearday(tm->tm_year, tm->tm_mon, tm->tm_mday));
+ date2isoyearday(tm->tm_year, tm->tm_mon, tm->tm_mday));
if (S_THth(n->suffix))
str_numth(s, s, S_TH_TYPE(n->suffix));
s += strlen(s);
s += strlen(s);
break;
case DCH_CC:
- if (is_interval) /* straight calculation */
+ if (is_interval) /* straight calculation */
i = tm->tm_year / 100;
- else /* century 21 starts in 2001 */
+ else /* century 21 starts in 2001 */
i = (tm->tm_year - 1) / 100 + 1;
if (i <= 99 && i >= -99)
sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2, i);
from_char_parse_int(&out->ss, &s, n);
s += SKIP_THth(n->suffix);
break;
- case DCH_MS: /* millisecond */
+ case DCH_MS: /* millisecond */
len = from_char_parse_int_len(&out->ms, &s, 3, n);
/*
s += SKIP_THth(n->suffix);
break;
- case DCH_US: /* microsecond */
+ case DCH_US: /* microsecond */
len = from_char_parse_int_len(&out->us, &s, 6, n);
out->us *= len == 1 ? 100000 :
s += SKIP_THth(n->suffix);
break;
case DCH_Q:
+
/*
* We ignore Q when converting to date because it is not
* normative.
break;
case DCH_Y_YYY:
{
- int matched, years, millenia;
+ int matched,
+ years,
+ millenia;
matched = sscanf(s, "%d,%03d", &millenia, &years);
if (matched != 2)
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
- errmsg("invalid input string for \"Y,YYY\"")));
+ errmsg("invalid input string for \"Y,YYY\"")));
years += (millenia * 1000);
from_char_set_int(&out->year, years, n);
out->yysz = 4;
s += SKIP_THth(n->suffix);
break;
case DCH_RM:
- from_char_seq_search(&value, &s, rm_months_upper,
+ from_char_seq_search(&value, &s, rm_months_upper,
ALL_UPPER, MAX_RM_LEN, n);
from_char_set_int(&out->mm, 12 - value, n);
break;
case DCH_rm:
- from_char_seq_search(&value, &s, rm_months_lower,
+ from_char_seq_search(&value, &s, rm_months_lower,
ALL_LOWER, MAX_RM_LEN, n);
from_char_set_int(&out->mm, 12 - value, n);
break;
if (tmfc.ddd && (tm->tm_mon <= 1 || tm->tm_mday <= 1))
{
/*
- * The month and day field have not been set, so we use the day-of-year
- * field to populate them. Depending on the date mode, this field may
- * be interpreted as a Gregorian day-of-year, or an ISO week date
- * day-of-year.
+ * The month and day field have not been set, so we use the
+ * day-of-year field to populate them. Depending on the date mode,
+ * this field may be interpreted as a Gregorian day-of-year, or an ISO
+ * week date day-of-year.
*/
if (!tm->tm_year && !tmfc.bc)
ereport(ERROR,
(errcode(ERRCODE_INVALID_DATETIME_FORMAT),
- errmsg("cannot calculate day of year without year information")));
+ errmsg("cannot calculate day of year without year information")));
if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
{
static const int ysum[2][13] = {
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
- {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
+ {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
y = ysum[isleap(tm->tm_year)];
for (ent = NUMCache; ent <= (NUMCache + NUM_CACHE_FIELDS); ent++)
{
/*
- * entry removed via NUM_cache_remove() can be used here,
- * which is why it's worth scanning first entry again
+ * entry removed via NUM_cache_remove() can be used here, which is
+ * why it's worth scanning first entry again
*/
if (ent->str[0] == '\0')
{
*/
if (lconv->decimal_point && *lconv->decimal_point)
Np->decimal = lconv->decimal_point;
+
else
Np->decimal = ".";
if (lconv->thousands_sep && *lconv->thousands_sep)
Np->L_thousands_sep = lconv->thousands_sep;
/* Make sure thousands separator doesn't match decimal point symbol. */
- else if (strcmp(Np->decimal, ",") != 0)
+ else if (strcmp(Np->decimal, ",") !=0)
Np->L_thousands_sep = ",";
else
Np->L_thousands_sep = ".";
/*
* Overflow check. The only possible overflow case is for arg1 =
* INT64_MIN, arg2 = -1, where the correct result is -INT64_MIN, which
- * can't be represented on a two's-complement machine. Most machines
+ * can't be represented on a two's-complement machine. Most machines
* produce INT64_MIN but it seems some produce zero.
*/
if (arg2 == -1 && arg1 < 0 && result <= 0)
/*
* When int8 is pass-by-reference, we provide this special case to avoid
* palloc overhead for COUNT(): when called from nodeAgg, we know that the
- * argument is modifiable local storage, so just update it in-place.
- * (If int8 is pass-by-value, then of course this is useless as well
- * as incorrect, so just ifdef it out.)
+ * argument is modifiable local storage, so just update it in-place. (If
+ * int8 is pass-by-value, then of course this is useless as well as
+ * incorrect, so just ifdef it out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (fcinfo->context &&
/*
* Overflow check. The only possible overflow case is for arg1 =
* INT64_MIN, arg2 = -1, where the correct result is -INT64_MIN, which
- * can't be represented on a two's-complement machine. Most machines
+ * can't be represented on a two's-complement machine. Most machines
* produce INT64_MIN but it seems some produce zero.
*/
if (arg2 == -1 && arg1 < 0 && result <= 0)
/*
* Overflow check. The only possible overflow case is for arg1 =
* INT64_MIN, arg2 = -1, where the correct result is -INT64_MIN, which
- * can't be represented on a two's-complement machine. Most machines
+ * can't be represented on a two's-complement machine. Most machines
* produce INT64_MIN but it seems some produce zero.
*/
if (arg2 == -1 && arg1 < 0 && result <= 0)
if (plen <= 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_ESCAPE_SEQUENCE),
- errmsg("LIKE pattern must not end with escape character")));
- if (TCHAR(*p) != TCHAR(*t))
+ errmsg("LIKE pattern must not end with escape character")));
+ if (TCHAR (*p) != TCHAR (*t))
return LIKE_FALSE;
}
else if (*p == '%')
} while (tlen > 0 && plen > 0 && *p == '_');
/*
- * If we are at the end of the pattern, succeed: % followed
- * by n _'s matches any string of at least n characters, and
- * we have now found there are at least n characters.
+ * If we are at the end of the pattern, succeed: % followed by
+ * n _'s matches any string of at least n characters, and we
+ * have now found there are at least n characters.
*/
if (plen <= 0)
return LIKE_TRUE;
}
else
{
- char firstpat = TCHAR(*p);
+ char firstpat = TCHAR (*p);
if (*p == '\\')
{
if (plen < 2)
return LIKE_FALSE;
- firstpat = TCHAR(p[1]);
+ firstpat = TCHAR (p[1]);
}
while (tlen > 0)
* Optimization to prevent most recursion: don't recurse
* unless first pattern byte matches first text byte.
*/
- if (TCHAR(*t) == firstpat)
+ if (TCHAR (*t) == firstpat)
{
int matched = MatchText(t, tlen, p, plen);
NextByte(p, plen);
continue;
}
- else if (TCHAR(*p) != TCHAR(*t))
+ else if (TCHAR (*p) != TCHAR (*t))
{
/* non-wildcard pattern char fails to match text char */
return LIKE_FALSE;
if (tlen > 0)
return LIKE_FALSE; /* end of pattern, but not of text */
- /* End of text string. Do we have matching pattern remaining? */
- while (plen > 0 && *p == '%') /* allow multiple %'s at end of pattern */
+ /* End of text string. Do we have matching pattern remaining? */
+ while (plen > 0 && *p == '%') /* allow multiple %'s at end of
+ * pattern */
NextByte(p, plen);
if (plen <= 0)
#ifdef MATCH_LOWER
#undef MATCH_LOWER
+
#endif
/*
* current_query()
- * Expose the current query to the user (useful in stored procedures)
- * We might want to use ActivePortal->sourceText someday.
+ * Expose the current query to the user (useful in stored procedures)
+ * We might want to use ActivePortal->sourceText someday.
*/
Datum
current_query(PG_FUNCTION_ARGS)
tupdesc = CreateTemplateTupleDesc(3, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "word",
TEXTOID, -1, 0);
- TupleDescInitEntry(tupdesc, (AttrNumber) 2, "catcode",
+ TupleDescInitEntry(tupdesc, (AttrNumber) 2, "catcode",
CHAROID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "catdesc",
TEXTOID, -1, 0);
/* if those functions think it's a bad format, try ISO8601 style */
if (dterr == DTERR_BAD_FORMAT)
- dterr = DecodeISO8601Interval(str,
+ dterr = DecodeISO8601Interval(str,
&dtype, tm, &fsec);
if (dterr != 0)
inet *src = PG_GETARG_INET_P(0);
inet *dst;
int bits;
- int byte;
+ int byte;
int nbits;
int maxbytes;
/* zero out any bits to the right of the netmask */
byte = bits / 8;
+
nbits = bits % 8;
/* clear the first byte, this might be a partial byte */
if (nbits != 0)
{
- ip_addr(dst)[byte] &= ~(0xFF >> nbits);
- byte++;
+ ip_addr(dst)[byte] &=~(0xFF >> nbits);
+ byte ++;
}
/* clear remaining bytes */
maxbytes = ip_addrsize(dst);
- while (byte < maxbytes)
+ while (byte <maxbytes)
{
ip_addr(dst)[byte] = 0;
- byte++;
+ byte ++;
}
PG_RETURN_INET_P(dst);
inet *src = PG_GETARG_INET_P(0);
int bits = PG_GETARG_INT32(1);
inet *dst;
- int byte;
+ int byte;
int nbits;
int maxbytes;
/* zero out any bits to the right of the new netmask */
byte = bits / 8;
+
nbits = bits % 8;
/* clear the first byte, this might be a partial byte */
if (nbits != 0)
{
- ip_addr(dst)[byte] &= ~(0xFF >> nbits);
- byte++;
+ ip_addr(dst)[byte] &=~(0xFF >> nbits);
+ byte ++;
}
/* clear remaining bytes */
maxbytes = ip_addrsize(dst);
- while (byte < maxbytes)
+ while (byte <maxbytes)
{
ip_addr(dst)[byte] = 0;
- byte++;
+ byte ++;
}
PG_RETURN_INET_P(dst);
{
inet *ip = PG_GETARG_INET_P(0);
inet *dst;
- int byte;
+ int byte;
int bits;
int maxbytes;
unsigned char mask;
a = ip_addr(ip);
b = ip_addr(dst);
- for (byte = 0; byte < maxbytes; byte++)
+ for (byte = 0; byte <maxbytes; byte ++)
{
if (bits >= 8)
{
bits = 0;
}
- b[byte] = a[byte] | mask;
+ b[byte] = a[byte] |mask;
}
ip_family(dst) = ip_family(ip);
{
inet *ip = PG_GETARG_INET_P(0);
inet *dst;
- int byte;
+ int byte;
int bits;
unsigned char mask;
unsigned char *a,
b = ip_addr(dst);
byte = 0;
+
while (bits)
{
if (bits >= 8)
bits = 0;
}
- b[byte] = a[byte] & mask;
- byte++;
+ b[byte] = a[byte] &mask;
+ byte ++;
}
ip_family(dst) = ip_family(ip);
{
inet *ip = PG_GETARG_INET_P(0);
inet *dst;
- int byte;
+ int byte;
int bits;
unsigned char mask;
unsigned char *b;
b = ip_addr(dst);
byte = 0;
+
while (bits)
{
if (bits >= 8)
}
b[byte] = mask;
- byte++;
+ byte ++;
}
ip_family(dst) = ip_family(ip);
{
inet *ip = PG_GETARG_INET_P(0);
inet *dst;
- int byte;
+ int byte;
int bits;
int maxbytes;
unsigned char mask;
b = ip_addr(dst);
byte = maxbytes - 1;
+
while (bits)
{
if (bits >= 8)
}
b[byte] = mask;
- byte--;
+ byte --;
}
ip_family(dst) = ip_family(ip);
static bool
addressOK(unsigned char *a, int bits, int family)
{
- int byte;
+ int byte;
int nbits;
int maxbits;
int maxbytes;
return true;
byte = bits / 8;
+
nbits = bits % 8;
mask = 0xff;
if (bits != 0)
mask >>= nbits;
- while (byte < maxbytes)
+ while (byte <maxbytes)
{
- if ((a[byte] & mask) != 0)
+ if ((a[byte] &mask) != 0)
return false;
mask = 0xff;
- byte++;
+ byte ++;
}
return true;
* two's complement, too bad.
*/
int nb = ip_addrsize(ip);
- int byte = 0;
+ int byte = 0;
unsigned char *pip = ip_addr(ip);
unsigned char *pip2 = ip_addr(ip2);
int carry = 1;
carry = pip[nb] + (~pip2[nb] & 0xFF) + carry;
lobyte = carry & 0xFF;
- if (byte < sizeof(int64))
+ if (byte <sizeof(int64))
{
- res |= ((int64) lobyte) << (byte * 8);
+ res |= ((int64) lobyte) << (byte *8);
}
else
{
errmsg("result is out of range")));
}
carry >>= 8;
- byte++;
+ byte ++;
}
/*
* If input is narrower than int64, overflow is not possible, but we
* have to do proper sign extension.
*/
- if (carry == 0 && byte < sizeof(int64))
- res |= ((int64) -1) << (byte * 8);
+ if (carry == 0 && byte <sizeof(int64))
+ res |= ((int64) -1) << (byte *8);
}
PG_RETURN_INT64(res);
/* ----------
- * NumericVar is the format we use for arithmetic. The digit-array part
+ * NumericVar is the format we use for arithmetic. The digit-array part
* is the same as the NumericData storage format, but the header is more
* complex.
*
static void zero_var(NumericVar *var);
static const char *set_var_from_str(const char *str, const char *cp,
- NumericVar *dest);
+ NumericVar *dest);
static void set_var_from_num(Numeric value, NumericVar *dest);
static void set_var_from_var(NumericVar *value, NumericVar *dest);
static char *get_str_from_var(NumericVar *var, int dscale);
static void div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
int rscale, bool round);
static void div_var_fast(NumericVar *var1, NumericVar *var2, NumericVar *result,
- int rscale, bool round);
+ int rscale, bool round);
static int select_div_scale(NumericVar *var1, NumericVar *var2);
static void mod_var(NumericVar *var1, NumericVar *var2, NumericVar *result);
static void ceil_var(NumericVar *var, NumericVar *result);
if (!isspace((unsigned char) *cp))
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
- errmsg("invalid input syntax for type numeric: \"%s\"",
- str)));
+ errmsg("invalid input syntax for type numeric: \"%s\"",
+ str)));
cp++;
}
}
/*
* We duplicate a few lines of code here because we would like to
* throw any trailing-junk syntax error before any semantic error
- * resulting from apply_typmod. We can't easily fold the two
- * cases together because we mustn't apply apply_typmod to a NaN.
+ * resulting from apply_typmod. We can't easily fold the two cases
+ * together because we mustn't apply apply_typmod to a NaN.
*/
while (*cp)
{
if (!isspace((unsigned char) *cp))
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
- errmsg("invalid input syntax for type numeric: \"%s\"",
- str)));
+ errmsg("invalid input syntax for type numeric: \"%s\"",
+ str)));
cp++;
}
/*
* The SQL spec requires that we emit a particular SQLSTATE error code for
- * certain error conditions. Specifically, we don't return a divide-by-zero
- * error code for 0 ^ -1.
+ * certain error conditions. Specifically, we don't return a
+ * divide-by-zero error code for 0 ^ -1.
*/
if (cmp_var(&arg1, &const_zero) == 0 &&
cmp_var(&arg2, &const_zero) < 0)
/*
* If we're invoked by nodeAgg, we can cheat and modify our first
* parameter in-place to avoid palloc overhead. If not, we need to return
- * the new value of the transition variable.
- * (If int8 is pass-by-value, then of course this is useless as well
- * as incorrect, so just ifdef it out.)
+ * the new value of the transition variable. (If int8 is pass-by-value,
+ * then of course this is useless as well as incorrect, so just ifdef it
+ * out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (fcinfo->context &&
/*
* If we're invoked by nodeAgg, we can cheat and modify our first
* parameter in-place to avoid palloc overhead. If not, we need to return
- * the new value of the transition variable.
- * (If int8 is pass-by-value, then of course this is useless as well
- * as incorrect, so just ifdef it out.)
+ * the new value of the transition variable. (If int8 is pass-by-value,
+ * then of course this is useless as well as incorrect, so just ifdef it
+ * out.)
*/
#ifndef USE_FLOAT8_BYVAL /* controls int8 too */
if (fcinfo->context &&
/* If rounding needed, figure one more digit to ensure correct result */
if (round)
res_ndigits++;
+
/*
* The working dividend normally requires res_ndigits + var2ndigits
* digits, but make it at least var1ndigits so we can load all of var1
/*
* We need a workspace with room for the working dividend (div_ndigits+1
* digits) plus room for the possibly-normalized divisor (var2ndigits
- * digits). It is convenient also to have a zero at divisor[0] with
- * the actual divisor data in divisor[1 .. var2ndigits]. Transferring the
+ * digits). It is convenient also to have a zero at divisor[0] with the
+ * actual divisor data in divisor[1 .. var2ndigits]. Transferring the
* digits into the workspace also allows us to realloc the result (which
* might be the same as either input var) before we begin the main loop.
* Note that we use palloc0 to ensure that divisor[0], dividend[0], and
if (var2ndigits == 1)
{
/*
- * If there's only a single divisor digit, we can use a fast path
- * (cf. Knuth section 4.3.1 exercise 16).
+ * If there's only a single divisor digit, we can use a fast path (cf.
+ * Knuth section 4.3.1 exercise 16).
*/
divisor1 = divisor[1];
carry = 0;
*
* We need the first divisor digit to be >= NBASE/2. If it isn't,
* make it so by scaling up both the divisor and dividend by the
- * factor "d". (The reason for allocating dividend[0] above is to
+ * factor "d". (The reason for allocating dividend[0] above is to
* leave room for possible carry here.)
*/
if (divisor[1] < HALF_NBASE)
{
- int d = NBASE / (divisor[1] + 1);
+ int d = NBASE / (divisor[1] + 1);
carry = 0;
for (i = var2ndigits; i > 0; i--)
divisor2 = divisor[2];
/*
- * Begin the main loop. Each iteration of this loop produces the
- * j'th quotient digit by dividing dividend[j .. j + var2ndigits]
- * by the divisor; this is essentially the same as the common manual
+ * Begin the main loop. Each iteration of this loop produces the j'th
+ * quotient digit by dividing dividend[j .. j + var2ndigits] by the
+ * divisor; this is essentially the same as the common manual
* procedure for long division.
*/
for (j = 0; j < res_ndigits; j++)
{
/* Estimate quotient digit from the first two dividend digits */
- int next2digits = dividend[j] * NBASE + dividend[j+1];
- int qhat;
+ int next2digits = dividend[j] * NBASE + dividend[j + 1];
+ int qhat;
/*
* If next2digits are 0, then quotient digit must be 0 and there's
- * no need to adjust the working dividend. It's worth testing
- * here to fall out ASAP when processing trailing zeroes in
- * a dividend.
+ * no need to adjust the working dividend. It's worth testing
+ * here to fall out ASAP when processing trailing zeroes in a
+ * dividend.
*/
if (next2digits == 0)
{
qhat = NBASE - 1;
else
qhat = next2digits / divisor1;
+
/*
* Adjust quotient digit if it's too large. Knuth proves that
- * after this step, the quotient digit will be either correct
- * or just one too large. (Note: it's OK to use dividend[j+2]
- * here because we know the divisor length is at least 2.)
+ * after this step, the quotient digit will be either correct or
+ * just one too large. (Note: it's OK to use dividend[j+2] here
+ * because we know the divisor length is at least 2.)
*/
while (divisor2 * qhat >
- (next2digits - qhat * divisor1) * NBASE + dividend[j+2])
+ (next2digits - qhat * divisor1) * NBASE + dividend[j + 2])
qhat--;
/* As above, need do nothing more when quotient digit is 0 */
}
/*
- * This avoids log(0) for cases of 0 raised to a non-integer.
- * 0 ^ 0 handled by power_var_int().
+ * This avoids log(0) for cases of 0 raised to a non-integer. 0 ^ 0
+ * handled by power_var_int().
*/
if (cmp_var(base, &const_zero) == 0)
{
set_var_from_var(&const_zero, result);
- result->dscale = NUMERIC_MIN_SIG_DIGITS; /* no need to round */
+ result->dscale = NUMERIC_MIN_SIG_DIGITS; /* no need to round */
return;
}
-
+
init_var(&ln_base);
init_var(&ln_num);
switch (exp)
{
case 0:
+
/*
- * While 0 ^ 0 can be either 1 or indeterminate (error), we
- * treat it as 1 because most programming languages do this.
- * SQL:2003 also requires a return value of 1.
- * http://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_power
+ * While 0 ^ 0 can be either 1 or indeterminate (error), we treat
+ * it as 1 because most programming languages do this. SQL:2003
+ * also requires a return value of 1.
+ * http://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_pow
+ * er
*/
set_var_from_var(&const_one, result);
result->dscale = rscale; /* no need to round */
Datum
lower(PG_FUNCTION_ARGS)
{
- text *in_string = PG_GETARG_TEXT_PP(0);
- char *out_string;
- text *result;
+ text *in_string = PG_GETARG_TEXT_PP(0);
+ char *out_string;
+ text *result;
out_string = str_tolower(VARDATA_ANY(in_string),
VARSIZE_ANY_EXHDR(in_string));
Datum
upper(PG_FUNCTION_ARGS)
{
- text *in_string = PG_GETARG_TEXT_PP(0);
- char *out_string;
- text *result;
+ text *in_string = PG_GETARG_TEXT_PP(0);
+ char *out_string;
+ text *result;
out_string = str_toupper(VARDATA_ANY(in_string),
VARSIZE_ANY_EXHDR(in_string));
Datum
initcap(PG_FUNCTION_ARGS)
{
- text *in_string = PG_GETARG_TEXT_PP(0);
- char *out_string;
- text *result;
+ text *in_string = PG_GETARG_TEXT_PP(0);
+ char *out_string;
+ text *result;
out_string = str_initcap(VARDATA_ANY(in_string),
VARSIZE_ANY_EXHDR(in_string));
/*----------
* Here is how the locale stuff is handled: LC_COLLATE and LC_CTYPE
- * are fixed at CREATE DATABASE time, stored in pg_database, and cannot
+ * are fixed at CREATE DATABASE time, stored in pg_database, and cannot
* be changed. Thus, the effects of strcoll(), strxfrm(), isupper(),
* toupper(), etc. are always in the same fixed locale.
*
static char lc_time_envbuf[LC_ENV_BUFSIZE];
#if defined(WIN32) && defined(LC_MESSAGES)
-static char *IsoLocaleName(const char *); /* MSVC specific */
+static char *IsoLocaleName(const char *); /* MSVC specific */
#endif
result = IsoLocaleName(locale);
if (result == NULL)
result = (char *) locale;
-#endif /* WIN32 */
+#endif /* WIN32 */
break;
-#endif /* LC_MESSAGES */
+#endif /* LC_MESSAGES */
case LC_MONETARY:
envvar = "LC_MONETARY";
envbuf = lc_monetary_envbuf;
* pg_strftime(), which isn't locale-aware and does not need to be replaced.
*/
static size_t
-strftime_win32(char *dst, size_t dstlen, const wchar_t *format, const struct tm *tm)
+strftime_win32(char *dst, size_t dstlen, const wchar_t *format, const struct tm * tm)
{
- size_t len;
- wchar_t wbuf[MAX_L10N_DATA];
- int encoding;
+ size_t len;
+ wchar_t wbuf[MAX_L10N_DATA];
+ int encoding;
encoding = GetDatabaseEncoding();
len = wcsftime(wbuf, MAX_L10N_DATA, format, tm);
if (len == 0)
- /* strftime call failed - return 0 with the contents of dst unspecified */
+
+ /*
+ * strftime call failed - return 0 with the contents of dst
+ * unspecified
+ */
return 0;
len = WideCharToMultiByte(CP_UTF8, 0, wbuf, len, dst, dstlen, NULL, NULL);
if (len == 0)
elog(ERROR,
- "could not convert string to UTF-8:error %lu", GetLastError());
+ "could not convert string to UTF-8:error %lu", GetLastError());
dst[len] = '\0';
if (encoding != PG_UTF8)
{
- char *convstr = pg_do_encoding_conversion(dst, len, PG_UTF8, encoding);
+ char *convstr = pg_do_encoding_conversion(dst, len, PG_UTF8, encoding);
+
if (dst != convstr)
{
strlcpy(dst, convstr, dstlen);
}
#define strftime(a,b,c,d) strftime_win32(a,b,L##c,d)
-
-#endif /* WIN32 */
+#endif /* WIN32 */
/*
void
cache_locale_time(void)
{
- char *save_lc_time;
+ char *save_lc_time;
time_t timenow;
- struct tm *timeinfo;
+ struct tm *timeinfo;
char buf[MAX_L10N_DATA];
char *ptr;
int i;
+
#ifdef WIN32
char *save_lc_ctype;
#endif
* contains the iso formatted locale name.
*/
static
-char *IsoLocaleName(const char *winlocname)
+char *
+IsoLocaleName(const char *winlocname)
{
-#if (_MSC_VER >= 1400) /* VC8.0 or later */
- static char iso_lc_messages[32];
+#if (_MSC_VER >= 1400) /* VC8.0 or later */
+ static char iso_lc_messages[32];
_locale_t loct = NULL;
if (pg_strcasecmp("c", winlocname) == 0 ||
loct = _create_locale(LC_CTYPE, winlocname);
if (loct != NULL)
{
- char isolang[32], isocrty[32];
- LCID lcid;
+ char isolang[32],
+ isocrty[32];
+ LCID lcid;
lcid = loct->locinfo->lc_handle[LC_CTYPE];
if (lcid == 0)
}
return NULL;
#else
- return NULL; /* Not supported on this version of msvc/mingw */
-#endif /* _MSC_VER >= 1400 */
+ return NULL; /* Not supported on this version of msvc/mingw */
+#endif /* _MSC_VER >= 1400 */
}
-#endif /* WIN32 && LC_MESSAGES */
+#endif /* WIN32 && LC_MESSAGES */
* ----------
*/
static const PGLZ_Strategy strategy_default_data = {
- 32, /* Data chunks less than 32 bytes are not compressed */
- INT_MAX, /* No upper limit on what we'll try to compress */
- 25, /* Require 25% compression rate, or not worth it */
- 1024, /* Give up if no compression in the first 1KB */
- 128, /* Stop history lookup if a match of 128 bytes is found */
- 10 /* Lower good match size by 10% at every loop iteration */
+ 32, /* Data chunks less than 32 bytes are not
+ * compressed */
+ INT_MAX, /* No upper limit on what we'll try to
+ * compress */
+ 25, /* Require 25% compression rate, or not worth
+ * it */
+ 1024, /* Give up if no compression in the first 1KB */
+ 128, /* Stop history lookup if a match of 128 bytes
+ * is found */
+ 10 /* Lower good match size by 10% at every loop
+ * iteration */
};
const PGLZ_Strategy *const PGLZ_strategy_default = &strategy_default_data;
static const PGLZ_Strategy strategy_always_data = {
- 0, /* Chunks of any size are compressed */
+ 0, /* Chunks of any size are compressed */
INT_MAX,
- 0, /* It's enough to save one single byte */
- INT_MAX, /* Never give up early */
- 128, /* Stop history lookup if a match of 128 bytes is found */
- 6 /* Look harder for a good match */
+ 0, /* It's enough to save one single byte */
+ INT_MAX, /* Never give up early */
+ 128, /* Stop history lookup if a match of 128 bytes
+ * is found */
+ 6 /* Look harder for a good match */
};
const PGLZ_Strategy *const PGLZ_strategy_always = &strategy_always_data;
strategy = PGLZ_strategy_default;
/*
- * If the strategy forbids compression (at all or if source chunk size
- * out of range), fail.
+ * If the strategy forbids compression (at all or if source chunk size out
+ * of range), fail.
*/
if (strategy->match_size_good <= 0 ||
slen < strategy->min_input_size ||
need_rate = 99;
/*
- * Compute the maximum result size allowed by the strategy, namely
- * the input size minus the minimum wanted compression rate. This had
- * better be <= slen, else we might overrun the provided output buffer.
+ * Compute the maximum result size allowed by the strategy, namely the
+ * input size minus the minimum wanted compression rate. This had better
+ * be <= slen, else we might overrun the provided output buffer.
*/
- if (slen > (INT_MAX/100))
+ if (slen > (INT_MAX / 100))
{
/* Approximate to avoid overflow */
result_max = (slen / 100) * (100 - need_rate);
/*
* If we've emitted more than first_success_by bytes without finding
- * anything compressible at all, fail. This lets us fall out
+ * anything compressible at all, fail. This lets us fall out
* reasonably quickly when looking at incompressible input (such as
* pre-compressed data).
*/
while (sp < srcend && dp < destend)
{
/*
- * Read one control byte and process the next 8 items (or as many
- * as remain in the compressed input).
+ * Read one control byte and process the next 8 items (or as many as
+ * remain in the compressed input).
*/
unsigned char ctrl = *sp++;
- int ctrlc;
+ int ctrlc;
for (ctrlc = 0; ctrlc < 8 && sp < srcend; ctrlc++)
{
len += *sp++;
/*
- * Check for output buffer overrun, to ensure we don't
- * clobber memory in case of corrupt input. Note: we must
- * advance dp here to ensure the error is detected below
- * the loop. We don't simply put the elog inside the loop
- * since that will probably interfere with optimization.
+ * Check for output buffer overrun, to ensure we don't clobber
+ * memory in case of corrupt input. Note: we must advance dp
+ * here to ensure the error is detected below the loop. We
+ * don't simply put the elog inside the loop since that will
+ * probably interfere with optimization.
*/
if (dp + len > destend)
{
* An unset control bit means LITERAL BYTE. So we just copy
* one from INPUT to OUTPUT.
*/
- if (dp >= destend) /* check for buffer overrun */
- break; /* do not clobber memory */
+ if (dp >= destend) /* check for buffer overrun */
+ break; /* do not clobber memory */
*dp++ = *sp++;
}
Datum
pg_stat_get_function_calls(PG_FUNCTION_ARGS)
{
- Oid funcid = PG_GETARG_OID(0);
+ Oid funcid = PG_GETARG_OID(0);
PgStat_StatFuncEntry *funcentry;
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
Datum
pg_stat_get_function_time(PG_FUNCTION_ARGS)
{
- Oid funcid = PG_GETARG_OID(0);
+ Oid funcid = PG_GETARG_OID(0);
PgStat_StatFuncEntry *funcentry;
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
Datum
pg_stat_get_function_self_time(PG_FUNCTION_ARGS)
{
- Oid funcid = PG_GETARG_OID(0);
+ Oid funcid = PG_GETARG_OID(0);
PgStat_StatFuncEntry *funcentry;
if ((funcentry = pgstat_fetch_stat_funcentry(funcid)) == NULL)
if (SRF_IS_FIRSTCALL())
{
MemoryContext oldcontext;
- TupleDesc tupdesc;
-
+ TupleDesc tupdesc;
+
funcctx = SRF_FIRSTCALL_INIT();
-
+
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
tupdesc = CreateTemplateTupleDesc(10, false);
/*
* Get one backend - locate by pid.
*
- * We lookup the backend early, so we can return zero rows if it doesn't
- * exist, instead of returning a single row full of NULLs.
+ * We lookup the backend early, so we can return zero rows if it
+ * doesn't exist, instead of returning a single row full of NULLs.
*/
- int pid = PG_GETARG_INT32(0);
- int i;
- int n = pgstat_fetch_stat_numbackends();
-
+ int pid = PG_GETARG_INT32(0);
+ int i;
+ int n = pgstat_fetch_stat_numbackends();
+
for (i = 1; i <= n; i++)
{
PgBackendStatus *be = pgstat_fetch_stat_beentry(i);
+
if (be)
{
if (be->st_procpid == pid)
{
- *(int *)(funcctx->user_fctx) = i;
+ *(int *) (funcctx->user_fctx) = i;
break;
}
}
}
- if (*(int *)(funcctx->user_fctx) == 0)
+ if (*(int *) (funcctx->user_fctx) == 0)
/* Pid not found, return zero rows */
funcctx->max_calls = 0;
else
funcctx->max_calls = 1;
}
-
+
MemoryContextSwitchTo(oldcontext);
}
if (funcctx->call_cntr < funcctx->max_calls)
{
/* for each row */
- Datum values[10];
- bool nulls[10];
- HeapTuple tuple;
+ Datum values[10];
+ bool nulls[10];
+ HeapTuple tuple;
PgBackendStatus *beentry;
- SockAddr zero_clientaddr;
+ SockAddr zero_clientaddr;
MemSet(values, 0, sizeof(values));
MemSet(nulls, 0, sizeof(nulls));
-
- if (*(int *)(funcctx->user_fctx) > 0)
+
+ if (*(int *) (funcctx->user_fctx) > 0)
/* Get specific pid slot */
- beentry = pgstat_fetch_stat_beentry(*(int *)(funcctx->user_fctx));
+ beentry = pgstat_fetch_stat_beentry(*(int *) (funcctx->user_fctx));
else
/* Get the next one in the list */
- beentry = pgstat_fetch_stat_beentry(funcctx->call_cntr+1); /* 1-based index */
+ beentry = pgstat_fetch_stat_beentry(funcctx->call_cntr + 1); /* 1-based index */
if (!beentry)
{
- int i;
+ int i;
- for (i = 0; i < sizeof(nulls)/sizeof(nulls[0]); i++)
+ for (i = 0; i < sizeof(nulls) / sizeof(nulls[0]); i++)
nulls[i] = true;
nulls[3] = false;
/* A zeroed client addr means we don't know */
memset(&zero_clientaddr, 0, sizeof(zero_clientaddr));
if (memcmp(&(beentry->st_clientaddr), &zero_clientaddr,
- sizeof(zero_clientaddr) == 0))
+ sizeof(zero_clientaddr) == 0))
{
nulls[8] = true;
nulls[9] = true;
#ifdef HAVE_IPV6
|| beentry->st_clientaddr.addr.ss_family == AF_INET6
#endif
- )
+ )
{
- char remote_host[NI_MAXHOST];
+ char remote_host[NI_MAXHOST];
char remote_port[NI_MAXSERV];
int ret;
{
clean_ipv6_addr(beentry->st_clientaddr.addr.ss_family, remote_host);
values[8] = DirectFunctionCall1(inet_in,
- CStringGetDatum(remote_host));
+ CStringGetDatum(remote_host));
values[9] = Int32GetDatum(atoi(remote_port));
}
}
else if (beentry->st_clientaddr.addr.ss_family == AF_UNIX)
{
/*
- * Unix sockets always reports NULL for host and -1 for port, so it's
- * possible to tell the difference to connections we have no
- * permissions to view, or with errors.
+ * Unix sockets always reports NULL for host and -1 for
+ * port, so it's possible to tell the difference to
+ * connections we have no permissions to view, or with
+ * errors.
*/
nulls[8] = true;
values[9] = DatumGetInt32(-1);
/*
* quote_nullable -
- * Returns a properly quoted literal, with null values returned
- * as the text string 'NULL'.
+ * Returns a properly quoted literal, with null values returned
+ * as the text string 'NULL'.
*/
Datum
quote_nullable(PG_FUNCTION_ARGS)
/* GUC-settable flavor parameter */
-int regex_flavor = REG_ADVANCED;
+int regex_flavor = REG_ADVANCED;
/* all the options of interest for regex functions */
}
/*
- * It is possible to have a match to the whole pattern but no match
- * for a subexpression; for example 'foo(bar)?' is considered to match
- * 'foo' but there is no subexpression match. So this extra test for
- * match failure is not redundant.
+ * It is possible to have a match to the whole pattern but no match for a
+ * subexpression; for example 'foo(bar)?' is considered to match 'foo' but
+ * there is no subexpression match. So this extra test for match failure
+ * is not redundant.
*/
if (so < 0 || eo < 0)
PG_RETURN_NULL();
ri_FetchPreparedPlan(RI_QueryKey *key)
{
RI_QueryHashEntry *entry;
- SPIPlanPtr plan;
+ SPIPlanPtr plan;
/*
* On the first call initialize the hashtable
return NULL;
/*
- * Check whether the plan is still valid. If it isn't, we don't want
- * to simply rely on plancache.c to regenerate it; rather we should
- * start from scratch and rebuild the query text too. This is to cover
- * cases such as table/column renames. We depend on the plancache
- * machinery to detect possible invalidations, though.
+ * Check whether the plan is still valid. If it isn't, we don't want to
+ * simply rely on plancache.c to regenerate it; rather we should start
+ * from scratch and rebuild the query text too. This is to cover cases
+ * such as table/column renames. We depend on the plancache machinery to
+ * detect possible invalidations, though.
*
* CAUTION: this check is only trustworthy if the caller has already
* locked both FK and PK rels.
return plan;
/*
- * Otherwise we might as well flush the cached plan now, to free a
- * little memory space before we make a new one.
+ * Otherwise we might as well flush the cached plan now, to free a little
+ * memory space before we make a new one.
*/
entry->plan = NULL;
if (plan)
ri_InitHashTables();
/*
- * Add the new plan. We might be overwriting an entry previously
- * found invalid by ri_FetchPreparedPlan.
+ * Add the new plan. We might be overwriting an entry previously found
+ * invalid by ri_FetchPreparedPlan.
*/
entry = (RI_QueryHashEntry *) hash_search(ri_query_cache,
(void *) key,
int32 record1_typmod;
Oid record2_type;
int32 record2_typmod;
- ColumnCompareData columns[1]; /* VARIABLE LENGTH ARRAY */
+ ColumnCompareData columns[1]; /* VARIABLE LENGTH ARRAY */
} RecordCompareData;
{
fcinfo->flinfo->fn_extra =
MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
- sizeof(RecordCompareData) - sizeof(ColumnCompareData)
+ sizeof(RecordCompareData) - sizeof(ColumnCompareData)
+ ncols * sizeof(ColumnCompareData));
my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
my_extra->ncolumns = ncols;
/*
* Scan corresponding columns, allowing for dropped columns in different
- * places in the two rows. i1 and i2 are physical column indexes,
- * j is the logical column index.
+ * places in the two rows. i1 and i2 are physical column indexes, j is
+ * the logical column index.
*/
i1 = i2 = j = 0;
while (i1 < ncolumns1 || i2 < ncolumns2)
errmsg("cannot compare dissimilar column types %s and %s at record column %d",
format_type_be(tupdesc1->attrs[i1]->atttypid),
format_type_be(tupdesc2->attrs[i2]->atttypid),
- j+1)));
+ j + 1)));
/*
* Lookup the comparison function if not done already
if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("could not identify a comparison function for type %s",
- format_type_be(typentry->type_id))));
+ errmsg("could not identify a comparison function for type %s",
+ format_type_be(typentry->type_id))));
my_extra->columns[j].typentry = typentry;
}
/*
* If we didn't break out of the loop early, check for column count
- * mismatch. (We do not report such mismatch if we found unequal
- * column values; is that a feature or a bug?)
+ * mismatch. (We do not report such mismatch if we found unequal column
+ * values; is that a feature or a bug?)
*/
if (result == 0)
{
{
fcinfo->flinfo->fn_extra =
MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
- sizeof(RecordCompareData) - sizeof(ColumnCompareData)
+ sizeof(RecordCompareData) - sizeof(ColumnCompareData)
+ ncols * sizeof(ColumnCompareData));
my_extra = (RecordCompareData *) fcinfo->flinfo->fn_extra;
my_extra->ncolumns = ncols;
/*
* Scan corresponding columns, allowing for dropped columns in different
- * places in the two rows. i1 and i2 are physical column indexes,
- * j is the logical column index.
+ * places in the two rows. i1 and i2 are physical column indexes, j is
+ * the logical column index.
*/
i1 = i2 = j = 0;
while (i1 < ncolumns1 || i2 < ncolumns2)
errmsg("cannot compare dissimilar column types %s and %s at record column %d",
format_type_be(tupdesc1->attrs[i1]->atttypid),
format_type_be(tupdesc2->attrs[i2]->atttypid),
- j+1)));
+ j + 1)));
/*
* Lookup the equality function if not done already
if (!OidIsValid(typentry->eq_opr_finfo.fn_oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_FUNCTION),
- errmsg("could not identify an equality operator for type %s",
- format_type_be(typentry->type_id))));
+ errmsg("could not identify an equality operator for type %s",
+ format_type_be(typentry->type_id))));
my_extra->columns[j].typentry = typentry;
}
/*
* If we didn't break out of the loop early, check for column count
- * mismatch. (We do not report such mismatch if we found unequal
- * column values; is that a feature or a bug?)
+ * mismatch. (We do not report such mismatch if we found unequal column
+ * values; is that a feature or a bug?)
*/
if (result)
{
bool force_colno,
deparse_context *context);
static void get_rule_orderby(List *orderList, List *targetList,
- bool force_colno, deparse_context *context);
+ bool force_colno, deparse_context *context);
static void get_rule_windowclause(Query *query, deparse_context *context);
static void get_rule_windowspec(WindowClause *wc, List *targetList,
- deparse_context *context);
+ deparse_context *context);
static void push_plan(deparse_namespace *dpns, Plan *subplan);
static char *get_variable(Var *var, int levelsup, bool showstar,
deparse_context *context);
static void printSubscripts(ArrayRef *aref, deparse_context *context);
static char *generate_relation_name(Oid relid, List *namespaces);
static char *generate_function_name(Oid funcid, int nargs, Oid *argtypes,
- bool *is_variadic);
+ bool *is_variadic);
static char *generate_operator_name(Oid operid, Oid arg1, Oid arg2);
static text *string_to_text(char *str);
static char *flatten_reloptions(Oid relid);
/*
* pg_get_functiondef
- * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
- * the specified function.
+ * Returns the complete "CREATE OR REPLACE FUNCTION ..." statement for
+ * the specified function.
*/
Datum
pg_get_functiondef(PG_FUNCTION_ARGS)
lang = (Form_pg_language) GETSTRUCT(langtup);
/*
- * We always qualify the function name, to ensure the right function
- * gets replaced.
+ * We always qualify the function name, to ensure the right function gets
+ * replaced.
*/
nsp = get_namespace_name(proc->pronamespace);
appendStringInfo(&buf, "CREATE OR REPLACE FUNCTION %s(",
tmp = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_proconfig, &isnull);
if (!isnull)
{
- ArrayType *a = DatumGetArrayTypeP(tmp);
+ ArrayType *a = DatumGetArrayTypeP(tmp);
int i;
Assert(ARR_ELEMTYPE(a) == TEXTOID);
for (i = 1; i <= ARR_DIMS(a)[0]; i++)
{
- Datum d;
+ Datum d;
d = array_ref(a, 1, &i,
-1 /* varlenarray */ ,
/*
* We always use dollar quoting. Figure out a suitable delimiter.
*
- * Since the user is likely to be editing the function body string,
- * we shouldn't use a short delimiter that he might easily create a
- * conflict with. Hence prefer "$function$", but extend if needed.
+ * Since the user is likely to be editing the function body string, we
+ * shouldn't use a short delimiter that he might easily create a conflict
+ * with. Hence prefer "$function$", but extend if needed.
*/
initStringInfo(&dq);
appendStringInfoString(&dq, "$function");
&isnull);
if (!isnull)
{
- char *str;
- List *argdefaults;
+ char *str;
+ List *argdefaults;
str = TextDatumGetCString(proargdefaults);
argdefaults = (List *) stringToNode(str);
inputargno = 0;
for (i = 0; i < numargs; i++)
{
- Oid argtype = argtypes[i];
- char *argname = argnames ? argnames[i] : NULL;
- char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
+ Oid argtype = argtypes[i];
+ char *argname = argnames ? argnames[i] : NULL;
+ char argmode = argmodes ? argmodes[i] : PROARGMODE_IN;
const char *modename;
- bool isinput;
+ bool isinput;
switch (argmode)
{
break;
default:
elog(ERROR, "invalid parameter mode '%c'", argmode);
- modename = NULL; /* keep compiler quiet */
+ modename = NULL; /* keep compiler quiet */
isinput = false;
break;
}
appendStringInfoString(buf, format_type_be(argtype));
if (print_defaults && isinput && inputargno > nlackdefaults)
{
- Node *expr;
+ Node *expr;
Assert(nextargdefault != NULL);
expr = (Node *) lfirst(nextargdefault);
* right child plans. A special case is that a nestloop inner indexscan
* might have OUTER Vars, but the outer side of the join is not a child
* plan node. To handle such cases the outer plan node must be passed
- * separately. (Pass NULL for outer_plan otherwise.)
+ * separately. (Pass NULL for outer_plan otherwise.)
*
* Note: plan and outer_plan really ought to be declared as "Plan *", but
* we use "Node *" to avoid having to include plannodes.h in builtins.h.
get_with_clause(Query *query, deparse_context *context)
{
StringInfo buf = context->buf;
- const char *sep;
- ListCell *l;
+ const char *sep;
+ ListCell *l;
if (query->cteList == NIL)
return;
/*
* Use column-number form if requested by caller. Otherwise, if
- * expression is a constant, force it to be dumped with an explicit
- * cast as decoration --- this is because a simple integer constant
- * is ambiguous (and will be misinterpreted by findTargetlistEntry())
- * if we dump it without any decoration. Otherwise, just dump the
- * expression normally.
+ * expression is a constant, force it to be dumped with an explicit cast
+ * as decoration --- this is because a simple integer constant is
+ * ambiguous (and will be misinterpreted by findTargetlistEntry()) if we
+ * dump it without any decoration. Otherwise, just dump the expression
+ * normally.
*/
if (force_colno)
{
dpns->inner_plan = ((SubqueryScan *) subplan)->subplan;
else if (IsA(subplan, CteScan))
{
- int ctePlanId = ((CteScan *) subplan)->ctePlanId;
+ int ctePlanId = ((CteScan *) subplan)->ctePlanId;
if (ctePlanId > 0 && ctePlanId <= list_length(dpns->subplans))
dpns->inner_plan = list_nth(dpns->subplans, ctePlanId - 1);
*/
if (IsA(var, RowExpr))
{
- RowExpr *r = (RowExpr *) var;
+ RowExpr *r = (RowExpr *) var;
if (fieldno > 0 && fieldno <= list_length(r->colnames))
return strVal(list_nth(r->colnames, fieldno - 1));
* This part has essentially the same logic as the parser's
* expandRecordVariable() function, but we are dealing with a different
* representation of the input context, and we only need one field name
- * not a TupleDesc. Also, we need special cases for finding subquery
- * and CTE subplans when deparsing Plan trees.
+ * not a TupleDesc. Also, we need special cases for finding subquery and
+ * CTE subplans when deparsing Plan trees.
*/
expr = (Node *) var; /* default if we can't drill down */
{
/*
* We're deparsing a Plan tree so we don't have complete
- * RTE entries (in particular, rte->subquery is NULL).
- * But the only place we'd see a Var directly referencing
- * a SUBQUERY RTE is in a SubqueryScan plan node, and we
- * can look into the child plan's tlist instead.
+ * RTE entries (in particular, rte->subquery is NULL). But
+ * the only place we'd see a Var directly referencing a
+ * SUBQUERY RTE is in a SubqueryScan plan node, and we can
+ * look into the child plan's tlist instead.
*/
TargetEntry *tle;
Plan *save_outer;
if (IsA(expr, Var))
{
/*
- * Recurse into the CTE to see what its Var refers
- * to. We have to build an additional level of
- * namespace to keep in step with varlevelsup in the
- * CTE. Furthermore it could be an outer CTE, so
- * we may have to delete some levels of namespace.
+ * Recurse into the CTE to see what its Var refers to.
+ * We have to build an additional level of namespace
+ * to keep in step with varlevelsup in the CTE.
+ * Furthermore it could be an outer CTE, so we may
+ * have to delete some levels of namespace.
*/
List *save_nslist = context->namespaces;
List *new_nslist;
/*
* We're deparsing a Plan tree so we don't have a CTE
* list. But the only place we'd see a Var directly
- * referencing a CTE RTE is in a CteScan plan node, and
- * we can look into the subplan's tlist instead.
+ * referencing a CTE RTE is in a CteScan plan node, and we
+ * can look into the subplan's tlist instead.
*/
TargetEntry *tle;
Plan *save_outer;
case T_SubPlan:
{
- SubPlan *subplan = (SubPlan *) node;
+ SubPlan *subplan = (SubPlan *) node;
/*
* We cannot see an already-planned subplan in rule deparsing,
- * only while EXPLAINing a query plan. We don't try to
+ * only while EXPLAINing a query plan. We don't try to
* reconstruct the original SQL, just reference the subplan
* that appears elsewhere in EXPLAIN's result.
*/
appendStringInfo(buf, "(alternatives: ");
foreach(lc, asplan->subplans)
{
- SubPlan *splan = (SubPlan *) lfirst(lc);
+ SubPlan *splan = (SubPlan *) lfirst(lc);
Assert(IsA(splan, SubPlan));
if (splan->useHashTable)
appendStringInfo(buf, "ARRAY[");
get_rule_expr((Node *) arrayexpr->elements, context, true);
appendStringInfoChar(buf, ']');
+
/*
* If the array isn't empty, we assume its elements are
* coerced to the desired type. If it's empty, though, we
*/
if (arrayexpr->elements == NIL)
appendStringInfo(buf, "::%s",
- format_type_with_typemod(arrayexpr->array_typeid, -1));
+ format_type_with_typemod(arrayexpr->array_typeid, -1));
}
break;
if (context->windowClause)
elog(ERROR, "could not find window clause for winref %u",
wfunc->winref);
+
/*
- * In EXPLAIN, we don't have window context information available,
- * so we have to settle for this:
+ * In EXPLAIN, we don't have window context information available, so
+ * we have to settle for this:
*/
appendStringInfoString(buf, "(?)");
}
const char *valptr;
/*
- * We form the string literal according to the prevailing setting
- * of standard_conforming_strings; we never use E''. User is
- * responsible for making sure result is used correctly.
+ * We form the string literal according to the prevailing setting of
+ * standard_conforming_strings; we never use E''. User is responsible for
+ * making sure result is used correctly.
*/
appendStringInfoChar(buf, '\'');
for (valptr = val; *valptr; valptr++)
* given that it is being called with the specified actual arg types.
* (Arg types matter because of ambiguous-function resolution rules.)
*
- * The result includes all necessary quoting and schema-prefixing. We can
+ * The result includes all necessary quoting and schema-prefixing. We can
* also pass back an indication of whether the function is variadic.
*/
static char *
* float8 oprjoin (internal, oid, internal, int2, internal);
*
* (Before Postgres 8.4, join estimators had only the first four of these
- * parameters. That signature is still allowed, but deprecated.) The
+ * parameters. That signature is still allowed, but deprecated.) The
* relationship between jointype and sjinfo is explained in the comments for
* clause_selectivity() --- the short version is that jointype is usually
* best ignored in favor of examining sjinfo.
static double eqjoinsel_inner(Oid operator,
VariableStatData *vardata1, VariableStatData *vardata2);
static double eqjoinsel_semi(Oid operator,
- VariableStatData *vardata1, VariableStatData *vardata2);
+ VariableStatData *vardata1, VariableStatData *vardata2);
static bool convert_to_scalar(Datum value, Oid valuetypid, double *scaledvalue,
Datum lobound, Datum hibound, Oid boundstypid,
double *scaledlobound, double *scaledhibound);
static char *convert_string_datum(Datum value, Oid typid);
static double convert_timevalue_to_scalar(Datum value, Oid typid);
static bool get_variable_range(PlannerInfo *root, VariableStatData *vardata,
- Oid sortop, Datum *min, Datum *max);
+ Oid sortop, Datum *min, Datum *max);
static Selectivity prefix_selectivity(VariableStatData *vardata,
Oid vartype, Oid opfamily, Const *prefixcon);
static Selectivity pattern_selectivity(Const *patt, Pattern_Type ptype);
double selec;
/*
- * If the constant is NULL, assume operator is strict and
- * return zero, ie, operator will never return TRUE.
+ * If the constant is NULL, assume operator is strict and return zero, ie,
+ * operator will never return TRUE.
*/
if (constisnull)
return 0.0;
/*
* If we matched the var to a unique index, assume there is exactly one
- * match regardless of anything else. (This is slightly bogus, since
- * the index's equality operator might be different from ours, but it's
- * more likely to be right than ignoring the information.)
+ * match regardless of anything else. (This is slightly bogus, since the
+ * index's equality operator might be different from ours, but it's more
+ * likely to be right than ignoring the information.)
*/
if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0)
return 1.0 / vardata->rel->tuples;
/*
* Is the constant "=" to any of the column's most common values?
- * (Although the given operator may not really be "=", we will
- * assume that seeing whether it returns TRUE is an appropriate
- * test. If you don't like this, maybe you shouldn't be using
- * eqsel for your operator...)
+ * (Although the given operator may not really be "=", we will assume
+ * that seeing whether it returns TRUE is an appropriate test. If you
+ * don't like this, maybe you shouldn't be using eqsel for your
+ * operator...)
*/
if (get_attstatsslot(vardata->statsTuple,
vardata->atttype, vardata->atttypmod,
{
/*
* Constant is "=" to this common value. We know selectivity
- * exactly (or as exactly as ANALYZE could calculate it,
- * anyway).
+ * exactly (or as exactly as ANALYZE could calculate it, anyway).
*/
selec = numbers[i];
}
else
{
/*
- * Comparison is against a constant that is neither NULL nor
- * any of the common values. Its selectivity cannot be more
- * than this:
+ * Comparison is against a constant that is neither NULL nor any
+ * of the common values. Its selectivity cannot be more than
+ * this:
*/
double sumcommon = 0.0;
double otherdistinct;
CLAMP_PROBABILITY(selec);
/*
- * and in fact it's probably a good deal less. We approximate
- * that all the not-common values share this remaining
- * fraction equally, so we divide by the number of other
- * distinct values.
+ * and in fact it's probably a good deal less. We approximate that
+ * all the not-common values share this remaining fraction
+ * equally, so we divide by the number of other distinct values.
*/
otherdistinct = get_variable_numdistinct(vardata) - nnumbers;
if (otherdistinct > 1)
selec /= otherdistinct;
/*
- * Another cross-check: selectivity shouldn't be estimated as
- * more than the least common "most common value".
+ * Another cross-check: selectivity shouldn't be estimated as more
+ * than the least common "most common value".
*/
if (nnumbers > 0 && selec > numbers[nnumbers - 1])
selec = numbers[nnumbers - 1];
/*
* If we matched the var to a unique index, assume there is exactly one
- * match regardless of anything else. (This is slightly bogus, since
- * the index's equality operator might be different from ours, but it's
- * more likely to be right than ignoring the information.)
+ * match regardless of anything else. (This is slightly bogus, since the
+ * index's equality operator might be different from ours, but it's more
+ * likely to be right than ignoring the information.)
*/
if (vardata->isunique && vardata->rel && vardata->rel->tuples >= 1.0)
return 1.0 / vardata->rel->tuples;
* result averaged over all possible values whether common or
* uncommon. (Essentially, we are assuming that the not-yet-known
* comparison value is equally likely to be any of the possible
- * values, regardless of their frequency in the table. Is that a
- * good idea?)
+ * values, regardless of their frequency in the table. Is that a good
+ * idea?)
*/
selec = 1.0 - stats->stanullfrac;
ndistinct = get_variable_numdistinct(vardata);
selec /= ndistinct;
/*
- * Cross-check: selectivity should never be estimated as more than
- * the most common value's.
+ * Cross-check: selectivity should never be estimated as more than the
+ * most common value's.
*/
if (get_attstatsslot(vardata->statsTuple,
vardata->atttype, vardata->atttypmod,
* essentially using the histogram just as a representative sample. However,
* small histograms are unlikely to be all that representative, so the caller
* should be prepared to fall back on some other estimation approach when the
- * histogram is missing or very small. It may also be prudent to combine this
+ * histogram is missing or very small. It may also be prudent to combine this
* approach with another one when the histogram is small.
*
* If the actual histogram size is not at least min_hist_size, we won't bother
* selectivity of the fixed prefix and remainder of pattern
* separately, then combine the two to get an estimate of the
* selectivity for the part of the column population represented by
- * the histogram. (For small histograms, we combine these approaches.)
+ * the histogram. (For small histograms, we combine these
+ * approaches.)
*
* We then add up data for any most-common-values values; these are
* not in the histogram population, and we can get exact answers for
restsel = pattern_selectivity(rest, ptype);
heursel = prefixsel * restsel;
- if (selec < 0) /* fewer than 10 histogram entries? */
+ if (selec < 0) /* fewer than 10 histogram entries? */
selec = heursel;
else
{
* histogram and heuristic selectivities, putting increasingly
* more trust in the histogram for larger sizes.
*/
- double hist_weight = hist_size / 100.0;
+ double hist_weight = hist_size / 100.0;
selec = selec * hist_weight + heursel * (1.0 - hist_weight);
}
/*
* Decide if it's a join clause. This should match clausesel.c's
- * treat_as_join_clause(), except that we intentionally consider only
- * the leading columns and not the rest of the clause.
+ * treat_as_join_clause(), except that we intentionally consider only the
+ * leading columns and not the rest of the clause.
*/
if (varRelid != 0)
{
/*
- * Caller is forcing restriction mode (eg, because we are examining
- * an inner indexscan qual).
+ * Caller is forcing restriction mode (eg, because we are examining an
+ * inner indexscan qual).
*/
is_join_clause = false;
}
else if (sjinfo == NULL)
{
/*
- * It must be a restriction clause, since it's being evaluated at
- * a scan node.
+ * It must be a restriction clause, since it's being evaluated at a
+ * scan node.
*/
is_join_clause = false;
}
PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);
Oid operator = PG_GETARG_OID(1);
List *args = (List *) PG_GETARG_POINTER(2);
+
#ifdef NOT_USED
JoinType jointype = (JoinType) PG_GETARG_INT16(3);
#endif
* end up with the same answer anyway.
*
* An additional hack we use here is to clamp the nd1 and nd2 values
- * to not more than what we are estimating the input relation sizes
- * to be, providing a crude correction for the selectivity of
- * restriction clauses on those relations. (We don't do that in the
- * other path since there we are comparing the nd values to stats for
- * the whole relations.)
+ * to not more than what we are estimating the input relation sizes to
+ * be, providing a crude correction for the selectivity of restriction
+ * clauses on those relations. (We don't do that in the other path
+ * since there we are comparing the nd values to stats for the whole
+ * relations.)
*/
double nullfrac1 = stats1 ? stats1->stanullfrac : 0.0;
double nullfrac2 = stats2 ? stats2->stanullfrac : 0.0;
/*
* Now we need to estimate the fraction of relation 1 that has at
- * least one join partner. We know for certain that the matched
- * MCVs do, so that gives us a lower bound, but we're really in the
- * dark about everything else. Our crude approach is: if nd1 <= nd2
- * then assume all non-null rel1 rows have join partners, else assume
- * for the uncertain rows that a fraction nd2/nd1 have join partners.
- * We can discount the known-matched MCVs from the distinct-values
- * counts before doing the division.
+ * least one join partner. We know for certain that the matched MCVs
+ * do, so that gives us a lower bound, but we're really in the dark
+ * about everything else. Our crude approach is: if nd1 <= nd2 then
+ * assume all non-null rel1 rows have join partners, else assume for
+ * the uncertain rows that a fraction nd2/nd1 have join partners. We
+ * can discount the known-matched MCVs from the distinct-values counts
+ * before doing the division.
*/
nd1 -= nmatches;
nd2 -= nmatches;
selec = Max(matchfreq1, 1.0 - nullfrac1);
else
{
- double uncertain = 1.0 - matchfreq1 - nullfrac1;
+ double uncertain = 1.0 - matchfreq1 - nullfrac1;
CLAMP_PROBABILITY(uncertain);
- selec = matchfreq1 + (nd2/nd1) * uncertain;
+ selec = matchfreq1 + (nd2 / nd1) * uncertain;
}
}
else
if (nd1 <= nd2 || nd2 <= 0)
selec = 1.0 - nullfrac1;
else
- selec = (nd2/nd1) * (1.0 - nullfrac1);
+ selec = (nd2 / nd1) * (1.0 - nullfrac1);
}
if (have_mcvs1)
* Look up the various operators we need. If we don't find them all, it
* probably means the opfamily is broken, but we just fail silently.
*
- * Note: we expect that pg_statistic histograms will be sorted by the
- * '<' operator, regardless of which sort direction we are considering.
+ * Note: we expect that pg_statistic histograms will be sorted by the '<'
+ * operator, regardless of which sort direction we are considering.
*/
switch (strategy)
{
/*
* Only one of the two "end" fractions can really be less than 1.0;
- * believe the smaller estimate and reset the other one to exactly 1.0.
- * If we get exactly equal estimates (as can easily happen with
- * self-joins), believe neither.
+ * believe the smaller estimate and reset the other one to exactly 1.0. If
+ * we get exactly equal estimates (as can easily happen with self-joins),
+ * believe neither.
*/
if (*leftend > *rightend)
*leftend = 1.0;
*leftend = *rightend = 1.0;
/*
- * Also, the fraction of the left variable that will be scanned before
- * the first join pair is found is the fraction that's < the right-side
+ * Also, the fraction of the left variable that will be scanned before the
+ * first join pair is found is the fraction that's < the right-side
* minimum value. But only believe non-default estimates, else stick with
* our own default.
*/
/*
* Only one of the two "start" fractions can really be more than zero;
- * believe the larger estimate and reset the other one to exactly 0.0.
- * If we get exactly equal estimates (as can easily happen with
- * self-joins), believe neither.
+ * believe the larger estimate and reset the other one to exactly 0.0. If
+ * we get exactly equal estimates (as can easily happen with self-joins),
+ * believe neither.
*/
if (*leftstart < *rightstart)
*leftstart = 0.0;
/*
* If the sort order is nulls-first, we're going to have to skip over any
- * nulls too. These would not have been counted by scalarineqsel, and
- * we can safely add in this fraction regardless of whether we believe
+ * nulls too. These would not have been counted by scalarineqsel, and we
+ * can safely add in this fraction regardless of whether we believe
* scalarineqsel's results or not. But be sure to clamp the sum to 1.0!
*/
if (nulls_first)
* is as follows:
* 1. Expressions yielding boolean are assumed to contribute two groups,
* independently of their content, and are ignored in the subsequent
- * steps. This is mainly because tests like "col IS NULL" break the
+ * steps. This is mainly because tests like "col IS NULL" break the
* heuristic used in step 2 especially badly.
* 2. Reduce the given expressions to a list of unique Vars used. For
* example, GROUP BY a, a + b is treated the same as GROUP BY a, b.
Assert(groupExprs != NIL);
/*
- * Count groups derived from boolean grouping expressions. For other
+ * Count groups derived from boolean grouping expressions. For other
* expressions, find the unique Vars used, treating an expression as a Var
* if we can find stats for it. For each one, record the statistical
* estimate of number of distinct values (total in its table, without
#if _MSC_VER == 1400 /* VS.Net 2005 */
/*
- * http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=99694
+ *
+ * http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?
+ * FeedbackID=99694
*/
{
char x[1];
if (vardata1->rel &&
bms_is_subset(vardata1->rel->relids, sjinfo->syn_righthand))
- *join_is_reversed = true; /* var1 is on RHS */
+ *join_is_reversed = true; /* var1 is on RHS */
else if (vardata2->rel &&
bms_is_subset(vardata2->rel->relids, sjinfo->syn_lefthand))
- *join_is_reversed = true; /* var2 is on LHS */
+ *join_is_reversed = true; /* var2 is on LHS */
else
*join_is_reversed = false;
}
(*get_relation_stats_hook) (root, rte, var->varattno, vardata))
{
/*
- * The hook took control of acquiring a stats tuple. If it
- * did supply a tuple, it'd better have supplied a freefunc.
+ * The hook took control of acquiring a stats tuple. If it did
+ * supply a tuple, it'd better have supplied a freefunc.
*/
if (HeapTupleIsValid(vardata->statsTuple) &&
!vardata->freefunc)
/*
* Has it got stats? We only consider stats for
- * non-partial indexes, since partial indexes
- * probably don't reflect whole-relation statistics;
- * the above check for uniqueness is the only info
- * we take from a partial index.
+ * non-partial indexes, since partial indexes probably
+ * don't reflect whole-relation statistics; the above
+ * check for uniqueness is the only info we take from
+ * a partial index.
*
* An index stats hook, however, must make its own
* decisions about what to do with partial indexes.
{
vardata->statsTuple =
SearchSysCache(STATRELATT,
- ObjectIdGetDatum(index->indexoid),
+ ObjectIdGetDatum(index->indexoid),
Int16GetDatum(pos + 1),
0, 0);
vardata->freefunc = ReleaseSysCache;
/*
* If there is a unique index for the variable, assume it is unique no
- * matter what pg_statistic says; the statistics could be out of date,
- * or we might have found a partial unique index that proves the var
- * is unique for this query.
+ * matter what pg_statistic says; the statistics could be out of date, or
+ * we might have found a partial unique index that proves the var is
+ * unique for this query.
*/
if (vardata->isunique)
stadistinct = -1.0;
Oid cmpopr;
FmgrInfo opproc;
Const *greaterstrcon;
- Selectivity eq_sel;
+ Selectivity eq_sel;
cmpopr = get_opfamily_member(opfamily, vartype, vartype,
BTGreaterEqualStrategyNumber);
}
/*
- * If the prefix is long then the two bounding values might be too
- * close together for the histogram to distinguish them usefully,
- * resulting in a zero estimate (plus or minus roundoff error).
- * To avoid returning a ridiculously small estimate, compute the
- * estimated selectivity for "variable = 'foo'", and clamp to that.
- * (Obviously, the resultant estimate should be at least that.)
+ * If the prefix is long then the two bounding values might be too close
+ * together for the histogram to distinguish them usefully, resulting in a
+ * zero estimate (plus or minus roundoff error). To avoid returning a
+ * ridiculously small estimate, compute the estimated selectivity for
+ * "variable = 'foo'", and clamp to that. (Obviously, the resultant
+ * estimate should be at least that.)
*
* We apply this even if we couldn't make a greater string. That case
* suggests that the prefix is near the maximum possible, and thus
- * probably off the end of the histogram, and thus we probably got a
- * very small estimate from the >= condition; so we still need to clamp.
+ * probably off the end of the histogram, and thus we probably got a very
+ * small estimate from the >= condition; so we still need to clamp.
*/
cmpopr = get_opfamily_member(opfamily, vartype, vartype,
BTEqualStrategyNumber);
/* Set at postmaster start */
TimestampTz PgStartTime;
+
/* Set at configuration reload */
TimestampTz PgReloadTime;
typedef struct
{
- TimestampTz current;
- TimestampTz finish;
+ TimestampTz current;
+ TimestampTz finish;
Interval step;
int step_sign;
} generate_series_timestamptz_fctx;
/* if those functions think it's a bad format, try ISO8601 style */
if (dterr == DTERR_BAD_FORMAT)
- dterr = DecodeISO8601Interval(str,
+ dterr = DecodeISO8601Interval(str,
&dtype, tm, &fsec);
if (dterr != 0)
tl = ArrayGetIntegerTypmods(ta, &n);
/*
- * tl[0] - interval range (fields bitmask) tl[1] - precision (optional)
+ * tl[0] - interval range (fields bitmask) tl[1] - precision (optional)
*
* Note we must validate tl[0] even though it's normally guaranteed
* correct by the grammar --- consider SELECT 'foo'::"interval"(1000).
int precision = INTERVAL_PRECISION(typmod);
/*
- * Our interpretation of intervals with a limited set of fields
- * is that fields to the right of the last one specified are zeroed
- * out, but those to the left of it remain valid. Thus for example
- * there is no operational difference between INTERVAL YEAR TO MONTH
- * and INTERVAL MONTH. In some cases we could meaningfully enforce
- * that higher-order fields are zero; for example INTERVAL DAY could
- * reject nonzero "month" field. However that seems a bit pointless
- * when we can't do it consistently. (We cannot enforce a range limit
- * on the highest expected field, since we do not have any equivalent
- * of SQL's <interval leading field precision>.)
+ * Our interpretation of intervals with a limited set of fields is
+ * that fields to the right of the last one specified are zeroed out,
+ * but those to the left of it remain valid. Thus for example there
+ * is no operational difference between INTERVAL YEAR TO MONTH and
+ * INTERVAL MONTH. In some cases we could meaningfully enforce that
+ * higher-order fields are zero; for example INTERVAL DAY could reject
+ * nonzero "month" field. However that seems a bit pointless when we
+ * can't do it consistently. (We cannot enforce a range limit on the
+ * highest expected field, since we do not have any equivalent of
+ * SQL's <interval leading field precision>.)
*
* Note: before PG 8.4 we interpreted a limited set of fields as
* actually causing a "modulo" operation on a given value, potentially
- * losing high-order as well as low-order information. But there is
+ * losing high-order as well as low-order information. But there is
* no support for such behavior in the standard, and it seems fairly
- * undesirable on data consistency grounds anyway. Now we only
+ * undesirable on data consistency grounds anyway. Now we only
* perform truncation or rounding of low-order fields.
*/
if (range == INTERVAL_FULL_RANGE)
strcpy(str, EARLY);
else if (TIMESTAMP_IS_NOEND(dt))
strcpy(str, LATE);
- else /* shouldn't happen */
+ else /* shouldn't happen */
elog(ERROR, "invalid argument for EncodeSpecialTimestamp");
}
PG_RETURN_TIMESTAMPTZ(timestamp);
/*
- * Look up the requested timezone. First we look in the date token table
+ * Look up the requested timezone. First we look in the date token table
* (to handle cases like "EST"), and if that fails, we look in the
* timezone database (to handle cases like "America/New_York"). (This
* matches the order in which timestamp input checks the cases; it's
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("time zone \"%s\" not recognized", tzname)));
- result = 0; /* keep compiler quiet */
+ result = 0; /* keep compiler quiet */
}
}
PG_RETURN_TIMESTAMP(timestamp);
/*
- * Look up the requested timezone. First we look in the date token table
+ * Look up the requested timezone. First we look in the date token table
* (to handle cases like "EST"), and if that fails, we look in the
* timezone database (to handle cases like "America/New_York"). (This
* matches the order in which timestamp input checks the cases; it's
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("time zone \"%s\" not recognized", tzname)));
- result = 0; /* keep compiler quiet */
+ result = 0; /* keep compiler quiet */
}
}
{
FuncCallContext *funcctx;
generate_series_timestamp_fctx *fctx;
- Timestamp result;
+ Timestamp result;
/* stuff done only on the first call of the function */
if (SRF_IS_FIRSTCALL())
{
- Timestamp start = PG_GETARG_TIMESTAMP(0);
- Timestamp finish = PG_GETARG_TIMESTAMP(1);
- Interval *step = PG_GETARG_INTERVAL_P(2);
+ Timestamp start = PG_GETARG_TIMESTAMP(0);
+ Timestamp finish = PG_GETARG_TIMESTAMP(1);
+ Interval *step = PG_GETARG_INTERVAL_P(2);
MemoryContext oldcontext;
- Interval interval_zero;
+ Interval interval_zero;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
{
/* increment current in preparation for next iteration */
fctx->current = DatumGetTimestamp(
- DirectFunctionCall2(timestamp_pl_interval,
- TimestampGetDatum(fctx->current),
- PointerGetDatum(&fctx->step)));
+ DirectFunctionCall2(timestamp_pl_interval,
+ TimestampGetDatum(fctx->current),
+ PointerGetDatum(&fctx->step)));
/* do when there is more left to send */
SRF_RETURN_NEXT(funcctx, TimestampGetDatum(result));
{
TimestampTz start = PG_GETARG_TIMESTAMPTZ(0);
TimestampTz finish = PG_GETARG_TIMESTAMPTZ(1);
- Interval *step = PG_GETARG_INTERVAL_P(2);
+ Interval *step = PG_GETARG_INTERVAL_P(2);
MemoryContext oldcontext;
- Interval interval_zero;
+ Interval interval_zero;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
{
/* increment current in preparation for next iteration */
fctx->current = DatumGetTimestampTz(
- DirectFunctionCall2(timestamptz_pl_interval,
- TimestampTzGetDatum(fctx->current),
- PointerGetDatum(&fctx->step)));
+ DirectFunctionCall2(timestamptz_pl_interval,
+ TimestampTzGetDatum(fctx->current),
+ PointerGetDatum(&fctx->step)));
/* do when there is more left to send */
SRF_RETURN_NEXT(funcctx, TimestampTzGetDatum(result));
/*-------------------------------------------------------------------------
*
* trigfuncs.c
- * Builtin functions for useful trigger support.
+ * Builtin functions for useful trigger support.
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
Datum
suppress_redundant_updates_trigger(PG_FUNCTION_ARGS)
{
- TriggerData *trigdata = (TriggerData *) fcinfo->context;
- HeapTuple newtuple, oldtuple, rettuple;
- HeapTupleHeader newheader, oldheader;
+ TriggerData *trigdata = (TriggerData *) fcinfo->context;
+ HeapTuple newtuple,
+ oldtuple,
+ rettuple;
+ HeapTupleHeader newheader,
+ oldheader;
- /* make sure it's called as a trigger */
- if (!CALLED_AS_TRIGGER(fcinfo))
- ereport(ERROR,
+ /* make sure it's called as a trigger */
+ if (!CALLED_AS_TRIGGER(fcinfo))
+ ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("suppress_redundant_updates_trigger: must be called as trigger")));
-
- /* and that it's called on update */
- if (! TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
- ereport(ERROR,
+
+ /* and that it's called on update */
+ if (!TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
+ ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("suppress_redundant_updates_trigger: must be called on update")));
- /* and that it's called before update */
- if (! TRIGGER_FIRED_BEFORE(trigdata->tg_event))
- ereport(ERROR,
+ /* and that it's called before update */
+ if (!TRIGGER_FIRED_BEFORE(trigdata->tg_event))
+ ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("suppress_redundant_updates_trigger: must be called before update")));
- /* and that it's called for each row */
- if (! TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
- ereport(ERROR,
+ /* and that it's called for each row */
+ if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
+ ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("suppress_redundant_updates_trigger: must be called for each row")));
/* get tuple data, set default result */
- rettuple = newtuple = trigdata->tg_newtuple;
+ rettuple = newtuple = trigdata->tg_newtuple;
oldtuple = trigdata->tg_trigtuple;
newheader = newtuple->t_data;
oldheader = oldtuple->t_data;
/*
- * We are called before the OID, if any, has been transcribed from the
- * old tuple to the new (in heap_update). To avoid a bogus compare
- * failure, copy the OID now. But check that someone didn't already put
- * another OID value into newtuple. (That's not actually possible at
- * present, but maybe someday.)
+ * We are called before the OID, if any, has been transcribed from the old
+ * tuple to the new (in heap_update). To avoid a bogus compare failure,
+ * copy the OID now. But check that someone didn't already put another
+ * OID value into newtuple. (That's not actually possible at present, but
+ * maybe someday.)
*/
- if (trigdata->tg_relation->rd_rel->relhasoids &&
+ if (trigdata->tg_relation->rd_rel->relhasoids &&
!OidIsValid(HeapTupleHeaderGetOid(newheader)))
HeapTupleHeaderSetOid(newheader, HeapTupleHeaderGetOid(oldheader));
/* if the tuple payload is the same ... */
- if (newtuple->t_len == oldtuple->t_len &&
+ if (newtuple->t_len == oldtuple->t_len &&
newheader->t_hoff == oldheader->t_hoff &&
- (HeapTupleHeaderGetNatts(newheader) ==
+ (HeapTupleHeaderGetNatts(newheader) ==
HeapTupleHeaderGetNatts(oldheader)) &&
- ((newheader->t_infomask & ~HEAP_XACT_MASK) ==
+ ((newheader->t_infomask & ~HEAP_XACT_MASK) ==
(oldheader->t_infomask & ~HEAP_XACT_MASK)) &&
- memcmp(((char *)newheader) + offsetof(HeapTupleHeaderData, t_bits),
- ((char *)oldheader) + offsetof(HeapTupleHeaderData, t_bits),
+ memcmp(((char *) newheader) + offsetof(HeapTupleHeaderData, t_bits),
+ ((char *) oldheader) + offsetof(HeapTupleHeaderData, t_bits),
newtuple->t_len - offsetof(HeapTupleHeaderData, t_bits)) == 0)
{
/* ... then suppress the update */
Datum
gin_cmp_tslexeme(PG_FUNCTION_ARGS)
{
- text *a = PG_GETARG_TEXT_PP(0);
- text *b = PG_GETARG_TEXT_PP(1);
- int cmp;
+ text *a = PG_GETARG_TEXT_PP(0);
+ text *b = PG_GETARG_TEXT_PP(1);
+ int cmp;
cmp = tsCompareString(
- VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
- VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
- false );
+ VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
+ VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
+ false);
- PG_FREE_IF_COPY(a,0);
- PG_FREE_IF_COPY(b,1);
- PG_RETURN_INT32( cmp );
+ PG_FREE_IF_COPY(a, 0);
+ PG_FREE_IF_COPY(b, 1);
+ PG_RETURN_INT32(cmp);
}
Datum
gin_cmp_prefix(PG_FUNCTION_ARGS)
{
- text *a = PG_GETARG_TEXT_PP(0);
- text *b = PG_GETARG_TEXT_PP(1);
+ text *a = PG_GETARG_TEXT_PP(0);
+ text *b = PG_GETARG_TEXT_PP(1);
+
#ifdef NOT_USED
StrategyNumber strategy = PG_GETARG_UINT16(2);
- Pointer extra_data = PG_GETARG_POINTER(3);
+ Pointer extra_data = PG_GETARG_POINTER(3);
#endif
- int cmp;
+ int cmp;
cmp = tsCompareString(
- VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
- VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
- true );
+ VARDATA_ANY(a), VARSIZE_ANY_EXHDR(a),
+ VARDATA_ANY(b), VARSIZE_ANY_EXHDR(b),
+ true);
- if ( cmp < 0 )
- cmp = 1; /* prevent continue scan */
+ if (cmp < 0)
+ cmp = 1; /* prevent continue scan */
- PG_FREE_IF_COPY(a,0);
- PG_FREE_IF_COPY(b,1);
- PG_RETURN_INT32( cmp );
+ PG_FREE_IF_COPY(a, 0);
+ PG_FREE_IF_COPY(b, 1);
+ PG_RETURN_INT32(cmp);
}
Datum
{
TSQuery query = PG_GETARG_TSQUERY(0);
int32 *nentries = (int32 *) PG_GETARG_POINTER(1);
+
/* StrategyNumber strategy = PG_GETARG_UINT16(2); */
- bool **ptr_partialmatch = (bool**) PG_GETARG_POINTER(3);
- Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
+ bool **ptr_partialmatch = (bool **) PG_GETARG_POINTER(3);
+ Pointer **extra_data = (Pointer **) PG_GETARG_POINTER(4);
Datum *entries = NULL;
- bool *partialmatch;
+ bool *partialmatch;
*nentries = 0;
j = 0,
len;
QueryItem *item;
- bool use_fullscan=false;
+ bool use_fullscan = false;
int *map_item_operand;
item = clean_NOT(GETQUERY(query), &len);
(*nentries)++;
entries = (Datum *) palloc(sizeof(Datum) * (*nentries));
- partialmatch = *ptr_partialmatch = (bool*) palloc(sizeof(bool) * (*nentries));
+ partialmatch = *ptr_partialmatch = (bool *) palloc(sizeof(bool) * (*nentries));
/*
- * Make map to convert item's number to corresponding
- * operand's (the same, entry's) number. Entry's number
- * is used in check array in consistent method. We use
- * the same map for each entry.
+ * Make map to convert item's number to corresponding operand's (the
+ * same, entry's) number. Entry's number is used in check array in
+ * consistent method. We use the same map for each entry.
*/
- *extra_data = (Pointer*) palloc0(sizeof(Pointer)*(*nentries));
+ *extra_data = (Pointer *) palloc0(sizeof(Pointer) * (*nentries));
map_item_operand = palloc0(sizeof(int) * (query->size + 1));
for (i = 0; i < query->size; i++)
txt = cstring_to_text_with_len(GETOPERAND(query) + val->distance,
val->length);
- (*extra_data)[j] = (Pointer)map_item_operand;
+ (*extra_data)[j] = (Pointer) map_item_operand;
map_item_operand[i] = j;
partialmatch[j] = val->prefix;
entries[j++] = PointerGetDatum(txt);
}
- if ( use_fullscan )
+ if (use_fullscan)
{
- (*extra_data)[j] = (Pointer)map_item_operand;
+ (*extra_data)[j] = (Pointer) map_item_operand;
map_item_operand[i] = j;
entries[j++] = PointerGetDatum(cstring_to_text_with_len("", 0));
}
*(gcv->need_recheck) = true;
/* convert item's number to corresponding entry's (operand's) number */
- j = gcv->map_item_operand[ ((QueryItem *) val) - gcv->first_item ];
+ j = gcv->map_item_operand[((QueryItem *) val) - gcv->first_item];
/* return presence of current entry in indexed value */
return gcv->check[j];
gin_tsquery_consistent(PG_FUNCTION_ARGS)
{
bool *check = (bool *) PG_GETARG_POINTER(0);
+
/* StrategyNumber strategy = PG_GETARG_UINT16(1); */
TSQuery query = PG_GETARG_TSQUERY(2);
+
/* int32 nkeys = PG_GETARG_INT32(3); */
- Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
+ Pointer *extra_data = (Pointer *) PG_GETARG_POINTER(4);
bool *recheck = (bool *) PG_GETARG_POINTER(5);
bool res = FALSE;
*/
gcv.first_item = item = GETQUERY(query);
gcv.check = check;
- gcv.map_item_operand = (int*)(extra_data[0]);
+ gcv.map_item_operand = (int *) (extra_data[0]);
gcv.need_recheck = recheck;
res = TS_execute(
/* Loop invariant: StopLow <= val < StopHigh */
- /*
- * we are not able to find a a prefix by hash value
+ /*
+ * we are not able to find a a prefix by hash value
*/
- if ( val->prefix )
+ if (val->prefix)
return true;
while (StopLow < StopHigh)
static bool
checkcondition_bit(void *checkval, QueryOperand *val)
{
- /*
- * we are not able to find a a prefix in signature tree
+ /*
+ * we are not able to find a a prefix in signature tree
*/
- if ( val->prefix )
- return true;
+ if (val->prefix)
+ return true;
return GETBIT(checkval, HASHVAL(val->valcrc));
}
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TSQuery query = PG_GETARG_TSQUERY(1);
+
/* StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); */
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
#define WAITSINGLEOPERAND 4
/*
- * subroutine to parse the modifiers (weight and prefix flag currently)
+ * subroutine to parse the modifiers (weight and prefix flag currently)
* part, like ':1AB' of a query.
*/
static char *
{
*(in->cur) = ':';
in->cur++;
- if ( curpol->prefix )
+ if (curpol->prefix)
{
*(in->cur) = '*';
in->cur++;
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
TSQuery query = PG_GETARG_TSQUERY(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
+
/* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4);
- TSQuerySign key = DatumGetTSQuerySign(entry->key);
+ TSQuerySign key = DatumGetTSQuerySign(entry->key);
TSQuerySign sq = makeTSQuerySign(query);
bool retval;
PG_FREE_IF_COPY(b,1); \
\
PG_RETURN_BOOL( CONDITION ); \
-} \
+} \
/* keep compiler quiet - no extra ; */ \
extern int no_such_variable
return (ao->valcrc > bo->valcrc) ? -1 : 1;
}
- return tsCompareString( an->word, ao->length, bn->word, bo->length, false);
+ return tsCompareString(an->word, ao->length, bn->word, bo->length, false);
}
}
}
-#define WordECompareQueryItem(e,q,p,i,m) \
+#define WordECompareQueryItem(e,q,p,i,m) \
tsCompareString((q) + (i)->distance, (i)->length, \
- (e) + (p)->pos, (p)->len, (m))
+ (e) + (p)->pos, (p)->len, (m))
/*
WordEntry *StopMiddle = StopHigh;
int difference;
- *nitem=0;
+ *nitem = 0;
/* Loop invariant: StopLow <= item < StopHigh */
while (StopLow < StopHigh)
if (difference == 0)
{
StopHigh = StopMiddle;
- *nitem=1;
+ *nitem = 1;
break;
}
else if (difference > 0)
StopHigh = StopMiddle;
}
- if ( item->prefix == true )
+ if (item->prefix == true)
{
- if ( StopLow >= StopHigh )
+ if (StopLow >= StopHigh)
StopMiddle = StopHigh;
- *nitem=0;
+ *nitem = 0;
- while( StopMiddle < (WordEntry *) STRPTR(t) &&
- WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0 )
+ while (StopMiddle < (WordEntry *) STRPTR(t) &&
+ WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0)
{
(*nitem)++;
StopMiddle++;
}
}
- return ( *nitem > 0 ) ? StopHigh : NULL;
+ return (*nitem > 0) ? StopHigh : NULL;
}
if (!entry)
continue;
- while( entry - firstentry < nitem )
+ while (entry - firstentry < nitem)
{
if (entry->haspos)
pos[i] = _POSVECPTR(t, entry);
if (dist || (dist == 0 && (pos[i] == &POSNULL || pos[k] == &POSNULL)))
{
float curw;
-
+
if (!dist)
dist = MAXENTRYPOS;
curw = sqrt(wpos(post[l]) * wpos(ct[p]) * word_distance(dist));
if (!entry)
continue;
- while( entry - firstentry < nitem )
+ while (entry - firstentry < nitem)
{
if (entry->haspos)
{
if (!entry)
continue;
- while( entry - firstentry < nitem )
+ while (entry - firstentry < nitem)
{
if (entry->haspos)
{
if (j == 0)
{
int k;
-
+
doc[cur].nitem = 0;
doc[cur].item = (QueryItem **) palloc(sizeof(QueryItem *) * qr->query->size);
-
+
for (k = 0; k < qr->query->size; k++)
{
QueryOperand *kptr = &item[k].operand;
QueryOperand *iptr = &item[i].operand;
-
+
if (k == i ||
(item[k].type == QI_VAL &&
compareQueryOperand(&kptr, &iptr, operand) == 0))
{
/*
- * if k == i, we've already checked above that it's
- * type == Q_VAL
+ * if k == i, we've already checked above that
+ * it's type == Q_VAL
*/
doc[cur].item[doc[cur].nitem] = item + k;
doc[cur].nitem++;
const WordEntryIN *b = (const WordEntryIN *) vb;
char *BufferStr = (char *) arg;
- return tsCompareString( &BufferStr[a->entry.pos], a->entry.len,
- &BufferStr[b->entry.pos], b->entry.len,
- false );
+ return tsCompareString(&BufferStr[a->entry.pos], a->entry.len,
+ &BufferStr[b->entry.pos], b->entry.len,
+ false);
}
/*
if (cur - tmpbuf > MAXSTRPOS)
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("string is too long for tsvector (%ld bytes, max %ld bytes)",
+ errmsg("string is too long for tsvector (%ld bytes, max %ld bytes)",
(long) (cur - tmpbuf), (long) MAXSTRPOS)));
/*
SET_VARSIZE(vec, hdrlen + datalen);
if (needSort)
- qsort_arg((void *) ARRPTR(vec), vec->size, sizeof(WordEntry),
- compareentry, (void*)STRPTR(vec));
+ qsort_arg((void *) ARRPTR(vec), vec->size, sizeof(WordEntry),
+ compareentry, (void *) STRPTR(vec));
PG_RETURN_TSVECTOR(vec);
}
typedef struct StatEntry
{
- uint32 ndoc; /* zero indicates that we already was here while
- walking throug the tree */
+ uint32 ndoc; /* zero indicates that we already was here
+ * while walking throug the tree */
uint32 nentry;
struct StatEntry *left;
struct StatEntry *right;
int4 weight;
uint32 maxdepth;
-
- StatEntry **stack;
+
+ StatEntry **stack;
uint32 stackpos;
- StatEntry* root;
+ StatEntry *root;
} TSVectorStat;
#define STATHDRSIZE (offsetof(TSVectorStat, data))
{
return (aptr->haspos > bptr->haspos) ? -1 : 1;
}
- else if ( (res=tsCompareString( STRPTR(a) + aptr->pos, aptr->len, STRPTR(b) + bptr->pos, bptr->len, false)) !=0 )
+ else if ((res = tsCompareString(STRPTR(a) + aptr->pos, aptr->len, STRPTR(b) + bptr->pos, bptr->len, false)) != 0)
{
return res;
}
PG_FREE_IF_COPY(a,0); \
PG_FREE_IF_COPY(b,1); \
PG_RETURN_##ret( res action 0 ); \
-} \
+} \
/* keep compiler quiet - no extra ; */ \
extern int no_such_variable
}
/*
- * Compare two strings by tsvector rules.
+ * Compare two strings by tsvector rules.
* if isPrefix = true then it returns not-zero value if b has prefix a
*/
int4
tsCompareString(char *a, int lena, char *b, int lenb, bool prefix)
{
- int cmp;
+ int cmp;
- if ( lena == 0 )
+ if (lena == 0)
{
- if ( prefix )
- cmp = 0; /* emtry string is equal to any if a prefix match */
+ if (prefix)
+ cmp = 0; /* emtry string is equal to any if a prefix
+ * match */
else
- cmp = (lenb>0) ? -1 : 0;
+ cmp = (lenb > 0) ? -1 : 0;
}
- else if ( lenb == 0 )
+ else if (lenb == 0)
{
- cmp = (lena>0) ? 1 : 0;
+ cmp = (lena > 0) ? 1 : 0;
}
else
{
cmp = memcmp(a, b, Min(lena, lenb));
- if ( prefix )
+ if (prefix)
{
- if ( cmp == 0 && lena > lenb )
+ if (cmp == 0 && lena > lenb)
{
/*
* b argument is not beginning with argument a
*/
- cmp=1;
+ cmp = 1;
}
}
- else if ( (cmp == 0) && (lena != lenb) )
+ else if ((cmp == 0) && (lena != lenb))
{
cmp = (lena < lenb) ? -1 : 1;
}
WordEntry *StopLow = chkval->arrb;
WordEntry *StopHigh = chkval->arre;
WordEntry *StopMiddle = StopHigh;
- int difference = -1;
- bool res=false;
+ int difference = -1;
+ bool res = false;
/* Loop invariant: StopLow <= val < StopHigh */
while (StopLow < StopHigh)
{
StopMiddle = StopLow + (StopHigh - StopLow) / 2;
- difference = tsCompareString( chkval->operand + val->distance, val->length,
- chkval->values + StopMiddle->pos, StopMiddle->len,
- false);
+ difference = tsCompareString(chkval->operand + val->distance, val->length,
+ chkval->values + StopMiddle->pos, StopMiddle->len,
+ false);
if (difference == 0)
{
StopHigh = StopMiddle;
}
- if ( res == false && val->prefix == true )
+ if (res == false && val->prefix == true)
{
/*
* there was a failed exact search, so we should scan further to find
* a prefix match.
*/
- if ( StopLow >= StopHigh )
+ if (StopLow >= StopHigh)
StopMiddle = StopHigh;
- while( res == false && StopMiddle < chkval->arre &&
- tsCompareString( chkval->operand + val->distance, val->length,
- chkval->values + StopMiddle->pos, StopMiddle->len,
- true) == 0 )
+ while (res == false && StopMiddle < chkval->arre &&
+ tsCompareString(chkval->operand + val->distance, val->length,
+ chkval->values + StopMiddle->pos, StopMiddle->len,
+ true) == 0)
{
res = (val->weight && StopMiddle->haspos) ?
checkclass_str(chkval, StopMiddle, val) : true;
}
}
- return res;
+ return res;
}
/*
return num;
}
-#define compareStatWord(a,e,t) \
+#define compareStatWord(a,e,t) \
tsCompareString((a)->lexeme, (a)->lenlexeme, \
STRPTR(t) + (e)->pos, (e)->len, \
false)
static void
insertStatEntry(MemoryContext persistentContext, TSVectorStat *stat, TSVector txt, uint32 off)
{
- WordEntry *we = ARRPTR(txt) + off;
- StatEntry *node = stat->root,
- *pnode=NULL;
+ WordEntry *we = ARRPTR(txt) + off;
+ StatEntry *node = stat->root,
+ *pnode = NULL;
int n,
res = 0;
- uint32 depth=1;
+ uint32 depth = 1;
- if (stat->weight == 0)
+ if (stat->weight == 0)
n = (we->haspos) ? POSDATALEN(txt, we) : 1;
else
n = (we->haspos) ? check_weight(txt, we, stat->weight) : 0;
- if ( n == 0 )
- return; /* nothing to insert */
+ if (n == 0)
+ return; /* nothing to insert */
- while( node )
+ while (node)
{
res = compareStatWord(node, we, txt);
else
{
pnode = node;
- node = ( res < 0 ) ? node->left : node->right;
+ node = (res < 0) ? node->left : node->right;
}
depth++;
}
if (node == NULL)
{
- node = MemoryContextAlloc(persistentContext, STATENTRYHDRSZ + we->len );
+ node = MemoryContextAlloc(persistentContext, STATENTRYHDRSZ + we->len);
node->left = node->right = NULL;
node->ndoc = 1;
node->nentry = n;
node->lenlexeme = we->len;
memcpy(node->lexeme, STRPTR(txt) + we->pos, node->lenlexeme);
- if ( pnode==NULL )
+ if (pnode == NULL)
{
stat->root = node;
}
else
pnode->right = node;
}
-
+
}
else
{
}
static void
-chooseNextStatEntry(MemoryContext persistentContext, TSVectorStat *stat, TSVector txt,
- uint32 low, uint32 high, uint32 offset)
+chooseNextStatEntry(MemoryContext persistentContext, TSVectorStat *stat, TSVector txt,
+ uint32 low, uint32 high, uint32 offset)
{
- uint32 pos;
- uint32 middle = (low + high) >> 1;
+ uint32 pos;
+ uint32 middle = (low + high) >> 1;
pos = (low + middle) >> 1;
if (low != middle && pos >= offset && pos - offset < txt->size)
- insertStatEntry( persistentContext, stat, txt, pos - offset );
+ insertStatEntry(persistentContext, stat, txt, pos - offset);
pos = (high + middle + 1) >> 1;
if (middle + 1 != high && pos >= offset && pos - offset < txt->size)
- insertStatEntry( persistentContext, stat, txt, pos - offset );
+ insertStatEntry(persistentContext, stat, txt, pos - offset);
if (low != middle)
chooseNextStatEntry(persistentContext, stat, txt, low, middle, offset);
static TSVectorStat *
ts_accum(MemoryContext persistentContext, TSVectorStat *stat, Datum data)
{
- TSVector txt = DatumGetTSVector(data);
- uint32 i,
- nbit = 0,
- offset;
+ TSVector txt = DatumGetTSVector(data);
+ uint32 i,
+ nbit = 0,
+ offset;
if (stat == NULL)
- { /* Init in first */
+ { /* Init in first */
stat = MemoryContextAllocZero(persistentContext, sizeof(TSVectorStat));
stat->maxdepth = 1;
}
nbit = 1 << nbit;
offset = (nbit - txt->size) / 2;
- insertStatEntry( persistentContext, stat, txt, (nbit >> 1) - offset );
+ insertStatEntry(persistentContext, stat, txt, (nbit >> 1) - offset);
chooseNextStatEntry(persistentContext, stat, txt, 0, nbit, offset);
return stat;
ts_setup_firstcall(FunctionCallInfo fcinfo, FuncCallContext *funcctx,
TSVectorStat *stat)
{
- TupleDesc tupdesc;
- MemoryContext oldcontext;
- StatEntry *node;
+ TupleDesc tupdesc;
+ MemoryContext oldcontext;
+ StatEntry *node;
funcctx->user_fctx = (void *) stat;
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
stat->stack = palloc0(sizeof(StatEntry *) * (stat->maxdepth + 1));
- stat->stackpos = 0;
+ stat->stackpos = 0;
node = stat->root;
/* find leftmost value */
for (;;)
{
- stat->stack[ stat->stackpos ] = node;
+ stat->stack[stat->stackpos] = node;
if (node->left)
{
stat->stackpos++;
}
static StatEntry *
-walkStatEntryTree(TSVectorStat *stat)
+walkStatEntryTree(TSVectorStat *stat)
{
- StatEntry *node = stat->stack[ stat->stackpos ];
+ StatEntry *node = stat->stack[stat->stackpos];
- if ( node == NULL )
+ if (node == NULL)
return NULL;
- if ( node->ndoc != 0 )
+ if (node->ndoc != 0)
{
/* return entry itself: we already was at left sublink */
return node;
static Datum
ts_process_call(FuncCallContext *funcctx)
{
- TSVectorStat *st;
- StatEntry *entry;
+ TSVectorStat *st;
+ StatEntry *entry;
st = (TSVectorStat *) funcctx->user_fctx;
if (SRF_IS_FIRSTCALL())
{
- TSVectorStat *stat;
+ TSVectorStat *stat;
text *txt = PG_GETARG_TEXT_P(0);
funcctx = SRF_FIRSTCALL_INIT();
if (SRF_IS_FIRSTCALL())
{
- TSVectorStat *stat;
+ TSVectorStat *stat;
text *txt = PG_GETARG_TEXT_P(0);
text *ws = PG_GETARG_TEXT_P(1);
{
const char *src = source;
bool braces = false;
- int i;
+ int i;
if (src[0] == '{')
{
maxlen)));
}
- PG_RETURN_VARCHAR_P((VarChar *) cstring_to_text_with_len(s_data,
+ PG_RETURN_VARCHAR_P((VarChar *) cstring_to_text_with_len(s_data,
maxmblen));
}
int len2;
/* Skip table for Boyer-Moore-Horspool search algorithm: */
int skiptablemask; /* mask for ANDing with skiptable subscripts */
- int skiptable[256]; /* skip distance for given mismatched char */
+ int skiptable[256]; /* skip distance for given mismatched char */
} TextPositionState;
#define DatumGetUnknownP(X) ((unknown *) PG_DETOAST_DATUM(X))
if (tunpacked != t)
pfree(tunpacked);
-
+
return result;
}
dst_len--;
if (dst_len >= src_len)
dst_len = src_len;
- else /* ensure truncation is encoding-safe */
+ else /* ensure truncation is encoding-safe */
dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
dst[dst_len] = '\0';
char *inputText = PG_GETARG_CSTRING(0);
char *tp;
char *rp;
- int byte;
+ int byte;
bytea *result;
- for (byte = 0, tp = inputText; *tp != '\0'; byte++)
+ for (byte = 0, tp = inputText; *tp != '\0'; byte ++)
{
if (tp[0] != '\\')
tp++;
}
}
- byte += VARHDRSZ;
+ byte +=VARHDRSZ;
+
result = (bytea *) palloc(byte);
SET_VARSIZE(result, byte);
(tp[3] >= '0' && tp[3] <= '7'))
{
byte = VAL(tp[1]);
- byte <<= 3;
- byte += VAL(tp[2]);
- byte <<= 3;
- *rp++ = byte + VAL(tp[3]);
+ byte <<=3;
+ byte +=VAL(tp[2]);
+ byte <<=3;
+ *rp++ = byte +VAL(tp[3]);
+
tp += 4;
}
else if ((tp[0] == '\\') &&
* searched (t1) and the "needle" is the pattern being sought (t2).
*
* If the needle is empty or bigger than the haystack then there is no
- * point in wasting cycles initializing the table. We also choose not
- * to use B-M-H for needles of length 1, since the skip table can't
- * possibly save anything in that case.
+ * point in wasting cycles initializing the table. We also choose not to
+ * use B-M-H for needles of length 1, since the skip table can't possibly
+ * save anything in that case.
*/
if (len1 >= len2 && len2 > 1)
{
- int searchlength = len1 - len2;
- int skiptablemask;
- int last;
- int i;
+ int searchlength = len1 - len2;
+ int skiptablemask;
+ int last;
+ int i;
/*
* First we must determine how much of the skip table to use. The
* declaration of TextPositionState allows up to 256 elements, but for
* short search problems we don't really want to have to initialize so
* many elements --- it would take too long in comparison to the
- * actual search time. So we choose a useful skip table size based on
+ * actual search time. So we choose a useful skip table size based on
* the haystack length minus the needle length. The closer the needle
* length is to the haystack length the less useful skipping becomes.
*
state->skiptable[i] = len2;
/*
- * Now examine the needle. For each character except the last one,
+ * Now examine the needle. For each character except the last one,
* set the corresponding table element to the appropriate skip
* distance. Note that when two characters share the same skip table
- * entry, the one later in the needle must determine the skip distance.
+ * entry, the one later in the needle must determine the skip
+ * distance.
*/
last = len2 - 1;
if (needle_len == 1)
{
/* No point in using B-M-H for a one-character needle */
- char nchar = *needle;
+ char nchar = *needle;
hptr = &haystack[start_pos];
while (hptr < haystack_end)
p = hptr;
while (*nptr == *p)
{
- /* Matched it all? If so, return 1-based position */
+ /* Matched it all? If so, return 1-based position */
if (nptr == needle)
return p - haystack + 1;
nptr--, p--;
}
+
/*
* No match, so use the haystack char at hptr to decide how
- * far to advance. If the needle had any occurrence of that
+ * far to advance. If the needle had any occurrence of that
* character (or more precisely, one sharing the same
* skiptable entry) before its last character, then we advance
* far enough to align the last such needle character with
- * that haystack position. Otherwise we can advance by the
+ * that haystack position. Otherwise we can advance by the
* whole needle length.
*/
hptr += state->skiptable[(unsigned char) *hptr & skiptablemask];
p = hptr;
while (*nptr == *p)
{
- /* Matched it all? If so, return 1-based position */
+ /* Matched it all? If so, return 1-based position */
if (nptr == needle)
return p - haystack + 1;
nptr--, p--;
}
+
/*
* No match, so use the haystack char at hptr to decide how
- * far to advance. If the needle had any occurrence of that
+ * far to advance. If the needle had any occurrence of that
* character (or more precisely, one sharing the same
* skiptable entry) before its last character, then we advance
* far enough to align the last such needle character with
- * that haystack position. Otherwise we can advance by the
+ * that haystack position. Otherwise we can advance by the
* whole needle length.
*/
hptr += state->skiptable[*hptr & skiptablemask];
bytea *v = PG_GETARG_BYTEA_PP(0);
int32 n = PG_GETARG_INT32(1);
int len;
- int byte;
+ int byte;
len = VARSIZE_ANY_EXHDR(v);
int byteNo,
bitNo;
int len;
- int byte;
+ int byte;
len = VARSIZE_ANY_EXHDR(v);
byte = ((unsigned char *) VARDATA_ANY(v))[byteNo];
- if (byte & (1 << bitNo))
+ if (byte &(1 << bitNo))
PG_RETURN_INT32(1);
else
PG_RETURN_INT32(0);
*/
typedef struct rank_context
{
- int64 rank; /* current rank */
+ int64 rank; /* current rank */
} rank_context;
/*
*/
typedef struct
{
- int32 ntile; /* current result */
+ int32 ntile; /* current result */
int64 rows_per_bucket; /* row number of current bucket */
- int64 boundary; /* how many rows should be in the bucket */
- int64 remainder; /* (total rows) % (bucket num) */
+ int64 boundary; /* how many rows should be in the bucket */
+ int64 remainder; /* (total rows) % (bucket num) */
} ntile_context;
static bool rank_up(WindowObject winobj);
static Datum leadlag_common(FunctionCallInfo fcinfo,
- bool forward, bool withoffset, bool withdefault);
+ bool forward, bool withoffset, bool withdefault);
/*
Datum
window_row_number(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
+ WindowObject winobj = PG_WINDOW_OBJECT();
int64 curpos = WinGetCurrentPosition(winobj);
WinSetMarkPosition(winobj, curpos);
Datum
window_rank(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- rank_context *context;
- bool up;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ rank_context *context;
+ bool up;
up = rank_up(winobj);
context = (rank_context *)
Datum
window_dense_rank(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- rank_context *context;
- bool up;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ rank_context *context;
+ bool up;
up = rank_up(winobj);
context = (rank_context *)
Datum
window_percent_rank(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- rank_context *context;
- bool up;
- int64 totalrows = WinGetPartitionRowCount(winobj);
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ rank_context *context;
+ bool up;
+ int64 totalrows = WinGetPartitionRowCount(winobj);
Assert(totalrows > 0);
Datum
window_cume_dist(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- rank_context *context;
- bool up;
- int64 totalrows = WinGetPartitionRowCount(winobj);
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ rank_context *context;
+ bool up;
+ int64 totalrows = WinGetPartitionRowCount(winobj);
Assert(totalrows > 0);
if (up || context->rank == 1)
{
/*
- * The current row is not peer to prior row or is just the first,
- * so count up the number of rows that are peer to the current.
+ * The current row is not peer to prior row or is just the first, so
+ * count up the number of rows that are peer to the current.
*/
- int64 row;
+ int64 row;
context->rank = WinGetCurrentPosition(winobj) + 1;
Datum
window_ntile(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- ntile_context *context;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ ntile_context *context;
context = (ntile_context *)
WinGetPartitionLocalMemory(winobj, sizeof(ntile_context));
nbuckets = DatumGetInt32(WinGetFuncArgCurrent(winobj, 0, &isnull));
/*
- * per spec:
- * If NT is the null value, then the result is the null value.
+ * per spec: If NT is the null value, then the result is the null
+ * value.
*/
if (isnull)
PG_RETURN_NULL();
/*
- * per spec:
- * If NT is less than or equal to 0 (zero), then an exception
- * condition is raised.
+ * per spec: If NT is less than or equal to 0 (zero), then an
+ * exception condition is raised.
*/
if (nbuckets <= 0)
ereport(ERROR,
else
{
/*
- * If the total number is not divisible, add 1 row to
- * leading buckets.
+ * If the total number is not divisible, add 1 row to leading
+ * buckets.
*/
context->remainder = total % nbuckets;
if (context->remainder != 0)
leadlag_common(FunctionCallInfo fcinfo,
bool forward, bool withoffset, bool withdefault)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- int32 offset;
- bool const_offset;
- Datum result;
- bool isnull;
- bool isout;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ int32 offset;
+ bool const_offset;
+ Datum result;
+ bool isnull;
+ bool isout;
if (withoffset)
{
Datum
window_first_value(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- Datum result;
- bool isnull;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ Datum result;
+ bool isnull;
result = WinGetFuncArgInFrame(winobj, 0,
0, WINDOW_SEEK_HEAD, true,
Datum
window_last_value(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- Datum result;
- bool isnull;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ Datum result;
+ bool isnull;
result = WinGetFuncArgInFrame(winobj, 0,
0, WINDOW_SEEK_TAIL, true,
Datum
window_nth_value(PG_FUNCTION_ARGS)
{
- WindowObject winobj = PG_WINDOW_OBJECT();
- bool const_offset;
- Datum result;
- bool isnull;
- int32 nth;
+ WindowObject winobj = PG_WINDOW_OBJECT();
+ bool const_offset;
+ Datum result;
+ bool isnull;
+ int32 nth;
nth = DatumGetInt32(WinGetFuncArgCurrent(winobj, 1, &isnull));
if (isnull)
/* GUC variables */
-int xmlbinary;
-int xmloption;
+int xmlbinary;
+int xmloption;
#ifdef USE_LIBXML
static void *xml_repalloc(void *ptr, size_t size);
static void xml_pfree(void *ptr);
static char *xml_pstrdup(const char *string);
-
-#endif /* USE_LIBXMLCONTEXT */
+#endif /* USE_LIBXMLCONTEXT */
static void xml_init(void);
static xmlChar *xml_text2xmlChar(text *in);
-static int parse_xml_decl(const xmlChar * str, size_t *lenp,
- xmlChar ** version, xmlChar ** encoding, int *standalone);
-static bool print_xml_decl(StringInfo buf, const xmlChar * version,
+static int parse_xml_decl(const xmlChar *str, size_t *lenp,
+ xmlChar **version, xmlChar **encoding, int *standalone);
+static bool print_xml_decl(StringInfo buf, const xmlChar *version,
pg_enc encoding, int standalone);
static xmlDocPtr xml_parse(text *data, XmlOptionType xmloption_arg,
- bool preserve_whitespace, xmlChar * encoding);
+ bool preserve_whitespace, xmlChar *encoding);
static text *xml_xmlnodetoxmltype(xmlNodePtr cur);
#endif /* USE_LIBXML */
if (!isnull)
{
str = map_sql_value_to_xml_value(value,
- exprType((Node *) e->expr), true);
+ exprType((Node *) e->expr), true);
arg_strings = lappend(arg_strings, str);
}
}
PG_TRY();
{
- buf = xmlBufferCreate();
- if (!buf)
- xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
- "could not allocate xmlBuffer");
- writer = xmlNewTextWriterMemory(buf, 0);
- if (!writer)
- xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
- "could not allocate xmlTextWriter");
+ buf = xmlBufferCreate();
+ if (!buf)
+ xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
+ "could not allocate xmlBuffer");
+ writer = xmlNewTextWriterMemory(buf, 0);
+ if (!writer)
+ xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
+ "could not allocate xmlTextWriter");
- xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name);
+ xmlTextWriterStartElement(writer, (xmlChar *) xexpr->name);
- forboth(arg, named_arg_strings, narg, xexpr->arg_names)
- {
- char *str = (char *) lfirst(arg);
- char *argname = strVal(lfirst(narg));
+ forboth(arg, named_arg_strings, narg, xexpr->arg_names)
+ {
+ char *str = (char *) lfirst(arg);
+ char *argname = strVal(lfirst(narg));
- if (str)
- xmlTextWriterWriteAttribute(writer,
- (xmlChar *) argname,
- (xmlChar *) str);
- }
+ if (str)
+ xmlTextWriterWriteAttribute(writer,
+ (xmlChar *) argname,
+ (xmlChar *) str);
+ }
- foreach(arg, arg_strings)
- {
- char *str = (char *) lfirst(arg);
+ foreach(arg, arg_strings)
+ {
+ char *str = (char *) lfirst(arg);
- xmlTextWriterWriteRaw(writer, (xmlChar *) str);
- }
+ xmlTextWriterWriteRaw(writer, (xmlChar *) str);
+ }
- xmlTextWriterEndElement(writer);
+ xmlTextWriterEndElement(writer);
- /* we MUST do this now to flush data out to the buffer ... */
- xmlFreeTextWriter(writer);
- writer = NULL;
+ /* we MUST do this now to flush data out to the buffer ... */
+ xmlFreeTextWriter(writer);
+ writer = NULL;
- result = xmlBuffer_to_xmltype(buf);
+ result = xmlBuffer_to_xmltype(buf);
}
PG_CATCH();
{
resetStringInfo(xml_err_buf);
/*
- * We re-establish the error callback function every time. This makes
+ * We re-establish the error callback function every time. This makes
* it safe for other subsystems (PL/Perl, say) to also use libxml with
* their own callbacks ... so long as they likewise set up the
* callbacks on every use. It's cheap enough to not be worth worrying
static xmlChar *
xml_pnstrdup(const xmlChar *str, size_t len)
{
- xmlChar *result;
+ xmlChar *result;
result = (xmlChar *) palloc((len + 1) * sizeof(xmlChar));
memcpy(result, str, len * sizeof(xmlChar));
* Result is 0 if OK, an error code if not.
*/
static int
-parse_xml_decl(const xmlChar * str, size_t *lenp,
- xmlChar ** version, xmlChar ** encoding, int *standalone)
+parse_xml_decl(const xmlChar *str, size_t *lenp,
+ xmlChar **version, xmlChar **encoding, int *standalone)
{
const xmlChar *p;
const xmlChar *save_p;
* which is the default version specified in SQL:2003.
*/
static bool
-print_xml_decl(StringInfo buf, const xmlChar * version,
+print_xml_decl(StringInfo buf, const xmlChar *version,
pg_enc encoding, int standalone)
{
xml_init(); /* why is this here? */
*/
static xmlDocPtr
xml_parse(text *data, XmlOptionType xmloption_arg, bool preserve_whitespace,
- xmlChar * encoding)
+ xmlChar *encoding)
{
int32 len;
xmlChar *string;
/* Use a TRY block to ensure the ctxt is released */
PG_TRY();
{
- if (xmloption_arg == XMLOPTION_DOCUMENT)
- {
- /*
- * Note, that here we try to apply DTD defaults
- * (XML_PARSE_DTDATTR) according to SQL/XML:10.16.7.d: 'Default
- * values defined by internal DTD are applied'. As for external
- * DTDs, we try to support them too, (see SQL/XML:10.16.7.e)
- */
- doc = xmlCtxtReadDoc(ctxt, utf8string,
- NULL,
- "UTF-8",
- XML_PARSE_NOENT | XML_PARSE_DTDATTR
- | (preserve_whitespace ? 0 : XML_PARSE_NOBLANKS));
- if (doc == NULL)
- xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT,
- "invalid XML document");
- }
- else
- {
- int res_code;
- size_t count;
- xmlChar *version = NULL;
- int standalone = -1;
-
- res_code = parse_xml_decl(utf8string,
- &count, &version, NULL, &standalone);
- if (res_code != 0)
- xml_ereport_by_code(ERROR, ERRCODE_INVALID_XML_CONTENT,
- "invalid XML content: invalid XML declaration",
- res_code);
-
- doc = xmlNewDoc(version);
- Assert(doc->encoding == NULL);
- doc->encoding = xmlStrdup((const xmlChar *) "UTF-8");
- doc->standalone = standalone;
-
- res_code = xmlParseBalancedChunkMemory(doc, NULL, NULL, 0,
- utf8string + count, NULL);
- if (res_code != 0)
+ if (xmloption_arg == XMLOPTION_DOCUMENT)
{
- xmlFreeDoc(doc);
- xml_ereport(ERROR, ERRCODE_INVALID_XML_CONTENT,
- "invalid XML content");
+ /*
+ * Note, that here we try to apply DTD defaults
+ * (XML_PARSE_DTDATTR) according to SQL/XML:10.16.7.d: 'Default
+ * values defined by internal DTD are applied'. As for external
+ * DTDs, we try to support them too, (see SQL/XML:10.16.7.e)
+ */
+ doc = xmlCtxtReadDoc(ctxt, utf8string,
+ NULL,
+ "UTF-8",
+ XML_PARSE_NOENT | XML_PARSE_DTDATTR
+ | (preserve_whitespace ? 0 : XML_PARSE_NOBLANKS));
+ if (doc == NULL)
+ xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT,
+ "invalid XML document");
+ }
+ else
+ {
+ int res_code;
+ size_t count;
+ xmlChar *version = NULL;
+ int standalone = -1;
+
+ res_code = parse_xml_decl(utf8string,
+ &count, &version, NULL, &standalone);
+ if (res_code != 0)
+ xml_ereport_by_code(ERROR, ERRCODE_INVALID_XML_CONTENT,
+ "invalid XML content: invalid XML declaration",
+ res_code);
+
+ doc = xmlNewDoc(version);
+ Assert(doc->encoding == NULL);
+ doc->encoding = xmlStrdup((const xmlChar *) "UTF-8");
+ doc->standalone = standalone;
+
+ res_code = xmlParseBalancedChunkMemory(doc, NULL, NULL, 0,
+ utf8string + count, NULL);
+ if (res_code != 0)
+ {
+ xmlFreeDoc(doc);
+ xml_ereport(ERROR, ERRCODE_INVALID_XML_CONTENT,
+ "invalid XML content");
+ }
}
- }
}
PG_CATCH();
{
{
return MemoryContextStrdup(LibxmlContext, string);
}
-
-#endif /* USE_LIBXMLCONTEXT */
+#endif /* USE_LIBXMLCONTEXT */
/*
static char *
unicode_to_sqlchar(pg_wchar c)
{
- unsigned char utf8string[5]; /* need room for trailing zero */
+ unsigned char utf8string[5]; /* need room for trailing zero */
char *result;
memset(utf8string, 0, sizeof(utf8string));
result = (char *) pg_do_encoding_conversion(utf8string,
pg_encoding_mblen(PG_UTF8,
- (char *) utf8string),
+ (char *) utf8string),
PG_UTF8,
GetDatabaseEncoding());
/* if pg_do_encoding_conversion didn't strdup, we must */
*
* When xml_escape_strings is true, then certain characters in string
* values are replaced by entity references (< etc.), as specified
- * in SQL/XML:2003 section 9.16 GR 8) ii). This is normally what is
- * wanted. The false case is mainly useful when the resulting value
+ * in SQL/XML:2003 section 9.16 GR 8) ii). This is normally what is
+ * wanted. The false case is mainly useful when the resulting value
* is used with xmlTextWriterWriteAttribute() to write out an
* attribute, because that function does the escaping itself. The SQL
* standard of 2003 is somewhat buggy in this regard, so we do our
if (xmlbinary == XMLBINARY_BASE64)
xmlTextWriterWriteBase64(writer, VARDATA_ANY(bstr),
- 0, VARSIZE_ANY_EXHDR(bstr));
+ 0, VARSIZE_ANY_EXHDR(bstr));
else
xmlTextWriterWriteBinHex(writer, VARDATA_ANY(bstr),
- 0, VARSIZE_ANY_EXHDR(bstr));
+ 0, VARSIZE_ANY_EXHDR(bstr));
/* we MUST do this now to flush data out to the buffer */
xmlFreeTextWriter(writer);
appendStringInfo(result, " <%s>%s</%s>\n",
colname,
map_sql_value_to_xml_value(colval,
- SPI_gettypeid(SPI_tuptable->tupdesc, i), true),
+ SPI_gettypeid(SPI_tuptable->tupdesc, i), true),
colname);
}
memcpy(string, datastr, len);
string[len] = '\0';
- xpath_expr = (xmlChar *) palloc((xpath_len +1) * sizeof(xmlChar));
+ xpath_expr = (xmlChar *) palloc((xpath_len + 1) * sizeof(xmlChar));
memcpy(xpath_expr, VARDATA(xpath_expr_text), xpath_len);
xpath_expr[xpath_len] = '\0';
PG_TRY();
{
- /*
- * redundant XML parsing (two parsings for the same value during one
- * command execution are possible)
- */
- ctxt = xmlNewParserCtxt();
- if (ctxt == NULL)
- xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
- "could not allocate parser context");
- doc = xmlCtxtReadMemory(ctxt, (char *) string, len, NULL, NULL, 0);
- if (doc == NULL)
- xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT,
- "could not parse XML document");
- xpathctx = xmlXPathNewContext(doc);
- if (xpathctx == NULL)
- xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
- "could not allocate XPath context");
- xpathctx->node = xmlDocGetRootElement(doc);
- if (xpathctx->node == NULL)
- xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
- "could not find root XML element");
-
- /* register namespaces, if any */
- if (ns_count > 0)
- {
- for (i = 0; i < ns_count; i++)
+ /*
+ * redundant XML parsing (two parsings for the same value during one
+ * command execution are possible)
+ */
+ ctxt = xmlNewParserCtxt();
+ if (ctxt == NULL)
+ xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
+ "could not allocate parser context");
+ doc = xmlCtxtReadMemory(ctxt, (char *) string, len, NULL, NULL, 0);
+ if (doc == NULL)
+ xml_ereport(ERROR, ERRCODE_INVALID_XML_DOCUMENT,
+ "could not parse XML document");
+ xpathctx = xmlXPathNewContext(doc);
+ if (xpathctx == NULL)
+ xml_ereport(ERROR, ERRCODE_OUT_OF_MEMORY,
+ "could not allocate XPath context");
+ xpathctx->node = xmlDocGetRootElement(doc);
+ if (xpathctx->node == NULL)
+ xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
+ "could not find root XML element");
+
+ /* register namespaces, if any */
+ if (ns_count > 0)
{
- char *ns_name;
- char *ns_uri;
-
- if (ns_names_uris_nulls[i * 2] ||
- ns_names_uris_nulls[i * 2 + 1])
- ereport(ERROR,
- (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
- errmsg("neither namespace name nor URI may be null")));
- ns_name = TextDatumGetCString(ns_names_uris[i * 2]);
- ns_uri = TextDatumGetCString(ns_names_uris[i * 2 + 1]);
- if (xmlXPathRegisterNs(xpathctx,
- (xmlChar *) ns_name,
- (xmlChar *) ns_uri) != 0)
- ereport(ERROR, /* is this an internal error??? */
- (errmsg("could not register XML namespace with name \"%s\" and URI \"%s\"",
- ns_name, ns_uri)));
+ for (i = 0; i < ns_count; i++)
+ {
+ char *ns_name;
+ char *ns_uri;
+
+ if (ns_names_uris_nulls[i * 2] ||
+ ns_names_uris_nulls[i * 2 + 1])
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("neither namespace name nor URI may be null")));
+ ns_name = TextDatumGetCString(ns_names_uris[i * 2]);
+ ns_uri = TextDatumGetCString(ns_names_uris[i * 2 + 1]);
+ if (xmlXPathRegisterNs(xpathctx,
+ (xmlChar *) ns_name,
+ (xmlChar *) ns_uri) != 0)
+ ereport(ERROR, /* is this an internal error??? */
+ (errmsg("could not register XML namespace with name \"%s\" and URI \"%s\"",
+ ns_name, ns_uri)));
+ }
}
- }
- xpathcomp = xmlXPathCompile(xpath_expr);
- if (xpathcomp == NULL) /* TODO: show proper XPath error details */
- xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
- "invalid XPath expression");
+ xpathcomp = xmlXPathCompile(xpath_expr);
+ if (xpathcomp == NULL) /* TODO: show proper XPath error details */
+ xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
+ "invalid XPath expression");
- xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx);
- if (xpathobj == NULL) /* TODO: reason? */
- xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
- "could not create XPath object");
+ xpathobj = xmlXPathCompiledEval(xpathcomp, xpathctx);
+ if (xpathobj == NULL) /* TODO: reason? */
+ xml_ereport(ERROR, ERRCODE_INTERNAL_ERROR,
+ "could not create XPath object");
- /* return empty array in cases when nothing is found */
- if (xpathobj->nodesetval == NULL)
- res_nitems = 0;
- else
- res_nitems = xpathobj->nodesetval->nodeNr;
+ /* return empty array in cases when nothing is found */
+ if (xpathobj->nodesetval == NULL)
+ res_nitems = 0;
+ else
+ res_nitems = xpathobj->nodesetval->nodeNr;
- if (res_nitems)
- {
- for (i = 0; i < xpathobj->nodesetval->nodeNr; i++)
+ if (res_nitems)
{
- Datum elem;
- bool elemisnull = false;
+ for (i = 0; i < xpathobj->nodesetval->nodeNr; i++)
+ {
+ Datum elem;
+ bool elemisnull = false;
- elem = PointerGetDatum(xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[i]));
- astate = accumArrayResult(astate, elem,
- elemisnull, XMLOID,
- CurrentMemoryContext);
+ elem = PointerGetDatum(xml_xmlnodetoxmltype(xpathobj->nodesetval->nodeTab[i]));
+ astate = accumArrayResult(astate, elem,
+ elemisnull, XMLOID,
+ CurrentMemoryContext);
+ }
}
}
- }
PG_CATCH();
{
if (xpathobj)
{
case BOOLOID:
*hashfunc = hashchar;
+
*eqfunc = F_BOOLEQ;
break;
case CHAROID:
*hashfunc = hashchar;
+
*eqfunc = F_CHAREQ;
break;
case NAMEOID:
*hashfunc = hashname;
+
*eqfunc = F_NAMEEQ;
break;
case INT2OID:
*hashfunc = hashint2;
+
*eqfunc = F_INT2EQ;
break;
case INT2VECTOROID:
*hashfunc = hashint2vector;
+
*eqfunc = F_INT2VECTOREQ;
break;
case INT4OID:
*hashfunc = hashint4;
+
*eqfunc = F_INT4EQ;
break;
case TEXTOID:
*hashfunc = hashtext;
+
*eqfunc = F_TEXTEQ;
break;
case OIDOID:
case REGCONFIGOID:
case REGDICTIONARYOID:
*hashfunc = hashoid;
+
*eqfunc = F_OIDEQ;
break;
case OIDVECTOROID:
*hashfunc = hashoidvector;
+
*eqfunc = F_OIDVECTOREQ;
break;
default:
elog(FATAL, "type %u not supported as catcache key", keytype);
*hashfunc = NULL; /* keep compiler quiet */
+
*eqfunc = InvalidOid;
break;
}
*/
static void
ProcessInvalidationMessagesMulti(InvalidationListHeader *hdr,
- void (*func) (const SharedInvalidationMessage *msgs, int n))
+ void (*func) (const SharedInvalidationMessage *msgs, int n))
{
ProcessMessageListMulti(hdr->cclist, func(msgs, n));
ProcessMessageListMulti(hdr->rclist, func(msgs, n));
/*
* Most of the time, relcache invalidation is associated with system
- * catalog updates, but there are a few cases where it isn't. Quick
- * hack to ensure that the next CommandCounterIncrement() will think
- * that we need to do CommandEndInvalidationMessages().
+ * catalog updates, but there are a few cases where it isn't. Quick hack
+ * to ensure that the next CommandCounterIncrement() will think that we
+ * need to do CommandEndInvalidationMessages().
*/
(void) GetCurrentCommandId(true);
* Prepare for invalidation messages for nontransactional updates.
*
* A nontransactional invalidation is one that must be sent whether or not
- * the current transaction eventually commits. We arrange for all invals
+ * the current transaction eventually commits. We arrange for all invals
* queued between this call and EndNonTransactionalInvalidation() to be sent
* immediately when the latter is called.
*
Assert(transInvalInfo->PriorCmdInvalidMsgs.rclist == NULL);
/*
- * At present, this function is only used for CTID-changing updates;
- * since the relcache init file doesn't store any tuple CTIDs, we
- * don't have to invalidate it. That might not be true forever
- * though, in which case we'd need code similar to AtEOXact_Inval.
+ * At present, this function is only used for CTID-changing updates; since
+ * the relcache init file doesn't store any tuple CTIDs, we don't have to
+ * invalidate it. That might not be true forever though, in which case
+ * we'd need code similar to AtEOXact_Inval.
*/
/* Send out the invals */
opcintype,
opcintype,
BTORDER_PROC);
+
if (!OidIsValid(*cmpfunc)) /* should not happen */
elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
BTORDER_PROC, opcintype, opcintype, opfamily);
/* ensure outputs are set on failure */
*cmpfunc = InvalidOid;
+
*reverse = false;
return false;
}
*
* The plan cache manager itself is principally responsible for tracking
* whether cached plans should be invalidated because of schema changes in
- * the objects they depend on. When (and if) the next demand for a cached
+ * the objects they depend on. When (and if) the next demand for a cached
* plan occurs, the query will be replanned. Note that this could result
* in an error, for example if a column referenced by the query is no
* longer present. The creator of a cached plan can specify whether it
* caller to notice changes and cope with them.
*
* Currently, we track exactly the dependencies of plans on relations and
- * user-defined functions. On relcache invalidation events or pg_proc
+ * user-defined functions. On relcache invalidation events or pg_proc
* syscache invalidation events, we invalidate just those plans that depend
* on the particular object being modified. (Note: this scheme assumes
* that any table modification that requires replanning will generate a
MemoryContext source_context;
MemoryContext oldcxt;
- Assert(query_string != NULL); /* required as of 8.4 */
+ Assert(query_string != NULL); /* required as of 8.4 */
/*
* Make a dedicated memory context for the CachedPlanSource and its
OverrideSearchPath *search_path;
MemoryContext oldcxt;
- Assert(query_string != NULL); /* required as of 8.4 */
+ Assert(query_string != NULL); /* required as of 8.4 */
/*
* Fetch current search_path into given context, but do any recalculation
/*
* If a snapshot is already set (the normal case), we can just use
- * that for parsing/planning. But if it isn't, install one. Note:
- * no point in checking whether parse analysis requires a snapshot;
+ * that for parsing/planning. But if it isn't, install one. Note: no
+ * point in checking whether parse analysis requires a snapshot;
* utility commands don't have invalidatable plans, so we'd not get
* here for such a command.
*/
Assert(plan->refcount > 0);
/*
- * Although we don't want to acquire locks here, it still seems
- * useful to check for expiration of a transient plan.
+ * Although we don't want to acquire locks here, it still seems useful
+ * to check for expiration of a transient plan.
*/
if (TransactionIdIsValid(plan->saved_xmin) &&
!TransactionIdEquals(plan->saved_xmin, TransactionXmin))
{
/* Invalidate the plan! */
plan->dead = true;
- break; /* out of invalItems scan */
+ break; /* out of invalItems scan */
}
}
if (plan->dead)
* Note there is no provision for flushing the cache. This is OK at the
* moment because there is no way to ALTER any interesting properties of an
* existing opclass --- all you can do is drop it, which will result in
- * a useless but harmless dead entry in the cache. To support altering
+ * a useless but harmless dead entry in the cache. To support altering
* opclass membership (not the same as opfamily membership!), we'd need to
* be able to flush this cache as well as the contents of relcache entries
* for indexes.
/*
* When testing for cache-flush hazards, we intentionally disable the
- * operator class cache and force reloading of the info on each call.
- * This is helpful because we want to test the case where a cache flush
- * occurs while we are loading the info, and it's very hard to provoke
- * that if this happens only once per opclass per backend.
+ * operator class cache and force reloading of the info on each call. This
+ * is helpful because we want to test the case where a cache flush occurs
+ * while we are loading the info, and it's very hard to provoke that if
+ * this happens only once per opclass per backend.
*/
#if defined(CLOBBER_CACHE_ALWAYS)
opcentry->valid = false;
relation->rd_rel->relisshared = false;
/*
- * Likewise, we must know if a relation is temp ... but formrdesc is
- * not used for any temp relations.
+ * Likewise, we must know if a relation is temp ... but formrdesc is not
+ * used for any temp relations.
*/
relation->rd_rel->relistemp = false;
heap_freetuple(pg_class_tuple);
/* We must recalculate physical address in case it changed */
RelationInitPhysicalAddr(relation);
+
/*
* Must reset targblock, fsm_nblocks and vm_nblocks in case rel was
* truncated
RelationGetRelationName(relation));
else
attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext,
- TextDatumGetCString(val));
+ TextDatumGetCString(val));
break;
}
},
256
},
- {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPERNAME */
+ {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPERNAME */
ForeignDataWrapperNameIndexId,
0,
1,
},
8
},
- {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPEROID */
+ {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPEROID */
ForeignDataWrapperOidIndexId,
0,
1,
},
8
},
- {ForeignServerRelationId, /* FOREIGNSERVERNAME */
+ {ForeignServerRelationId, /* FOREIGNSERVERNAME */
ForeignServerNameIndexId,
0,
1,
},
32
},
- {ForeignServerRelationId, /* FOREIGNSERVEROID */
+ {ForeignServerRelationId, /* FOREIGNSERVEROID */
ForeignServerOidIndexId,
0,
1,
},
1024
},
- {UserMappingRelationId, /* USERMAPPINGOID */
+ {UserMappingRelationId, /* USERMAPPINGOID */
UserMappingOidIndexId,
0,
1,
},
128
},
- {UserMappingRelationId, /* USERMAPPINGUSERSERVER */
+ {UserMappingRelationId, /* USERMAPPINGUSERSERVER */
UserMappingUserServerIndexId,
0,
2,
/*
* Max string length to send to syslog(). Note that this doesn't count the
* sequence-number prefix we add, and of course it doesn't count the prefix
- * added by syslog itself. On many implementations it seems that the hard
+ * added by syslog itself. On many implementations it seems that the hard
* limit is approximately 2K bytes including both those prefixes.
*/
#ifndef PG_SYSLOG_LIMIT
MemoryContextReset(ErrorContext);
/*
- * Infinite error recursion might be due to something broken
- * in a context traceback routine. Abandon them too. We also abandon
+ * Infinite error recursion might be due to something broken in a
+ * context traceback routine. Abandon them too. We also abandon
* attempting to print the error statement (which, if long, could
* itself be the source of the recursive failure).
*/
*/
int
errmsg_plural(const char *fmt_singular, const char *fmt_plural,
- unsigned long n, ...)
+ unsigned long n,...)
{
ErrorData *edata = &errordata[errordata_stack_depth];
MemoryContext oldcontext;
*/
int
errdetail_plural(const char *fmt_singular, const char *fmt_plural,
- unsigned long n, ...)
+ unsigned long n,...)
{
ErrorData *edata = &errordata[errordata_stack_depth];
MemoryContext oldcontext;
tz = log_timezone ? log_timezone : gmt_timezone;
pg_strftime(formatted_log_time, FORMATTED_TS_LEN,
- /* leave room for milliseconds... */
+ /* leave room for milliseconds... */
"%Y-%m-%d %H:%M:%S %Z",
pg_localtime(&stamp_time, tz));
write_csvlog(ErrorData *edata)
{
StringInfoData buf;
- bool print_stmt = false;
+ bool print_stmt = false;
/* static counter for line numbers */
static long log_line_number = 0;
psdisp = get_ps_display(&displen);
appendStringInfo(&msgbuf, "%.*s", displen, psdisp);
appendCSVLiteral(&buf, msgbuf.data);
-
+
pfree(msgbuf.data);
}
appendStringInfoChar(&buf, ',');
/* file error location */
if (Log_error_verbosity >= PGERROR_VERBOSE)
{
- StringInfoData msgbuf;
+ StringInfoData msgbuf;
initStringInfo(&msgbuf);
static void *internal_load_library(const char *libname);
static void incompatible_module_error(const char *libname,
- const Pg_magic_struct *module_magic_data);
+ const Pg_magic_struct *module_magic_data);
static void internal_unload_library(const char *libname);
static bool file_exists(const char *name);
static char *expand_dynamic_library_name(const char *name);
incompatible_module_error(const char *libname,
const Pg_magic_struct *module_magic_data)
{
- StringInfoData details;
+ StringInfoData details;
/*
* If the version doesn't match, just report that, because the rest of the
ereport(ERROR,
(errmsg("incompatible library \"%s\": version mismatch",
libname),
- errdetail("Server is version %d.%d, library is version %d.%d.",
- magic_data.version / 100,
- magic_data.version % 100,
- module_magic_data->version / 100,
- module_magic_data->version % 100)));
+ errdetail("Server is version %d.%d, library is version %d.%d.",
+ magic_data.version / 100,
+ magic_data.version % 100,
+ module_magic_data->version / 100,
+ module_magic_data->version % 100)));
/*
* Otherwise, spell out which fields don't agree.
if (details.len)
appendStringInfoChar(&details, '\n');
appendStringInfo(&details,
- _("Server has FLOAT4PASSBYVAL = %s, library has %s."),
+ _("Server has FLOAT4PASSBYVAL = %s, library has %s."),
magic_data.float4byval ? "true" : "false",
module_magic_data->float4byval ? "true" : "false");
}
if (details.len)
appendStringInfoChar(&details, '\n');
appendStringInfo(&details,
- _("Server has FLOAT8PASSBYVAL = %s, library has %s."),
+ _("Server has FLOAT8PASSBYVAL = %s, library has %s."),
magic_data.float8byval ? "true" : "false",
module_magic_data->float8byval ? "true" : "false");
}
if (details.len == 0)
appendStringInfo(&details,
- _("Magic block has unexpected length or padding difference."));
+ _("Magic block has unexpected length or padding difference."));
ereport(ERROR,
(errmsg("incompatible library \"%s\": magic block mismatch",
finfo->fn_nargs = fbp->nargs;
finfo->fn_strict = fbp->strict;
finfo->fn_retset = fbp->retset;
- finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
+ finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
finfo->fn_addr = fbp->func;
finfo->fn_oid = functionId;
return;
/*
* If it has prosecdef set, or non-null proconfig, use
- * fmgr_security_definer call handler --- unless we are being called
- * again by fmgr_security_definer.
+ * fmgr_security_definer call handler --- unless we are being called again
+ * by fmgr_security_definer.
*
* When using fmgr_security_definer, function stats tracking is always
- * disabled at the outer level, and instead we set the flag properly
- * in fmgr_security_definer's private flinfo and implement the tracking
+ * disabled at the outer level, and instead we set the flag properly in
+ * fmgr_security_definer's private flinfo and implement the tracking
* inside fmgr_security_definer. This loses the ability to charge the
* overhead of fmgr_security_definer to the function, but gains the
- * ability to set the track_functions GUC as a local GUC parameter of
- * an interesting function and have the right things happen.
+ * ability to set the track_functions GUC as a local GUC parameter of an
+ * interesting function and have the right things happen.
*/
if (!ignore_security &&
(procedureStruct->prosecdef ||
!heap_attisnull(procedureTuple, Anum_pg_proc_proconfig)))
{
finfo->fn_addr = fmgr_security_definer;
- finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
+ finfo->fn_stats = TRACK_FUNC_ALL; /* ie, never track */
finfo->fn_oid = functionId;
ReleaseSysCache(procedureTuple);
return;
/*
* We don't need to restore GUC or userid settings on error, because the
- * ensuing xact or subxact abort will do that. The PG_TRY block is only
+ * ensuing xact or subxact abort will do that. The PG_TRY block is only
* needed to clean up the flinfo link.
*/
save_flinfo = fcinfo->flinfo;
*
* One important difference from the bare function call is that we will
* push any active SPI context, allowing SPI-using I/O functions to be
- * called from other SPI functions without extra notation. This is a hack,
+ * called from other SPI functions without extra notation. This is a hack,
* but the alternative of expecting all SPI functions to do SPI_push/SPI_pop
* around I/O calls seems worse.
*/
return PointerGetDatum(retval);
#endif /* INT64_IS_BUSTED */
}
-
-#endif /* USE_FLOAT8_BYVAL */
+#endif /* USE_FLOAT8_BYVAL */
Datum
Float4GetDatum(float4 X)
{
#ifdef USE_FLOAT4_BYVAL
- union {
- float4 value;
- int32 retval;
- } myunion;
+ union
+ {
+ float4 value;
+ int32 retval;
+ } myunion;
myunion.value = X;
return SET_4_BYTES(myunion.retval);
float4
DatumGetFloat4(Datum X)
{
- union {
- int32 value;
- float4 retval;
- } myunion;
+ union
+ {
+ int32 value;
+ float4 retval;
+ } myunion;
myunion.value = GET_4_BYTES(X);
return myunion.retval;
}
-
-#endif /* USE_FLOAT4_BYVAL */
+#endif /* USE_FLOAT4_BYVAL */
Datum
Float8GetDatum(float8 X)
{
#ifdef USE_FLOAT8_BYVAL
- union {
- float8 value;
- int64 retval;
- } myunion;
+ union
+ {
+ float8 value;
+ int64 retval;
+ } myunion;
myunion.value = X;
return SET_8_BYTES(myunion.retval);
float8
DatumGetFloat8(Datum X)
{
- union {
- int64 value;
- float8 retval;
- } myunion;
+ union
+ {
+ int64 value;
+ float8 retval;
+ } myunion;
myunion.value = GET_8_BYTES(X);
return myunion.retval;
}
-
-#endif /* USE_FLOAT8_BYVAL */
+#endif /* USE_FLOAT8_BYVAL */
/*-------------------------------------------------------------------------
arg = (Node *) list_nth(args, argnum);
/*
- * Either a true Const or an external Param will have a value that
- * doesn't change during the execution of the query. In future we
- * might want to consider other cases too, e.g. now().
+ * Either a true Const or an external Param will have a value that doesn't
+ * change during the execution of the query. In future we might want to
+ * consider other cases too, e.g. now().
*/
if (IsA(arg, Const))
return true;
/*
* First call
*/
- ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
- MemoryContext multi_call_ctx;
+ ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+ MemoryContext multi_call_ctx;
/*
* Create a suitably long-lived context to hold cross-call data
* ever throw any kind of error. This is because they are used by
* StartTransaction and AbortTransaction to save/restore the settings,
* and during the first transaction within a backend, the value to be saved
- * and perhaps restored is indeed invalid. We have to be able to get
+ * and perhaps restored is indeed invalid. We have to be able to get
* through AbortTransaction without asserting in case InitPostgres fails.
*/
void
/*
* Choose notice level: avoid repeat messages when re-loading a library
- * that was preloaded into the postmaster. (Only possible in EXEC_BACKEND
+ * that was preloaded into the postmaster. (Only possible in EXEC_BACKEND
* configurations)
*/
#ifdef EXEC_BACKEND
#ifdef ENABLE_NLS
if (my_exec_path[0] != '\0')
{
- char locale_path[MAXPGPATH];
+ char locale_path[MAXPGPATH];
get_locale_path(my_exec_path, locale_path);
bindtextdomain(domain, locale_path);
/* If we have no other source of client_encoding, use server encoding */
SetConfigOption("client_encoding", GetDatabaseEncodingName(),
PGC_BACKEND, PGC_S_DEFAULT);
-
- /* assign locale variables */
+
+ /* assign locale variables */
collate = NameStr(dbform->datcollate);
ctype = NameStr(dbform->datctype);
-
+
if (setlocale(LC_COLLATE, collate) == NULL)
- ereport(FATAL,
+ ereport(FATAL,
(errmsg("database locale is incompatible with operating system"),
- errdetail("The database was initialized with LC_COLLATE \"%s\", "
- " which is not recognized by setlocale().", collate),
- errhint("Recreate the database with another locale or install the missing locale.")));
-
+ errdetail("The database was initialized with LC_COLLATE \"%s\", "
+ " which is not recognized by setlocale().", collate),
+ errhint("Recreate the database with another locale or install the missing locale.")));
+
if (setlocale(LC_CTYPE, ctype) == NULL)
- ereport(FATAL,
+ ereport(FATAL,
(errmsg("database locale is incompatible with operating system"),
- errdetail("The database was initialized with LC_CTYPE \"%s\", "
- " which is not recognized by setlocale().", ctype),
- errhint("Recreate the database with another locale or install the missing locale.")));
-
+ errdetail("The database was initialized with LC_CTYPE \"%s\", "
+ " which is not recognized by setlocale().", ctype),
+ errhint("Recreate the database with another locale or install the missing locale.")));
+
/* Make the locale settings visible as GUC variables, too */
SetConfigOption("lc_collate", collate, PGC_INTERNAL, PGC_S_OVERRIDE);
SetConfigOption("lc_ctype", ctype, PGC_INTERNAL, PGC_S_OVERRIDE);
MyProcPort->canAcceptConnections == CAC_WAITBACKUP)
ereport(FATAL,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("must be superuser to connect during database shutdown")));
+ errmsg("must be superuser to connect during database shutdown")));
/*
* Check a normal user hasn't connected to a superuser reserved slot.
/*
* Note: There are a few characters like the "Numero" sign that exist in
* all the other cyrillic encodings (win1251, ISO_8859-5 and cp866), but
- * not in KOI8R. As we use MULE_INTERNAL/KOI8R as an intermediary, we
- * will fail to convert those characters.
+ * not in KOI8R. As we use MULE_INTERNAL/KOI8R as an intermediary, we will
+ * fail to convert those characters.
*/
buf = palloc(len * ENCODING_GROWTH_RATE + 1);
win8662mic(src, buf, len);
/*
* We maintain a simple linked list caching the fmgr lookup info for the
* currently selected conversion functions, as well as any that have been
- * selected previously in the current session. (We remember previous
+ * selected previously in the current session. (We remember previous
* settings because we must be able to restore a previous setting during
* transaction rollback, without doing any fresh catalog accesses.)
*
{
int s_encoding; /* server and client encoding IDs */
int c_encoding;
- FmgrInfo to_server_info; /* lookup info for conversion procs */
+ FmgrInfo to_server_info; /* lookup info for conversion procs */
FmgrInfo to_client_info;
} ConvProcInfo;
{
/*
* If we're in a live transaction, it's safe to access the catalogs,
- * so look up the functions. We repeat the lookup even if the info
- * is already cached, so that we can react to changes in the contents
- * of pg_conversion.
+ * so look up the functions. We repeat the lookup even if the info is
+ * already cached, so that we can react to changes in the contents of
+ * pg_conversion.
*/
Oid to_server_proc,
to_client_proc;
ToClientConvProc = &convinfo->to_client_info;
/*
- * Remove any older entry for the same encoding pair (this is just
- * to avoid memory leakage).
+ * Remove any older entry for the same encoding pair (this is just to
+ * avoid memory leakage).
*/
foreach(lc, ConvProcList)
{
else
{
/*
- * If we're not in a live transaction, the only thing we can do
- * is restore a previous setting using the cache. This covers all
- * transaction-rollback cases. The only case it might not work for
- * is trying to change client_encoding on the fly by editing
+ * If we're not in a live transaction, the only thing we can do is
+ * restore a previous setting using the cache. This covers all
+ * transaction-rollback cases. The only case it might not work for is
+ * trying to change client_encoding on the fly by editing
* postgresql.conf and SIGHUP'ing. Which would probably be a stupid
* thing to do anyway.
*/
*
* CAUTION: although the presence of a length argument means that callers
* can pass non-null-terminated strings, care is required because the same
- * string will be passed back if no conversion occurs. Such callers *must*
+ * string will be passed back if no conversion occurs. Such callers *must*
* check whether result == src and handle that case differently.
*
* Note: we try to avoid raising error, since that could get us into
size_t
wchar2char(char *to, const wchar_t *from, size_t tolen)
{
- size_t result;
-
+ size_t result;
+
if (tolen == 0)
return 0;
#ifdef WIN32
+
/*
- * On Windows, the "Unicode" locales assume UTF16 not UTF8 encoding,
- * and for some reason mbstowcs and wcstombs won't do this for us,
- * so we use MultiByteToWideChar().
+ * On Windows, the "Unicode" locales assume UTF16 not UTF8 encoding, and
+ * for some reason mbstowcs and wcstombs won't do this for us, so we use
+ * MultiByteToWideChar().
*/
if (GetDatabaseEncoding() == PG_UTF8)
{
result = WideCharToMultiByte(CP_UTF8, 0, from, -1, to, tolen,
- NULL, NULL);
+ NULL, NULL);
/* A zero return is failure */
if (result <= 0)
result = -1;
else
#endif /* WIN32 */
{
- Assert( !lc_ctype_is_c() );
+ Assert(!lc_ctype_is_c());
result = wcstombs(to, from, tolen);
}
return result;
/* mbstowcs requires ending '\0' */
char *str = pnstrdup(from, fromlen);
- Assert( !lc_ctype_is_c() );
+ Assert(!lc_ctype_is_c());
result = mbstowcs(to, str, tolen);
pfree(str);
}
(errcode(ERRCODE_CHARACTER_NOT_IN_REPERTOIRE),
errmsg("invalid multibyte character for locale"),
errhint("The server's LC_CTYPE locale is probably incompatible with the database encoding.")));
- }
+ }
return result;
}
-
#endif
/* convert a multibyte string to a wchar */
pg_bind_textdomain_codeset(const char *domainname)
{
#if defined(ENABLE_NLS)
- int encoding = GetDatabaseEncoding();
- int i;
+ int encoding = GetDatabaseEncoding();
+ int i;
/*
- * gettext() uses the codeset specified by LC_CTYPE by default,
- * so if that matches the database encoding we don't need to do
- * anything. In CREATE DATABASE, we enforce or trust that the
- * locale's codeset matches database encoding, except for the C
- * locale. In C locale, we bind gettext() explicitly to the right
- * codeset.
+ * gettext() uses the codeset specified by LC_CTYPE by default, so if that
+ * matches the database encoding we don't need to do anything. In CREATE
+ * DATABASE, we enforce or trust that the locale's codeset matches
+ * database encoding, except for the C locale. In C locale, we bind
+ * gettext() explicitly to the right codeset.
*
- * On Windows, though, gettext() tends to get confused so we always
- * bind it.
+ * On Windows, though, gettext() tends to get confused so we always bind
+ * it.
*/
#ifndef WIN32
const char *ctype = setlocale(LC_CTYPE, NULL);
*-------------------------------------------------------------------
*/
pg_wchar_tbl pg_wchar_table[] = {
- {pg_ascii2wchar_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII */
+ {pg_ascii2wchar_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII */
{pg_eucjp2wchar_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JP */
{pg_euccn2wchar_with_len, pg_euccn_mblen, pg_euccn_dsplen, pg_euccn_verifier, 2}, /* PG_EUC_CN */
{pg_euckr2wchar_with_len, pg_euckr_mblen, pg_euckr_dsplen, pg_euckr_verifier, 3}, /* PG_EUC_KR */
ereport(ERROR,
(errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
- errmsg("character 0x%s of encoding \"%s\" has no equivalent in \"%s\"",
- buf,
- pg_enc2name_tbl[src_encoding].name,
- pg_enc2name_tbl[dest_encoding].name)));
+ errmsg("character 0x%s of encoding \"%s\" has no equivalent in \"%s\"",
+ buf,
+ pg_enc2name_tbl[src_encoding].name,
+ pg_enc2name_tbl[dest_encoding].name)));
}
#endif
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*-
* Copyright (c) 1990, 1993
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* Copyright (c) 1989, 1993
static int syslog_facility = LOG_LOCAL0;
static bool assign_syslog_facility(int newval,
- bool doit, GucSource source);
+ bool doit, GucSource source);
static const char *assign_syslog_ident(const char *ident,
bool doit, GucSource source);
#endif
static bool assign_effective_io_concurrency(int newval, bool doit, GucSource source);
static const char *assign_pgstat_temp_directory(const char *newval, bool doit, GucSource source);
-static char *config_enum_get_options(struct config_enum *record,
- const char *prefix, const char *suffix,
- const char *separator);
+static char *config_enum_get_options(struct config_enum * record,
+ const char *prefix, const char *suffix,
+ const char *separator);
/*
};
static const struct config_enum_entry regex_flavor_options[] = {
- {"advanced", REG_ADVANCED, false},
- {"extended", REG_EXTENDED, false},
- {"basic", REG_BASIC, false},
- {NULL, 0, false}
+ {"advanced", REG_ADVANCED, false},
+ {"extended", REG_EXTENDED, false},
+ {"basic", REG_BASIC, false},
+ {NULL, 0, false}
};
static const struct config_enum_entry isolation_level_options[] = {
{
{"effective_io_concurrency",
#ifdef USE_PREFETCH
- PGC_USERSET,
+ PGC_USERSET,
#else
- PGC_INTERNAL,
+ PGC_INTERNAL,
#endif
- RESOURCES,
+ RESOURCES,
gettext_noop("Number of simultaneous requests that can be handled efficiently by the disk subsystem."),
gettext_noop("For RAID arrays, this should be approximately the number of drive spindles in the array.")
},
{
{"segment_size", PGC_INTERNAL, PRESET_OPTIONS,
- gettext_noop("Shows the number of pages per disk file."),
- NULL,
- GUC_UNIT_BLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
+ gettext_noop("Shows the number of pages per disk file."),
+ NULL,
+ GUC_UNIT_BLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&segment_size,
RELSEG_SIZE, RELSEG_SIZE, RELSEG_SIZE, NULL, NULL
GUC_UNIT_XBLOCKS | GUC_NOT_IN_SAMPLE | GUC_DISALLOW_IN_FILE
},
&wal_segment_size,
- (XLOG_SEG_SIZE / XLOG_BLCKSZ),
- (XLOG_SEG_SIZE / XLOG_BLCKSZ),
+ (XLOG_SEG_SIZE / XLOG_BLCKSZ),
+ (XLOG_SEG_SIZE / XLOG_BLCKSZ),
(XLOG_SEG_SIZE / XLOG_BLCKSZ),
NULL, NULL
},
XACT_READ_COMMITTED, isolation_level_options, NULL, NULL
},
- {
+ {
{"IntervalStyle", PGC_USERSET, CLIENT_CONN_LOCALE,
gettext_noop("Sets the display format for interval values."),
NULL,
NULL
},
&sync_method,
- DEFAULT_SYNC_METHOD, sync_method_options,
+ DEFAULT_SYNC_METHOD, sync_method_options,
assign_xlog_sync_method, NULL
},
static int guc_var_compare(const void *a, const void *b);
static int guc_name_compare(const char *namea, const char *nameb);
-static void InitializeOneGUCOption(struct config_generic *gconf);
+static void InitializeOneGUCOption(struct config_generic * gconf);
static void push_old_value(struct config_generic * gconf, GucAction action);
static void ReportGUCOption(struct config_generic * record);
static void ShowGUCConfigOption(const char *name, DestReceiver *dest);
*((struct config_string *) gconf)->variable);
break;
case PGC_ENUM:
- val->enumval =
+ val->enumval =
*((struct config_enum *) gconf)->variable;
break;
}
* Initialize one GUC option variable to its compiled-in default.
*/
static void
-InitializeOneGUCOption(struct config_generic *gconf)
+InitializeOneGUCOption(struct config_generic * gconf)
{
gconf->status = 0;
gconf->reset_source = PGC_S_DEFAULT;
switch (gconf->vartype)
{
case PGC_BOOL:
- {
- struct config_bool *conf = (struct config_bool *) gconf;
-
- if (conf->assign_hook)
- if (!(*conf->assign_hook) (conf->boot_val, true,
- PGC_S_DEFAULT))
- elog(FATAL, "failed to initialize %s to %d",
- conf->gen.name, (int) conf->boot_val);
- *conf->variable = conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_INT:
- {
- struct config_int *conf = (struct config_int *) gconf;
-
- Assert(conf->boot_val >= conf->min);
- Assert(conf->boot_val <= conf->max);
- if (conf->assign_hook)
- if (!(*conf->assign_hook) (conf->boot_val, true,
- PGC_S_DEFAULT))
- elog(FATAL, "failed to initialize %s to %d",
- conf->gen.name, conf->boot_val);
- *conf->variable = conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_REAL:
- {
- struct config_real *conf = (struct config_real *) gconf;
-
- Assert(conf->boot_val >= conf->min);
- Assert(conf->boot_val <= conf->max);
- if (conf->assign_hook)
- if (!(*conf->assign_hook) (conf->boot_val, true,
- PGC_S_DEFAULT))
- elog(FATAL, "failed to initialize %s to %g",
- conf->gen.name, conf->boot_val);
- *conf->variable = conf->reset_val = conf->boot_val;
- break;
- }
- case PGC_STRING:
- {
- struct config_string *conf = (struct config_string *) gconf;
- char *str;
-
- *conf->variable = NULL;
- conf->reset_val = NULL;
-
- if (conf->boot_val == NULL)
{
- /* leave the value NULL, do not call assign hook */
+ struct config_bool *conf = (struct config_bool *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->boot_val, true,
+ PGC_S_DEFAULT))
+ elog(FATAL, "failed to initialize %s to %d",
+ conf->gen.name, (int) conf->boot_val);
+ *conf->variable = conf->reset_val = conf->boot_val;
break;
}
+ case PGC_INT:
+ {
+ struct config_int *conf = (struct config_int *) gconf;
- str = guc_strdup(FATAL, conf->boot_val);
- conf->reset_val = str;
+ Assert(conf->boot_val >= conf->min);
+ Assert(conf->boot_val <= conf->max);
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->boot_val, true,
+ PGC_S_DEFAULT))
+ elog(FATAL, "failed to initialize %s to %d",
+ conf->gen.name, conf->boot_val);
+ *conf->variable = conf->reset_val = conf->boot_val;
+ break;
+ }
+ case PGC_REAL:
+ {
+ struct config_real *conf = (struct config_real *) gconf;
- if (conf->assign_hook)
+ Assert(conf->boot_val >= conf->min);
+ Assert(conf->boot_val <= conf->max);
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->boot_val, true,
+ PGC_S_DEFAULT))
+ elog(FATAL, "failed to initialize %s to %g",
+ conf->gen.name, conf->boot_val);
+ *conf->variable = conf->reset_val = conf->boot_val;
+ break;
+ }
+ case PGC_STRING:
{
- const char *newstr;
+ struct config_string *conf = (struct config_string *) gconf;
+ char *str;
+
+ *conf->variable = NULL;
+ conf->reset_val = NULL;
- newstr = (*conf->assign_hook) (str, true,
- PGC_S_DEFAULT);
- if (newstr == NULL)
+ if (conf->boot_val == NULL)
{
- elog(FATAL, "failed to initialize %s to \"%s\"",
- conf->gen.name, str);
+ /* leave the value NULL, do not call assign hook */
+ break;
}
- else if (newstr != str)
+
+ str = guc_strdup(FATAL, conf->boot_val);
+ conf->reset_val = str;
+
+ if (conf->assign_hook)
{
- free(str);
+ const char *newstr;
- /*
- * See notes in set_config_option about casting
- */
- str = (char *) newstr;
- conf->reset_val = str;
+ newstr = (*conf->assign_hook) (str, true,
+ PGC_S_DEFAULT);
+ if (newstr == NULL)
+ {
+ elog(FATAL, "failed to initialize %s to \"%s\"",
+ conf->gen.name, str);
+ }
+ else if (newstr != str)
+ {
+ free(str);
+
+ /*
+ * See notes in set_config_option about casting
+ */
+ str = (char *) newstr;
+ conf->reset_val = str;
+ }
}
+ *conf->variable = str;
+ break;
}
- *conf->variable = str;
- break;
- }
case PGC_ENUM:
- {
- struct config_enum *conf = (struct config_enum *) gconf;
-
- if (conf->assign_hook)
- if (!(*conf->assign_hook) (conf->boot_val, true,
- PGC_S_DEFAULT))
- elog(FATAL, "failed to initialize %s to %s",
- conf->gen.name,
- config_enum_lookup_by_value(conf, conf->boot_val));
- *conf->variable = conf->reset_val = conf->boot_val;
- break;
- }
+ {
+ struct config_enum *conf = (struct config_enum *) gconf;
+
+ if (conf->assign_hook)
+ if (!(*conf->assign_hook) (conf->boot_val, true,
+ PGC_S_DEFAULT))
+ elog(FATAL, "failed to initialize %s to %s",
+ conf->gen.name,
+ config_enum_lookup_by_value(conf, conf->boot_val));
+ *conf->variable = conf->reset_val = conf->boot_val;
+ break;
+ }
}
}
case PGC_ENUM:
{
struct config_enum *conf = (struct config_enum *) gconf;
- int newval = newvalue.enumval;
+ int newval = newvalue.enumval;
if (*conf->variable != newval)
{
if (conf->assign_hook)
if (!(*conf->assign_hook) (newval,
- true, PGC_S_OVERRIDE))
+ true, PGC_S_OVERRIDE))
elog(LOG, "failed to commit %s as %s",
conf->gen.name,
config_enum_lookup_by_value(conf, newval));
* allocated for modification.
*/
const char *
-config_enum_lookup_by_value(struct config_enum *record, int val)
+config_enum_lookup_by_value(struct config_enum * record, int val)
{
const struct config_enum_entry *entry;
elog(ERROR, "could not find enum option %d for %s",
val, record->gen.name);
- return NULL; /* silence compiler */
+ return NULL; /* silence compiler */
}
* true. If it's not found, return FALSE and retval is set to 0.
*/
bool
-config_enum_lookup_by_name(struct config_enum *record, const char *value,
+config_enum_lookup_by_name(struct config_enum * record, const char *value,
int *retval)
{
const struct config_enum_entry *entry;
* If suffix is non-NULL, it is added to the end of the string.
*/
static char *
-config_enum_get_options(struct config_enum *record, const char *prefix,
+config_enum_get_options(struct config_enum * record, const char *prefix,
const char *suffix, const char *separator)
{
const struct config_enum_entry *entry;
- StringInfoData retstr;
+ StringInfoData retstr;
int seplen;
initStringInfo(&retstr);
appendStringInfoString(&retstr, prefix);
-
+
seplen = strlen(separator);
for (entry = record->options; entry && entry->name; entry++)
{
}
/*
- * All the entries may have been hidden, leaving the string empty
- * if no prefix was given. This indicates a broken GUC setup, since
- * there is no use for an enum without any values, so we just check
- * to make sure we don't write to invalid memory instead of actually
- * trying to do something smart with it.
+ * All the entries may have been hidden, leaving the string empty if no
+ * prefix was given. This indicates a broken GUC setup, since there is no
+ * use for an enum without any values, so we just check to make sure we
+ * don't write to invalid memory instead of actually trying to do
+ * something smart with it.
*/
if (retstr.len >= seplen)
{
if (changeVal && !is_newvalue_equal(record, value))
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
- errmsg("attempted change of parameter \"%s\" ignored",
- name),
+ errmsg("attempted change of parameter \"%s\" ignored",
+ name),
errdetail("This parameter cannot be changed after server start.")));
return true;
}
{
ereport(elevel,
(errcode(ERRCODE_CANT_CHANGE_RUNTIME_PARAM),
- errmsg("attempted change of parameter \"%s\" ignored",
- name),
+ errmsg("attempted change of parameter \"%s\" ignored",
+ name),
errdetail("This parameter cannot be changed after server start.")));
return false;
}
{
if (!config_enum_lookup_by_name(conf, value, &newval))
{
- char *hintmsg;
-
- hintmsg = config_enum_get_options(conf,
- "Available values: ",
+ char *hintmsg;
+
+ hintmsg = config_enum_get_options(conf,
+ "Available values: ",
".", ", ");
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid value for parameter \"%s\": \"%s\"",
- name, value),
+ errmsg("invalid value for parameter \"%s\": \"%s\"",
+ name, value),
hintmsg ? errhint("%s", _(hintmsg)) : 0));
if (hintmsg)
{
ereport(elevel,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid value for parameter \"%s\": \"%s\"",
- name,
- config_enum_lookup_by_value(conf, newval))));
+ errmsg("invalid value for parameter \"%s\": \"%s\"",
+ name,
+ config_enum_lookup_by_value(conf, newval))));
return false;
}
int elevel;
/*
- * To avoid cluttering the log, only the postmaster bleats loudly
- * about problems with the config file.
+ * To avoid cluttering the log, only the postmaster bleats loudly about
+ * problems with the config file.
*/
elevel = IsUnderPostmaster ? DEBUG3 : LOG;
case PGC_ENUM:
return config_enum_lookup_by_value((struct config_enum *) record,
- *((struct config_enum *) record)->variable);
+ *((struct config_enum *) record)->variable);
}
return NULL;
}
case PGC_ENUM:
return config_enum_lookup_by_value((struct config_enum *) record,
- ((struct config_enum *) record)->reset_val);
+ ((struct config_enum *) record)->reset_val);
}
return NULL;
}
* report (in addition to the generic "invalid value for option FOO" that
* guc.c will provide). Note that the result might be ERROR or a lower
* level, so the caller must be prepared for control to return from ereport,
- * or not. If control does return, return false/NULL from the hook function.
+ * or not. If control does return, return false/NULL from the hook function.
*
* At some point it'd be nice to replace this with a mechanism that allows
* the custom message to become the DETAIL line of guc.c's generic message.
{
/*
* If we're a postmaster child, this is probably "undo" during
- * transaction abort, so we don't want to clutter the log. There's
- * a small chance of a real problem with an OVERRIDE setting,
- * though, so suppressing the message entirely wouldn't be desirable.
+ * transaction abort, so we don't want to clutter the log. There's a
+ * small chance of a real problem with an OVERRIDE setting, though, so
+ * suppressing the message entirely wouldn't be desirable.
*/
elevel = IsUnderPostmaster ? DEBUG5 : LOG;
}
/*
* Each list member may be a plain A_Const node, or an A_Const within a
- * TypeCast; the latter case is supported only for ConstInterval
- * arguments (for SET TIME ZONE).
+ * TypeCast; the latter case is supported only for ConstInterval arguments
+ * (for SET TIME ZONE).
*/
foreach(l, args)
{
- Node *arg = (Node *) lfirst(l);
+ Node *arg = (Node *) lfirst(l);
char *val;
TypeName *typename = NULL;
- A_Const *con;
+ A_Const *con;
if (l != list_head(args))
appendStringInfo(&buf, ", ");
if (IsA(arg, TypeCast))
{
- TypeCast *tc = (TypeCast *) arg;
+ TypeCast *tc = (TypeCast *) arg;
arg = tc->arg;
typename = tc->typename;
struct config_generic *gen;
/*
- * Only allow custom PGC_POSTMASTER variables to be created during
- * shared library preload; any later than that, we can't ensure that
- * the value doesn't change after startup. This is a fatal elog if it
- * happens; just erroring out isn't safe because we don't know what
- * the calling loadable module might already have hooked into.
+ * Only allow custom PGC_POSTMASTER variables to be created during shared
+ * library preload; any later than that, we can't ensure that the value
+ * doesn't change after startup. This is a fatal elog if it happens; just
+ * erroring out isn't safe because we don't know what the calling loadable
+ * module might already have hooked into.
*/
if (context == PGC_POSTMASTER &&
!process_shared_preload_libraries_in_progress)
const char **nameAddr = &name;
const char *value;
struct config_string *pHolder;
- GucContext phcontext;
+ GucContext phcontext;
struct config_generic **res;
/*
*res = variable;
/*
- * Infer context for assignment based on source of existing value.
- * We can't tell this with exact accuracy, but we can at least do
- * something reasonable in typical cases.
+ * Infer context for assignment based on source of existing value. We
+ * can't tell this with exact accuracy, but we can at least do something
+ * reasonable in typical cases.
*/
switch (pHolder->gen.source)
{
case PGC_S_ENV_VAR:
case PGC_S_FILE:
case PGC_S_ARGV:
+
/*
- * If we got past the check in init_custom_variable, we can
- * safely assume that any existing value for a PGC_POSTMASTER
- * variable was set in postmaster context.
+ * If we got past the check in init_custom_variable, we can safely
+ * assume that any existing value for a PGC_POSTMASTER variable
+ * was set in postmaster context.
*/
if (variable->context == PGC_POSTMASTER)
phcontext = PGC_POSTMASTER;
const char *long_desc,
int *valueAddr,
int bootValue,
- const struct config_enum_entry *options,
+ const struct config_enum_entry * options,
GucContext context,
int flags,
GucEnumAssignHook assign_hook,
/* enumvals */
values[11] = NULL;
- /* boot_val */
- snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
- values[12] = pstrdup(buffer);
+ /* boot_val */
+ snprintf(buffer, sizeof(buffer), "%d", lconf->boot_val);
+ values[12] = pstrdup(buffer);
- /* reset_val */
- snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
- values[13] = pstrdup(buffer);
+ /* reset_val */
+ snprintf(buffer, sizeof(buffer), "%d", lconf->reset_val);
+ values[13] = pstrdup(buffer);
}
break;
/* enumvals */
values[11] = NULL;
- /* boot_val */
- snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
- values[12] = pstrdup(buffer);
+ /* boot_val */
+ snprintf(buffer, sizeof(buffer), "%g", lconf->boot_val);
+ values[12] = pstrdup(buffer);
- /* reset_val */
- snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
- values[13] = pstrdup(buffer);
+ /* reset_val */
+ snprintf(buffer, sizeof(buffer), "%g", lconf->reset_val);
+ values[13] = pstrdup(buffer);
}
break;
case PGC_STRING:
{
- struct config_string *lconf = (struct config_string *) conf;
+ struct config_string *lconf = (struct config_string *) conf;
/* min_val */
values[9] = NULL;
/* enumvals */
values[11] = NULL;
- /* boot_val */
- if (lconf->boot_val == NULL)
- values[12] = NULL;
+ /* boot_val */
+ if (lconf->boot_val == NULL)
+ values[12] = NULL;
else
values[12] = pstrdup(lconf->boot_val);
- /* reset_val */
- if (lconf->reset_val == NULL)
- values[13] = NULL;
+ /* reset_val */
+ if (lconf->reset_val == NULL)
+ values[13] = NULL;
else
values[13] = pstrdup(lconf->reset_val);
}
case PGC_ENUM:
{
- struct config_enum *lconf = (struct config_enum *) conf;
+ struct config_enum *lconf = (struct config_enum *) conf;
/* min_val */
values[9] = NULL;
values[10] = NULL;
/* enumvals */
- /* NOTE! enumvals with double quotes in them are not supported! */
+
+ /*
+ * NOTE! enumvals with double quotes in them are not
+ * supported!
+ */
values[11] = config_enum_get_options((struct config_enum *) conf,
"{\"", "\"}", "\",\"");
- /* boot_val */
+ /* boot_val */
values[12] = pstrdup(config_enum_lookup_by_value(lconf,
- lconf->boot_val));
+ lconf->boot_val));
- /* reset_val */
+ /* reset_val */
values[13] = pstrdup(config_enum_lookup_by_value(lconf,
- lconf->reset_val));
+ lconf->reset_val));
}
break;
/* enumvals */
values[11] = NULL;
- /* boot_val */
- values[12] = NULL;
+ /* boot_val */
+ values[12] = NULL;
- /* reset_val */
- values[13] = NULL;
+ /* reset_val */
+ values[13] = NULL;
}
break;
}
- /*
- * If the setting came from a config file, set the source location.
- * For security reasons, we don't show source file/line number for
+ /*
+ * If the setting came from a config file, set the source location. For
+ * security reasons, we don't show source file/line number for
* non-superusers.
*/
if (conf->source == PGC_S_FILE && superuser())
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 12, "enumvals",
TEXTARRAYOID, -1, 0);
- TupleDescInitEntry(tupdesc, (AttrNumber) 13, "boot_val",
- TEXTOID, -1, 0);
- TupleDescInitEntry(tupdesc, (AttrNumber) 14, "reset_val",
- TEXTOID, -1, 0);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 13, "boot_val",
+ TEXTOID, -1, 0);
+ TupleDescInitEntry(tupdesc, (AttrNumber) 14, "reset_val",
+ TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 15, "sourcefile",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 16, "sourceline",
{
/*
* Use int64 arithmetic to avoid overflows in units
- * conversion. If INT64_IS_BUSTED we might overflow
+ * conversion. If INT64_IS_BUSTED we might overflow
* anyway and print bogus answers, but there are few
- * enough such machines that it doesn't seem worth
- * trying harder.
+ * enough such machines that it doesn't seem worth trying
+ * harder.
*/
int64 result = *conf->variable;
const char *unit;
{
struct config_enum *conf = (struct config_enum *) record;
- if(conf->show_hook)
+ if (conf->show_hook)
val = (*conf->show_hook) ();
else
val = config_enum_lookup_by_value(conf, *conf->variable);
* variable source, integer
*/
static void
-write_one_nondefault_variable(FILE *fp, struct config_generic *gconf)
+write_one_nondefault_variable(FILE *fp, struct config_generic * gconf)
{
if (gconf->source == PGC_S_DEFAULT)
return;
switch (gconf->vartype)
{
case PGC_BOOL:
- {
- struct config_bool *conf = (struct config_bool *) gconf;
+ {
+ struct config_bool *conf = (struct config_bool *) gconf;
- if (*conf->variable)
- fprintf(fp, "true");
- else
- fprintf(fp, "false");
- }
- break;
+ if (*conf->variable)
+ fprintf(fp, "true");
+ else
+ fprintf(fp, "false");
+ }
+ break;
case PGC_INT:
- {
- struct config_int *conf = (struct config_int *) gconf;
+ {
+ struct config_int *conf = (struct config_int *) gconf;
- fprintf(fp, "%d", *conf->variable);
- }
- break;
+ fprintf(fp, "%d", *conf->variable);
+ }
+ break;
case PGC_REAL:
- {
- struct config_real *conf = (struct config_real *) gconf;
+ {
+ struct config_real *conf = (struct config_real *) gconf;
- /* Could lose precision here? */
- fprintf(fp, "%f", *conf->variable);
- }
- break;
+ /* Could lose precision here? */
+ fprintf(fp, "%f", *conf->variable);
+ }
+ break;
case PGC_STRING:
- {
- struct config_string *conf = (struct config_string *) gconf;
+ {
+ struct config_string *conf = (struct config_string *) gconf;
- fprintf(fp, "%s", *conf->variable);
- }
- break;
+ fprintf(fp, "%s", *conf->variable);
+ }
+ break;
case PGC_ENUM:
- {
- struct config_enum *conf = (struct config_enum *) gconf;
-
- fprintf(fp, "%s",
- config_enum_lookup_by_value(conf, *conf->variable));
- }
- break;
+ {
+ struct config_enum *conf = (struct config_enum *) gconf;
+
+ fprintf(fp, "%s",
+ config_enum_lookup_by_value(conf, *conf->variable));
+ }
+ break;
}
fputc(0, fp);
list_free(elemlist);
ereport(GUC_complaint_elevel(source),
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid list syntax for parameter \"log_destination\"")));
+ errmsg("invalid list syntax for parameter \"log_destination\"")));
return NULL;
}
*
* drives | I/O requests
* -------+----------------
- * 1 | 1
- * 2 | 2/1 + 2/2 = 3
- * 3 | 3/1 + 3/2 + 3/3 = 5 1/2
- * 4 | 4/1 + 4/2 + 4/3 + 4/4 = 8 1/3
- * n | n * H(n)
+ * 1 | 1
+ * 2 | 2/1 + 2/2 = 3
+ * 3 | 3/1 + 3/2 + 3/3 = 5 1/2
+ * 4 | 4/1 + 4/2 + 4/3 + 4/4 = 8 1/3
+ * n | n * H(n)
*
* This is called the "coupon collector problem" and H(n) is called the
* harmonic series. This could be approximated by n * ln(n), but for
return false;
#else
return true;
-#endif /* USE_PREFETCH */
+#endif /* USE_PREFETCH */
}
static const char *
canonicalize_path(canon_val);
- tname = guc_malloc(ERROR, strlen(canon_val) + 12); /* /pgstat.tmp */
+ tname = guc_malloc(ERROR, strlen(canon_val) + 12); /* /pgstat.tmp */
sprintf(tname, "%s/pgstat.tmp", canon_val);
- fname = guc_malloc(ERROR, strlen(canon_val) + 13); /* /pgstat.stat */
+ fname = guc_malloc(ERROR, strlen(canon_val) + 13); /* /pgstat.stat */
sprintf(fname, "%s/pgstat.stat", canon_val);
if (pgstat_stat_tmpname)
case PGC_ENUM:
printf("ENUM\t%s\t\t\t",
config_enum_lookup_by_value(&structToPrint->_enum,
- structToPrint->_enum.boot_val));
+ structToPrint->_enum.boot_val));
break;
default:
}
save_ctr = ctr;
}
-
-#endif /* RANDOMIZE_ALLOCATED_MEMORY */
+#endif /* RANDOMIZE_ALLOCATED_MEMORY */
/*
while (owner->nsnapshots > 0)
{
if (isCommit)
- PrintSnapshotLeakWarning(owner->snapshots[owner->nsnapshots -1]);
- UnregisterSnapshot(owner->snapshots[owner->nsnapshots -1]);
+ PrintSnapshotLeakWarning(owner->snapshots[owner->nsnapshots - 1]);
+ UnregisterSnapshot(owner->snapshots[owner->nsnapshots - 1]);
}
/* Clean up index scans too */
ResourceOwnerForgetSnapshot(ResourceOwner owner, Snapshot snapshot)
{
Snapshot *snapshots = owner->snapshots;
- int ns1 = owner->nsnapshots -1;
+ int ns1 = owner->nsnapshots - 1;
int i;
for (i = ns1; i >= 0; i--)
int tapenum, unsigned int len);
static void reversedirection_heap(Tuplesortstate *state);
static int comparetup_index_btree(const SortTuple *a, const SortTuple *b,
- Tuplesortstate *state);
+ Tuplesortstate *state);
static int comparetup_index_hash(const SortTuple *a, const SortTuple *b,
- Tuplesortstate *state);
+ Tuplesortstate *state);
static void copytup_index(Tuplesortstate *state, SortTuple *stup, void *tup);
static void writetup_index(Tuplesortstate *state, int tapenum,
SortTuple *stup);
state->nKeys = nkeys;
TRACE_POSTGRESQL_SORT_START(HEAP_SORT,
- false, /* no unique check */
+ false, /* no unique check */
nkeys,
workMem,
randomAccess);
#ifdef TRACE_SORT
if (trace_sort)
elog(LOG,
- "begin index sort: hash_mask = 0x%x, workMem = %d, randomAccess = %c",
+ "begin index sort: hash_mask = 0x%x, workMem = %d, randomAccess = %c",
hash_mask,
workMem, randomAccess ? 't' : 'f');
#endif
state->nKeys = 1; /* always a one-column sort */
TRACE_POSTGRESQL_SORT_START(DATUM_SORT,
- false, /* no unique check */
+ false, /* no unique check */
1,
workMem,
randomAccess);
#else
/*
- * If you disabled TRACE_SORT, you can still probe sort__done, but
- * you ain't getting space-used stats.
+ * If you disabled TRACE_SORT, you can still probe sort__done, but you
+ * ain't getting space-used stats.
*/
TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, 0L);
#endif
writetup_heap(Tuplesortstate *state, int tapenum, SortTuple *stup)
{
MinimalTuple tuple = (MinimalTuple) stup->tuple;
+
/* the part of the MinimalTuple we'll write: */
char *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
unsigned int tupbodylen = tuple->t_len - MINIMAL_TUPLE_DATA_OFFSET;
+
/* total on-disk footprint: */
unsigned int tuplen = tupbodylen + sizeof(int);
CHECK_FOR_INTERRUPTS();
/*
- * Fetch hash keys and mask off bits we don't want to sort by.
- * We know that the first column of the index tuple is the hash key.
+ * Fetch hash keys and mask off bits we don't want to sort by. We know
+ * that the first column of the index tuple is the hash key.
*/
Assert(!a->isnull1);
hash1 = DatumGetUInt32(a->datum1) & state->hash_mask;
* When the caller requests backward-scan capability, we write the temp file
* in a format that allows either forward or backward scan. Otherwise, only
* forward scan is allowed. A request for backward scan must be made before
- * putting any tuples into the tuplestore. Rewind is normally allowed but
+ * putting any tuples into the tuplestore. Rewind is normally allowed but
* can be turned off via tuplestore_set_eflags; turning off rewind for all
* read pointers enables truncation of the tuplestore at the oldest read point
* for minimal memory usage. (The caller must explicitly call tuplestore_trim
*
* Special case: if eof_reached is true, then the pointer's read position is
* implicitly equal to the write position, and current/file/offset aren't
- * maintained. This way we need not update all the read pointers each time
+ * maintained. This way we need not update all the read pointers each time
* we write.
*/
typedef struct
int readptrsize; /* allocated length of readptrs array */
int writepos_file; /* file# (valid if READFILE state) */
- off_t writepos_offset; /* offset (valid if READFILE state) */
+ off_t writepos_offset; /* offset (valid if READFILE state) */
};
#define COPYTUP(state,tup) ((*(state)->copytup) (state, tup))
/* Make room for another read pointer if needed */
if (state->readptrcount >= state->readptrsize)
{
- int newcnt = state->readptrsize * 2;
+ int newcnt = state->readptrsize * 2;
state->readptrs = (TSReadPointer *)
repalloc(state->readptrs, newcnt * sizeof(TSReadPointer));
/* no work */
break;
case TSS_READFILE:
+
/*
- * First, save the current read position in the pointer about
- * to become inactive.
+ * First, save the current read position in the pointer about to
+ * become inactive.
*/
if (!oldptr->eof_reached)
BufFileTell(state->myfile,
*/
PrepareTempTablespaces();
state->myfile = BufFileCreateTemp(state->interXact);
+
/*
- * Freeze the decision about whether trailing length words
- * will be used. We can't change this choice once data is on
- * tape, even though callers might drop the requirement.
+ * Freeze the decision about whether trailing length words will be
+ * used. We can't change this choice once data is on tape, even
+ * though callers might drop the requirement.
*/
state->backward = (state->eflags & EXEC_FLAG_BACKWARD) != 0;
state->status = TSS_WRITEFILE;
case TSS_WRITEFILE:
/*
- * Update read pointers as needed; see API spec above.
- * Note: BufFileTell is quite cheap, so not worth trying
- * to avoid multiple calls.
+ * Update read pointers as needed; see API spec above. Note:
+ * BufFileTell is quite cheap, so not worth trying to avoid
+ * multiple calls.
*/
readptr = state->readptrs;
for (i = 0; i < state->readptrcount; readptr++, i++)
Assert(!state->truncated);
return NULL;
}
- readptr->current--; /* last returned tuple */
+ readptr->current--; /* last returned tuple */
}
if (readptr->current <= 0)
{
}
/*
- * tuplestore_copy_read_pointer - copy a read pointer's state to another
+ * tuplestore_copy_read_pointer - copy a read pointer's state to another
*/
void
tuplestore_copy_read_pointer(Tuplestorestate *state,
if (dptr->eflags != sptr->eflags)
{
/* Possible change of overall eflags, so copy and then recompute */
- int eflags;
- int i;
+ int eflags;
+ int i;
*dptr = *sptr;
eflags = state->readptrs[0].eflags;
/* no work */
break;
case TSS_READFILE:
+
/*
* This case is a bit tricky since the active read pointer's
* position corresponds to the seek point, not what is in its
int i;
/*
- * Truncation is disallowed if any read pointer requires rewind capability.
+ * Truncation is disallowed if any read pointer requires rewind
+ * capability.
*/
if (state->eflags & EXEC_FLAG_REWIND)
return;
/*
* Note: you might think we could remove all the tuples before the oldest
- * "current", since that one is the next to be returned. However,
- * since tuplestore_gettuple returns a direct pointer to our
- * internal copy of the tuple, it's likely that the caller has
- * still got the tuple just before "current" referenced in a slot.
- * So we keep one extra tuple before the oldest "current". (Strictly
- * speaking, we could require such callers to use the "copy" flag to
- * tuplestore_gettupleslot, but for efficiency we allow this one case
- * to not use "copy".)
+ * "current", since that one is the next to be returned. However, since
+ * tuplestore_gettuple returns a direct pointer to our internal copy of
+ * the tuple, it's likely that the caller has still got the tuple just
+ * before "current" referenced in a slot. So we keep one extra tuple
+ * before the oldest "current". (Strictly speaking, we could require such
+ * callers to use the "copy" flag to tuplestore_gettupleslot, but for
+ * efficiency we allow this one case to not use "copy".)
*/
nremove = oldest - 1;
if (nremove <= 0)
writetup_heap(Tuplestorestate *state, void *tup)
{
MinimalTuple tuple = (MinimalTuple) tup;
+
/* the part of the MinimalTuple we'll write: */
char *tupbody = (char *) tuple + MINIMAL_TUPLE_DATA_OFFSET;
unsigned int tupbodylen = tuple->t_len - MINIMAL_TUPLE_DATA_OFFSET;
+
/* total on-disk footprint: */
unsigned int tuplen = tupbodylen + sizeof(int);
/* read in the tuple proper */
tuple->t_len = tuplen;
if (BufFileRead(state->myfile, (void *) tupbody,
- tupbodylen) != (size_t) tupbodylen)
+ tupbodylen) != (size_t) tupbodylen)
elog(ERROR, "unexpected end of data");
if (state->backward) /* need trailing length word? */
if (BufFileRead(state->myfile, (void *) &tuplen,
* (tracked by separate refcounts on each snapshot), its memory can be freed.
*
* These arrangements let us reset MyProc->xmin when there are no snapshots
- * referenced by this transaction. (One possible improvement would be to be
+ * referenced by this transaction. (One possible improvement would be to be
* able to advance Xmin when the snapshot with the earliest Xmin is no longer
- * referenced. That's a bit harder though, it requires more locking, and
+ * referenced. That's a bit harder though, it requires more locking, and
* anyway it should be rather uncommon to keep snapshots referenced for too
* long.)
*
static SnapshotData SecondarySnapshotData = {HeapTupleSatisfiesMVCC};
/* Pointers to valid snapshots */
-static Snapshot CurrentSnapshot = NULL;
-static Snapshot SecondarySnapshot = NULL;
+static Snapshot CurrentSnapshot = NULL;
+static Snapshot SecondarySnapshot = NULL;
/*
* These are updated by GetSnapshotData. We initialize them this way
* mode, we don't want it to say that BootstrapTransactionId is in progress.
*
* RecentGlobalXmin is initialized to InvalidTransactionId, to ensure that no
- * one tries to use a stale value. Readers should ensure that it has been set
+ * one tries to use a stale value. Readers should ensure that it has been set
* to something else before using it.
*/
TransactionId TransactionXmin = FirstNormalTransactionId;
} ActiveSnapshotElt;
/* Top of the stack of active snapshots */
-static ActiveSnapshotElt *ActiveSnapshot = NULL;
+static ActiveSnapshotElt *ActiveSnapshot = NULL;
/*
* How many snapshots is resowner.c tracking for us?
* smarter about advancing our MyProc->xmin we will need to be more
* sophisticated about this, perhaps keeping our own list of snapshots.
*/
-static int RegisteredSnapshots = 0;
+static int RegisteredSnapshots = 0;
/* first GetTransactionSnapshot call in a transaction? */
-bool FirstSnapshotSet = false;
+bool FirstSnapshotSet = false;
/*
* Remembers whether this transaction registered a serializable snapshot at
* start. We cannot trust FirstSnapshotSet in combination with
* IsXactIsoLevelSerializable, because GUC may be reset before us.
*/
-static bool registered_serializable = false;
+static bool registered_serializable = false;
static Snapshot CopySnapshot(Snapshot snapshot);
static void FreeSnapshot(Snapshot snapshot);
-static void SnapshotResetXmin(void);
+static void SnapshotResetXmin(void);
/*
FirstSnapshotSet = true;
/*
- * In serializable mode, the first snapshot must live until end of xact
- * regardless of what the caller does with it, so we must register it
- * internally here and unregister it at end of xact.
+ * In serializable mode, the first snapshot must live until end of
+ * xact regardless of what the caller does with it, so we must
+ * register it internally here and unregister it at end of xact.
*/
if (IsXactIsoLevelSerializable)
{
CurrentSnapshot = RegisterSnapshotOnOwner(CurrentSnapshot,
- TopTransactionResourceOwner);
+ TopTransactionResourceOwner);
registered_serializable = true;
}
/*
* SnapshotSetCommandId
- * Propagate CommandCounterIncrement into the static snapshots, if set
+ * Propagate CommandCounterIncrement into the static snapshots, if set
*/
void
SnapshotSetCommandId(CommandId curcid)
/*
* PushActiveSnapshot
- * Set the given snapshot as the current active snapshot
+ * Set the given snapshot as the current active snapshot
*
* If this is the first use of this snapshot, create a new long-lived copy with
* active refcount=1. Otherwise, only increment the refcount.
void
PushActiveSnapshot(Snapshot snap)
{
- ActiveSnapshotElt *newactive;
+ ActiveSnapshotElt *newactive;
Assert(snap != InvalidSnapshot);
/*
* PushUpdatedSnapshot
- * As above, except we set the snapshot's CID to the current CID.
+ * As above, except we set the snapshot's CID to the current CID.
*/
void
PushUpdatedSnapshot(Snapshot snapshot)
void
PopActiveSnapshot(void)
{
- ActiveSnapshotElt *newstack;
+ ActiveSnapshotElt *newstack;
newstack = ActiveSnapshot->as_next;
/*
* GetActiveSnapshot
- * Return the topmost snapshot in the Active stack.
+ * Return the topmost snapshot in the Active stack.
*/
Snapshot
GetActiveSnapshot(void)
/*
* ActiveSnapshotSet
- * Return whether there is at least one snapshot in the Active stack
+ * Return whether there is at least one snapshot in the Active stack
*/
bool
ActiveSnapshotSet(void)
/*
* RegisterSnapshot
- * Register a snapshot as being in use by the current resource owner
+ * Register a snapshot as being in use by the current resource owner
*
* If InvalidSnapshot is passed, it is not registered.
*/
/*
* RegisterSnapshotOnOwner
- * As above, but use the specified resource owner
+ * As above, but use the specified resource owner
*/
Snapshot
RegisterSnapshotOnOwner(Snapshot snapshot, ResourceOwner owner)
{
- Snapshot snap;
+ Snapshot snap;
if (snapshot == InvalidSnapshot)
return InvalidSnapshot;
/*
* UnregisterSnapshotFromOwner
- * As above, but use the specified resource owner
+ * As above, but use the specified resource owner
*/
void
UnregisterSnapshotFromOwner(Snapshot snapshot, ResourceOwner owner)
void
AtSubCommit_Snapshot(int level)
{
- ActiveSnapshotElt *active;
+ ActiveSnapshotElt *active;
/*
* Relabel the active snapshots set in this subtransaction as though they
/*
* AtSubAbort_Snapshot
- * Clean up snapshots after a subtransaction abort
+ * Clean up snapshots after a subtransaction abort
*/
void
AtSubAbort_Snapshot(int level)
/* Forget the active snapshots set by this subtransaction */
while (ActiveSnapshot && ActiveSnapshot->as_level >= level)
{
- ActiveSnapshotElt *next;
+ ActiveSnapshotElt *next;
next = ActiveSnapshot->as_next;
AtEarlyCommit_Snapshot(void)
{
/*
- * On a serializable transaction we must unregister our private refcount to
- * the serializable snapshot.
+ * On a serializable transaction we must unregister our private refcount
+ * to the serializable snapshot.
*/
if (registered_serializable)
UnregisterSnapshotFromOwner(CurrentSnapshot,
/*
* AtEOXact_Snapshot
- * Snapshot manager's cleanup function for end of transaction
+ * Snapshot manager's cleanup function for end of transaction
*/
void
AtEOXact_Snapshot(bool isCommit)
/* On commit, complain about leftover snapshots */
if (isCommit)
{
- ActiveSnapshotElt *active;
+ ActiveSnapshotElt *active;
if (RegisteredSnapshots != 0)
elog(WARNING, "%d registered snapshots seem to remain after cleanup",
*
* Summary of visibility functions:
*
- * HeapTupleSatisfiesMVCC()
- * visible to supplied snapshot, excludes current command
- * HeapTupleSatisfiesNow()
- * visible to instant snapshot, excludes current command
- * HeapTupleSatisfiesUpdate()
- * like HeapTupleSatisfiesNow(), but with user-supplied command
- * counter and more complex result
- * HeapTupleSatisfiesSelf()
- * visible to instant snapshot and current command
- * HeapTupleSatisfiesDirty()
- * like HeapTupleSatisfiesSelf(), but includes open transactions
- * HeapTupleSatisfiesVacuum()
- * visible to any running transaction, used by VACUUM
- * HeapTupleSatisfiesToast()
- * visible unless part of interrupted vacuum, used for TOAST
- * HeapTupleSatisfiesAny()
- * all tuples are visible
+ * HeapTupleSatisfiesMVCC()
+ * visible to supplied snapshot, excludes current command
+ * HeapTupleSatisfiesNow()
+ * visible to instant snapshot, excludes current command
+ * HeapTupleSatisfiesUpdate()
+ * like HeapTupleSatisfiesNow(), but with user-supplied command
+ * counter and more complex result
+ * HeapTupleSatisfiesSelf()
+ * visible to instant snapshot and current command
+ * HeapTupleSatisfiesDirty()
+ * like HeapTupleSatisfiesSelf(), but includes open transactions
+ * HeapTupleSatisfiesVacuum()
+ * visible to any running transaction, used by VACUUM
+ * HeapTupleSatisfiesToast()
+ * visible unless part of interrupted vacuum, used for TOAST
+ * HeapTupleSatisfiesAny()
+ * all tuples are visible
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
static void usage(const char *progname);
#ifdef WIN32
-static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo);
+static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo);
#endif
if (!pw)
{
fprintf(stderr,
- _("%s: could not obtain information about current user: %s\n"),
+ _("%s: could not obtain information about current user: %s\n"),
progname, strerror(errno));
exit(1);
}
_("%s: file \"%s\" does not exist\n"), progname, path);
fprintf(stderr,
_("This might mean you have a corrupted installation or identified\n"
- "the wrong directory with the invocation option -L.\n"));
+ "the wrong directory with the invocation option -L.\n"));
}
else
{
fprintf(stderr,
- _("%s: could not access file \"%s\": %s\n"), progname, path,
- strerror(errno));
+ _("%s: could not access file \"%s\": %s\n"), progname, path,
+ strerror(errno));
fprintf(stderr,
_("This might mean you have a corrupted installation or identified\n"
- "the wrong directory with the invocation option -L.\n"));
+ "the wrong directory with the invocation option -L.\n"));
}
exit(1);
}
fprintf(stderr,
_("%s: file \"%s\" is not a regular file\n"), progname, path);
fprintf(stderr,
- _("This might mean you have a corrupted installation or identified\n"
- "the wrong directory with the invocation option -L.\n"));
+ _("This might mean you have a corrupted installation or identified\n"
+ "the wrong directory with the invocation option -L.\n"));
exit(1);
}
}
bki_lines = replace_token(bki_lines, "ENCODING", encodingid);
bki_lines = replace_token(bki_lines, "LC_COLLATE", lc_collate);
-
+
bki_lines = replace_token(bki_lines, "LC_CTYPE", lc_ctype);
-
+
/*
* Pass correct LC_xxx environment to bootstrap.
*
#ifdef WIN32
/*
- * On win32, if the encoding chosen is UTF8, all locales are OK
- * (assuming the actual locale name passed the checks above). This is
- * because UTF8 is a pseudo-codepage, that we convert to UTF16 before
- * doing any operations on, and UTF16 supports all locales.
+ * On win32, if the encoding chosen is UTF8, all locales are OK (assuming
+ * the actual locale name passed the checks above). This is because UTF8
+ * is a pseudo-codepage, that we convert to UTF16 before doing any
+ * operations on, and UTF16 supports all locales.
*/
|| user_enc == PG_UTF8
#endif
{
fprintf(stderr, _("%s: encoding mismatch\n"), progname);
fprintf(stderr,
- _("The encoding you selected (%s) and the encoding that the\n"
+ _("The encoding you selected (%s) and the encoding that the\n"
"selected locale uses (%s) do not match. This would lead to\n"
"misbehavior in various character string processing functions.\n"
"Rerun %s and either do not specify an encoding explicitly,\n"
- "or choose a matching combination.\n"),
+ "or choose a matching combination.\n"),
pg_encoding_to_char(user_enc),
pg_encoding_to_char(locale_enc),
progname);
}
#ifdef WIN32
-typedef BOOL(WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
+typedef BOOL (WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
#define DISABLE_MAX_PRIVILEGE 0x1
* NOT execute anything.
*/
static int
-CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo)
+CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo)
{
BOOL b;
STARTUPINFO si;
}
if (!CreateProcessAsUser(restrictedToken,
- NULL,
- cmd,
- NULL,
- NULL,
- TRUE,
- CREATE_SUSPENDED,
- NULL,
- NULL,
- &si,
- processInfo))
+ NULL,
+ cmd,
+ NULL,
+ NULL,
+ TRUE,
+ CREATE_SUSPENDED,
+ NULL,
+ NULL,
+ &si,
+ processInfo))
{
fprintf(stderr, "CreateProcessAsUser failed: %lu\n", GetLastError());
printf(_(" -E, --encoding=ENCODING set default encoding for new databases\n"));
printf(_(" --locale=LOCALE set default locale for new databases\n"));
printf(_(" --lc-collate=, --lc-ctype=, --lc-messages=LOCALE\n"
- " --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n"
- " set default locale in the respective category for\n"
- " new databases (default taken from environment)\n"));
+ " --lc-monetary=, --lc-numeric=, --lc-time=LOCALE\n"
+ " set default locale in the respective category for\n"
+ " new databases (default taken from environment)\n"));
printf(_(" --no-locale equivalent to --locale=C\n"));
printf(_(" --pwfile=FILE read password for the new superuser from file\n"));
printf(_(" -T, --text-search-config=CFG\n"
user_enc = atoi(encodingid);
if (!check_locale_encoding(lc_ctype, user_enc) ||
!check_locale_encoding(lc_collate, user_enc))
- exit(1); /* check_locale_encoding printed the error */
+ exit(1); /* check_locale_encoding printed the error */
if (strlen(default_text_search_config) == 0)
{
_("%s: directory \"%s\" exists but is not empty\n"),
progname, xlog_dir);
fprintf(stderr,
- _("If you want to store the transaction log there, either\n"
- "remove or empty the directory \"%s\".\n"),
+ _("If you want to store the transaction log there, either\n"
+ "remove or empty the directory \"%s\".\n"),
xlog_dir);
exit_nicely();
/*
* This slightly-chintzy coding will work as long as the control file
- * timestamps are within the range of time_t; that should be the case
- * in all foreseeable circumstances, so we don't bother importing the
+ * timestamps are within the range of time_t; that should be the case in
+ * all foreseeable circumstances, so we don't bother importing the
* backend's timezone library into pg_controldata.
*
* Use variable for format to suppress overly-anal-retentive gcc warning
static void WINAPI pgwin32_ServiceHandler(DWORD);
static void WINAPI pgwin32_ServiceMain(DWORD, LPTSTR *);
static void pgwin32_doRunAsService(void);
-static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo, bool as_service);
+static int CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service);
static SERVICE_STATUS status;
static SERVICE_STATUS_HANDLE hStatus = (SERVICE_STATUS_HANDLE) 0;
/*
* Look in post_opts for a -p switch.
*
- * This parsing code is not amazingly bright; it could for instance
- * get fooled if ' -p' occurs within a quoted argument value. Given
- * that few people pass complicated settings in post_opts, it's
- * probably good enough.
+ * This parsing code is not amazingly bright; it could for instance get
+ * fooled if ' -p' occurs within a quoted argument value. Given that few
+ * people pass complicated settings in post_opts, it's probably good
+ * enough.
*/
for (p = post_opts; *p;)
{
/*
* Search config file for a 'port' option.
*
- * This parsing code isn't amazingly bright either, but it should be
- * okay for valid port settings.
+ * This parsing code isn't amazingly bright either, but it should be okay
+ * for valid port settings.
*/
if (!*portstr)
{
*/
status.dwWaitHint += 6000;
status.dwCheckPoint++;
- SetServiceStatus(hStatus, (LPSERVICE_STATUS) & status);
+ SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
}
else
{
if (post_opts == NULL)
{
- post_opts = ""; /* default */
+ post_opts = ""; /* default */
if (ctl_command == RESTART_COMMAND)
{
char **optlines;
*/
if ((arg1 = strstr(optline, " \"")) != NULL)
{
- *arg1 = '\0'; /* terminate so we get only program name */
- post_opts = arg1 + 1; /* point past whitespace */
+ *arg1 = '\0'; /* terminate so we get only program
+ * name */
+ post_opts = arg1 + 1; /* point past whitespace */
}
if (postgres_path == NULL)
postgres_path = optline;
{
int cnt;
pgpid_t pid;
- struct stat statbuf;
+ struct stat statbuf;
pid = get_pgpid();
{
int cnt;
pgpid_t pid;
- struct stat statbuf;
+ struct stat statbuf;
pid = get_pgpid();
pgwin32_SetServiceStatus(DWORD currentState)
{
status.dwCurrentState = currentState;
- SetServiceStatus(hStatus, (LPSERVICE_STATUS) & status);
+ SetServiceStatus(hStatus, (LPSERVICE_STATUS) &status);
}
static void WINAPI
}
static void WINAPI
-pgwin32_ServiceMain(DWORD argc, LPTSTR * argv)
+pgwin32_ServiceMain(DWORD argc, LPTSTR *argv)
{
PROCESS_INFORMATION pi;
DWORD ret;
* also load the couple of functions that *do* exist in minwg headers but not
* on NT4. That way, we don't break on NT4.
*/
-typedef BOOL(WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
-typedef BOOL(WINAPI * __IsProcessInJob) (HANDLE, HANDLE, PBOOL);
-typedef HANDLE(WINAPI * __CreateJobObject) (LPSECURITY_ATTRIBUTES, LPCTSTR);
-typedef BOOL(WINAPI * __SetInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
-typedef BOOL(WINAPI * __AssignProcessToJobObject) (HANDLE, HANDLE);
-typedef BOOL(WINAPI * __QueryInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
+typedef BOOL (WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
+typedef BOOL (WINAPI * __IsProcessInJob) (HANDLE, HANDLE, PBOOL);
+typedef HANDLE (WINAPI * __CreateJobObject) (LPSECURITY_ATTRIBUTES, LPCTSTR);
+typedef BOOL (WINAPI * __SetInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
+typedef BOOL (WINAPI * __AssignProcessToJobObject) (HANDLE, HANDLE);
+typedef BOOL (WINAPI * __QueryInformationJobObject) (HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
/* Windows API define missing from MingW headers */
#define DISABLE_MAX_PRIVILEGE 0x1
* automatically destroyed when pg_ctl exits.
*/
static int
-CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION * processInfo, bool as_service)
+CreateRestrictedProcess(char *cmd, PROCESS_INFORMATION *processInfo, bool as_service)
{
int r;
BOOL b;
osv.dwOSVersionInfoSize = sizeof(osv);
if (!GetVersionEx(&osv) ||
osv.dwMajorVersion < 6 ||
- (osv.dwMajorVersion == 6 && osv.dwMinorVersion == 0))
+ (osv.dwMajorVersion == 6 && osv.dwMinorVersion == 0))
{
/*
- * On Windows 7 (and presumably later), JOB_OBJECT_UILIMIT_HANDLES prevents us from
- * starting as a service. So we only enable it on Vista and earlier (version <= 6.0)
+ * On Windows 7 (and presumably later),
+ * JOB_OBJECT_UILIMIT_HANDLES prevents us from
+ * starting as a service. So we only enable it on
+ * Vista and earlier (version <= 6.0)
*/
uiRestrictions.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_HANDLES;
}
}
#ifndef __CYGWIN__
- AddUserToDacl(processInfo->hProcess);
+ AddUserToDacl(processInfo->hProcess);
#endif
-
+
CloseHandle(restrictedToken);
ResumeThread(processInfo->hThread);
printf(_(" %s start [-w] [-t SECS] [-D DATADIR] [-s] [-l FILENAME] [-o \"OPTIONS\"]\n"), progname);
printf(_(" %s stop [-W] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n"), progname);
printf(_(" %s restart [-w] [-t SECS] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n"
- " [-o \"OPTIONS\"]\n"), progname);
+ " [-o \"OPTIONS\"]\n"), progname);
printf(_(" %s reload [-D DATADIR] [-s]\n"), progname);
printf(_(" %s status [-D DATADIR]\n"), progname);
printf(_(" %s kill SIGNALNAME PID\n"), progname);
TSTemplateInfo *tmplinfo;
TSDictInfo *dictinfo;
TSConfigInfo *cfginfo;
- FdwInfo *fdwinfo;
+ FdwInfo *fdwinfo;
ForeignServerInfo *srvinfo;
int numNamespaces;
int numAggregates;
PQExpBuffer privs, PQExpBuffer privswgo);
static char *copyAclUserName(PQExpBuffer output, char *input);
static void AddAcl(PQExpBuffer aclbuf, const char *keyword,
- const char *subname);
+ const char *subname);
#ifdef WIN32
static bool parallel_init_done = false;
init_parallel_dump_utils(void)
{
#ifdef WIN32
- if (! parallel_init_done)
+ if (!parallel_init_done)
{
tls_index = TlsAlloc();
parallel_init_done = true;
}
/*
- * Quotes input string if it's not a legitimate SQL identifier as-is.
+ * Quotes input string if it's not a legitimate SQL identifier as-is.
*
- * Note that the returned string must be used before calling fmtId again,
- * since we re-use the same return buffer each time. Non-reentrant but
- * reduces memory leakage. (On Windows the memory leakage will be one buffer
- * per thread, which is at least better than one per call).
+ * Note that the returned string must be used before calling fmtId again,
+ * since we re-use the same return buffer each time. Non-reentrant but
+ * reduces memory leakage. (On Windows the memory leakage will be one buffer
+ * per thread, which is at least better than one per call).
*/
const char *
fmtId(const char *rawid)
{
- /*
+ /*
* The Tls code goes awry if we use a static var, so we provide for both
* static and auto, and omit any use of the static var when using Tls.
*/
#ifdef WIN32
if (parallel_init_done)
- id_return = (PQExpBuffer) TlsGetValue(tls_index); /* 0 when not set */
+ id_return = (PQExpBuffer) TlsGetValue(tls_index); /* 0 when not set */
else
id_return = s_id_return;
#else
{
/* new buffer */
id_return = createPQExpBuffer();
-#ifdef WIN32
+#ifdef WIN32
if (parallel_init_done)
- TlsSetValue(tls_index,id_return);
+ TlsSetValue(tls_index, id_return);
else
s_id_return = id_return;
#else
s_id_return = id_return;
#endif
-
+
}
/*
fmtId(grantee->data));
if (privswgo->len > 0)
appendPQExpBuffer(firstsql,
- "GRANT %s ON %s %s TO %s WITH GRANT OPTION;\n",
+ "GRANT %s ON %s %s TO %s WITH GRANT OPTION;\n",
privswgo->data, type, name,
fmtId(grantee->data));
}
#include "parser/keywords.h"
/*
- * We don't need the token number, so leave it out to avoid requiring other
+ * We don't need the token number, so leave it out to avoid requiring other
* backend headers.
*/
#define PG_KEYWORD(a,b,c) {a,0,c},
{
int create; /* Issue commands to create the database */
int noOwner; /* Don't try to match original object owner */
- int noTablespace; /* Don't issue tablespace-related commands */
+ int noTablespace; /* Don't issue tablespace-related commands */
int disable_triggers; /* disable triggers during data-only
* restore */
int use_setsessauth;/* Use SET SESSION AUTHORIZATION commands
typedef struct _restore_args
{
ArchiveHandle *AH;
- TocEntry *te;
+ TocEntry *te;
} RestoreArgs;
typedef struct _parallel_slot
static void ResetOutput(ArchiveHandle *AH, OutputContext savedContext);
static int restore_toc_entry(ArchiveHandle *AH, TocEntry *te,
- RestoreOptions *ropt, bool is_parallel);
+ RestoreOptions *ropt, bool is_parallel);
static void restore_toc_entries_parallel(ArchiveHandle *AH);
static thandle spawn_restore(RestoreArgs *args);
static thandle reap_child(ParallelSlot *slots, int n_slots, int *work_status);
static bool work_in_progress(ParallelSlot *slots, int n_slots);
-static int get_next_slot(ParallelSlot *slots, int n_slots);
+static int get_next_slot(ParallelSlot *slots, int n_slots);
static TocEntry *get_next_work_item(ArchiveHandle *AH,
- TocEntry **first_unprocessed,
- ParallelSlot *slots, int n_slots);
+ TocEntry **first_unprocessed,
+ ParallelSlot *slots, int n_slots);
static parallel_restore_result parallel_restore(RestoreArgs *args);
static void mark_work_done(ArchiveHandle *AH, thandle worker, int status,
- ParallelSlot *slots, int n_slots);
+ ParallelSlot *slots, int n_slots);
static void fix_dependencies(ArchiveHandle *AH);
static bool has_lock_conflicts(TocEntry *te1, TocEntry *te2);
static void repoint_table_dependencies(ArchiveHandle *AH,
- DumpId tableId, DumpId tableDataId);
+ DumpId tableId, DumpId tableDataId);
static void identify_locking_dependencies(TocEntry *te,
- TocEntry **tocsByDumpId);
+ TocEntry **tocsByDumpId);
static void reduce_dependencies(ArchiveHandle *AH, TocEntry *te);
static void mark_create_done(ArchiveHandle *AH, TocEntry *te);
static void inhibit_data_for_failed_table(ArchiveHandle *AH, TocEntry *te);
die_horribly(AH, modulename, "-C and -c are incompatible options\n");
/*
- * -1 is not compatible with -C, because we can't create a database
- * inside a transaction block.
+ * -1 is not compatible with -C, because we can't create a database inside
+ * a transaction block.
*/
if (ropt->create && ropt->single_txn)
die_horribly(AH, modulename, "-C and -1 are incompatible options\n");
* Make sure we won't need (de)compression we haven't got
*/
#ifndef HAVE_LIBZ
- if (AH->compression != 0 && AH->PrintTocDataPtr != NULL)
+ if (AH->compression != 0 && AH->PrintTocDataPtr !=NULL)
{
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
restore_toc_entry(ArchiveHandle *AH, TocEntry *te,
RestoreOptions *ropt, bool is_parallel)
{
- int retval = 0;
+ int retval = 0;
teReqs reqs;
bool defnDumped;
defnDumped = false;
- if ((reqs & REQ_SCHEMA) != 0) /* We want the schema */
+ if ((reqs & REQ_SCHEMA) != 0) /* We want the schema */
{
ahlog(AH, 1, "creating %s %s\n", te->desc, te->tag);
if (AH->lastErrorTE == te)
{
/*
- * We failed to create the table.
- * If --no-data-for-failed-tables was given,
- * mark the corresponding TABLE DATA to be ignored.
+ * We failed to create the table. If
+ * --no-data-for-failed-tables was given, mark the
+ * corresponding TABLE DATA to be ignored.
*
- * In the parallel case this must be done in the parent,
- * so we just set the return value.
+ * In the parallel case this must be done in the parent, so we
+ * just set the return value.
*/
if (ropt->noDataForFailedTables)
{
else
{
/*
- * We created the table successfully. Mark the
- * corresponding TABLE DATA for possible truncation.
+ * We created the table successfully. Mark the corresponding
+ * TABLE DATA for possible truncation.
*
- * In the parallel case this must be done in the parent,
- * so we just set the return value.
+ * In the parallel case this must be done in the parent, so we
+ * just set the return value.
*/
if (is_parallel)
retval = WORKER_CREATE_DONE;
if ((reqs & REQ_DATA) != 0)
{
/*
- * hadDumper will be set if there is genuine data component for
- * this node. Otherwise, we need to check the defn field for
- * statements that need to be executed in data-only restores.
+ * hadDumper will be set if there is genuine data component for this
+ * node. Otherwise, we need to check the defn field for statements
+ * that need to be executed in data-only restores.
*/
if (te->hadDumper)
{
/*
* If we can output the data, then restore it.
*/
- if (AH->PrintTocDataPtr != NULL && (reqs & REQ_DATA) != 0)
+ if (AH->PrintTocDataPtr !=NULL && (reqs & REQ_DATA) != 0)
{
_printTocEntry(AH, te, ropt, true, false);
te->tag);
/*
- * In parallel restore, if we created the table earlier
- * in the run then we wrap the COPY in a transaction and
- * precede it with a TRUNCATE. If archiving is not on
- * this prevents WAL-logging the COPY. This obtains a
- * speedup similar to that from using single_txn mode
- * in non-parallel restores.
+ * In parallel restore, if we created the table earlier in
+ * the run then we wrap the COPY in a transaction and
+ * precede it with a TRUNCATE. If archiving is not on
+ * this prevents WAL-logging the COPY. This obtains a
+ * speedup similar to that from using single_txn mode in
+ * non-parallel restores.
*/
if (is_parallel && te->created)
{
}
/*
- * If we have a copy statement, use it. As of V1.3,
- * these are separate to allow easy import from
- * withing a database connection. Pre 1.3 archives can
- * not use DB connections and are sent to output only.
+ * If we have a copy statement, use it. As of V1.3, these
+ * are separate to allow easy import from withing a
+ * database connection. Pre 1.3 archives can not use DB
+ * connections and are sent to output only.
*
- * For V1.3+, the table data MUST have a copy
- * statement so that we can go into appropriate mode
- * with libpq.
+ * For V1.3+, the table data MUST have a copy statement so
+ * that we can go into appropriate mode with libpq.
*/
if (te->copyStmt && strlen(te->copyStmt) > 0)
{
te->tag, te->owner);
if (ropt->verbose && te->nDeps > 0)
{
- int i;
+ int i;
ahprintf(AH, ";\tdepends on:");
for (i = 0; i < te->nDeps; i++)
res = lo_write(AH->connection, AH->loFd, AH->lo_buf, AH->lo_buf_used);
ahlog(AH, 5, ngettext("wrote %lu byte of large object data (result = %lu)\n",
- "wrote %lu bytes of large object data (result = %lu)\n",
+ "wrote %lu bytes of large object data (result = %lu)\n",
AH->lo_buf_used),
(unsigned long) AH->lo_buf_used, (unsigned long) res);
if (res != AH->lo_buf_used)
static void
_doSetFixedOutputState(ArchiveHandle *AH)
{
- /* Disable statement_timeout in archive for pg_restore/psql */
+ /* Disable statement_timeout in archive for pg_restore/psql */
ahprintf(AH, "SET statement_timeout = 0;\n");
/* Select the correct character set encoding */
thandle ret_child;
TocEntry *te;
- ahlog(AH,2,"entering restore_toc_entries_parallel\n");
+ ahlog(AH, 2, "entering restore_toc_entries_parallel\n");
/* we haven't got round to making this work for all archive formats */
if (AH->ClonePtr == NULL || AH->ReopenPtr == NULL)
fix_dependencies(AH);
/*
- * Do all the early stuff in a single connection in the parent.
- * There's no great point in running it in parallel, in fact it will
- * actually run faster in a single connection because we avoid all the
- * connection and setup overhead.
+ * Do all the early stuff in a single connection in the parent. There's no
+ * great point in running it in parallel, in fact it will actually run
+ * faster in a single connection because we avoid all the connection and
+ * setup overhead.
*/
while ((next_work_item = get_next_work_item(AH, &first_unprocessed,
NULL, 0)) != NULL)
}
/*
- * Now close parent connection in prep for parallel steps. We do this
+ * Now close parent connection in prep for parallel steps. We do this
* mainly to ensure that we don't exceed the specified number of parallel
* connections.
*/
* left to be done.
*/
- ahlog(AH,1,"entering main parallel loop\n");
+ ahlog(AH, 1, "entering main parallel loop\n");
while ((next_work_item = get_next_work_item(AH, &first_unprocessed,
slots, n_slots)) != NULL ||
{
if (next_work_item != NULL)
{
- teReqs reqs;
+ teReqs reqs;
/* If not to be dumped, don't waste time launching a worker */
reqs = _tocEntryRequired(next_work_item, AH->ropt, false);
if ((next_slot = get_next_slot(slots, n_slots)) != NO_SLOT)
{
/* There is work still to do and a worker slot available */
- thandle child;
+ thandle child;
RestoreArgs *args;
ahlog(AH, 1, "launching item %d %s %s\n",
}
}
- ahlog(AH,1,"finished main parallel loop\n");
+ ahlog(AH, 1, "finished main parallel loop\n");
/*
* Now reconnect the single parent connection.
_doSetFixedOutputState(AH);
/*
- * Make sure there is no non-ACL work left due to, say,
- * circular dependencies, or some other pathological condition.
- * If so, do it in the single parent connection.
+ * Make sure there is no non-ACL work left due to, say, circular
+ * dependencies, or some other pathological condition. If so, do it in the
+ * single parent connection.
*/
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
static thandle
spawn_restore(RestoreArgs *args)
{
- thandle child;
+ thandle child;
/* Ensure stdio state is quiesced before forking */
fflush(NULL);
}
/*
- * collect status from a completed worker child
+ * collect status from a completed worker child
*/
static thandle
reap_child(ParallelSlot *slots, int n_slots, int *work_status)
return wait(work_status);
#else
static HANDLE *handles = NULL;
- int hindex, snum, tnum;
- thandle ret_child;
- DWORD res;
+ int hindex,
+ snum,
+ tnum;
+ thandle ret_child;
+ DWORD res;
/* first time around only, make space for handles to listen on */
if (handles == NULL)
- handles = (HANDLE *) calloc(sizeof(HANDLE),n_slots);
+ handles = (HANDLE *) calloc(sizeof(HANDLE), n_slots);
/* set up list of handles to listen to */
- for (snum=0, tnum=0; snum < n_slots; snum++)
+ for (snum = 0, tnum = 0; snum < n_slots; snum++)
if (slots[snum].child_id != 0)
handles[tnum++] = slots[snum].child_id;
ret_child = handles[hindex - WAIT_OBJECT_0];
/* get the result */
- GetExitCodeThread(ret_child,&res);
+ GetExitCodeThread(ret_child, &res);
*work_status = res;
/* dispose of handle to stop leaks */
static bool
work_in_progress(ParallelSlot *slots, int n_slots)
{
- int i;
+ int i;
for (i = 0; i < n_slots; i++)
{
static int
get_next_slot(ParallelSlot *slots, int n_slots)
{
- int i;
+ int i;
for (i = 0; i < n_slots; i++)
{
static bool
has_lock_conflicts(TocEntry *te1, TocEntry *te2)
{
- int j,k;
+ int j,
+ k;
for (j = 0; j < te1->nLockDeps; j++)
{
get_next_work_item(ArchiveHandle *AH, TocEntry **first_unprocessed,
ParallelSlot *slots, int n_slots)
{
- bool pref_non_data = false; /* or get from AH->ropt */
- TocEntry *data_te = NULL;
- TocEntry *te;
- int i,k;
+ bool pref_non_data = false; /* or get from AH->ropt */
+ TocEntry *data_te = NULL;
+ TocEntry *te;
+ int i,
+ k;
/*
* Bogus heuristics for pref_non_data
*/
if (pref_non_data)
{
- int count = 0;
+ int count = 0;
- for (k=0; k < n_slots; k++)
+ for (k = 0; k < n_slots; k++)
if (slots[k].args->te != NULL &&
slots[k].args->te->section == SECTION_DATA)
count++;
*/
for (; te != AH->toc; te = te->next)
{
- bool conflicts = false;
+ bool conflicts = false;
/* Ignore if already done or still waiting on dependencies */
if (te->restored || te->depCount > 0)
/*
* Check to see if the item would need exclusive lock on something
- * that a currently running item also needs lock on, or vice versa.
- * If so, we don't want to schedule them together.
+ * that a currently running item also needs lock on, or vice versa. If
+ * so, we don't want to schedule them together.
*/
for (i = 0; i < n_slots && !conflicts; i++)
{
- TocEntry *running_te;
+ TocEntry *running_te;
if (slots[i].args == NULL)
continue;
if (data_te != NULL)
return data_te;
- ahlog(AH,2,"no item ready\n");
+ ahlog(AH, 2, "no item ready\n");
return NULL;
}
parallel_restore(RestoreArgs *args)
{
ArchiveHandle *AH = args->AH;
- TocEntry *te = args->te;
+ TocEntry *te = args->te;
RestoreOptions *ropt = AH->ropt;
- int retval;
+ int retval;
/*
- * Close and reopen the input file so we have a private file pointer
- * that doesn't stomp on anyone else's file pointer, if we're actually
- * going to need to read from the file. Otherwise, just close it
- * except on Windows, where it will possibly be needed by other threads.
+ * Close and reopen the input file so we have a private file pointer that
+ * doesn't stomp on anyone else's file pointer, if we're actually going to
+ * need to read from the file. Otherwise, just close it except on Windows,
+ * where it will possibly be needed by other threads.
*
- * Note: on Windows, since we are using threads not processes, the
- * reopen call *doesn't* close the original file pointer but just open
- * a new one.
+ * Note: on Windows, since we are using threads not processes, the reopen
+ * call *doesn't* close the original file pointer but just open a new one.
*/
- if (te->section == SECTION_DATA )
+ if (te->section == SECTION_DATA)
(AH->ReopenPtr) (AH);
#ifndef WIN32
else
AH->connection = NULL;
/* If we reopened the file, we are done with it, so close it now */
- if (te->section == SECTION_DATA )
+ if (te->section == SECTION_DATA)
(AH->ClosePtr) (AH);
if (retval == 0 && AH->public.n_errors)
mark_work_done(ArchiveHandle *AH, thandle worker, int status,
ParallelSlot *slots, int n_slots)
{
- TocEntry *te = NULL;
- int i;
+ TocEntry *te = NULL;
+ int i;
for (i = 0; i < n_slots; i++)
{
{
TocEntry **tocsByDumpId;
TocEntry *te;
- int i;
+ int i;
/*
* For some of the steps here, it is convenient to have an array that
- * indexes the TOC entries by dump ID, rather than searching the TOC
- * list repeatedly. Entries for dump IDs not present in the TOC will
- * be NULL.
+ * indexes the TOC entries by dump ID, rather than searching the TOC list
+ * repeatedly. Entries for dump IDs not present in the TOC will be NULL.
*
* Also, initialize the depCount fields.
*/
* dependencies.
*
* Note: currently, a TABLE DATA should always have exactly one
- * dependency, on its TABLE item. So we don't bother to search,
- * but look just at the first dependency. We do trouble to make sure
- * that it's a TABLE, if possible. However, if the dependency isn't
- * in the archive then just assume it was a TABLE; this is to cover
- * cases where the table was suppressed but we have the data and some
- * dependent post-data items.
+ * dependency, on its TABLE item. So we don't bother to search, but look
+ * just at the first dependency. We do trouble to make sure that it's a
+ * TABLE, if possible. However, if the dependency isn't in the archive
+ * then just assume it was a TABLE; this is to cover cases where the table
+ * was suppressed but we have the data and some dependent post-data items.
*/
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
if (strcmp(te->desc, "TABLE DATA") == 0 && te->nDeps > 0)
{
- DumpId tableId = te->dependencies[0];
+ DumpId tableId = te->dependencies[0];
if (tocsByDumpId[tableId - 1] == NULL ||
strcmp(tocsByDumpId[tableId - 1]->desc, "TABLE") == 0)
}
/*
- * Pre-8.4 versions of pg_dump neglected to set up a dependency from
- * BLOB COMMENTS to BLOBS. Cope. (We assume there's only one BLOBS
- * and only one BLOB COMMENTS in such files.)
+ * Pre-8.4 versions of pg_dump neglected to set up a dependency from BLOB
+ * COMMENTS to BLOBS. Cope. (We assume there's only one BLOBS and only
+ * one BLOB COMMENTS in such files.)
*/
if (AH->version < K_VERS_1_11)
{
/*
* It is possible that the dependencies list items that are not in the
- * archive at all. Subtract such items from the depCounts.
+ * archive at all. Subtract such items from the depCounts.
*/
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
DumpId tableId, DumpId tableDataId)
{
TocEntry *te;
- int i;
+ int i;
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
/*
* We assume the item requires exclusive lock on each TABLE DATA item
- * listed among its dependencies. (This was originally a dependency
- * on the TABLE, but fix_dependencies repointed it to the data item.
- * Note that all the entry types we are interested in here are POST_DATA,
- * so they will all have been changed this way.)
+ * listed among its dependencies. (This was originally a dependency on
+ * the TABLE, but fix_dependencies repointed it to the data item. Note
+ * that all the entry types we are interested in here are POST_DATA, so
+ * they will all have been changed this way.)
*/
lockids = (DumpId *) malloc(te->nDeps * sizeof(DumpId));
nlockids = 0;
for (i = 0; i < te->nDeps; i++)
{
- DumpId depid = te->dependencies[i];
+ DumpId depid = te->dependencies[i];
if (tocsByDumpId[depid - 1] &&
strcmp(tocsByDumpId[depid - 1]->desc, "TABLE DATA") == 0)
static void
reduce_dependencies(ArchiveHandle *AH, TocEntry *te)
{
- DumpId target = te->dumpId;
- int i;
+ DumpId target = te->dumpId;
+ int i;
- ahlog(AH,2,"reducing dependencies for %d\n",target);
+ ahlog(AH, 2, "reducing dependencies for %d\n", target);
/*
* We must examine all entries, not only the ones after the target item,
ArchiveHandle *clone;
/* Make a "flat" copy */
- clone = (ArchiveHandle *) malloc(sizeof(ArchiveHandle));
+ clone = (ArchiveHandle *) malloc(sizeof(ArchiveHandle));
if (clone == NULL)
die_horribly(AH, modulename, "out of memory\n");
memcpy(clone, AH, sizeof(ArchiveHandle));
#define K_VERS_1_9 (( (1 * 256 + 9) * 256 + 0) * 256 + 0) /* add default_with_oids
* tracking */
#define K_VERS_1_10 (( (1 * 256 + 10) * 256 + 0) * 256 + 0) /* add tablespace */
-#define K_VERS_1_11 (( (1 * 256 + 11) * 256 + 0) * 256 + 0) /* add toc section indicator */
+#define K_VERS_1_11 (( (1 * 256 + 11) * 256 + 0) * 256 + 0) /* add toc section
+ * indicator */
#define K_VERS_MAX (( (1 * 256 + 11) * 256 + 255) * 256 + 0)
StartBlobPtr StartBlobPtr;
EndBlobPtr EndBlobPtr;
- ClonePtr ClonePtr; /* Clone format-specific fields */
- DeClonePtr DeClonePtr; /* Clean up cloned fields */
+ ClonePtr ClonePtr; /* Clone format-specific fields */
+ DeClonePtr DeClonePtr; /* Clean up cloned fields */
CustomOutPtr CustomOutPtr; /* Alternative script output routine */
/* Stuff for direct DB connection */
char *archdbname; /* DB name *read* from archive */
enum trivalue promptPassword;
- char *savedPassword; /* password for ropt->username, if known */
+ char *savedPassword; /* password for ropt->username, if known */
PGconn *connection;
int connectToDB; /* Flag to indicate if direct DB connection is
* required */
struct _tocEntry *next;
CatalogId catalogId;
DumpId dumpId;
- teSection section;
+ teSection section;
bool hadDumper; /* Archiver was passed a dumper routine (used
* in restore) */
char *tag; /* index tag */
AH->StartBlobPtr = _StartBlob;
AH->EndBlobPtr = _EndBlob;
AH->EndBlobsPtr = _EndBlobs;
- AH->ClonePtr = _Clone;
- AH->DeClonePtr = _DeClone;
+ AH->ClonePtr = _Clone;
+ AH->DeClonePtr = _DeClone;
/*
* Set up some special context used in compressing data.
* is because on Windows, this is used within a multithreading context,
* and we don't want a thread closing the parent file handle.)
*/
-static void
+static void
_ReopenArchive(ArchiveHandle *AH)
{
lclContext *ctx = (lclContext *) AH->formatData;
pgoff_t tpos;
if (AH->mode == archModeWrite)
- die_horribly(AH,modulename,"can only reopen input archives\n");
+ die_horribly(AH, modulename, "can only reopen input archives\n");
if (AH->fSpec == NULL || strcmp(AH->fSpec, "") == 0)
- die_horribly(AH,modulename,"cannot reopen stdin\n");
+ die_horribly(AH, modulename, "cannot reopen stdin\n");
if (!ctx->hasSeek)
- die_horribly(AH,modulename,"cannot reopen non-seekable file\n");
+ die_horribly(AH, modulename, "cannot reopen non-seekable file\n");
errno = 0;
tpos = ftello(AH->FH);
if (errno)
- die_horribly(AH, modulename, "could not determine seek position in archive file: %s\n",
+ die_horribly(AH, modulename, "could not determine seek position in archive file: %s\n",
strerror(errno));
#ifndef WIN32
if (fclose(AH->FH) != 0)
- die_horribly(AH, modulename, "could not close archive file: %s\n",
+ die_horribly(AH, modulename, "could not close archive file: %s\n",
strerror(errno));
#endif
AH->fSpec, strerror(errno));
if (fseeko(AH->FH, tpos, SEEK_SET) != 0)
- die_horribly(AH, modulename, "could not set seek position in archive file: %s\n",
+ die_horribly(AH, modulename, "could not set seek position in archive file: %s\n",
strerror(errno));
}
die_horribly(AH, modulename, "out of memory\n");
/*
- * Note: we do not make a local lo_buf because we expect at most one
- * BLOBS entry per archive, so no parallelism is possible. Likewise,
+ * Note: we do not make a local lo_buf because we expect at most one BLOBS
+ * entry per archive, so no parallelism is possible. Likewise,
* TOC-entry-local state isn't an issue because any one TOC entry is
* touched by just one worker child.
*/
_DeClone(ArchiveHandle *AH)
{
lclContext *ctx = (lclContext *) AH->formatData;
-
+
free(ctx->zlibOut);
free(ctx->zlibIn);
free(ctx->zp);
*
* Note: it's not really all that sensible to use a single-entry password
* cache if the username keeps changing. In current usage, however, the
- * username never does change, so one savedPassword is sufficient. We do
+ * username never does change, so one savedPassword is sufficient. We do
* update the cache on the off chance that the password has changed since the
* start of the run.
*/
char errStmt[DB_MAX_ERR_STMT];
#ifdef NOT_USED
- fprintf(stderr, "Executing: '%s'\n\n", qry);
+ fprintf(stderr, "Executing: '%s'\n\n", qry);
#endif
res = PQexec(conn, qry);
static void dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo);
static void dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo);
static void dumpUserMappings(Archive *fout, const char *target,
- const char *servername, const char *namespace,
- const char *owner, CatalogId catalogId, DumpId dumpId);
+ const char *servername, const char *namespace,
+ const char *owner, CatalogId catalogId, DumpId dumpId);
static void dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
const char *type, const char *name, const char *subname,
static void getTableDataFKConstraints(void);
static char *format_function_arguments(FuncInfo *finfo, char *funcargs);
static char *format_function_arguments_old(FuncInfo *finfo, int nallargs,
- char **allargtypes,
- char **argmodes,
- char **argnames);
+ char **allargtypes,
+ char **argmodes,
+ char **argnames);
static char *format_function_signature(FuncInfo *finfo, bool honor_quotes);
static const char *convertRegProcReference(const char *proc);
static const char *convertOperatorReference(const char *opr);
RestoreOptions *ropt;
static int disable_triggers = 0;
- static int outputNoTablespaces = 0;
+ static int outputNoTablespaces = 0;
static int use_setsessauth = 0;
struct option long_options[] = {
}
/*
- * We allow the server to be back to 7.0, and up to any minor release
- * of our own major version. (See also version check in pg_dumpall.c.)
+ * We allow the server to be back to 7.0, and up to any minor release of
+ * our own major version. (See also version check in pg_dumpall.c.)
*/
g_fout->minRemoteVersion = 70000;
g_fout->maxRemoteVersion = (my_version / 100) * 100 + 99;
printf(_(" -N, --exclude-schema=SCHEMA do NOT dump the named schema(s)\n"));
printf(_(" -o, --oids include OIDs in dump\n"));
printf(_(" -O, --no-owner skip restoration of object ownership in\n"
- " plain-text format\n"));
+ " plain-text format\n"));
printf(_(" -s, --schema-only dump only the schema, no data\n"));
printf(_(" -S, --superuser=NAME superuser user name to use in plain-text format\n"));
printf(_(" -t, --table=TABLE dump the named table(s) only\n"));
printf(_(" --no-tablespaces do not dump tablespace assignments\n"));
printf(_(" --role=ROLENAME do SET ROLE before dump\n"));
printf(_(" --use-set-session-authorization\n"
- " use SET SESSION AUTHORIZATION commands instead of\n"
- " ALTER OWNER commands to set ownership\n"));
+ " use SET SESSION AUTHORIZATION commands instead of\n"
+ " ALTER OWNER commands to set ownership\n"));
printf(_("\nConnection options:\n"));
printf(_(" -h, --host=HOSTNAME database server host or socket directory\n"));
* Mark a type as to be dumped or not
*
* If it's a table's rowtype or an autogenerated array type, we also apply a
- * special type code to facilitate sorting into the desired order. (We don't
+ * special type code to facilitate sorting into the desired order. (We don't
* want to consider those to be ordinary types because that would bring tables
* up into the datatype part of the dump order.) Those tests should be made
* first to ensure the objType change is applied regardless of namespace etc.
if (dobjs[i]->objType == DO_FK_CONSTRAINT)
{
ConstraintInfo *cinfo = (ConstraintInfo *) dobjs[i];
- TableInfo *ftable;
+ TableInfo *ftable;
/* Not interesting unless both tables are to be dumped */
if (cinfo->contable == NULL ||
if (ftable == NULL ||
ftable->dataObj == NULL)
continue;
+
/*
- * Okay, make referencing table's TABLE_DATA object depend on
- * the referenced table's TABLE_DATA object.
+ * Okay, make referencing table's TABLE_DATA object depend on the
+ * referenced table's TABLE_DATA object.
*/
addObjectDependency(&cinfo->contable->dataObj->dobj,
ftable->dataObj->dobj.dumpId);
/*
* guessConstraintInheritance:
* In pre-8.4 databases, we can't tell for certain which constraints
- * are inherited. We assume a CHECK constraint is inherited if its name
+ * are inherited. We assume a CHECK constraint is inherited if its name
* matches the name of any constraint in the parent. Originally this code
* tried to compare the expression texts, but that can fail for various
* reasons --- for example, if the parent and child tables are in different
appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
"(%s datdba) AS dba, "
"pg_encoding_to_char(encoding) AS encoding, "
- "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
+ "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
"shobj_description(oid, 'pg_database') AS description "
appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
"(%s datdba) AS dba, "
"pg_encoding_to_char(encoding) AS encoding, "
- "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
+ "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace "
"FROM pg_database "
"WHERE datname = ",
{
appendPQExpBuffer(creaQry, "\n-- For binary upgrade, set datfrozenxid.\n");
appendPQExpBuffer(creaQry, "UPDATE pg_database\n"
- "SET datfrozenxid = '%u'\n"
- "WHERE datname = ",
- frozenxid);
+ "SET datfrozenxid = '%u'\n"
+ "WHERE datname = ",
+ frozenxid);
appendStringLiteralAH(creaQry, datname, AH);
appendPQExpBuffer(creaQry, ";\n");
}
-
+
appendPQExpBuffer(delQry, "DROP DATABASE %s;\n",
fmtId(datname));
dba, /* Owner */
false, /* with oids */
"DATABASE", /* Desc */
- SECTION_PRE_DATA, /* Section */
+ SECTION_PRE_DATA, /* Section */
creaQry->data, /* Create */
delQry->data, /* Del */
NULL, /* Copy */
if (comment && strlen(comment))
{
resetPQExpBuffer(dbQry);
- /* Generates warning when loaded into a differently-named database.*/
+
+ /*
+ * Generates warning when loaded into a differently-named
+ * database.
+ */
appendPQExpBuffer(dbQry, "COMMENT ON DATABASE %s IS ", fmtId(datname));
appendStringLiteralAH(dbQry, comment, AH);
appendPQExpBuffer(dbQry, ";\n");
/* Cursor to get all BLOB comments */
if (AH->remoteVersion >= 70300)
blobQry = "DECLARE blobcmt CURSOR FOR SELECT loid, "
- "obj_description(loid, 'pg_largeobject') "
- "FROM (SELECT DISTINCT loid FROM "
- "pg_description d JOIN pg_largeobject l ON (objoid = loid) "
- "WHERE classoid = 'pg_largeobject'::regclass) ss";
+ "obj_description(loid, 'pg_largeobject') "
+ "FROM (SELECT DISTINCT loid FROM "
+ "pg_description d JOIN pg_largeobject l ON (objoid = loid) "
+ "WHERE classoid = 'pg_largeobject'::regclass) ss";
else if (AH->remoteVersion >= 70200)
blobQry = "DECLARE blobcmt CURSOR FOR SELECT loid, "
- "obj_description(loid, 'pg_largeobject') "
- "FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
+ "obj_description(loid, 'pg_largeobject') "
+ "FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
else if (AH->remoteVersion >= 70100)
blobQry = "DECLARE blobcmt CURSOR FOR SELECT loid, "
- "obj_description(loid) "
- "FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
+ "obj_description(loid) "
+ "FROM (SELECT DISTINCT loid FROM pg_largeobject) ss";
else
blobQry = "DECLARE blobcmt CURSOR FOR SELECT oid, "
- " ( "
- " SELECT description "
- " FROM pg_description pd "
- " WHERE pd.objoid=pc.oid "
- " ) "
- "FROM pg_class pc WHERE relkind = 'l'";
+ " ( "
+ " SELECT description "
+ " FROM pg_description pd "
+ " WHERE pd.objoid=pc.oid "
+ " ) "
+ "FROM pg_class pc WHERE relkind = 'l'";
res = PQexec(g_conn, blobQry);
check_sql_result(res, g_conn, blobQry, PGRES_COMMAND_OK);
"d.refobjid AS owning_tab, "
"d.refobjsubid AS owning_col, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
- "array_to_string(c.reloptions, ', ') AS reloptions, "
+ "array_to_string(c.reloptions, ', ') AS reloptions, "
"array_to_string(array(SELECT 'toast.' || x FROM unnest(tc.reloptions) x), ', ') AS toast_reloptions "
"FROM pg_class c "
"LEFT JOIN pg_depend d ON "
"d.classid = c.tableoid AND d.objid = c.oid AND "
"d.objsubid = 0 AND "
"d.refclassid = c.tableoid AND d.deptype = 'a') "
- "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
+ "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
"WHERE c.relkind in ('%c', '%c', '%c', '%c') "
"ORDER BY c.oid",
username_subquery,
"d.refobjid AS owning_tab, "
"d.refobjsubid AS owning_col, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
- "array_to_string(c.reloptions, ', ') AS reloptions, "
+ "array_to_string(c.reloptions, ', ') AS reloptions, "
"NULL AS toast_reloptions "
"FROM pg_class c "
"LEFT JOIN pg_depend d ON "
/*
* Arrange to fail instead of waiting forever for a table lock.
*
- * NB: this coding assumes that the only queries issued within
- * the following loop are LOCK TABLEs; else the timeout may be
- * undesirably applied to other things too.
+ * NB: this coding assumes that the only queries issued within the
+ * following loop are LOCK TABLEs; else the timeout may be undesirably
+ * applied to other things too.
*/
resetPQExpBuffer(query);
appendPQExpBuffer(query, "SET statement_timeout = ");
{
appendPQExpBuffer(query, "SELECT tableoid, oid, "
"castsource, casttarget, castfunc, castcontext, "
- "CASE WHEN castfunc = 0 THEN 'b' ELSE 'f' END AS castmethod "
+ "CASE WHEN castfunc = 0 THEN 'b' ELSE 'f' END AS castmethod "
"FROM pg_cast ORDER BY 3,4");
}
else
{
/* need left join here to not fail on dropped columns ... */
appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
- "a.attstattarget, a.attstorage, t.typstorage, "
- "a.attnotnull, a.atthasdef, a.attisdropped, "
- "a.attlen, a.attalign, a.attislocal, "
+ "a.attstattarget, a.attstorage, t.typstorage, "
+ "a.attnotnull, a.atthasdef, a.attisdropped, "
+ "a.attlen, a.attalign, a.attislocal, "
"pg_catalog.format_type(t.oid,a.atttypmod) AS atttypname "
"FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
"ON a.atttypid = t.oid "
* explicitly set or was just a default.
*/
appendPQExpBuffer(q, "SELECT a.attnum, a.attname, "
- "a.atttypmod, -1 AS attstattarget, a.attstorage, "
+ "a.atttypmod, -1 AS attstattarget, a.attstorage, "
"t.typstorage, a.attnotnull, a.atthasdef, "
"false AS attisdropped, 0 AS attlen, "
"' ' AS attalign, false AS attislocal, "
"attstorage AS typstorage, "
"attnotnull, atthasdef, false AS attisdropped, "
"0 AS attlen, ' ' AS attalign, "
- "false AS attislocal, "
+ "false AS attislocal, "
"(SELECT typname FROM pg_type WHERE oid = atttypid) AS atttypname "
"FROM pg_attribute a "
"WHERE attrelid = '%u'::oid "
/*
- * ALTER TABLE DROP COLUMN clears pg_attribute.atttypid, so we
- * set the column data type to 'TEXT; we will later drop the
- * column.
+ * ALTER TABLE DROP COLUMN clears pg_attribute.atttypid, so we set the
+ * column data type to 'TEXT; we will later drop the column.
*/
if (binary_upgrade)
{
tbinfo->atttypnames[j] = strdup("TEXT");
}
}
-
+
/*
* Get info about column defaults
*/
if (g_fout->remoteVersion >= 80400)
{
appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
- "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
+ "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
"conislocal "
"FROM pg_catalog.pg_constraint "
"WHERE conrelid = '%u'::pg_catalog.oid "
else if (g_fout->remoteVersion >= 70400)
{
appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
- "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
+ "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
"true AS conislocal "
"FROM pg_catalog.pg_constraint "
"WHERE conrelid = '%u'::pg_catalog.oid "
constrs[j].dobj.dumpId);
/*
- * If the constraint is inherited, this will be detected
- * later (in pre-8.4 databases). We also detect later if the
+ * If the constraint is inherited, this will be detected later
+ * (in pre-8.4 databases). We also detect later if the
* constraint must be split out from the table definition.
*/
}
int ntups;
int i;
PQExpBuffer query = createPQExpBuffer();
- FdwInfo *fdwinfo;
+ FdwInfo *fdwinfo;
int i_oid;
int i_fdwname;
int i_rolname;
selectSourceSchema("pg_catalog");
appendPQExpBuffer(query, "SELECT oid, fdwname, "
- "(%s fdwowner) AS rolname, fdwvalidator::pg_catalog.regproc, fdwacl,"
+ "(%s fdwowner) AS rolname, fdwvalidator::pg_catalog.regproc, fdwacl,"
"array_to_string(ARRAY("
- " SELECT option_name || ' ' || quote_literal(option_value) "
- " FROM pg_options_to_table(fdwoptions)), ', ') AS fdwoptions "
+ " SELECT option_name || ' ' || quote_literal(option_value) "
+ " FROM pg_options_to_table(fdwoptions)), ', ') AS fdwoptions "
"FROM pg_foreign_data_wrapper",
username_subquery);
"(%s srvowner) AS rolname, "
"srvfdw, srvtype, srvversion, srvacl,"
"array_to_string(ARRAY("
- " SELECT option_name || ' ' || quote_literal(option_value) "
- " FROM pg_options_to_table(srvoptions)), ', ') AS srvoptions "
+ " SELECT option_name || ' ' || quote_literal(option_value) "
+ " FROM pg_options_to_table(srvoptions)), ', ') AS srvoptions "
"FROM pg_foreign_server",
username_subquery);
appendPQExpBuffer(query, ";\n");
/*
- * We mark comments as SECTION_NONE because they really belong
- * in the same section as their parent, whether that is
- * pre-data or post-data.
+ * We mark comments as SECTION_NONE because they really belong in the
+ * same section as their parent, whether that is pre-data or
+ * post-data.
*/
ArchiveEntry(fout, nilCatalogId, createDumpId(),
target, namespace, NULL, owner,
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
* This is used when we can rely on pg_get_function_arguments to format
* the argument list.
*/
-static char *format_function_arguments(FuncInfo *finfo, char *funcargs)
+static char *
+format_function_arguments(FuncInfo *finfo, char *funcargs)
{
PQExpBufferData fn;
PQExpBuffer delqry;
PQExpBuffer asPart;
PGresult *res;
- char *funcsig; /* identity signature */
- char *funcfullsig; /* full signature */
+ char *funcsig; /* identity signature */
+ char *funcfullsig; /* full signature */
char *funcsig_tag;
int ntups;
char *proretset;
*/
appendPQExpBuffer(query,
"SELECT proretset, prosrc, probin, "
- "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
- "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
- "pg_catalog.pg_get_function_result(oid) AS funcresult, "
+ "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
+ "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
+ "pg_catalog.pg_get_function_result(oid) AS funcresult, "
"proiswindow, provolatile, proisstrict, prosecdef, "
"proconfig, procost, prorows, "
"(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
getFormattedTypeName(cast->castsource, zeroAsNone),
getFormattedTypeName(cast->casttarget, zeroAsNone));
- switch(cast->castmethod)
+ switch (cast->castmethod)
{
case COERCION_METHOD_BINARY:
appendPQExpBuffer(defqry, "WITHOUT FUNCTION");
appendPQExpBuffer(defqry, "WITH INOUT");
break;
case COERCION_METHOD_FUNCTION:
+
/*
* Always qualify the function name, in case it is not in
* pg_catalog schema (format_function_signature won't qualify it).
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
*
* XXX RECHECK is gone as of 8.4, but we'll still print it if dumping
* an older server's opclass in which it is used. This is to avoid
- * hard-to-detect breakage if a newer pg_dump is used to dump from
- * an older server and then reload into that old version. This can
- * go away once 8.3 is so old as to not be of interest to anyone.
+ * hard-to-detect breakage if a newer pg_dump is used to dump from an
+ * older server and then reload into that old version. This can go
+ * away once 8.3 is so old as to not be of interest to anyone.
*/
appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
"amopopr::pg_catalog.regoperator "
/*
* XXX RECHECK is gone as of 8.4, but we'll still print it if dumping
* an older server's opclass in which it is used. This is to avoid
- * hard-to-detect breakage if a newer pg_dump is used to dump from
- * an older server and then reload into that old version. This can
- * go away once 8.3 is so old as to not be of interest to anyone.
+ * hard-to-detect breakage if a newer pg_dump is used to dump from an
+ * older server and then reload into that old version. This can go
+ * away once 8.3 is so old as to not be of interest to anyone.
*/
appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
- "amopopr::pg_catalog.regoperator "
- "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
+ "amopopr::pg_catalog.regoperator "
+ "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
"WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
- "AND refobjid = '%u'::pg_catalog.oid "
+ "AND refobjid = '%u'::pg_catalog.oid "
"AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
- "AND objid = ao.oid "
- "ORDER BY amopstrategy",
- opfinfo->dobj.catId.oid);
+ "AND objid = ao.oid "
+ "ORDER BY amopstrategy",
+ opfinfo->dobj.catId.oid);
}
else
{
appendPQExpBuffer(query, "SELECT amopstrategy, amopreqcheck, "
- "amopopr::pg_catalog.regoperator "
- "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
+ "amopopr::pg_catalog.regoperator "
+ "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
"WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
- "AND refobjid = '%u'::pg_catalog.oid "
+ "AND refobjid = '%u'::pg_catalog.oid "
"AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
- "AND objid = ao.oid "
- "ORDER BY amopstrategy",
- opfinfo->dobj.catId.oid);
+ "AND objid = ao.oid "
+ "ORDER BY amopstrategy",
+ opfinfo->dobj.catId.oid);
}
res_ops = PQexec(g_conn, query->data);
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
dumpUserMappings(fout, q->data,
srvinfo->dobj.name, NULL,
srvinfo->rolname,
- srvinfo->dobj.catId, srvinfo->dobj.dumpId);
+ srvinfo->dobj.catId, srvinfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
*/
static void
dumpUserMappings(Archive *fout, const char *target,
- const char *servername, const char *namespace,
- const char *owner,
- CatalogId catalogId, DumpId dumpId)
+ const char *servername, const char *namespace,
+ const char *owner,
+ CatalogId catalogId, DumpId dumpId)
{
PQExpBuffer q;
PQExpBuffer delq;
for (i = 0; i < ntups; i++)
{
char *umuser;
- char *umoptions;
+ char *umoptions;
umuser = PQgetvalue(res, i, i_umuser);
umoptions = PQgetvalue(res, i, i_umoptions);
{
if (tbinfo->dobj.dump)
{
- char *namecopy;
+ char *namecopy;
if (tbinfo->relkind == RELKIND_SEQUENCE)
dumpSequence(fout, tbinfo);
tbinfo->relacl);
/*
- * Handle column ACLs, if any. Note: we pull these with a separate
+ * Handle column ACLs, if any. Note: we pull these with a separate
* query rather than trying to fetch them during getTableAttrs, so
* that we won't miss ACLs on system columns.
*/
if (g_fout->remoteVersion >= 80400)
{
PQExpBuffer query = createPQExpBuffer();
- PGresult *res;
- int i;
+ PGresult *res;
+ int i;
appendPQExpBuffer(query,
- "SELECT attname, attacl FROM pg_catalog.pg_attribute "
+ "SELECT attname, attacl FROM pg_catalog.pg_attribute "
"WHERE attrelid = '%u' AND NOT attisdropped AND attacl IS NOT NULL "
"ORDER BY attnum",
tbinfo->dobj.catId.oid);
for (i = 0; i < PQntuples(res); i++)
{
- char *attname = PQgetvalue(res, i, 0);
- char *attacl = PQgetvalue(res, i, 1);
- char *attnamecopy;
- char *acltag;
+ char *attname = PQgetvalue(res, i, 0);
+ char *attacl = PQgetvalue(res, i, 1);
+ char *attnamecopy;
+ char *acltag;
attnamecopy = strdup(fmtId(attname));
acltag = malloc(strlen(tbinfo->dobj.name) + strlen(attname) + 2);
}
if ((tbinfo->reloptions && strlen(tbinfo->reloptions) > 0) ||
- (tbinfo->toast_reloptions && strlen(tbinfo->toast_reloptions) > 0))
+ (tbinfo->toast_reloptions && strlen(tbinfo->toast_reloptions) > 0))
{
- bool addcomma = false;
+ bool addcomma = false;
appendPQExpBuffer(q, "\nWITH (");
if (tbinfo->reloptions && strlen(tbinfo->reloptions) > 0)
appendPQExpBuffer(q, ";\n");
/*
- * For binary-compatible heap files, we create dropped columns
- * above and drop them here.
+ * For binary-compatible heap files, we create dropped columns above
+ * and drop them here.
*/
if (binary_upgrade)
{
fmtId(tbinfo->attnames[j]));
/*
- * ALTER TABLE DROP COLUMN clears pg_attribute.atttypid,
- * so we have to set pg_attribute.attlen and
- * pg_attribute.attalign values because that is what
- * is used to skip over dropped columns in the heap tuples.
- * We have atttypmod, but it seems impossible to know the
- * correct data type that will yield pg_attribute values
- * that match the old installation.
- * See comment in backend/catalog/heap.c::RemoveAttributeById()
+ * ALTER TABLE DROP COLUMN clears pg_attribute.atttypid,
+ * so we have to set pg_attribute.attlen and
+ * pg_attribute.attalign values because that is what is
+ * used to skip over dropped columns in the heap tuples.
+ * We have atttypmod, but it seems impossible to know the
+ * correct data type that will yield pg_attribute values
+ * that match the old installation. See comment in
+ * backend/catalog/heap.c::RemoveAttributeById()
*/
appendPQExpBuffer(q, "\n-- For binary upgrade, recreate dropped column's length and alignment.\n");
appendPQExpBuffer(q, "UPDATE pg_attribute\n"
- "SET attlen = %d, "
- "attalign = '%c'\n"
- "WHERE attname = '%s'\n"
- " AND attrelid = \n"
- " (\n"
- " SELECT oid\n"
- " FROM pg_class\n"
- " WHERE relnamespace = "
- "(SELECT oid FROM pg_namespace "
- "WHERE nspname = CURRENT_SCHEMA)\n"
- " AND relname = ",
- tbinfo->attlen[j],
- tbinfo->attalign[j],
- tbinfo->attnames[j]);
+ "SET attlen = %d, "
+ "attalign = '%c'\n"
+ "WHERE attname = '%s'\n"
+ " AND attrelid = \n"
+ " (\n"
+ " SELECT oid\n"
+ " FROM pg_class\n"
+ " WHERE relnamespace = "
+ "(SELECT oid FROM pg_namespace "
+ "WHERE nspname = CURRENT_SCHEMA)\n"
+ " AND relname = ",
+ tbinfo->attlen[j],
+ tbinfo->attalign[j],
+ tbinfo->attnames[j]);
appendStringLiteralAH(q, tbinfo->dobj.name, fout);
appendPQExpBuffer(q, "\n );\n");
}
}
appendPQExpBuffer(q, "\n-- For binary upgrade, set relfrozenxid.\n");
appendPQExpBuffer(q, "UPDATE pg_class\n"
- "SET relfrozenxid = '%u'\n"
- "WHERE relname = ",
- tbinfo->frozenxid);
+ "SET relfrozenxid = '%u'\n"
+ "WHERE relname = ",
+ tbinfo->frozenxid);
appendStringLiteralAH(q, tbinfo->dobj.name, fout);
appendPQExpBuffer(q, "\n AND relnamespace = "
- "(SELECT oid FROM pg_namespace "
- "WHERE nspname = CURRENT_SCHEMA);\n");
+ "(SELECT oid FROM pg_namespace "
+ "WHERE nspname = CURRENT_SCHEMA);\n");
}
-
+
/* Loop dumping statistics and storage statements */
for (j = 0; j < tbinfo->numatts; j++)
{
if (g_fout->remoteVersion >= 80400)
{
appendPQExpBuffer(query,
- "SELECT sequence_name, "
- "start_value, last_value, increment_by, "
- "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
- " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
- " ELSE max_value "
- "END AS max_value, "
- "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
- " WHEN increment_by < 0 AND min_value = %s THEN NULL "
- " ELSE min_value "
- "END AS min_value, "
- "cache_value, is_cycled, is_called from %s",
- bufx, bufm,
- fmtId(tbinfo->dobj.name));
+ "SELECT sequence_name, "
+ "start_value, last_value, increment_by, "
+ "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
+ " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
+ " ELSE max_value "
+ "END AS max_value, "
+ "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
+ " WHEN increment_by < 0 AND min_value = %s THEN NULL "
+ " ELSE min_value "
+ "END AS min_value, "
+ "cache_value, is_cycled, is_called from %s",
+ bufx, bufm,
+ fmtId(tbinfo->dobj.name));
}
else
{
appendPQExpBuffer(query,
- "SELECT sequence_name, "
- "0 AS start_value, last_value, increment_by, "
- "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
- " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
- " ELSE max_value "
- "END AS max_value, "
- "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
- " WHEN increment_by < 0 AND min_value = %s THEN NULL "
- " ELSE min_value "
- "END AS min_value, "
- "cache_value, is_cycled, is_called from %s",
- bufx, bufm,
- fmtId(tbinfo->dobj.name));
+ "SELECT sequence_name, "
+ "0 AS start_value, last_value, increment_by, "
+ "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
+ " WHEN increment_by < 0 AND max_value = -1 THEN NULL "
+ " ELSE max_value "
+ "END AS max_value, "
+ "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
+ " WHEN increment_by < 0 AND min_value = %s THEN NULL "
+ " ELSE min_value "
+ "END AS min_value, "
+ "cache_value, is_cycled, is_called from %s",
+ bufx, bufm,
+ fmtId(tbinfo->dobj.name));
}
res = PQexec(g_conn, query->data);
/*
* Versions before 8.4 did not remember the true start value. If
* is_called is false then the sequence has never been incremented
- * so we can use last_val. Otherwise punt and let it default.
+ * so we can use last_val. Otherwise punt and let it default.
*/
if (!called)
appendPQExpBuffer(query, " START WITH %s\n", last);
if (ntups != 1)
{
write_msg(NULL, ngettext("query returned %d row instead of one: %s\n",
- "query returned %d rows instead of one: %s\n",
+ "query returned %d rows instead of one: %s\n",
ntups),
ntups, query->data);
exit_nicely();
char relkind;
char *reltablespace; /* relation tablespace */
char *reloptions; /* options specified by WITH (...) */
- char *toast_reloptions; /* ditto, for the TOAST table */
+ char *toast_reloptions; /* ditto, for the TOAST table */
bool hasindex; /* does it have any indexes? */
bool hasrules; /* does it have any rules? */
bool hastriggers; /* does it have any triggers? */
*/
int numParents; /* number of (immediate) parent tables */
struct _tableInfo **parents; /* TableInfos of immediate parents */
- struct _tableDataInfo *dataObj; /* TableDataInfo, if dumping its data */
+ struct _tableDataInfo *dataObj; /* TableDataInfo, if dumping its data */
} TableInfo;
typedef struct _attrDefInfo
/*
* If all the objects are TABLE_DATA items, what we must have is a
* circular set of foreign key constraints (or a single self-referential
- * table). Print an appropriate complaint and break the loop arbitrarily.
+ * table). Print an appropriate complaint and break the loop arbitrarily.
*/
for (i = 0; i < nLoop; i++)
{
write_msg(NULL, "Consider using a full dump instead of a --data-only dump to avoid this problem.\n");
if (nLoop > 1)
removeObjectDependency(loop[0], loop[1]->dumpId);
- else /* must be a self-dependency */
+ else /* must be a self-dependency */
removeObjectDependency(loop[0], loop[0]->dumpId);
return;
}
if (nLoop > 1)
removeObjectDependency(loop[0], loop[1]->dumpId);
- else /* must be a self-dependency */
+ else /* must be a self-dependency */
removeObjectDependency(loop[0], loop[0]->dumpId);
}
static int runPgDump(const char *dbname);
static PGconn *connectDatabase(const char *dbname, const char *pghost, const char *pgport,
- const char *pguser, enum trivalue prompt_password, bool fail_on_error);
+ const char *pguser, enum trivalue prompt_password, bool fail_on_error);
static PGresult *executeQuery(PGconn *conn, const char *query);
static void executeCommand(PGconn *conn, const char *query);
disable_dollar_quoting = 1;
else if (strcmp(optarg, "disable-triggers") == 0)
disable_triggers = 1;
- else if (strcmp(optarg, "no-tablespaces") == 0)
+ else if (strcmp(optarg, "no-tablespaces") == 0)
no_tablespaces = 1;
else if (strcmp(optarg, "use-set-session-authorization") == 0)
use_setsessauth = 1;
if (!data_only)
{
/*
- * If asked to --clean, do that first. We can avoid detailed
+ * If asked to --clean, do that first. We can avoid detailed
* dependency analysis because databases never depend on each other,
- * and tablespaces never depend on each other. Roles could have
+ * and tablespaces never depend on each other. Roles could have
* grants to each other, but DROP ROLE will clean those up silently.
*/
if (output_clean)
}
/*
- * Now create objects as requested. Be careful that option logic
- * here is the same as for drops above.
+ * Now create objects as requested. Be careful that option logic here
+ * is the same as for drops above.
*/
if (!tablespaces_only)
{
printf(_(" --no-tablespaces do not dump tablespace assignments\n"));
printf(_(" --role=ROLENAME do SET ROLE before dump\n"));
printf(_(" --use-set-session-authorization\n"
- " use SET SESSION AUTHORIZATION commands instead of\n"
- " ALTER OWNER commands to set ownership\n"));
+ " use SET SESSION AUTHORIZATION commands instead of\n"
+ " ALTER OWNER commands to set ownership\n"));
printf(_("\nConnection options:\n"));
printf(_(" -h, --host=HOSTNAME database server host or socket directory\n"));
printf(_(" -W, --password force password prompt (should happen automatically)\n"));
printf(_("\nIf -f/--file is not used, then the SQL script will be written to the standard\n"
- "output.\n\n"));
+ "output.\n\n"));
printf(_("Report bugs to <pgsql-bugs@postgresql.org>.\n"));
}
/*
* We dump CREATE ROLE followed by ALTER ROLE to ensure that the role
- * will acquire the right properties even if it already exists (ie,
- * it won't hurt for the CREATE to fail). This is particularly
- * important for the role we are connected as, since even with --clean
- * we will have failed to drop it.
+ * will acquire the right properties even if it already exists (ie, it
+ * won't hurt for the CREATE to fail). This is particularly important
+ * for the role we are connected as, since even with --clean we will
+ * have failed to drop it.
*/
appendPQExpBuffer(buf, "CREATE ROLE %s;\n", fmtId(rolename));
appendPQExpBuffer(buf, "ALTER ROLE %s WITH", fmtId(rolename));
* commands for just those databases with values different from defaults.
*
* We consider template0's encoding and locale (or, pre-7.1, template1's)
- * to define the installation default. Pre-8.4 installations do not
- * have per-database locale settings; for them, every database must
- * necessarily be using the installation default, so there's no need to
- * do anything (which is good, since in very old versions there is no
- * good way to find out what the installation locale is anyway...)
+ * to define the installation default. Pre-8.4 installations do not have
+ * per-database locale settings; for them, every database must necessarily
+ * be using the installation default, so there's no need to do anything
+ * (which is good, since in very old versions there is no good way to find
+ * out what the installation locale is anyway...)
*/
if (server_version >= 80400)
res = executeQuery(conn,
"SELECT datname, "
"coalesce(rolname, (select rolname from pg_authid where oid=(select datdba from pg_database where datname='template0'))), "
"pg_encoding_to_char(d.encoding), "
- "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
+ "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
"datistemplate, datacl, datconnlimit, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = d.dattablespace) AS dattablespace "
"FROM pg_database d LEFT JOIN pg_authid u ON (datdba = u.oid) "
"SELECT datname, "
"coalesce(usename, (select usename from pg_shadow where usesysid=(select datdba from pg_database where datname='template0'))), "
"pg_encoding_to_char(d.encoding), "
- "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
+ "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
"datistemplate, datacl, -1 as datconnlimit, "
"(SELECT spcname FROM pg_tablespace t WHERE t.oid = d.dattablespace) AS dattablespace "
"FROM pg_database d LEFT JOIN pg_shadow u ON (datdba = usesysid) "
"SELECT datname, "
"coalesce(usename, (select usename from pg_shadow where usesysid=(select datdba from pg_database where datname='template0'))), "
"pg_encoding_to_char(d.encoding), "
- "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
+ "null::text AS datcollate, null::text AS datctype, datfrozenxid, "
"datistemplate, datacl, -1 as datconnlimit, "
"'pg_default' AS dattablespace "
"FROM pg_database d LEFT JOIN pg_shadow u ON (datdba = usesysid) "
char *dbencoding = PQgetvalue(res, i, 2);
char *dbcollate = PQgetvalue(res, i, 3);
char *dbctype = PQgetvalue(res, i, 4);
- uint32 dbfrozenxid = atooid(PQgetvalue(res, i, 5));
+ uint32 dbfrozenxid = atooid(PQgetvalue(res, i, 5));
char *dbistemplate = PQgetvalue(res, i, 6);
char *dbacl = PQgetvalue(res, i, 7);
char *dbconnlimit = PQgetvalue(res, i, 8);
*/
static PGconn *
connectDatabase(const char *dbname, const char *pghost, const char *pgport,
- const char *pguser, enum trivalue prompt_password, bool fail_on_error)
+ const char *pguser, enum trivalue prompt_password, bool fail_on_error)
{
PGconn *conn;
bool new_pass;
}
/*
- * We allow the server to be back to 7.0, and up to any minor release
- * of our own major version. (See also version check in pg_dump.c.)
+ * We allow the server to be back to 7.0, and up to any minor release of
+ * our own major version. (See also version check in pg_dump.c.)
*/
if (my_version != server_version
&& (server_version < 70000 ||
appendPQExpBufferChar(buf, *p);
}
appendPQExpBufferChar(buf, '\'');
-
-#else /* WIN32 */
+#else /* WIN32 */
appendPQExpBufferChar(buf, '"');
for (p = str; *p; p++)
appendPQExpBufferChar(buf, *p);
}
appendPQExpBufferChar(buf, '"');
-#endif /* WIN32 */
+#endif /* WIN32 */
}
char *inputFileSpec;
static int disable_triggers = 0;
static int no_data_for_failed_tables = 0;
- static int outputNoTablespaces = 0;
+ static int outputNoTablespaces = 0;
static int use_setsessauth = 0;
struct option cmdopts[] = {
break;
case 0:
- /*
- * This covers the long options without a short equivalent,
- * including those equivalent to -X xxx.
+
+ /*
+ * This covers the long options without a short equivalent,
+ * including those equivalent to -X xxx.
*/
break;
printf(_(" -I, --index=NAME restore named index\n"));
printf(_(" -j, --jobs=NUM use this many parallel jobs to restore\n"));
printf(_(" -L, --use-list=FILENAME use table of contents from this file for\n"
- " selecting/ordering output\n"));
+ " selecting/ordering output\n"));
printf(_(" -n, --schema=NAME restore only objects in this schema\n"));
printf(_(" -O, --no-owner skip restoration of object ownership\n"));
printf(_(" -P, --function=NAME(args)\n"
printf(_(" --no-tablespaces do not dump tablespace assignments\n"));
printf(_(" --role=ROLENAME do SET ROLE before restore\n"));
printf(_(" --use-set-session-authorization\n"
- " use SET SESSION AUTHORIZATION commands instead of\n"
- " ALTER OWNER commands to set ownership\n"));
+ " use SET SESSION AUTHORIZATION commands instead of\n"
+ " ALTER OWNER commands to set ownership\n"));
printf(_(" -1, --single-transaction\n"
" restore as a single transaction\n"));
/*
* We have to use postgres.h not postgres_fe.h here, because there's so much
* backend-only stuff in the XLOG include files we need. But we need a
- * frontend-ish environment otherwise. Hence this ugly hack.
+ * frontend-ish environment otherwise. Hence this ugly hack.
*/
#define FRONTEND 1
struct dirent *xlde;
char path[MAXPGPATH];
-#define ARCHSTATDIR XLOGDIR "/archive_status"
+#define ARCHSTATDIR XLOGDIR "/archive_status"
xldir = opendir(ARCHSTATDIR);
if (xldir == NULL)
{
if (strspn(xlde->d_name, "0123456789ABCDEF") == 24 &&
(strcmp(xlde->d_name + 24, ".ready") == 0 ||
- strcmp(xlde->d_name + 24, ".done") == 0))
+ strcmp(xlde->d_name + 24, ".done") == 0))
{
snprintf(path, MAXPGPATH, "%s/%s", ARCHSTATDIR, xlde->d_name);
if (unlink(path) < 0)
"TypesSupported",
0,
REG_DWORD,
- (LPBYTE) & data,
+ (LPBYTE) &data,
sizeof(DWORD)))
{
MessageBox(NULL, "Could not set the supported types.", "PostgreSQL error", MB_OK | MB_ICONSTOP);
PsqlScanState scan_state,
PQExpBuffer query_buf);
static bool do_edit(const char *filename_arg, PQExpBuffer query_buf,
- bool *edited);
+ bool *edited);
static bool do_connect(char *dbname, char *user, char *host, char *port);
static bool do_shell(const char *command);
static bool lookup_function_oid(PGconn *conn, const char *desc, Oid *foid);
else if (cmd[0] == 'd')
{
char *pattern;
- bool show_verbose, show_system;
+ bool show_verbose,
+ show_system;
/* We don't do SQLID reduction on the pattern yet */
pattern = psql_scan_slash_option(scan_state,
case 'n':
case 't':
case 'w':
- success = describeFunctions(&cmd[2], pattern, show_verbose, show_system);
+ success = describeFunctions(&cmd[2], pattern, show_verbose, show_system);
break;
default:
status = PSQL_CMD_UNKNOWN;
}
break;
case 'e': /* SQL/MED subsystem */
- switch(cmd[2])
+ switch (cmd[2])
{
case 's':
success = listForeignServers(pattern, show_verbose);
if (status != PSQL_CMD_ERROR)
{
- bool edited = false;
+ bool edited = false;
if (!do_edit(0, query_buf, &edited))
status = PSQL_CMD_ERROR;
else if (strcmp(cmd, "timing") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
- OT_NORMAL, NULL, false);
+ OT_NORMAL, NULL, false);
+
if (opt)
pset.timing = ParseVariableBool(opt);
else
PQsetNoticeProcessor(n_conn, NoticeProcessor, NULL);
pset.db = n_conn;
SyncVariables();
- connection_warnings(); /* Must be after SyncVariables */
+ connection_warnings(); /* Must be after SyncVariables */
/* Tell the user about the new connection */
if (!pset.quiet)
server_version = server_ver_str;
}
- printf(_("%s (%s, server %s)\n"),
- pset.progname, PG_VERSION, server_version);
+ printf(_("%s (%s, server %s)\n"),
+ pset.progname, PG_VERSION, server_version);
}
else
printf("%s (%s)\n", pset.progname, PG_VERSION);
if (pset.sversion / 100 != client_ver / 100)
printf(_("WARNING: %s version %d.%d, server version %d.%d.\n"
- " Some psql features might not work.\n"),
- pset.progname, client_ver / 10000, (client_ver / 100) % 100,
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ " Some psql features might not work.\n"),
+ pset.progname, client_ver / 10000, (client_ver / 100) % 100,
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
#ifdef WIN32
checkWin32Codepage();
printf(_("SSL connection (cipher: %s, bits: %i)\n"),
SSL_get_cipher(ssl), sslbits);
#else
+
/*
- * If psql is compiled without SSL but is using a libpq with SSL,
- * we cannot figure out the specifics about the connection. But
- * we know it's SSL secured.
+ * If psql is compiled without SSL but is using a libpq with SSL, we
+ * cannot figure out the specifics about the connection. But we know it's
+ * SSL secured.
*/
if (PQgetssl(pset.db))
printf(_("SSL connection (unknown cipher)\n"));
{
printf(_("WARNING: Console code page (%u) differs from Windows code page (%u)\n"
" 8-bit characters might not work correctly. See psql reference\n"
- " page \"Notes for Windows users\" for details.\n"),
+ " page \"Notes for Windows users\" for details.\n"),
concp, wincp);
}
}
{
bool result = true;
PQExpBuffer query;
- PGresult *res;
+ PGresult *res;
query = createPQExpBuffer();
printfPQExpBuffer(query, "SELECT ");
{
bool result = true;
PQExpBuffer query;
- PGresult *res;
+ PGresult *res;
query = createPQExpBuffer();
printfPQExpBuffer(query, "SELECT pg_catalog.pg_get_functiondef(%u)", oid);
const char *oid,
bool verbose);
static void add_tablespace_footer(printTableContent *const cont, char relkind,
- Oid tablespace, const bool newline);
+ Oid tablespace, const bool newline);
static void add_role_attribute(PQExpBuffer buf, const char *const str);
static bool listTSParsersVerbose(const char *pattern);
static bool describeOneTSParser(const char *oid, const char *nspname,
printfPQExpBuffer(&buf,
"SELECT n.nspname as \"%s\",\n"
" p.proname AS \"%s\",\n"
- " pg_catalog.format_type(p.prorettype, NULL) AS \"%s\",\n",
+ " pg_catalog.format_type(p.prorettype, NULL) AS \"%s\",\n",
gettext_noop("Schema"),
gettext_noop("Name"),
gettext_noop("Result data type"));
if (pset.sversion >= 80200)
- appendPQExpBuffer(&buf,
- " CASE WHEN p.pronargs = 0\n"
- " THEN CAST('*' AS pg_catalog.text)\n"
- " ELSE\n"
- " pg_catalog.array_to_string(ARRAY(\n"
- " SELECT\n"
- " pg_catalog.format_type(p.proargtypes[s.i], NULL)\n"
- " FROM\n"
- " pg_catalog.generate_series(0, pg_catalog.array_upper(p.proargtypes, 1)) AS s(i)\n"
- " ), ', ')\n"
- " END AS \"%s\",\n",
- gettext_noop("Argument data types"));
+ appendPQExpBuffer(&buf,
+ " CASE WHEN p.pronargs = 0\n"
+ " THEN CAST('*' AS pg_catalog.text)\n"
+ " ELSE\n"
+ " pg_catalog.array_to_string(ARRAY(\n"
+ " SELECT\n"
+ " pg_catalog.format_type(p.proargtypes[s.i], NULL)\n"
+ " FROM\n"
+ " pg_catalog.generate_series(0, pg_catalog.array_upper(p.proargtypes, 1)) AS s(i)\n"
+ " ), ', ')\n"
+ " END AS \"%s\",\n",
+ gettext_noop("Argument data types"));
else
- appendPQExpBuffer(&buf,
- " pg_catalog.format_type(p.proargtypes[0], NULL) AS \"%s\",\n",
- gettext_noop("Argument data types"));
+ appendPQExpBuffer(&buf,
+ " pg_catalog.format_type(p.proargtypes[0], NULL) AS \"%s\",\n",
+ gettext_noop("Argument data types"));
appendPQExpBuffer(&buf,
" pg_catalog.obj_description(p.oid, 'pg_proc') as \"%s\"\n"
"WHERE p.proisagg\n",
gettext_noop("Description"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "p.proname", NULL,
if (verbose && pset.sversion >= 80200)
appendPQExpBuffer(&buf,
- ",\n pg_catalog.shobj_description(oid, 'pg_tablespace') AS \"%s\"",
+ ",\n pg_catalog.shobj_description(oid, 'pg_tablespace') AS \"%s\"",
gettext_noop("Description"));
appendPQExpBuffer(&buf,
gettext_noop("Schema"),
gettext_noop("Name"));
- if (pset.sversion >= 80400)
+ if (pset.sversion >= 80400)
appendPQExpBuffer(&buf,
- " pg_catalog.pg_get_function_result(p.oid) as \"%s\",\n"
- " pg_catalog.pg_get_function_arguments(p.oid) as \"%s\",\n"
+ " pg_catalog.pg_get_function_result(p.oid) as \"%s\",\n"
+ " pg_catalog.pg_get_function_arguments(p.oid) as \"%s\",\n"
" CASE\n"
" WHEN p.proisagg THEN '%s'\n"
" WHEN p.proiswindow THEN '%s'\n"
" ELSE '%s'\n"
"END as \"%s\"",
gettext_noop("Result data type"),
- gettext_noop("Argument data types"),
- /* translator: "agg" is short for "aggregate" */
- gettext_noop("agg"),
- gettext_noop("window"),
- gettext_noop("trigger"),
- gettext_noop("normal"),
- gettext_noop("Type"));
- else if (pset.sversion >= 80100)
+ gettext_noop("Argument data types"),
+ /* translator: "agg" is short for "aggregate" */
+ gettext_noop("agg"),
+ gettext_noop("window"),
+ gettext_noop("trigger"),
+ gettext_noop("normal"),
+ gettext_noop("Type"));
+ else if (pset.sversion >= 80100)
appendPQExpBuffer(&buf,
- " CASE WHEN p.proretset THEN 'SETOF ' ELSE '' END ||\n"
+ " CASE WHEN p.proretset THEN 'SETOF ' ELSE '' END ||\n"
" pg_catalog.format_type(p.prorettype, NULL) as \"%s\",\n"
- " CASE WHEN proallargtypes IS NOT NULL THEN\n"
- " pg_catalog.array_to_string(ARRAY(\n"
- " SELECT\n"
- " CASE\n"
- " WHEN p.proargmodes[s.i] = 'i' THEN ''\n"
+ " CASE WHEN proallargtypes IS NOT NULL THEN\n"
+ " pg_catalog.array_to_string(ARRAY(\n"
+ " SELECT\n"
+ " CASE\n"
+ " WHEN p.proargmodes[s.i] = 'i' THEN ''\n"
" WHEN p.proargmodes[s.i] = 'o' THEN 'OUT '\n"
- " WHEN p.proargmodes[s.i] = 'b' THEN 'INOUT '\n"
- " WHEN p.proargmodes[s.i] = 'v' THEN 'VARIADIC '\n"
- " END ||\n"
- " CASE\n"
+ " WHEN p.proargmodes[s.i] = 'b' THEN 'INOUT '\n"
+ " WHEN p.proargmodes[s.i] = 'v' THEN 'VARIADIC '\n"
+ " END ||\n"
+ " CASE\n"
" WHEN COALESCE(p.proargnames[s.i], '') = '' THEN ''\n"
- " ELSE p.proargnames[s.i] || ' ' \n"
- " END ||\n"
+ " ELSE p.proargnames[s.i] || ' ' \n"
+ " END ||\n"
" pg_catalog.format_type(p.proallargtypes[s.i], NULL)\n"
- " FROM\n"
- " pg_catalog.generate_series(1, pg_catalog.array_upper(p.proallargtypes, 1)) AS s(i)\n"
- " ), ', ')\n"
- " ELSE\n"
- " pg_catalog.array_to_string(ARRAY(\n"
- " SELECT\n"
- " CASE\n"
+ " FROM\n"
+ " pg_catalog.generate_series(1, pg_catalog.array_upper(p.proallargtypes, 1)) AS s(i)\n"
+ " ), ', ')\n"
+ " ELSE\n"
+ " pg_catalog.array_to_string(ARRAY(\n"
+ " SELECT\n"
+ " CASE\n"
" WHEN COALESCE(p.proargnames[s.i+1], '') = '' THEN ''\n"
- " ELSE p.proargnames[s.i+1] || ' '\n"
- " END ||\n"
+ " ELSE p.proargnames[s.i+1] || ' '\n"
+ " END ||\n"
" pg_catalog.format_type(p.proargtypes[s.i], NULL)\n"
- " FROM\n"
- " pg_catalog.generate_series(0, pg_catalog.array_upper(p.proargtypes, 1)) AS s(i)\n"
- " ), ', ')\n"
- " END AS \"%s\",\n"
- " CASE\n"
- " WHEN p.proisagg THEN '%s'\n"
- " WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN '%s'\n"
- " ELSE '%s'\n"
- " END AS \"%s\"",
+ " FROM\n"
+ " pg_catalog.generate_series(0, pg_catalog.array_upper(p.proargtypes, 1)) AS s(i)\n"
+ " ), ', ')\n"
+ " END AS \"%s\",\n"
+ " CASE\n"
+ " WHEN p.proisagg THEN '%s'\n"
+ " WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN '%s'\n"
+ " ELSE '%s'\n"
+ " END AS \"%s\"",
gettext_noop("Result data type"),
gettext_noop("Argument data types"),
- /* translator: "agg" is short for "aggregate" */
+ /* translator: "agg" is short for "aggregate" */
gettext_noop("agg"),
gettext_noop("trigger"),
gettext_noop("normal"),
gettext_noop("Type"));
else
appendPQExpBuffer(&buf,
- " CASE WHEN p.proretset THEN 'SETOF ' ELSE '' END ||\n"
+ " CASE WHEN p.proretset THEN 'SETOF ' ELSE '' END ||\n"
" pg_catalog.format_type(p.prorettype, NULL) as \"%s\",\n"
- " pg_catalog.oidvectortypes(p.proargtypes) as \"%s\",\n"
- " CASE\n"
- " WHEN p.proisagg THEN '%s'\n"
- " WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN '%s'\n"
- " ELSE '%s'\n"
- " END AS \"%s\"",
+ " pg_catalog.oidvectortypes(p.proargtypes) as \"%s\",\n"
+ " CASE\n"
+ " WHEN p.proisagg THEN '%s'\n"
+ " WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN '%s'\n"
+ " ELSE '%s'\n"
+ " END AS \"%s\"",
gettext_noop("Result data type"),
gettext_noop("Argument data types"),
- /* translator: "agg" is short for "aggregate" */
+ /* translator: "agg" is short for "aggregate" */
gettext_noop("agg"),
gettext_noop("trigger"),
gettext_noop("normal"),
" WHEN p.provolatile = 's' THEN '%s'\n"
" WHEN p.provolatile = 'v' THEN '%s'\n"
"END as \"%s\""
- ",\n pg_catalog.pg_get_userbyid(p.proowner) as \"%s\",\n"
+ ",\n pg_catalog.pg_get_userbyid(p.proowner) as \"%s\",\n"
" l.lanname as \"%s\",\n"
" p.prosrc as \"%s\",\n"
" pg_catalog.obj_description(p.oid, 'pg_proc') as \"%s\"",
appendPQExpBuffer(&buf,
"\nFROM pg_catalog.pg_proc p"
- "\n LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n");
+ "\n LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n");
if (verbose)
appendPQExpBuffer(&buf,
- " LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang\n");
+ " LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang\n");
have_where = false;
/* filter by function type, if requested */
if (showNormal && showAggregate && showTrigger && showWindow)
- /* Do nothing */;
+ /* Do nothing */ ;
else if (showNormal)
{
if (!showAggregate)
}
else
{
- bool needs_or = false;
+ bool needs_or = false;
appendPQExpBuffer(&buf, "WHERE (\n ");
have_where = true;
/* Note: at least one of these must be true ... */
if (showAggregate)
{
- appendPQExpBuffer(&buf,"p.proisagg\n");
+ appendPQExpBuffer(&buf, "p.proisagg\n");
needs_or = true;
}
if (showTrigger)
if (needs_or)
appendPQExpBuffer(&buf, " OR ");
appendPQExpBuffer(&buf,
- "p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype\n");
+ "p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype\n");
needs_or = true;
}
if (showWindow)
"n.nspname", "p.proname", NULL,
"pg_catalog.pg_function_is_visible(p.oid)");
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
appendPQExpBuffer(&buf, "ORDER BY 1, 2, 4;");
gettext_noop("Elements"));
appendPQExpBuffer(&buf,
- " pg_catalog.obj_description(t.oid, 'pg_type') as \"%s\"\n",
+ " pg_catalog.obj_description(t.oid, 'pg_type') as \"%s\"\n",
gettext_noop("Description"));
appendPQExpBuffer(&buf, "FROM pg_catalog.pg_type t\n"
appendPQExpBuffer(&buf, "WHERE (t.typrelid = 0 ");
appendPQExpBuffer(&buf, "OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c "
"WHERE c.oid = t.typrelid))\n");
+
/*
* do not include array types (before 8.3 we have to use the assumption
* that their names start with underscore)
else
appendPQExpBuffer(&buf, " AND t.typname !~ '^_'\n");
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
/* Match name pattern against either internal or external name */
processSQLNamePattern(pset.db, &buf, pattern, true, false,
gettext_noop("Result type"),
gettext_noop("Description"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, true,
"n.nspname", "o.oprname", NULL,
printfPQExpBuffer(&buf,
"SELECT d.datname as \"%s\",\n"
- " pg_catalog.pg_get_userbyid(d.datdba) as \"%s\",\n"
- " pg_catalog.pg_encoding_to_char(d.encoding) as \"%s\",\n",
+ " pg_catalog.pg_get_userbyid(d.datdba) as \"%s\",\n"
+ " pg_catalog.pg_encoding_to_char(d.encoding) as \"%s\",\n",
gettext_noop("Name"),
gettext_noop("Owner"),
gettext_noop("Encoding"));
",\n t.spcname as \"%s\"",
gettext_noop("Tablespace"));
if (verbose && pset.sversion >= 80200)
- appendPQExpBuffer(&buf,
+ appendPQExpBuffer(&buf,
",\n pg_catalog.shobj_description(d.oid, 'pg_database') as \"%s\"",
gettext_noop("Description"));
appendPQExpBuffer(&buf,
" ",
gettext_noop("Schema"),
gettext_noop("Name"),
- gettext_noop("table"), gettext_noop("view"), gettext_noop("sequence"),
+ gettext_noop("table"), gettext_noop("view"), gettext_noop("sequence"),
gettext_noop("Type"));
printACLColumn(&buf, "c.relacl");
" WHERE p.proisagg\n",
gettext_noop("aggregate"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "p.proname", NULL,
" WHERE NOT p.proisagg\n",
gettext_noop("function"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "p.proname", NULL,
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace\n",
gettext_noop("operator"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
-
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
+
processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false,
"n.nspname", "o.oprname", NULL,
"pg_catalog.pg_operator_is_visible(o.oid)");
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n",
gettext_noop("data type"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false,
"n.nspname", "pg_catalog.format_type(t.oid, NULL)",
gettext_noop("index"),
gettext_noop("sequence"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "c.relname", NULL,
" WHERE r.rulename != '_RETURN'\n",
gettext_noop("rule"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
/* XXX not sure what to do about visibility rule here? */
processSQLNamePattern(pset.db, &buf, pattern, true, false,
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n",
gettext_noop("trigger"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
/* XXX not sure what to do about visibility rule here? */
processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false,
"FROM pg_catalog.pg_class c\n"
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n");
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, "WHERE n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, !showSystem && !pattern, false,
"n.nspname", "c.relname", NULL,
PGresult *res = NULL;
printTableOpt myopt = pset.popt.topt;
printTableContent cont;
- bool printTableInitialized = false;
+ bool printTableInitialized = false;
int i;
char *view_def = NULL;
char *headers[6];
if (pset.sversion >= 80400)
{
printfPQExpBuffer(&buf,
- "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
+ "SELECT c.relchecks, c.relkind, c.relhasindex, c.relhasrules, "
"c.relhastriggers, c.relhasoids, "
"%s, c.reltablespace\n"
"FROM pg_catalog.pg_class c\n "
- "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
+ "LEFT JOIN pg_catalog.pg_class tc ON (c.reltoastrelid = tc.oid)\n"
"WHERE c.oid = '%s'\n",
(verbose ?
- "pg_catalog.array_to_string(c.reloptions || "
- "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
- : "''"),
+ "pg_catalog.array_to_string(c.reloptions || "
+ "array(select 'toast.' || x from pg_catalog.unnest(tc.reloptions) x), ', ')\n"
+ : "''"),
oid);
}
else if (pset.sversion >= 80200)
{
printfPQExpBuffer(&buf,
- "SELECT relchecks, relkind, relhasindex, relhasrules, "
+ "SELECT relchecks, relkind, relhasindex, relhasrules, "
"reltriggers <> 0, relhasoids, "
"%s, reltablespace\n"
"FROM pg_catalog.pg_class WHERE oid = '%s'",
(verbose ?
- "pg_catalog.array_to_string(reloptions, E', ')" : "''"),
+ "pg_catalog.array_to_string(reloptions, E', ')" : "''"),
oid);
}
else if (pset.sversion >= 80000)
{
printfPQExpBuffer(&buf,
- "SELECT relchecks, relkind, relhasindex, relhasrules, "
+ "SELECT relchecks, relkind, relhasindex, relhasrules, "
"reltriggers <> 0, relhasoids, "
"'', reltablespace\n"
"FROM pg_catalog.pg_class WHERE oid = '%s'",
else
{
printfPQExpBuffer(&buf,
- "SELECT relchecks, relkind, relhasindex, relhasrules, "
+ "SELECT relchecks, relkind, relhasindex, relhasrules, "
"reltriggers <> 0, relhasoids, "
"'', ''\n"
"FROM pg_catalog.pg_class WHERE oid = '%s'",
tableinfo.hastriggers = strcmp(PQgetvalue(res, 0, 4), "t") == 0;
tableinfo.hasoids = strcmp(PQgetvalue(res, 0, 5), "t") == 0;
tableinfo.reloptions = pset.sversion >= 80200 ?
- strdup(PQgetvalue(res, 0, 6)) : 0;
+ strdup(PQgetvalue(res, 0, 6)) : 0;
tableinfo.tablespace = (pset.sversion >= 80000) ?
- atooid(PQgetvalue(res, 0, 7)) : 0;
+ atooid(PQgetvalue(res, 0, 7)) : 0;
PQclear(res);
res = NULL;
-
+
/*
- * If it's a sequence, fetch its values and store into an
- * array that will be used later.
+ * If it's a sequence, fetch its values and store into an array that will
+ * be used later.
*/
if (tableinfo.relkind == 'S')
{
PGresult *result;
-
+
#define SEQ_NUM_COLS 10
printfPQExpBuffer(&buf,
"SELECT sequence_name, last_value,\n"
fmtId(schemaname));
/* must be separate because fmtId isn't reentrant */
appendPQExpBuffer(&buf, ".%s", fmtId(relationname));
-
+
result = PSQLexec(buf.data, false);
if (!result)
goto error_return;
-
- seq_values = pg_malloc_zero((SEQ_NUM_COLS+1) * sizeof(*seq_values));
-
- for (i = 0; i < SEQ_NUM_COLS; i++)
+
+ seq_values = pg_malloc_zero((SEQ_NUM_COLS + 1) * sizeof(*seq_values));
+
+ for (i = 0; i < SEQ_NUM_COLS; i++)
seq_values[i] = pg_strdup(PQgetvalue(result, 0, i));
-
+
PQclear(result);
}
if (tableinfo.relkind == 'S')
headers[cols++] = gettext_noop("Value");
-
+
if (verbose)
{
headers[cols++] = gettext_noop("Storage");
headers[cols++] = gettext_noop("Description");
}
-
+
printTableInit(&cont, &myopt, title.data, cols, numrows);
printTableInitialized = true;
PGresult *result;
printfPQExpBuffer(&buf,
- "SELECT pg_catalog.pg_get_viewdef('%s'::pg_catalog.oid, true)",
+ "SELECT pg_catalog.pg_get_viewdef('%s'::pg_catalog.oid, true)",
oid);
result = PSQLexec(buf.data, false);
if (!result)
/* Storage and Description */
if (verbose)
{
- char *storage = PQgetvalue(res, i, 5);
+ char *storage = PQgetvalue(res, i, 5);
/* these strings are literal in our syntax, so not translated. */
- printTableAddCell(&cont, (storage[0]=='p' ? "plain" :
- (storage[0]=='m' ? "main" :
- (storage[0]=='x' ? "extended" :
- (storage[0]=='e' ? "external" :
+ printTableAddCell(&cont, (storage[0] == 'p' ? "plain" :
+ (storage[0] == 'm' ? "main" :
+ (storage[0] == 'x' ? "extended" :
+ (storage[0] == 'e' ? "external" :
"???")))),
false);
printTableAddCell(&cont, PQgetvalue(res, i, 6), false);
PGresult *result;
printfPQExpBuffer(&buf,
- "SELECT i.indisunique, i.indisprimary, i.indisclustered, ");
+ "SELECT i.indisunique, i.indisprimary, i.indisclustered, ");
if (pset.sversion >= 80200)
appendPQExpBuffer(&buf, "i.indisvalid, ");
else
{
printfPQExpBuffer(&buf,
"SELECT c2.relname, i.indisprimary, i.indisunique, i.indisclustered, ");
- if (pset.sversion >= 80200)
+ if (pset.sversion >= 80200)
appendPQExpBuffer(&buf, "i.indisvalid, ");
- else
+ else
appendPQExpBuffer(&buf, "true as indisvalid, ");
appendPQExpBuffer(&buf, "pg_catalog.pg_get_indexdef(i.indexrelid, 0, true)");
- if (pset.sversion >= 80000)
+ if (pset.sversion >= 80000)
appendPQExpBuffer(&buf, ", c2.reltablespace");
appendPQExpBuffer(&buf,
"\nFROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i\n"
/* Label as primary key or unique (but not both) */
appendPQExpBuffer(&buf,
- strcmp(PQgetvalue(result, i, 1), "t") == 0
+ strcmp(PQgetvalue(result, i, 1), "t") == 0
? " PRIMARY KEY," :
- (strcmp(PQgetvalue(result, i, 2), "t") == 0
- ? " UNIQUE,"
- : ""));
+ (strcmp(PQgetvalue(result, i, 2), "t") == 0
+ ? " UNIQUE,"
+ : ""));
/* Everything after "USING" is echoed verbatim */
indexdef = PQgetvalue(result, i, 5);
usingpos = strstr(indexdef, " USING ");
/* Print tablespace of the index on the same line */
if (pset.sversion >= 80000)
- add_tablespace_footer(&cont, 'i',
- atooid(PQgetvalue(result, i, 6)),
+ add_tablespace_footer(&cont, 'i',
+ atooid(PQgetvalue(result, i, 6)),
false);
}
}
"SELECT r.conname, "
"pg_catalog.pg_get_constraintdef(r.oid, true)\n"
"FROM pg_catalog.pg_constraint r\n"
- "WHERE r.conrelid = '%s' AND r.contype = 'c'\nORDER BY 1",
+ "WHERE r.conrelid = '%s' AND r.contype = 'c'\nORDER BY 1",
oid);
result = PSQLexec(buf.data, false);
if (!result)
{
printfPQExpBuffer(&buf,
"SELECT conname,\n"
- " pg_catalog.pg_get_constraintdef(r.oid, true) as condef\n"
+ " pg_catalog.pg_get_constraintdef(r.oid, true) as condef\n"
"FROM pg_catalog.pg_constraint r\n"
"WHERE r.conrelid = '%s' AND r.contype = 'f' ORDER BY 1",
oid);
if (tableinfo.hastriggers)
{
printfPQExpBuffer(&buf,
- "SELECT conname, conrelid::pg_catalog.regclass,\n"
- " pg_catalog.pg_get_constraintdef(c.oid, true) as condef\n"
+ "SELECT conname, conrelid::pg_catalog.regclass,\n"
+ " pg_catalog.pg_get_constraintdef(c.oid, true) as condef\n"
"FROM pg_catalog.pg_constraint c\n"
- "WHERE c.confrelid = '%s' AND c.contype = 'f' ORDER BY 1",
+ "WHERE c.confrelid = '%s' AND c.contype = 'f' ORDER BY 1",
oid);
result = PSQLexec(buf.data, false);
if (!result)
printTableAddFooter(&cont, _("Referenced by:"));
for (i = 0; i < tuples; i++)
{
- /* translator: the first %s is a FK name, the following are
- * a table name and the FK definition */
+ /*
+ * translator: the first %s is a FK name, the following
+ * are a table name and the FK definition
+ */
printfPQExpBuffer(&buf, _(" \"%s\" IN %s %s"),
PQgetvalue(result, i, 0),
PQgetvalue(result, i, 1),
int category;
/*
- * split the output into 4 different categories. Enabled triggers,
- * disabled triggers and the two special ALWAYS and REPLICA
- * configurations.
+ * split the output into 4 different categories. Enabled
+ * triggers, disabled triggers and the two special ALWAYS and
+ * REPLICA configurations.
*/
for (category = 0; category < 4; category++)
{
const char *usingpos;
const char *tgenabled;
- /* Check if this trigger falls into the current category */
+ /*
+ * Check if this trigger falls into the current
+ * category
+ */
tgenabled = PQgetvalue(result, i, 2);
list_trigger = false;
switch (category)
termPQExpBuffer(&buf);
termPQExpBuffer(&title);
termPQExpBuffer(&tmpbuf);
-
+
if (seq_values)
{
for (ptr = seq_values; *ptr; ptr++)
free(*ptr);
free(seq_values);
}
-
+
if (modifiers)
{
for (ptr = modifiers; *ptr; ptr++)
{
/* Append the tablespace to the latest footer */
printfPQExpBuffer(&buf, "%s", cont->footer->data);
- /* translator: before this string there's an index
- * description like '"foo_pkey" PRIMARY KEY, btree (a)' */
+
+ /*
+ * translator: before this string there's an index
+ * description like '"foo_pkey" PRIMARY KEY, btree (a)'
+ */
appendPQExpBuffer(&buf, _(", tablespace \"%s\""),
PQgetvalue(result, 0, 0));
printTableSetFooter(cont, buf.data);
if (pset.sversion >= 80100)
{
printfPQExpBuffer(&buf,
- "SELECT r.rolname, r.rolsuper, r.rolinherit,\n"
- " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin,\n"
- " r.rolconnlimit,\n"
- " ARRAY(SELECT b.rolname\n"
- " FROM pg_catalog.pg_auth_members m\n"
- " JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)\n"
- " WHERE m.member = r.oid) as memberof");
+ "SELECT r.rolname, r.rolsuper, r.rolinherit,\n"
+ " r.rolcreaterole, r.rolcreatedb, r.rolcanlogin,\n"
+ " r.rolconnlimit,\n"
+ " ARRAY(SELECT b.rolname\n"
+ " FROM pg_catalog.pg_auth_members m\n"
+ " JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)\n"
+ " WHERE m.member = r.oid) as memberof");
if (verbose && pset.sversion >= 80200)
{
processSQLNamePattern(pset.db, &buf, pattern, false, false,
NULL, "r.rolname", NULL, NULL);
- }
- else
- {
- printfPQExpBuffer(&buf,
- "SELECT u.usename AS rolname,\n"
- " u.usesuper AS rolsuper,\n"
- " true AS rolinherit, false AS rolcreaterole,\n"
- " u.usecreatedb AS rolcreatedb, true AS rolcanlogin,\n"
- " -1 AS rolconnlimit,\n"
- " ARRAY(SELECT g.groname FROM pg_catalog.pg_group g WHERE u.usesysid = ANY(g.grolist)) as memberof"
- "\nFROM pg_catalog.pg_user u\n");
+ }
+ else
+ {
+ printfPQExpBuffer(&buf,
+ "SELECT u.usename AS rolname,\n"
+ " u.usesuper AS rolsuper,\n"
+ " true AS rolinherit, false AS rolcreaterole,\n"
+ " u.usecreatedb AS rolcreatedb, true AS rolcanlogin,\n"
+ " -1 AS rolconnlimit,\n"
+ " ARRAY(SELECT g.groname FROM pg_catalog.pg_group g WHERE u.usesysid = ANY(g.grolist)) as memberof"
+ "\nFROM pg_catalog.pg_user u\n");
processSQLNamePattern(pset.db, &buf, pattern, false, false,
NULL, "u.usename", NULL, NULL);
- }
+ }
appendPQExpBuffer(&buf, "ORDER BY 1;");
if (showSeq)
appendPQExpBuffer(&buf, "'S',");
if (showSystem || pattern)
- appendPQExpBuffer(&buf, "'s',"); /* was RELKIND_SPECIAL in <= 8.1 */
+ appendPQExpBuffer(&buf, "'s',"); /* was RELKIND_SPECIAL in <=
+ * 8.1 */
appendPQExpBuffer(&buf, "''"); /* dummy */
appendPQExpBuffer(&buf, ")\n");
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
/*
* TOAST objects are suppressed unconditionally. Since we don't provide
gettext_noop("Modifier"),
gettext_noop("Check"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "t.typname", NULL,
gettext_noop("yes"), gettext_noop("no"),
gettext_noop("Default?"));
- if (!showSystem && !pattern)
- appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
- " AND n.nspname <> 'information_schema'\n");
+ if (!showSystem && !pattern)
+ appendPQExpBuffer(&buf, " AND n.nspname <> 'pg_catalog'\n"
+ " AND n.nspname <> 'information_schema'\n");
processSQLNamePattern(pset.db, &buf, pattern, true, false,
"n.nspname", "c.conname", NULL,
static const bool translate_columns[] = {false, false, false, true};
initPQExpBuffer(&buf);
+
/*
* We need a left join to pg_proc for binary casts; the others are just
* paranoia. Also note that we don't attempt to localize '(binary
printfPQExpBuffer(&buf,
"SELECT pg_catalog.format_type(castsource, NULL) AS \"%s\",\n"
" pg_catalog.format_type(casttarget, NULL) AS \"%s\",\n"
- " CASE WHEN castfunc = 0 THEN '(binary coercible)'\n"
+ " CASE WHEN castfunc = 0 THEN '(binary coercible)'\n"
" ELSE p.proname\n"
" END as \"%s\",\n"
" CASE WHEN c.castcontext = 'e' THEN '%s'\n"
gettext_noop("Source type"),
gettext_noop("Target type"),
gettext_noop("Function"),
- gettext_noop("no"), gettext_noop("in assignment"), gettext_noop("yes"),
+ gettext_noop("no"), gettext_noop("in assignment"), gettext_noop("yes"),
gettext_noop("Implicit?"));
/*
appendPQExpBuffer(&buf, ",\n ");
printACLColumn(&buf, "n.nspacl");
appendPQExpBuffer(&buf,
- ",\n pg_catalog.obj_description(n.oid, 'pg_namespace') AS \"%s\"",
+ ",\n pg_catalog.obj_description(n.oid, 'pg_namespace') AS \"%s\"",
gettext_noop("Description"));
}
appendPQExpBuffer(&buf,
- "\nFROM pg_catalog.pg_namespace n\n"
+ "\nFROM pg_catalog.pg_namespace n\n"
"WHERE (n.nspname !~ '^pg_temp_' OR\n"
" n.nspname = (pg_catalog.current_schemas(true))[1])\n"); /* temp schema is first */
}
appendPQExpBuffer(&buf,
- "\nFROM pg_catalog.pg_foreign_server s\n"
- " JOIN pg_catalog.pg_foreign_data_wrapper f ON f.oid=s.srvfdw\n");
+ "\nFROM pg_catalog.pg_foreign_server s\n"
+ " JOIN pg_catalog.pg_foreign_data_wrapper f ON f.oid=s.srvfdw\n");
processSQLNamePattern(pset.db, &buf, pattern, false, false,
NULL, "s.srvname", NULL, NULL);
* printACLColumn
*
* Helper function for consistently formatting ACL (privilege) columns.
- * The proper targetlist entry is appended to buf. Note lack of any
+ * The proper targetlist entry is appended to buf. Note lack of any
* whitespace or comma decoration.
*/
static void
printf(_("\nOutput format options:\n"));
printf(_(" -A, --no-align unaligned table output mode\n"));
printf(_(" -F, --field-separator=STRING\n"
- " set field separator (default: \"%s\")\n"),
+ " set field separator (default: \"%s\")\n"),
DEFAULT_FIELD_SEP);
printf(_(" -H, --html HTML table output mode\n"));
printf(_(" -P, --pset=VAR[=ARG] set printing option VAR to ARG (see \\pset command)\n"));
printf(_(" -R, --record-separator=STRING\n"
- " set record separator (default: newline)\n"));
+ " set record separator (default: newline)\n"));
printf(_(" -t, --tuples-only print rows only\n"));
printf(_(" -T, --table-attr=TEXT set HTML table tag attributes (e.g., width, border)\n"));
printf(_(" -x, --expanded turn on expanded table output\n"));
fprintf(output, _("Connection\n"));
fprintf(output, _(" \\c[onnect] [DBNAME|- USER|- HOST|- PORT|-]\n"
- " connect to new database (currently \"%s\")\n"),
+ " connect to new database (currently \"%s\")\n"),
PQdb(pset.db));
fprintf(output, _(" \\encoding [ENCODING] show or set client encoding\n"));
fprintf(output, _(" \\password [USERNAME] securely change the password for a user\n"));
for (i = 0; i < nrows; i++)
{
fprintf(output, " ");
- for (j = 0; j < ncolumns-1; j++)
+ for (j = 0; j < ncolumns - 1; j++)
fprintf(output, "%-*s",
QL_MAX_CMD_LEN + 1,
VALUE_OR_NULL(QL_HELP[i + j * nrows].cmd));
MainLoop(FILE *source)
{
PsqlScanState scan_state; /* lexer working state */
- volatile PQExpBuffer query_buf; /* buffer for query being accumulated */
+ volatile PQExpBuffer query_buf; /* buffer for query being accumulated */
volatile PQExpBuffer previous_buf; /* if there isn't anything in the new
- * buffer yet, use this one for \e, etc. */
+ * buffer yet, use this one for \e,
+ * etc. */
PQExpBuffer history_buf; /* earlier lines of a multi-line command, not
* yet saved to readline history */
char *line; /* current line of input */
printf(_("Type: \\copyright for distribution terms\n"
" \\h for help with SQL commands\n"
" \\? for help with psql commands\n"
- " \\g or terminate with semicolon to execute query\n"
+ " \\g or terminate with semicolon to execute query\n"
" \\q to quit\n"));
fflush(stdout);
}
if (linewidth > width)
width = linewidth;
- format_size += 1; /* For NUL char */
+ format_size += 1; /* For NUL char */
/* Set results */
if (result_width)
}
/*
- * Format a string into one or more "struct lineptr" lines.
- * lines[i].ptr == NULL indicates the end of the array.
+ * Format a string into one or more "struct lineptr" lines.
+ * lines[i].ptr == NULL indicates the end of the array.
*
* This MUST be kept in sync with pg_wcssize!
*/
void
pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
- struct lineptr *lines, int count)
+ struct lineptr * lines, int count)
{
int w,
chlen = 0;
len -= chlen;
}
lines->width = linewidth;
- *ptr++ = '\0'; /* Terminate formatted string */
+ *ptr++ = '\0'; /* Terminate formatted string */
if (count <= 0)
- exit(1); /* Screwup */
+ exit(1); /* Screwup */
- (lines+1)->ptr = NULL; /* terminate line array */
+ (lines + 1)->ptr = NULL; /* terminate line array */
}
unsigned char *
extern int pg_wcswidth(const unsigned char *pwcs, size_t len, int encoding);
extern void pg_wcsformat(unsigned char *pwcs, size_t len, int encoding, struct lineptr * lines, int count);
extern void pg_wcssize(unsigned char *pwcs, size_t len, int encoding,
- int *width, int *height, int *format_size);
+ int *width, int *height, int *format_size);
#endif /* MBPRINT_H */
static char *thousands_sep;
/* Local functions */
-static int strlen_max_width(unsigned char *str, int *target_width, int encoding);
+static int strlen_max_width(unsigned char *str, int *target_width, int encoding);
static void IsPagerNeeded(const printTableContent *cont, const int extra_lines,
- FILE **fout, bool *is_pager);
+ FILE **fout, bool *is_pager);
static void *
int encoding = cont->opt->encoding;
unsigned short opt_border = cont->opt->border;
- unsigned int col_count = 0, cell_count = 0;
+ unsigned int col_count = 0,
+ cell_count = 0;
unsigned int i,
j;
*max_width,
*width_wrap,
*width_average;
- unsigned int *max_nl_lines, /* value split by newlines */
- *curr_nl_line,
- *max_bytes;
+ unsigned int *max_nl_lines, /* value split by newlines */
+ *curr_nl_line,
+ *max_bytes;
unsigned char **format_buf;
unsigned int width_total;
unsigned int total_header_width;
unsigned int extra_row_output_lines = 0;
unsigned int extra_output_lines = 0;
- const char * const *ptr;
+ const char *const * ptr;
struct lineptr **col_lineptrs; /* pointers to line pointer per column */
bool *header_done; /* Have all header lines been output? */
int *bytes_output; /* Bytes output for column value */
- int output_columns = 0; /* Width of interactive console */
+ int output_columns = 0; /* Width of interactive console */
bool is_pager = false;
if (cancel_pressed)
/* If we have rows, compute average */
if (col_count != 0 && cell_count != 0)
{
- int rows = cell_count / col_count;
-
+ int rows = cell_count / col_count;
+
for (i = 0; i < col_count; i++)
width_average[i] /= rows;
}
/*
* At this point: max_width[] contains the max width of each column,
* max_nl_lines[] contains the max number of lines in each column,
- * max_bytes[] contains the maximum storage space for formatting
- * strings, width_total contains the giant width sum. Now we allocate
- * some memory for line pointers.
+ * max_bytes[] contains the maximum storage space for formatting strings,
+ * width_total contains the giant width sum. Now we allocate some memory
+ * for line pointers.
*/
for (i = 0; i < col_count; i++)
{
/* Add entry for ptr == NULL array termination */
col_lineptrs[i] = pg_local_calloc(max_nl_lines[i] + 1,
- sizeof(**col_lineptrs));
+ sizeof(**col_lineptrs));
format_buf[i] = pg_local_malloc(max_bytes[i] + 1);
* Optional optimized word wrap. Shrink columns with a high max/avg
* ratio. Slighly bias against wider columns. (Increases chance a
* narrow column will fit in its cell.) If available columns is
- * positive... and greater than the width of the unshrinkable column
+ * positive... and greater than the width of the unshrinkable column
* headers
*/
if (output_columns > 0 && output_columns >= total_header_width)
int worst_col = -1;
/*
- * Find column that has the highest ratio of its maximum
- * width compared to its average width. This tells us which
- * column will produce the fewest wrapped values if shortened.
- * width_wrap starts as equal to max_width.
+ * Find column that has the highest ratio of its maximum width
+ * compared to its average width. This tells us which column
+ * will produce the fewest wrapped values if shortened.
+ * width_wrap starts as equal to max_width.
*/
for (i = 0; i < col_count; i++)
{
if (width_average[i] && width_wrap[i] > width_header[i])
{
/* Penalize wide columns by 1% of their width */
- double ratio;
+ double ratio;
ratio = (double) width_wrap[i] / width_average[i] +
max_width[i] * 0.01;
fout = PageOutput(INT_MAX, cont->opt->pager); /* force pager */
is_pager = true;
}
-
+
/* Check if newlines or our wrapping now need the pager */
if (!is_pager)
{
int width,
nl_lines,
bytes_required;
-
+
pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding,
&width, &nl_lines, &bytes_required);
if (opt_numeric_locale && cont->align[i] == 'r')
width += additional_numeric_locale_len(*ptr);
-
+
/*
- * A row can have both wrapping and newlines that cause
- * it to display across multiple lines. We check
- * for both cases below.
+ * A row can have both wrapping and newlines that cause it to
+ * display across multiple lines. We check for both cases below.
*/
if (width > 0 && width_wrap[i])
{
unsigned int extra_lines;
- extra_lines = (width-1) / width_wrap[i] + nl_lines;
+ extra_lines = (width - 1) / width_wrap[i] + nl_lines;
if (extra_lines > extra_row_output_lines)
extra_row_output_lines = extra_lines;
}
}
IsPagerNeeded(cont, extra_output_lines, &fout, &is_pager);
}
-
+
/* time to output */
if (cont->opt->start_table)
{
/* print title */
if (cont->title && !opt_tuples_only)
{
- int width, height;
+ int width,
+ height;
pg_wcssize((unsigned char *) cont->title, strlen(cont->title),
encoding, &width, &height, NULL);
break;
/*
- * Format each cell. Format again, if it's a numeric formatting locale
- * (e.g. 123,456 vs. 123456)
+ * Format each cell. Format again, if it's a numeric formatting
+ * locale (e.g. 123,456 vs. 123456)
*/
for (j = 0; j < col_count; j++)
{
memset(bytes_output, 0, col_count * sizeof(int));
/*
- * Each time through this loop, one display line is output.
- * It can either be a full value or a partial value if embedded
- * newlines exist or if 'format=wrapping' mode is enabled.
+ * Each time through this loop, one display line is output. It can
+ * either be a full value or a partial value if embedded newlines
+ * exist or if 'format=wrapping' mode is enabled.
*/
do
{
{
/* We have a valid array element, so index it */
struct lineptr *this_line = &col_lineptrs[j][curr_nl_line[j]];
- int bytes_to_output;
- int chars_to_output = width_wrap[j];
- bool finalspaces = (opt_border == 2 || j < col_count - 1);
+ int bytes_to_output;
+ int chars_to_output = width_wrap[j];
+ bool finalspaces = (opt_border == 2 || j < col_count - 1);
if (!this_line->ptr)
{
&chars_to_output, encoding);
/*
- * If we exceeded width_wrap, it means the display width
- * of a single character was wider than our target width.
- * In that case, we have to pretend we are only printing
- * the target display width and make the best of it.
+ * If we exceeded width_wrap, it means the display width
+ * of a single character was wider than our target width.
+ * In that case, we have to pretend we are only printing
+ * the target display width and make the best of it.
*/
if (chars_to_output > width_wrap[j])
chars_to_output = width_wrap[j];
- if (cont->aligns[j] == 'r') /* Right aligned cell */
+ if (cont->aligns[j] == 'r') /* Right aligned cell */
{
/* spaces first */
fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
if (opt_border == 0)
fputc(' ', fout);
/* Next value is beyond past newlines? */
- else if (col_lineptrs[j+1][curr_nl_line[j+1]].ptr == NULL)
+ else if (col_lineptrs[j + 1][curr_nl_line[j + 1]].ptr == NULL)
fputs(" ", fout);
/* In wrapping of value? */
- else if (bytes_output[j+1] != 0)
+ else if (bytes_output[j + 1] != 0)
fputs(" ; ", fout);
/* After first newline value */
- else if (curr_nl_line[j+1] != 0)
+ else if (curr_nl_line[j + 1] != 0)
fputs(" : ", fout);
else
- /* Ordinary line */
+ /* Ordinary line */
fputs(" | ", fout);
}
}
const bool translate, const char align)
{
#ifndef ENABLE_NLS
- (void) translate; /* unused parameter */
+ (void) translate; /* unused parameter */
#endif
if (content->header >= content->headers + content->ncolumns)
const bool translate)
{
#ifndef ENABLE_NLS
- (void) translate; /* unused parameter */
+ (void) translate; /* unused parameter */
#endif
if (content->cell >= content->cells + (content->ncolumns * content->nrows))
* strdup'd, so there is no need to keep the original footer string around.
*
* Footers are never translated by the function. If you want the footer
- * translated you must do so yourself, before calling printTableAddFooter. The
+ * translated you must do so yourself, before calling printTableAddFooter. The
* reason this works differently to headers and cells is that footers tend to
* be made of up individually translated components, rather than being
* translated as a whole.
printTable(const printTableContent *cont, FILE *fout, FILE *flog)
{
bool is_pager = false;
-
+
if (cancel_pressed)
return;
/* print_aligned_text() handles the pager itself */
if ((cont->opt->format != PRINT_ALIGNED &&
cont->opt->format != PRINT_WRAPPED) ||
- cont->opt->expanded)
+ cont->opt->expanded)
IsPagerNeeded(cont, 0, &fout, &is_pager);
/* print the stuff */
{
for (c = 0; c < cont.ncolumns; c++)
{
- char *cell;
- bool translate;
+ char *cell;
+ bool translate;
if (PQgetisnull(result, r, c))
cell = opt->nullPrint ? opt->nullPrint : "";
/* set footers */
if (opt->footers)
{
- char **footer;
+ char **footer;
for (footer = opt->footers; *footer; footer++)
printTableAddFooter(&cont, *footer);
/*
* Compute the byte distance to the end of the string or *target_width
- * display character positions, whichever comes first. Update *target_width
+ * display character positions, whichever comes first. Update *target_width
* to be the number of display character positions actually filled.
*/
static int
{
unsigned char *start = str;
unsigned char *end = str + strlen((char *) str);
- int curr_width = 0;
+ int curr_width = 0;
while (str < end)
{
- int char_width = PQdsplen((char *) str, encoding);
+ int char_width = PQdsplen((char *) str, encoding);
/*
- * If the display width of the new character causes
- * the string to exceed its target width, skip it
- * and return. However, if this is the first character
- * of the string (curr_width == 0), we have to accept it.
+ * If the display width of the new character causes the string to
+ * exceed its target width, skip it and return. However, if this is
+ * the first character of the string (curr_width == 0), we have to
+ * accept it.
*/
if (*target_width < curr_width + char_width && curr_width != 0)
break;
curr_width += char_width;
-
+
str += PQmblen((char *) str, encoding);
}
*target_width = curr_width;
-
+
return str - start;
}
*/
typedef struct printTableFooter
{
- char *data;
+ char *data;
struct printTableFooter *next;
} printTableFooter;
typedef struct printTableContent
{
const printTableOpt *opt;
- const char *title; /* May be NULL */
- int ncolumns; /* Specified in Init() */
- int nrows; /* Specified in Init() */
+ const char *title; /* May be NULL */
+ int ncolumns; /* Specified in Init() */
+ int nrows; /* Specified in Init() */
const char **headers; /* NULL-terminated array of header strings */
const char **header; /* Pointer to the last added header */
const char **cells; /* NULL-terminated array of cell content
- strings */
+ * strings */
const char **cell; /* Pointer to the last added cell */
- printTableFooter *footers; /* Pointer to the first footer */
+ printTableFooter *footers; /* Pointer to the first footer */
printTableFooter *footer; /* Pointer to the last added footer */
- char *aligns; /* Array of alignment specifiers; 'l' or 'r',
- one per column */
- char *align; /* Pointer to the last added alignment */
+ char *aligns; /* Array of alignment specifiers; 'l' or 'r',
+ * one per column */
+ char *align; /* Pointer to the last added alignment */
} printTableContent;
typedef struct printQueryOpt
char *title; /* override title */
char **footers; /* override footer (default is "(xx rows)") */
bool default_footer; /* print default footer if footers==NULL */
- bool translate_header; /* do gettext on column headers */
- const bool *translate_columns; /* translate_columns[i-1] => do gettext on col i */
+ bool translate_header; /* do gettext on column headers */
+ const bool *translate_columns; /* translate_columns[i-1] => do
+ * gettext on col i */
} printQueryOpt;
extern void html_escaped_print(const char *in, FILE *fout);
extern void printTableInit(printTableContent *const content,
- const printTableOpt *opt, const char *title,
- const int ncolumns, const int nrows);
-extern void printTableAddHeader(printTableContent *const content,
- const char *header, const bool translate, const char align);
-extern void printTableAddCell(printTableContent *const content,
- const char *cell, const bool translate);
-extern void printTableAddFooter(printTableContent *const content,
- const char *footer);
-extern void printTableSetFooter(printTableContent *const content,
- const char *footer);
+ const printTableOpt *opt, const char *title,
+ const int ncolumns, const int nrows);
+extern void printTableAddHeader(printTableContent *const content,
+ const char *header, const bool translate, const char align);
+extern void printTableAddCell(printTableContent *const content,
+ const char *cell, const bool translate);
+extern void printTableAddFooter(printTableContent *const content,
+ const char *footer);
+extern void printTableSetFooter(printTableContent *const content,
+ const char *footer);
extern void printTableCleanup(printTableContent *const content);
extern void printTable(const printTableContent *cont, FILE *fout, FILE *flog);
extern void printQuery(const PGresult *result, const printQueryOpt *opt,
- FILE *fout, FILE *flog);
+ FILE *fout, FILE *flog);
-extern void setDecimalLocale(void);
+extern void setDecimalLocale(void);
#ifndef __CYGWIN__
#define DEFAULT_PAGER "more"
* Communication variables set by COMPLETE_WITH_FOO macros and then used by
* the completion callback functions. Ugly but there is no better way.
*/
-static const char *completion_charp; /* to pass a string */
+static const char *completion_charp; /* to pass a string */
static const char *const * completion_charpp; /* to pass a list of strings */
static const char *completion_info_charp; /* to pass a second string */
static const char *completion_info_charp2; /* to pass a third string */
{
static const char *const list_ALTER[] =
{"AGGREGATE", "CONVERSION", "DATABASE", "DOMAIN", "FOREIGN DATA WRAPPER", "FUNCTION",
- "GROUP", "INDEX", "LANGUAGE", "OPERATOR", "ROLE", "SCHEMA", "SERVER", "SEQUENCE", "TABLE",
+ "GROUP", "INDEX", "LANGUAGE", "OPERATOR", "ROLE", "SCHEMA", "SERVER", "SEQUENCE", "TABLE",
"TABLESPACE", "TEXT SEARCH", "TRIGGER", "TYPE", "USER", "USER MAPPING FOR", "VIEW", NULL};
COMPLETE_WITH_LIST(list_ALTER);
{
static const char *const list_privileg[] =
{"SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES",
- "TRIGGER", "CREATE", "CONNECT", "TEMPORARY", "EXECUTE", "USAGE",
- "ALL", NULL};
+ "TRIGGER", "CREATE", "CONNECT", "TEMPORARY", "EXECUTE", "USAGE",
+ "ALL", NULL};
COMPLETE_WITH_LIST(list_privileg);
}
COMPLETE_WITH_ATTR(prev_wd, "");
/*
- * Complete INSERT INTO <table> with "VALUES" or "SELECT" or
- * "TABLE" or "DEFAULT VALUES"
+ * Complete INSERT INTO <table> with "VALUES" or "SELECT" or "TABLE" or
+ * "DEFAULT VALUES"
*/
else if (pg_strcasecmp(prev3_wd, "INSERT") == 0 &&
pg_strcasecmp(prev2_wd, "INTO") == 0)
COMPLETE_WITH_LIST(list_INSERT);
}
- /* Complete INSERT INTO <table> (attribs) with "VALUES" or "SELECT" or "TABLE" */
+
+ /*
+ * Complete INSERT INTO <table> (attribs) with "VALUES" or "SELECT" or
+ * "TABLE"
+ */
else if (pg_strcasecmp(prev4_wd, "INSERT") == 0 &&
pg_strcasecmp(prev3_wd, "INTO") == 0 &&
prev_wd[strlen(prev_wd) - 1] == ')')
}
/*
- * "Safe" wrapper around strdup(). Pulled from psql/common.c
+ * "Safe" wrapper around strdup(). Pulled from psql/common.c
*/
char *
pg_strdup(const char *string)
static void
reindex_one_database(const char *name, const char *dbname, const char *type,
const char *host, const char *port, const char *username,
- enum trivalue prompt_password, const char *progname, bool echo)
+ enum trivalue prompt_password, const char *progname, bool echo)
{
PQExpBufferData sql;
#define NUM_CLOG_BUFFERS 8
-extern void TransactionIdSetTreeStatus(TransactionId xid, int nsubxids,
- TransactionId *subxids, XidStatus status, XLogRecPtr lsn);
+extern void TransactionIdSetTreeStatus(TransactionId xid, int nsubxids,
+ TransactionId *subxids, XidStatus status, XLogRecPtr lsn);
extern XidStatus TransactionIdGetStatus(TransactionId xid, XLogRecPtr *lsn);
extern Size CLOGShmemSize(void);
Snapshot snapshot,
int nkeys, ScanKey key);
extern IndexScanDesc index_beginscan_bitmap(Relation indexRelation,
- Snapshot snapshot,
- int nkeys, ScanKey key);
+ Snapshot snapshot,
+ int nkeys, ScanKey key);
extern void index_rescan(IndexScanDesc scan, ScanKey key);
extern void index_endscan(IndexScanDesc scan);
extern void index_markpos(IndexScanDesc scan);
extern bool systable_recheck_tuple(SysScanDesc sysscan, HeapTuple tup);
extern void systable_endscan(SysScanDesc sysscan);
extern SysScanDesc systable_beginscan_ordered(Relation heapRelation,
- Relation indexRelation,
- Snapshot snapshot,
- int nkeys, ScanKey key);
+ Relation indexRelation,
+ Snapshot snapshot,
+ int nkeys, ScanKey key);
extern HeapTuple systable_getnext_ordered(SysScanDesc sysscan,
- ScanDirection direction);
+ ScanDirection direction);
extern void systable_endscan_ordered(SysScanDesc sysscan);
#endif /* GENAM_H */
/*
* Max depth allowed in search tree during bulk inserts. This is to keep from
* degenerating to O(N^2) behavior when the tree is unbalanced due to sorted
- * or nearly-sorted input. (Perhaps it would be better to use a balanced-tree
+ * or nearly-sorted input. (Perhaps it would be better to use a balanced-tree
* algorithm, but in common cases that would only add useless overhead.)
*/
#define GIN_MAX_TREE_DEPTH 100
#define GIN_DELETED (1 << 2)
#define GIN_META (1 << 3)
#define GIN_LIST (1 << 4)
-#define GIN_LIST_FULLROW (1 << 5) /* makes sense only on GIN_LIST page */
+#define GIN_LIST_FULLROW (1 << 5) /* makes sense only on GIN_LIST page */
/* Page numbers of fixed-location pages */
#define GIN_METAPAGE_BLKNO (0)
* pages. These store fast-inserted entries that haven't yet been moved
* into the regular GIN structure.
*/
- BlockNumber head;
- BlockNumber tail;
+ BlockNumber head;
+ BlockNumber tail;
/*
* Free space in bytes in the pending list's tail page.
*/
- uint32 tailFreeSize;
+ uint32 tailFreeSize;
/*
- * We store both number of pages and number of heap tuples
- * that are in the pending list.
+ * We store both number of pages and number of heap tuples that are in the
+ * pending list.
*/
- BlockNumber nPendingPages;
- int64 nPendingHeapTuples;
+ BlockNumber nPendingPages;
+ int64 nPendingHeapTuples;
} GinMetaPageData;
#define GinPageGetMeta(p) \
#define GinDataPageGetRightBound(page) ((ItemPointer) PageGetContents(page))
#define GinDataPageGetData(page) \
(PageGetContents(page) + MAXALIGN(sizeof(ItemPointerData)))
-#define GinSizeOfItem(page) \
+#define GinSizeOfItem(page) \
(GinPageIsLeaf(page) ? sizeof(ItemPointerData) : sizeof(PostingItem))
#define GinDataPageGetItem(page,i) \
(GinDataPageGetData(page) + ((i)-1) * GinSizeOfItem(page))
* List pages
*/
#define GinListPageSize \
- ( BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(GinPageOpaqueData)) )
+ ( BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(GinPageOpaqueData)) )
/*
* Storage type for GIN's reloptions
*/
typedef struct GinOptions
{
- int32 vl_len_; /* varlena header (do not touch directly!) */
+ int32 vl_len_; /* varlena header (do not touch directly!) */
bool useFastUpdate; /* use fast updates? */
} GinOptions;
-#define GIN_DEFAULT_USE_FASTUPDATE true
+#define GIN_DEFAULT_USE_FASTUPDATE true
#define GinGetUseFastUpdate(relation) \
((relation)->rd_options ? \
((GinOptions *) (relation)->rd_options)->useFastUpdate : GIN_DEFAULT_USE_FASTUPDATE)
FmgrInfo extractValueFn[INDEX_MAX_KEYS];
FmgrInfo extractQueryFn[INDEX_MAX_KEYS];
FmgrInfo consistentFn[INDEX_MAX_KEYS];
- FmgrInfo comparePartialFn[INDEX_MAX_KEYS]; /* optional method */
+ FmgrInfo comparePartialFn[INDEX_MAX_KEYS]; /* optional method */
- bool canPartialMatch[INDEX_MAX_KEYS]; /* can opclass perform partial
- * match (prefix search)? */
+ bool canPartialMatch[INDEX_MAX_KEYS]; /* can opclass perform
+ * partial match (prefix
+ * search)? */
- TupleDesc tupdesc[INDEX_MAX_KEYS];
- TupleDesc origTupdesc;
- bool oneCol;
+ TupleDesc tupdesc[INDEX_MAX_KEYS];
+ TupleDesc origTupdesc;
+ bool oneCol;
} GinState;
/* XLog stuff */
typedef struct ginxlogUpdateMeta
{
- RelFileNode node;
+ RelFileNode node;
GinMetaPageData metadata;
- BlockNumber prevTail;
- BlockNumber newRightlink;
- int32 ntuples; /* if ntuples > 0 then metadata.tail was updated
- * with that many tuples; else new sub list was
- * inserted */
+ BlockNumber prevTail;
+ BlockNumber newRightlink;
+ int32 ntuples; /* if ntuples > 0 then metadata.tail was
+ * updated with that many tuples; else new sub
+ * list was inserted */
/* array of inserted tuples follows */
} ginxlogUpdateMeta;
typedef struct ginxlogInsertListPage
{
- RelFileNode node;
- BlockNumber blkno;
- BlockNumber rightlink;
- int32 ntuples;
+ RelFileNode node;
+ BlockNumber blkno;
+ BlockNumber rightlink;
+ int32 ntuples;
/* array of inserted tuples follows */
} ginxlogInsertListPage;
#define GIN_NDELETE_AT_ONCE 16
typedef struct ginxlogDeleteListPages
{
- RelFileNode node;
+ RelFileNode node;
GinMetaPageData metadata;
- int32 ndeleted;
- BlockNumber toDelete[GIN_NDELETE_AT_ONCE];
+ int32 ndeleted;
+ BlockNumber toDelete[GIN_NDELETE_AT_ONCE];
} ginxlogDeleteListPages;
extern void GinInitPage(Page page, uint32 f, Size pageSize);
extern void GinInitMetabuffer(Buffer b);
extern int compareEntries(GinState *ginstate, OffsetNumber attnum, Datum a, Datum b);
-extern int compareAttEntries(GinState *ginstate, OffsetNumber attnum_a, Datum a,
- OffsetNumber attnum_b, Datum b);
+extern int compareAttEntries(GinState *ginstate, OffsetNumber attnum_a, Datum a,
+ OffsetNumber attnum_b, Datum b);
extern Datum *extractEntriesS(GinState *ginstate, OffsetNumber attnum, Datum value,
int32 *nentries, bool *needUnique);
extern Datum *extractEntriesSU(GinState *ginstate, OffsetNumber attnum, Datum value, int32 *nentries);
extern Datum ginbuild(PG_FUNCTION_ARGS);
extern Datum gininsert(PG_FUNCTION_ARGS);
extern void ginEntryInsert(Relation index, GinState *ginstate,
- OffsetNumber attnum, Datum value,
- ItemPointerData *items, uint32 nitem,
- bool isBuild);
+ OffsetNumber attnum, Datum value,
+ ItemPointerData *items, uint32 nitem,
+ bool isBuild);
/* ginxlog.c */
extern void gin_redo(XLogRecPtr lsn, XLogRecord *record);
BlockNumber rightblkno;
/* Entry options */
- OffsetNumber entryAttnum;
+ OffsetNumber entryAttnum;
Datum entryValue;
IndexTuple entry;
bool isDelete;
/* ginentrypage.c */
extern IndexTuple GinFormTuple(GinState *ginstate, OffsetNumber attnum, Datum key,
- ItemPointerData *ipd, uint32 nipd);
+ ItemPointerData *ipd, uint32 nipd);
extern void GinShortenTuple(IndexTuple itup, uint32 nipd);
extern void prepareEntryScan(GinBtree btree, Relation index, OffsetNumber attnum,
- Datum value, GinState *ginstate);
+ Datum value, GinState *ginstate);
extern void entryFillRoot(GinBtree btree, Buffer root, Buffer lbuf, Buffer rbuf);
extern IndexTuple ginPageGetLinkItup(Buffer buf);
/* entry, got from extractQueryFn */
Datum entry;
- OffsetNumber attnum;
- Pointer extra_data;
+ OffsetNumber attnum;
+ Pointer extra_data;
/* Current page in posting tree */
Buffer buffer;
/* used for Posting list and one page in Posting tree */
ItemPointerData *list;
- uint32 nlist;
- OffsetNumber offset;
+ uint32 nlist;
+ OffsetNumber offset;
bool isFinished;
bool reduceResult;
/* array of scans per entry */
GinScanEntry scanEntry;
- Pointer *extra_data;
+ Pointer *extra_data;
/* for calling consistentFn(GinScanKey->entryRes, strategy, query) */
StrategyNumber strategy;
Datum query;
- OffsetNumber attnum;
+ OffsetNumber attnum;
ItemPointerData curItem;
bool firstCall;
/* ginbulk.c */
typedef struct EntryAccumulator
{
- OffsetNumber attnum;
- Datum value;
- uint32 length;
- uint32 number;
+ OffsetNumber attnum;
+ Datum value;
+ uint32 length;
+ uint32 number;
ItemPointerData *list;
- bool shouldSort;
+ bool shouldSort;
struct EntryAccumulator *left;
struct EntryAccumulator *right;
} EntryAccumulator;
typedef struct GinTupleCollector
{
- IndexTuple *tuples;
- uint32 ntuples;
- uint32 lentuples;
- uint32 sumsize;
+ IndexTuple *tuples;
+ uint32 ntuples;
+ uint32 lentuples;
+ uint32 sumsize;
} GinTupleCollector;
extern void ginHeapTupleFastInsert(Relation index, GinState *ginstate,
- GinTupleCollector *collector);
+ GinTupleCollector *collector);
extern uint32 ginHeapTupleFastCollect(Relation index, GinState *ginstate,
- GinTupleCollector *collector,
- OffsetNumber attnum, Datum value, ItemPointer item);
+ GinTupleCollector *collector,
+ OffsetNumber attnum, Datum value, ItemPointer item);
extern void ginInsertCleanup(Relation index, GinState *ginstate,
- bool vac_delay, IndexBulkDeleteResult *stats);
+ bool vac_delay, IndexBulkDeleteResult *stats);
-#endif /* GIN_H */
+#endif /* GIN_H */
typedef struct ItemResult
{
- ItemPointerData heapPtr;
- OffsetNumber pageOffset; /* offset in index page */
- bool recheck;
+ ItemPointerData heapPtr;
+ OffsetNumber pageOffset; /* offset in index page */
+ bool recheck;
} ItemResult;
/*
{
GISTSearchStack *stack;
GISTSearchStack *markstk;
- bool qual_ok; /* false if qual can never be satisfied */
+ bool qual_ok; /* false if qual can never be satisfied */
GISTSTATE *giststate;
MemoryContext tempCxt;
Buffer curbuf;
ItemPointerData curpos;
- ItemResult pageData[BLCKSZ/sizeof(IndexTupleData)];
- OffsetNumber nPageData;
- OffsetNumber curPageData;
+ ItemResult pageData[BLCKSZ / sizeof(IndexTupleData)];
+ OffsetNumber nPageData;
+ OffsetNumber curPageData;
} GISTScanOpaqueData;
typedef GISTScanOpaqueData *GISTScanOpaque;
extern void gistcheckpage(Relation rel, Buffer buf);
extern Buffer gistNewBuffer(Relation r);
extern void gistfillbuffer(Page page, IndexTuple *itup, int len,
- OffsetNumber off);
+ OffsetNumber off);
extern IndexTuple *gistextractpage(Page page, int *len /* out */ );
extern IndexTuple *gistjoinvector(
IndexTuple *itvec, int *len,
extern void _hash_checkpage(Relation rel, Buffer buf, int flags);
extern uint32 _hash_get_indextuple_hashkey(IndexTuple itup);
extern IndexTuple _hash_form_tuple(Relation index,
- Datum *values, bool *isnull);
+ Datum *values, bool *isnull);
extern OffsetNumber _hash_binsearch(Page page, uint32 hash_value);
extern OffsetNumber _hash_binsearch_last(Page page, uint32 hash_value);
TransactionId cutoff_xid,
OffsetNumber *offsets, int offcnt);
extern XLogRecPtr log_newpage(RelFileNode *rnode, ForkNumber forkNum,
- BlockNumber blk, Page page);
+ BlockNumber blk, Page page);
/* in heap/pruneheap.c */
extern void heap_page_prune_opt(Relation relation, Buffer buffer,
*/
typedef struct BulkInsertStateData
{
- BufferAccessStrategy strategy; /* our BULKWRITE strategy object */
- Buffer current_buf; /* current insertion target page */
+ BufferAccessStrategy strategy; /* our BULKWRITE strategy object */
+ Buffer current_buf; /* current insertion target page */
} BulkInsertStateData;
* the MINIMAL_TUPLE_OFFSET distance. t_len does not include that, however.
*
* MINIMAL_TUPLE_DATA_OFFSET is the offset to the first useful (non-pad) data
- * other than the length word. tuplesort.c and tuplestore.c use this to avoid
+ * other than the length word. tuplesort.c and tuplestore.c use this to avoid
* writing the padding to disk.
*/
#define MINIMAL_TUPLE_OFFSET \
typedef struct xl_heap_delete
{
xl_heaptid target; /* deleted tuple id */
- bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
+ bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
} xl_heap_delete;
#define SizeOfHeapDelete (offsetof(xl_heap_delete, all_visible_cleared) + sizeof(bool))
typedef struct xl_heap_insert
{
xl_heaptid target; /* inserted tuple id */
- bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
+ bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
/* xl_heap_header & TUPLE DATA FOLLOWS AT END OF STRUCT */
} xl_heap_insert;
{
xl_heaptid target; /* deleted tuple id */
ItemPointerData newtid; /* new inserted tuple id */
- bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
- bool new_all_visible_cleared; /* same for the page of newtid */
+ bool all_visible_cleared; /* PD_ALL_VISIBLE was cleared */
+ bool new_all_visible_cleared; /* same for the page of newtid */
/* NEW TUPLE xl_heap_header (PLUS xmax & xmin IF MOVE OP) */
/* and TUPLE DATA FOLLOWS AT END OF STRUCT */
} xl_heap_update;
bool *doReplace);
extern void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
Datum *values, bool *isnull);
+
/* these three are deprecated versions of the three above: */
extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
Datum *values, char *nulls);
* than BlockNumber for alignment reasons: SizeOfBtreeSplit is only 16-bit
* aligned.)
*
- * If level > 0, an IndexTuple representing the HIKEY of the left page
- * follows. We don't need this on leaf pages, because it's the same
- * as the leftmost key in the new right page. Also, it's suppressed if
+ * If level > 0, an IndexTuple representing the HIKEY of the left page
+ * follows. We don't need this on leaf pages, because it's the same as
+ * the leftmost key in the new right page. Also, it's suppressed if
* XLogInsert chooses to store the left page's whole page image.
*
* In the _L variants, next are OffsetNumber newitemoff and the new item.
/* kinds supported by reloptions */
typedef enum relopt_kind
{
- RELOPT_KIND_HEAP = (1 << 0),
- RELOPT_KIND_TOAST = (1 << 1),
- RELOPT_KIND_BTREE = (1 << 2),
- RELOPT_KIND_HASH = (1 << 3),
- RELOPT_KIND_GIN = (1 << 4),
- RELOPT_KIND_GIST = (1 << 5),
+ RELOPT_KIND_HEAP = (1 << 0),
+ RELOPT_KIND_TOAST = (1 << 1),
+ RELOPT_KIND_BTREE = (1 << 2),
+ RELOPT_KIND_HASH = (1 << 3),
+ RELOPT_KIND_GIN = (1 << 4),
+ RELOPT_KIND_GIST = (1 << 5),
/* if you add a new kind, make sure you update "last_default" too */
RELOPT_KIND_LAST_DEFAULT = RELOPT_KIND_GIST,
/* some compilers treat enums as signed ints, so we can't use 1 << 31 */
/* generic struct to hold shared data */
typedef struct relopt_gen
{
- const char *name; /* must be first (used as list termination marker) */
+ const char *name; /* must be first (used as list termination
+ * marker) */
const char *desc;
bits32 kinds;
int namelen;
- relopt_type type;
+ relopt_type type;
} relopt_gen;
/* holds a parsed value */
bool isset;
union
{
- bool bool_val;
- int int_val;
- double real_val;
- char *string_val; /* allocated separately */
- } values;
+ bool bool_val;
+ int int_val;
+ double real_val;
+ char *string_val; /* allocated separately */
+ } values;
} relopt_value;
/* reloptions records for specific variable types */
relopt_gen gen;
int default_len;
bool default_isnull;
- validate_string_relopt validate_cb;
- char default_val[1]; /* variable length, zero-terminated */
+ validate_string_relopt validate_cb;
+ char default_val[1]; /* variable length, zero-terminated */
} relopt_string;
/* This is the table datatype for fillRelOptions */
typedef struct
{
const char *optname; /* option's name */
- relopt_type opttype; /* option's datatype */
+ relopt_type opttype; /* option's datatype */
int offset; /* offset of field in result struct */
} relopt_parse_elt;
* parseRelOptions:
* for (i = 0; options[i].gen->name; i++)
* {
- * if (HAVE_RELOPTION("fillfactor", options[i])
- * {
- * HANDLE_INT_RELOPTION("fillfactor", rdopts->fillfactor, options[i], &isset);
- * continue;
- * }
- * if (HAVE_RELOPTION("default_row_acl", options[i])
- * {
- * ...
- * }
- * ...
- * if (validate)
- * ereport(ERROR,
- * (errmsg("unknown option")));
- * }
+ * if (HAVE_RELOPTION("fillfactor", options[i])
+ * {
+ * HANDLE_INT_RELOPTION("fillfactor", rdopts->fillfactor, options[i], &isset);
+ * continue;
+ * }
+ * if (HAVE_RELOPTION("default_row_acl", options[i])
+ * {
+ * ...
+ * }
+ * ...
+ * if (validate)
+ * ereport(ERROR,
+ * (errmsg("unknown option")));
+ * }
*
- * Note that this is more or less the same that fillRelOptions does, so only
- * use this if you need to do something non-standard within some option's
- * code block.
+ * Note that this is more or less the same that fillRelOptions does, so only
+ * use this if you need to do something non-standard within some option's
+ * code block.
*/
#define HAVE_RELOPTION(optname, option) \
(pg_strncasecmp(option.gen->name, optname, option.gen->namelen + 1) == 0)
#define HANDLE_INT_RELOPTION(optname, var, option, wasset) \
do { \
if (option.isset) \
- var = option.values.int_val; \
+ var = option.values.int_val; \
else \
- var = ((relopt_int *) option.gen)->default_val; \
+ var = ((relopt_int *) option.gen)->default_val; \
(wasset) != NULL ? *(wasset) = option.isset : (dummyret)NULL; \
} while (0)
#define HANDLE_BOOL_RELOPTION(optname, var, option, wasset) \
do { \
if (option.isset) \
- var = option.values.bool_val; \
+ var = option.values.bool_val; \
else \
var = ((relopt_bool *) option.gen)->default_val; \
(wasset) != NULL ? *(wasset) = option.isset : (dummyret) NULL; \
} while (0)
-#define HANDLE_REAL_RELOPTION(optname, var, option, wasset) \
+#define HANDLE_REAL_RELOPTION(optname, var, option, wasset) \
do { \
if (option.isset) \
- var = option.values.real_val; \
+ var = option.values.real_val; \
else \
var = ((relopt_real *) option.gen)->default_val; \
(wasset) != NULL ? *(wasset) = option.isset : (dummyret) NULL; \
* "base" is a pointer to the reloptions structure, and "offset" is an integer
* variable that must be initialized to sizeof(reloptions structure). This
* struct must have been allocated with enough space to hold any string option
- * present, including terminating \0 for every option. SET_VARSIZE() must be
+ * present, including terminating \0 for every option. SET_VARSIZE() must be
* called on the struct with this offset as the second argument, after all the
* string options have been processed.
*/
-#define HANDLE_STRING_RELOPTION(optname, var, option, base, offset, wasset) \
+#define HANDLE_STRING_RELOPTION(optname, var, option, base, offset, wasset) \
do { \
relopt_string *optstring = (relopt_string *) option.gen;\
char *string_val; \
extern void *allocateReloptStruct(Size base, relopt_value *options,
int numoptions);
extern void fillRelOptions(void *rdopts, Size basesize,
- relopt_value *options, int numoptions,
- bool validate,
- const relopt_parse_elt *elems, int nelems);
+ relopt_value *options, int numoptions,
+ bool validate,
+ const relopt_parse_elt *elems, int nelems);
extern bytea *default_reloptions(Datum reloptions, bool validate,
relopt_kind kind);
extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate);
extern bytea *index_reloptions(RegProcedure amoptions, Datum reloptions,
- bool validate);
+ bool validate);
#endif /* RELOPTIONS_H */
/*-------------------------------------------------------------------------
*
* visibilitymap.h
- * visibility map interface
+ * visibility map interface
*
*
* Portions Copyright (c) 2007-2009, PostgreSQL Global Development Group
extern void visibilitymap_clear(Relation rel, BlockNumber heapBlk);
extern void visibilitymap_pin(Relation rel, BlockNumber heapBlk,
- Buffer *vmbuf);
+ Buffer *vmbuf);
extern void visibilitymap_set(Relation rel, BlockNumber heapBlk,
- XLogRecPtr recptr, Buffer *vmbuf);
+ XLogRecPtr recptr, Buffer *vmbuf);
extern bool visibilitymap_test(Relation rel, BlockNumber heapBlk, Buffer *vmbuf);
extern void visibilitymap_truncate(Relation rel, BlockNumber heapblk);
int nrels; /* number of RelFileNodes */
int nsubxacts; /* number of subtransaction XIDs */
/* Array of RelFileNode(s) to drop at commit */
- RelFileNode xnodes[1]; /* VARIABLE LENGTH ARRAY */
+ RelFileNode xnodes[1]; /* VARIABLE LENGTH ARRAY */
/* ARRAY OF COMMITTED SUBTRANSACTION XIDs FOLLOWS */
} xl_xact_commit;
int nrels; /* number of RelFileNodes */
int nsubxacts; /* number of subtransaction XIDs */
/* Array of RelFileNode(s) to drop at abort */
- RelFileNode xnodes[1]; /* VARIABLE LENGTH ARRAY */
+ RelFileNode xnodes[1]; /* VARIABLE LENGTH ARRAY */
/* ARRAY OF ABORTED SUBTRANSACTION XIDs FOLLOWS */
} xl_xact_abort;
extern void XLogDropRelation(RelFileNode rnode, ForkNumber forknum);
extern void XLogDropDatabase(Oid dbid);
extern void XLogTruncateRelation(RelFileNode rnode, ForkNumber forkNum,
- BlockNumber nblocks);
+ BlockNumber nblocks);
extern Buffer XLogReadBuffer(RelFileNode rnode, BlockNumber blkno, bool init);
extern Buffer XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
- BlockNumber blkno, ReadBufferMode mode);
+ BlockNumber blkno, ReadBufferMode mode);
extern Relation CreateFakeRelcacheEntry(RelFileNode rnode);
extern void FreeFakeRelcacheEntry(Relation fakerel);
/*
* Use this to mark string constants as needing translation at some later
- * time, rather than immediately. This is useful for cases where you need
+ * time, rather than immediately. This is useful for cases where you need
* access to the original string and translated string, and for cases where
* immediate translation is not possible, like when initializing global
* variables.
#define CppAsString2(x) CppAsString(x)
#ifdef SO_MAJOR_VERSION
-# define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION)
+#define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION)
#else
-# define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION)
+#define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION)
#endif
#if defined(HAVE_WCSTOMBS) && defined(HAVE_TOWLOWER)
#define USE_WIDE_UPPER_LOWER
#endif
-
+
/* EXEC_BACKEND defines */
#ifdef EXEC_BACKEND
#define NON_EXEC_STATIC
extern bool IsSharedRelation(Oid relationId);
extern Oid GetNewOid(Relation relation);
-extern Oid GetNewOidWithIndex(Relation relation, Oid indexId,
- AttrNumber oidcolumn);
+extern Oid GetNewOidWithIndex(Relation relation, Oid indexId,
+ AttrNumber oidcolumn);
extern Oid GetNewRelFileNode(Oid reltablespace, bool relisshared,
Relation pg_class);
* "Catalog version number" for PostgreSQL.
*
* The catalog version number is used to flag incompatible changes in
- * the PostgreSQL system catalogs. Whenever anyone changes the format of
+ * the PostgreSQL system catalogs. Whenever anyone changes the format of
* a system catalog relation, or adds, deletes, or modifies standard
* catalog entries in such a way that an updated backend wouldn't work
* with an old database (or vice versa), the catalog version number
SharedDependencyType deptype);
extern void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId,
- int32 objectSubId);
+ int32 objectSubId);
extern void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner);
int nnewmembers, Oid *newmembers);
extern bool checkSharedDependencies(Oid classId, Oid objectId,
- char **detail_msg, char **detail_log_msg);
+ char **detail_msg, char **detail_log_msg);
extern void copyTemplateDependencies(Oid templateDbId, Oid newDbId);
*
*-------------------------------------------------------------------------
*/
-#ifndef GENBKI_H
+#ifndef GENBKI_H
#define GENBKI_H
/* Introduces a catalog's structure definition */
extern List *heap_truncate_find_FKs(List *relationIds);
extern void InsertPgAttributeTuple(Relation pg_attribute_rel,
- Form_pg_attribute new_attribute,
- CatalogIndexState indstate);
+ Form_pg_attribute new_attribute,
+ CatalogIndexState indstate);
extern void InsertPgClassTuple(Relation pg_class_desc,
Relation new_rel_desc,
#define ForeignDataWrapperNameIndexId 548
DECLARE_UNIQUE_INDEX(pg_foreign_server_oid_index, 113, on pg_foreign_server using btree(oid oid_ops));
-#define ForeignServerOidIndexId 113
+#define ForeignServerOidIndexId 113
DECLARE_UNIQUE_INDEX(pg_foreign_server_name_index, 549, on pg_foreign_server using btree(srvname name_ops));
#define ForeignServerNameIndexId 549
extern bool TypeIsVisible(Oid typid);
extern FuncCandidateList FuncnameGetCandidates(List *names, int nargs,
- bool expand_variadic,
- bool expand_defaults);
+ bool expand_variadic,
+ bool expand_defaults);
extern bool FunctionIsVisible(Oid funcid);
extern Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright);
*/
/* default operators int2 */
-DATA(insert ( 1976 21 21 1 95 403 ));
-DATA(insert ( 1976 21 21 2 522 403 ));
-DATA(insert ( 1976 21 21 3 94 403 ));
-DATA(insert ( 1976 21 21 4 524 403 ));
-DATA(insert ( 1976 21 21 5 520 403 ));
+DATA(insert ( 1976 21 21 1 95 403 ));
+DATA(insert ( 1976 21 21 2 522 403 ));
+DATA(insert ( 1976 21 21 3 94 403 ));
+DATA(insert ( 1976 21 21 4 524 403 ));
+DATA(insert ( 1976 21 21 5 520 403 ));
/* crosstype operators int24 */
-DATA(insert ( 1976 21 23 1 534 403 ));
-DATA(insert ( 1976 21 23 2 540 403 ));
-DATA(insert ( 1976 21 23 3 532 403 ));
-DATA(insert ( 1976 21 23 4 542 403 ));
-DATA(insert ( 1976 21 23 5 536 403 ));
+DATA(insert ( 1976 21 23 1 534 403 ));
+DATA(insert ( 1976 21 23 2 540 403 ));
+DATA(insert ( 1976 21 23 3 532 403 ));
+DATA(insert ( 1976 21 23 4 542 403 ));
+DATA(insert ( 1976 21 23 5 536 403 ));
/* crosstype operators int28 */
-DATA(insert ( 1976 21 20 1 1864 403 ));
-DATA(insert ( 1976 21 20 2 1866 403 ));
-DATA(insert ( 1976 21 20 3 1862 403 ));
-DATA(insert ( 1976 21 20 4 1867 403 ));
-DATA(insert ( 1976 21 20 5 1865 403 ));
+DATA(insert ( 1976 21 20 1 1864 403 ));
+DATA(insert ( 1976 21 20 2 1866 403 ));
+DATA(insert ( 1976 21 20 3 1862 403 ));
+DATA(insert ( 1976 21 20 4 1867 403 ));
+DATA(insert ( 1976 21 20 5 1865 403 ));
/* default operators int4 */
-DATA(insert ( 1976 23 23 1 97 403 ));
-DATA(insert ( 1976 23 23 2 523 403 ));
-DATA(insert ( 1976 23 23 3 96 403 ));
-DATA(insert ( 1976 23 23 4 525 403 ));
-DATA(insert ( 1976 23 23 5 521 403 ));
+DATA(insert ( 1976 23 23 1 97 403 ));
+DATA(insert ( 1976 23 23 2 523 403 ));
+DATA(insert ( 1976 23 23 3 96 403 ));
+DATA(insert ( 1976 23 23 4 525 403 ));
+DATA(insert ( 1976 23 23 5 521 403 ));
/* crosstype operators int42 */
-DATA(insert ( 1976 23 21 1 535 403 ));
-DATA(insert ( 1976 23 21 2 541 403 ));
-DATA(insert ( 1976 23 21 3 533 403 ));
-DATA(insert ( 1976 23 21 4 543 403 ));
-DATA(insert ( 1976 23 21 5 537 403 ));
+DATA(insert ( 1976 23 21 1 535 403 ));
+DATA(insert ( 1976 23 21 2 541 403 ));
+DATA(insert ( 1976 23 21 3 533 403 ));
+DATA(insert ( 1976 23 21 4 543 403 ));
+DATA(insert ( 1976 23 21 5 537 403 ));
/* crosstype operators int48 */
-DATA(insert ( 1976 23 20 1 37 403 ));
-DATA(insert ( 1976 23 20 2 80 403 ));
-DATA(insert ( 1976 23 20 3 15 403 ));
-DATA(insert ( 1976 23 20 4 82 403 ));
-DATA(insert ( 1976 23 20 5 76 403 ));
+DATA(insert ( 1976 23 20 1 37 403 ));
+DATA(insert ( 1976 23 20 2 80 403 ));
+DATA(insert ( 1976 23 20 3 15 403 ));
+DATA(insert ( 1976 23 20 4 82 403 ));
+DATA(insert ( 1976 23 20 5 76 403 ));
/* default operators int8 */
-DATA(insert ( 1976 20 20 1 412 403 ));
-DATA(insert ( 1976 20 20 2 414 403 ));
-DATA(insert ( 1976 20 20 3 410 403 ));
-DATA(insert ( 1976 20 20 4 415 403 ));
-DATA(insert ( 1976 20 20 5 413 403 ));
+DATA(insert ( 1976 20 20 1 412 403 ));
+DATA(insert ( 1976 20 20 2 414 403 ));
+DATA(insert ( 1976 20 20 3 410 403 ));
+DATA(insert ( 1976 20 20 4 415 403 ));
+DATA(insert ( 1976 20 20 5 413 403 ));
/* crosstype operators int82 */
-DATA(insert ( 1976 20 21 1 1870 403 ));
-DATA(insert ( 1976 20 21 2 1872 403 ));
-DATA(insert ( 1976 20 21 3 1868 403 ));
-DATA(insert ( 1976 20 21 4 1873 403 ));
-DATA(insert ( 1976 20 21 5 1871 403 ));
+DATA(insert ( 1976 20 21 1 1870 403 ));
+DATA(insert ( 1976 20 21 2 1872 403 ));
+DATA(insert ( 1976 20 21 3 1868 403 ));
+DATA(insert ( 1976 20 21 4 1873 403 ));
+DATA(insert ( 1976 20 21 5 1871 403 ));
/* crosstype operators int84 */
-DATA(insert ( 1976 20 23 1 418 403 ));
-DATA(insert ( 1976 20 23 2 420 403 ));
-DATA(insert ( 1976 20 23 3 416 403 ));
-DATA(insert ( 1976 20 23 4 430 403 ));
-DATA(insert ( 1976 20 23 5 419 403 ));
+DATA(insert ( 1976 20 23 1 418 403 ));
+DATA(insert ( 1976 20 23 2 420 403 ));
+DATA(insert ( 1976 20 23 3 416 403 ));
+DATA(insert ( 1976 20 23 4 430 403 ));
+DATA(insert ( 1976 20 23 5 419 403 ));
/*
* btree oid_ops
*/
-DATA(insert ( 1989 26 26 1 609 403 ));
-DATA(insert ( 1989 26 26 2 611 403 ));
-DATA(insert ( 1989 26 26 3 607 403 ));
-DATA(insert ( 1989 26 26 4 612 403 ));
-DATA(insert ( 1989 26 26 5 610 403 ));
+DATA(insert ( 1989 26 26 1 609 403 ));
+DATA(insert ( 1989 26 26 2 611 403 ));
+DATA(insert ( 1989 26 26 3 607 403 ));
+DATA(insert ( 1989 26 26 4 612 403 ));
+DATA(insert ( 1989 26 26 5 610 403 ));
/*
* btree tid_ops
*/
-DATA(insert ( 2789 27 27 1 2799 403 ));
-DATA(insert ( 2789 27 27 2 2801 403 ));
+DATA(insert ( 2789 27 27 1 2799 403 ));
+DATA(insert ( 2789 27 27 2 2801 403 ));
DATA(insert ( 2789 27 27 3 387 403 ));
-DATA(insert ( 2789 27 27 4 2802 403 ));
-DATA(insert ( 2789 27 27 5 2800 403 ));
+DATA(insert ( 2789 27 27 4 2802 403 ));
+DATA(insert ( 2789 27 27 5 2800 403 ));
/*
* btree oidvector_ops
*/
-DATA(insert ( 1991 30 30 1 645 403 ));
-DATA(insert ( 1991 30 30 2 647 403 ));
-DATA(insert ( 1991 30 30 3 649 403 ));
-DATA(insert ( 1991 30 30 4 648 403 ));
-DATA(insert ( 1991 30 30 5 646 403 ));
+DATA(insert ( 1991 30 30 1 645 403 ));
+DATA(insert ( 1991 30 30 2 647 403 ));
+DATA(insert ( 1991 30 30 3 649 403 ));
+DATA(insert ( 1991 30 30 4 648 403 ));
+DATA(insert ( 1991 30 30 5 646 403 ));
/*
* btree float_ops
* btree name_ops
*/
-DATA(insert ( 1986 19 19 1 660 403 ));
-DATA(insert ( 1986 19 19 2 661 403 ));
+DATA(insert ( 1986 19 19 1 660 403 ));
+DATA(insert ( 1986 19 19 2 661 403 ));
DATA(insert ( 1986 19 19 3 93 403 ));
-DATA(insert ( 1986 19 19 4 663 403 ));
-DATA(insert ( 1986 19 19 5 662 403 ));
+DATA(insert ( 1986 19 19 4 663 403 ));
+DATA(insert ( 1986 19 19 5 662 403 ));
/*
* btree text_ops
*/
-DATA(insert ( 1994 25 25 1 664 403 ));
-DATA(insert ( 1994 25 25 2 665 403 ));
+DATA(insert ( 1994 25 25 1 664 403 ));
+DATA(insert ( 1994 25 25 2 665 403 ));
DATA(insert ( 1994 25 25 3 98 403 ));
-DATA(insert ( 1994 25 25 4 667 403 ));
-DATA(insert ( 1994 25 25 5 666 403 ));
+DATA(insert ( 1994 25 25 4 667 403 ));
+DATA(insert ( 1994 25 25 5 666 403 ));
/*
* btree bpchar_ops
* btree time_ops
*/
-DATA(insert ( 1996 1083 1083 1 1110 403 ));
-DATA(insert ( 1996 1083 1083 2 1111 403 ));
-DATA(insert ( 1996 1083 1083 3 1108 403 ));
-DATA(insert ( 1996 1083 1083 4 1113 403 ));
-DATA(insert ( 1996 1083 1083 5 1112 403 ));
+DATA(insert ( 1996 1083 1083 1 1110 403 ));
+DATA(insert ( 1996 1083 1083 2 1111 403 ));
+DATA(insert ( 1996 1083 1083 3 1108 403 ));
+DATA(insert ( 1996 1083 1083 4 1113 403 ));
+DATA(insert ( 1996 1083 1083 5 1112 403 ));
/*
* btree timetz_ops
*/
-DATA(insert ( 2000 1266 1266 1 1552 403 ));
-DATA(insert ( 2000 1266 1266 2 1553 403 ));
-DATA(insert ( 2000 1266 1266 3 1550 403 ));
-DATA(insert ( 2000 1266 1266 4 1555 403 ));
-DATA(insert ( 2000 1266 1266 5 1554 403 ));
+DATA(insert ( 2000 1266 1266 1 1552 403 ));
+DATA(insert ( 2000 1266 1266 2 1553 403 ));
+DATA(insert ( 2000 1266 1266 3 1550 403 ));
+DATA(insert ( 2000 1266 1266 4 1555 403 ));
+DATA(insert ( 2000 1266 1266 5 1554 403 ));
/*
* btree interval_ops
*/
-DATA(insert ( 1982 1186 1186 1 1332 403 ));
-DATA(insert ( 1982 1186 1186 2 1333 403 ));
-DATA(insert ( 1982 1186 1186 3 1330 403 ));
-DATA(insert ( 1982 1186 1186 4 1335 403 ));
-DATA(insert ( 1982 1186 1186 5 1334 403 ));
+DATA(insert ( 1982 1186 1186 1 1332 403 ));
+DATA(insert ( 1982 1186 1186 2 1333 403 ));
+DATA(insert ( 1982 1186 1186 3 1330 403 ));
+DATA(insert ( 1982 1186 1186 4 1335 403 ));
+DATA(insert ( 1982 1186 1186 5 1334 403 ));
/*
* btree macaddr
* btree numeric
*/
-DATA(insert ( 1988 1700 1700 1 1754 403 ));
-DATA(insert ( 1988 1700 1700 2 1755 403 ));
-DATA(insert ( 1988 1700 1700 3 1752 403 ));
-DATA(insert ( 1988 1700 1700 4 1757 403 ));
-DATA(insert ( 1988 1700 1700 5 1756 403 ));
+DATA(insert ( 1988 1700 1700 1 1754 403 ));
+DATA(insert ( 1988 1700 1700 2 1755 403 ));
+DATA(insert ( 1988 1700 1700 3 1752 403 ));
+DATA(insert ( 1988 1700 1700 4 1757 403 ));
+DATA(insert ( 1988 1700 1700 5 1756 403 ));
/*
* btree bool
* btree varbit
*/
-DATA(insert ( 2002 1562 1562 1 1806 403 ));
-DATA(insert ( 2002 1562 1562 2 1808 403 ));
-DATA(insert ( 2002 1562 1562 3 1804 403 ));
-DATA(insert ( 2002 1562 1562 4 1809 403 ));
-DATA(insert ( 2002 1562 1562 5 1807 403 ));
+DATA(insert ( 2002 1562 1562 1 1806 403 ));
+DATA(insert ( 2002 1562 1562 2 1808 403 ));
+DATA(insert ( 2002 1562 1562 3 1804 403 ));
+DATA(insert ( 2002 1562 1562 4 1809 403 ));
+DATA(insert ( 2002 1562 1562 5 1807 403 ));
/*
* btree text pattern
*/
-DATA(insert ( 2095 25 25 1 2314 403 ));
-DATA(insert ( 2095 25 25 2 2315 403 ));
+DATA(insert ( 2095 25 25 1 2314 403 ));
+DATA(insert ( 2095 25 25 2 2315 403 ));
DATA(insert ( 2095 25 25 3 98 403 ));
-DATA(insert ( 2095 25 25 4 2317 403 ));
-DATA(insert ( 2095 25 25 5 2318 403 ));
+DATA(insert ( 2095 25 25 4 2317 403 ));
+DATA(insert ( 2095 25 25 5 2318 403 ));
/*
* btree bpchar pattern
*/
-DATA(insert ( 2097 1042 1042 1 2326 403 ));
-DATA(insert ( 2097 1042 1042 2 2327 403 ));
-DATA(insert ( 2097 1042 1042 3 1054 403 ));
-DATA(insert ( 2097 1042 1042 4 2329 403 ));
-DATA(insert ( 2097 1042 1042 5 2330 403 ));
+DATA(insert ( 2097 1042 1042 1 2326 403 ));
+DATA(insert ( 2097 1042 1042 2 2327 403 ));
+DATA(insert ( 2097 1042 1042 3 1054 403 ));
+DATA(insert ( 2097 1042 1042 4 2329 403 ));
+DATA(insert ( 2097 1042 1042 5 2330 403 ));
/*
* btree money_ops
DATA(insert ( 1977 23 23 1 96 405 ));
DATA(insert ( 1977 20 20 1 410 405 ));
DATA(insert ( 1977 21 23 1 532 405 ));
-DATA(insert ( 1977 21 20 1 1862 405 ));
+DATA(insert ( 1977 21 20 1 1862 405 ));
DATA(insert ( 1977 23 21 1 533 405 ));
DATA(insert ( 1977 23 20 1 15 405 ));
-DATA(insert ( 1977 20 21 1 1868 405 ));
+DATA(insert ( 1977 20 21 1 1868 405 ));
DATA(insert ( 1977 20 23 1 416 405 ));
/* interval_ops */
-DATA(insert ( 1983 1186 1186 1 1330 405 ));
+DATA(insert ( 1983 1186 1186 1 1330 405 ));
/* macaddr_ops */
DATA(insert ( 1985 829 829 1 1220 405 ));
/* name_ops */
DATA(insert ( 1987 19 19 1 93 405 ));
/* oid_ops */
-DATA(insert ( 1990 26 26 1 607 405 ));
+DATA(insert ( 1990 26 26 1 607 405 ));
/* oidvector_ops */
-DATA(insert ( 1992 30 30 1 649 405 ));
+DATA(insert ( 1992 30 30 1 649 405 ));
/* text_ops */
DATA(insert ( 1995 25 25 1 98 405 ));
/* time_ops */
-DATA(insert ( 1997 1083 1083 1 1108 405 ));
+DATA(insert ( 1997 1083 1083 1 1108 405 ));
/* timestamptz_ops */
-DATA(insert ( 1999 1184 1184 1 1320 405 ));
+DATA(insert ( 1999 1184 1184 1 1320 405 ));
/* timetz_ops */
-DATA(insert ( 2001 1266 1266 1 1550 405 ));
+DATA(insert ( 2001 1266 1266 1 1550 405 ));
/* timestamp_ops */
-DATA(insert ( 2040 1114 1114 1 2060 405 ));
+DATA(insert ( 2040 1114 1114 1 2060 405 ));
/* bool_ops */
DATA(insert ( 2222 16 16 1 91 405 ));
/* bytea_ops */
-DATA(insert ( 2223 17 17 1 1955 405 ));
+DATA(insert ( 2223 17 17 1 1955 405 ));
/* int2vector_ops */
-DATA(insert ( 2224 22 22 1 386 405 ));
+DATA(insert ( 2224 22 22 1 386 405 ));
/* xid_ops */
-DATA(insert ( 2225 28 28 1 352 405 ));
+DATA(insert ( 2225 28 28 1 352 405 ));
/* cid_ops */
-DATA(insert ( 2226 29 29 1 385 405 ));
+DATA(insert ( 2226 29 29 1 385 405 ));
/* abstime_ops */
DATA(insert ( 2227 702 702 1 560 405 ));
/* reltime_ops */
/* text_pattern_ops */
DATA(insert ( 2229 25 25 1 98 405 ));
/* bpchar_pattern_ops */
-DATA(insert ( 2231 1042 1042 1 1054 405 ));
+DATA(insert ( 2231 1042 1042 1 1054 405 ));
/* aclitem_ops */
-DATA(insert ( 2235 1033 1033 1 974 405 ));
+DATA(insert ( 2235 1033 1033 1 974 405 ));
/* uuid_ops */
DATA(insert ( 2969 2950 2950 1 2972 405 ));
/* numeric_ops */
/*
* btree tsvector_ops
*/
-DATA(insert ( 3626 3614 3614 1 3627 403 ));
-DATA(insert ( 3626 3614 3614 2 3628 403 ));
-DATA(insert ( 3626 3614 3614 3 3629 403 ));
-DATA(insert ( 3626 3614 3614 4 3631 403 ));
-DATA(insert ( 3626 3614 3614 5 3632 403 ));
+DATA(insert ( 3626 3614 3614 1 3627 403 ));
+DATA(insert ( 3626 3614 3614 2 3628 403 ));
+DATA(insert ( 3626 3614 3614 3 3629 403 ));
+DATA(insert ( 3626 3614 3614 4 3631 403 ));
+DATA(insert ( 3626 3614 3614 5 3632 403 ));
/*
* GiST tsvector_ops
*/
-DATA(insert ( 3655 3614 3615 1 3636 783 ));
+DATA(insert ( 3655 3614 3615 1 3636 783 ));
/*
* GIN tsvector_ops
*/
-DATA(insert ( 3659 3614 3615 1 3636 2742 ));
-DATA(insert ( 3659 3614 3615 2 3660 2742 ));
+DATA(insert ( 3659 3614 3615 1 3636 2742 ));
+DATA(insert ( 3659 3614 3615 2 3660 2742 ));
/*
* btree tsquery_ops
*/
-DATA(insert ( 3683 3615 3615 1 3674 403 ));
-DATA(insert ( 3683 3615 3615 2 3675 403 ));
-DATA(insert ( 3683 3615 3615 3 3676 403 ));
-DATA(insert ( 3683 3615 3615 4 3678 403 ));
-DATA(insert ( 3683 3615 3615 5 3679 403 ));
+DATA(insert ( 3683 3615 3615 1 3674 403 ));
+DATA(insert ( 3683 3615 3615 2 3675 403 ));
+DATA(insert ( 3683 3615 3615 3 3676 403 ));
+DATA(insert ( 3683 3615 3615 4 3678 403 ));
+DATA(insert ( 3683 3615 3615 5 3679 403 ));
/*
* GiST tsquery_ops
*/
-DATA(insert ( 3702 3615 3615 7 3693 783 ));
-DATA(insert ( 3702 3615 3615 8 3694 783 ));
+DATA(insert ( 3702 3615 3615 7 3693 783 ));
+DATA(insert ( 3702 3615 3615 8 3694 783 ));
#endif /* PG_AMOP_H */
/*
* ATTRIBUTE_FIXED_PART_SIZE is the size of the fixed-layout,
- * guaranteed-not-null part of a pg_attribute row. This is in fact as much
+ * guaranteed-not-null part of a pg_attribute row. This is in fact as much
* of the row as gets copied into tuple descriptors, so don't expect you
* can access fields beyond attinhcount except in a real tuple!
*/
{ 1249, {"attisdropped"}, 16, -1, 1, 15, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
{ 1249, {"attislocal"}, 16, -1, 1, 16, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
{ 1249, {"attinhcount"}, 23, -1, 4, 17, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0, { 0 } }, \
-{ 1249, {"attacl"}, 1034, -1, -1, 18, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0, { 0 } }
+{ 1249, {"attacl"}, 1034, -1, -1, 18, 1, -1, -1, false, 'x', 'i', false, false, false, true, 0, { 0 } }
DATA(insert ( 1249 attrelid 26 -1 4 1 0 -1 -1 t p i t f f t 0 _null_));
DATA(insert ( 1249 attname 19 -1 NAMEDATALEN 2 0 -1 -1 f p c t f f t 0 _null_));
{ 1259, {"reltoastidxid"}, 26, -1, 4, 11, 0, -1, -1, true, 'p', 'i', true, false, false, true, 0, { 0 } }, \
{ 1259, {"relhasindex"}, 16, -1, 1, 12, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
{ 1259, {"relisshared"}, 16, -1, 1, 13, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
-{ 1259, {"relistemp"}, 16, -1, 1, 14, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
+{ 1259, {"relistemp"}, 16, -1, 1, 14, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
{ 1259, {"relkind"}, 18, -1, 1, 15, 0, -1, -1, true, 'p', 'c', true, false, false, true, 0, { 0 } }, \
{ 1259, {"relnatts"}, 21, -1, 2, 16, 0, -1, -1, true, 'p', 's', true, false, false, true, 0, { 0 } }, \
{ 1259, {"relchecks"}, 21, -1, 2, 17, 0, -1, -1, true, 'p', 's', true, false, false, true, 0, { 0 } }, \
{
COERCION_METHOD_FUNCTION = 'f', /* use a function */
COERCION_METHOD_BINARY = 'b', /* types are binary-compatible */
- COERCION_METHOD_INOUT = 'i' /* use input/output functions */
+ COERCION_METHOD_INOUT = 'i' /* use input/output functions */
} CoercionMethod;
bool relhasoids; /* T if we generate OIDs for rows of rel */
bool relhaspkey; /* has (or has had) PRIMARY KEY index */
bool relhasrules; /* has (or has had) any rules */
- bool relhastriggers; /* has (or has had) any TRIGGERs */
+ bool relhastriggers; /* has (or has had) any TRIGGERs */
bool relhassubclass; /* has (or has had) derived classes */
TransactionId relfrozenxid; /* all Xids < this are frozen in this rel */
/*-------------------------------------------------------------------------
*
* pg_conversion_fn.h
- * prototypes for functions in catalog/pg_conversion.c
+ * prototypes for functions in catalog/pg_conversion.c
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* typedef struct FormData_pg_foreign_server
* ----------------
*/
-#define ForeignServerRelationId 1417
+#define ForeignServerRelationId 1417
CATALOG(pg_foreign_server,1417)
{
DATA(insert OID = 96 ( "=" PGNSP PGUID b t t 23 23 16 96 518 int4eq eqsel eqjoinsel ));
DATA(insert OID = 97 ( "<" PGNSP PGUID b f f 23 23 16 521 525 int4lt scalarltsel scalarltjoinsel ));
DATA(insert OID = 98 ( "=" PGNSP PGUID b t t 25 25 16 98 531 texteq eqsel eqjoinsel ));
-#define TextEqualOperator 98
+#define TextEqualOperator 98
DATA(insert OID = 349 ( "||" PGNSP PGUID b f f 2277 2283 2277 0 0 array_append - - ));
DATA(insert OID = 374 ( "||" PGNSP PGUID b f f 2283 2277 2277 0 0 array_prepend - - ));
Oid proallargtypes[1]; /* all param types (NULL if IN only) */
char proargmodes[1]; /* parameter modes (NULL if IN only) */
text proargnames[1]; /* parameter names (NULL if no names) */
- text proargdefaults; /* list of expression trees for argument
+ text proargdefaults; /* list of expression trees for argument
* defaults (NULL if none) */
text prosrc; /* procedure source text */
bytea probin; /* secondary procedure info (can be NULL) */
DESCR("greater-than");
DATA(insert OID = 74 ( charge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "18 18" _null_ _null_ _null_ _null_ charge _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 77 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "18" _null_ _null_ _null_ _null_ chartoi4 _null_ _null_ _null_ ));
+DATA(insert OID = 77 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "18" _null_ _null_ _null_ _null_ chartoi4 _null_ _null_ _null_ ));
DESCR("convert char to int4");
-DATA(insert OID = 78 ( char PGNSP PGUID 12 1 0 0 f f f t f i 1 0 18 "23" _null_ _null_ _null_ _null_ i4tochar _null_ _null_ _null_ ));
+DATA(insert OID = 78 ( char PGNSP PGUID 12 1 0 0 f f f t f i 1 0 18 "23" _null_ _null_ _null_ _null_ i4tochar _null_ _null_ _null_ ));
DESCR("convert int4 to char");
DATA(insert OID = 79 ( nameregexeq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameregexeq _null_ _null_ _null_ ));
DESCR("matches regex., case-sensitive");
DATA(insert OID = 1256 ( textregexne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ textregexne _null_ _null_ _null_ ));
DESCR("does not match regex., case-sensitive");
-DATA(insert OID = 1257 ( textlen PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textlen _null_ _null_ _null_ ));
+DATA(insert OID = 1257 ( textlen PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textlen _null_ _null_ _null_ ));
DESCR("length");
DATA(insert OID = 1258 ( textcat PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ textcat _null_ _null_ _null_ ));
DESCR("concatenate");
DATA(insert OID = 116 ( box_below_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "603 603" _null_ _null_ _null_ _null_ box_below_eq _null_ _null_ _null_ ));
DESCR("is below (allows touching)");
-DATA(insert OID = 117 ( point_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 600 "2275" _null_ _null_ _null_ _null_ point_in _null_ _null_ _null_ ));
+DATA(insert OID = 117 ( point_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 600 "2275" _null_ _null_ _null_ _null_ point_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 118 ( point_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "600" _null_ _null_ _null_ _null_ point_out _null_ _null_ _null_ ));
+DATA(insert OID = 118 ( point_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "600" _null_ _null_ _null_ _null_ point_out _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 119 ( lseg_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 601 "2275" _null_ _null_ _null_ _null_ lseg_in _null_ _null_ _null_ ));
+DATA(insert OID = 119 ( lseg_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 601 "2275" _null_ _null_ _null_ _null_ lseg_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 120 ( lseg_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "601" _null_ _null_ _null_ _null_ lseg_out _null_ _null_ _null_ ));
+DATA(insert OID = 120 ( lseg_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "601" _null_ _null_ _null_ _null_ lseg_out _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 121 ( path_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 602 "2275" _null_ _null_ _null_ _null_ path_in _null_ _null_ _null_ ));
+DATA(insert OID = 121 ( path_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 602 "2275" _null_ _null_ _null_ _null_ path_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 122 ( path_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "602" _null_ _null_ _null_ _null_ path_out _null_ _null_ _null_ ));
+DATA(insert OID = 122 ( path_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "602" _null_ _null_ _null_ _null_ path_out _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 123 ( box_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 603 "2275" _null_ _null_ _null_ _null_ box_in _null_ _null_ _null_ ));
+DATA(insert OID = 123 ( box_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 603 "2275" _null_ _null_ _null_ _null_ box_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 124 ( box_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "603" _null_ _null_ _null_ _null_ box_out _null_ _null_ _null_ ));
+DATA(insert OID = 124 ( box_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "603" _null_ _null_ _null_ _null_ box_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 125 ( box_overlap PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "603 603" _null_ _null_ _null_ _null_ box_overlap _null_ _null_ _null_ ));
DESCR("overlaps");
/* OIDS 200 - 299 */
-DATA(insert OID = 200 ( float4in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "2275" _null_ _null_ _null_ _null_ float4in _null_ _null_ _null_ ));
+DATA(insert OID = 200 ( float4in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "2275" _null_ _null_ _null_ _null_ float4in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 201 ( float4out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "700" _null_ _null_ _null_ _null_ float4out _null_ _null_ _null_ ));
+DATA(insert OID = 201 ( float4out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "700" _null_ _null_ _null_ _null_ float4out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 202 ( float4mul PGNSP PGUID 12 1 0 0 f f f t f i 2 0 700 "700 700" _null_ _null_ _null_ _null_ float4mul _null_ _null_ _null_ ));
DESCR("multiply");
DESCR("negate");
DATA(insert OID = 207 ( float4abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "700" _null_ _null_ _null_ _null_ float4abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 208 ( float4_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1022 "1022 700" _null_ _null_ _null_ _null_ float4_accum _null_ _null_ _null_ ));
+DATA(insert OID = 208 ( float4_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1022 "1022 700" _null_ _null_ _null_ _null_ float4_accum _null_ _null_ _null_ ));
DESCR("aggregate transition function");
DATA(insert OID = 209 ( float4larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 700 "700 700" _null_ _null_ _null_ _null_ float4larger _null_ _null_ _null_ ));
DESCR("larger of two");
DATA(insert OID = 211 ( float4smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 700 "700 700" _null_ _null_ _null_ _null_ float4smaller _null_ _null_ _null_ ));
DESCR("smaller of two");
-DATA(insert OID = 212 ( int4um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4um _null_ _null_ _null_ ));
+DATA(insert OID = 212 ( int4um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4um _null_ _null_ _null_ ));
DESCR("negate");
-DATA(insert OID = 213 ( int2um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2um _null_ _null_ _null_ ));
+DATA(insert OID = 213 ( int2um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2um _null_ _null_ _null_ ));
DESCR("negate");
-DATA(insert OID = 214 ( float8in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "2275" _null_ _null_ _null_ _null_ float8in _null_ _null_ _null_ ));
+DATA(insert OID = 214 ( float8in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "2275" _null_ _null_ _null_ _null_ float8in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 215 ( float8out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "701" _null_ _null_ _null_ _null_ float8out _null_ _null_ _null_ ));
+DATA(insert OID = 215 ( float8out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "701" _null_ _null_ _null_ _null_ float8out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 216 ( float8mul PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ float8mul _null_ _null_ _null_ ));
DESCR("multiply");
DESCR("negate");
DATA(insert OID = 221 ( float8abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ float8abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 222 ( float8_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1022 "1022 701" _null_ _null_ _null_ _null_ float8_accum _null_ _null_ _null_ ));
+DATA(insert OID = 222 ( float8_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1022 "1022 701" _null_ _null_ _null_ _null_ float8_accum _null_ _null_ _null_ ));
DESCR("aggregate transition function");
DATA(insert OID = 223 ( float8larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ float8larger _null_ _null_ _null_ ));
DESCR("larger of two");
DATA(insert OID = 239 ( line_distance PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "628 628" _null_ _null_ _null_ _null_ line_distance _null_ _null_ _null_ ));
DESCR("distance between");
-DATA(insert OID = 240 ( abstimein PGNSP PGUID 12 1 0 0 f f f t f s 1 0 702 "2275" _null_ _null_ _null_ _null_ abstimein _null_ _null_ _null_ ));
+DATA(insert OID = 240 ( abstimein PGNSP PGUID 12 1 0 0 f f f t f s 1 0 702 "2275" _null_ _null_ _null_ _null_ abstimein _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 241 ( abstimeout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "702" _null_ _null_ _null_ _null_ abstimeout _null_ _null_ _null_ ));
+DATA(insert OID = 241 ( abstimeout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "702" _null_ _null_ _null_ _null_ abstimeout _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 242 ( reltimein PGNSP PGUID 12 1 0 0 f f f t f s 1 0 703 "2275" _null_ _null_ _null_ _null_ reltimein _null_ _null_ _null_ ));
+DATA(insert OID = 242 ( reltimein PGNSP PGUID 12 1 0 0 f f f t f s 1 0 703 "2275" _null_ _null_ _null_ _null_ reltimein _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 243 ( reltimeout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "703" _null_ _null_ _null_ _null_ reltimeout _null_ _null_ _null_ ));
+DATA(insert OID = 243 ( reltimeout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "703" _null_ _null_ _null_ _null_ reltimeout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 244 ( timepl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 702 "702 703" _null_ _null_ _null_ _null_ timepl _null_ _null_ _null_ ));
DESCR("add");
DATA(insert OID = 245 ( timemi PGNSP PGUID 12 1 0 0 f f f t f i 2 0 702 "702 703" _null_ _null_ _null_ _null_ timemi _null_ _null_ _null_ ));
DESCR("subtract");
-DATA(insert OID = 246 ( tintervalin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 704 "2275" _null_ _null_ _null_ _null_ tintervalin _null_ _null_ _null_ ));
+DATA(insert OID = 246 ( tintervalin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 704 "2275" _null_ _null_ _null_ _null_ tintervalin _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 247 ( tintervalout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "704" _null_ _null_ _null_ _null_ tintervalout _null_ _null_ _null_ ));
+DATA(insert OID = 247 ( tintervalout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "704" _null_ _null_ _null_ _null_ tintervalout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 248 ( intinterval PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "702 704" _null_ _null_ _null_ _null_ intinterval _null_ _null_ _null_ ));
DESCR("abstime in tinterval");
DATA(insert OID = 249 ( tintervalrel PGNSP PGUID 12 1 0 0 f f f t f i 1 0 703 "704" _null_ _null_ _null_ _null_ tintervalrel _null_ _null_ _null_ ));
DESCR("tinterval to reltime");
-DATA(insert OID = 250 ( timenow PGNSP PGUID 12 1 0 0 f f f t f s 0 0 702 "" _null_ _null_ _null_ _null_ timenow _null_ _null_ _null_ ));
+DATA(insert OID = 250 ( timenow PGNSP PGUID 12 1 0 0 f f f t f s 0 0 702 "" _null_ _null_ _null_ _null_ timenow _null_ _null_ _null_ ));
DESCR("current date and time (abstime)");
DATA(insert OID = 251 ( abstimeeq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "702 702" _null_ _null_ _null_ _null_ abstimeeq _null_ _null_ _null_ ));
DESCR("equal");
DESCR("greater-than");
DATA(insert OID = 310 ( float84ge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "701 700" _null_ _null_ _null_ _null_ float84ge _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 320 ( width_bucket PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "701 701 701 23" _null_ _null_ _null_ _null_ width_bucket_float8 _null_ _null_ _null_ ));
+DATA(insert OID = 320 ( width_bucket PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "701 701 701 23" _null_ _null_ _null_ _null_ width_bucket_float8 _null_ _null_ _null_ ));
DESCR("bucket number of operand in equidepth histogram");
DATA(insert OID = 311 ( float8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "700" _null_ _null_ _null_ _null_ ftod _null_ _null_ _null_ ));
DESCR("convert float4 to float8");
DATA(insert OID = 312 ( float4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "701" _null_ _null_ _null_ _null_ dtof _null_ _null_ _null_ ));
DESCR("convert float8 to float4");
-DATA(insert OID = 313 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "21" _null_ _null_ _null_ _null_ i2toi4 _null_ _null_ _null_ ));
+DATA(insert OID = 313 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "21" _null_ _null_ _null_ _null_ i2toi4 _null_ _null_ _null_ ));
DESCR("convert int2 to int4");
-DATA(insert OID = 314 ( int2 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "23" _null_ _null_ _null_ _null_ i4toi2 _null_ _null_ _null_ ));
+DATA(insert OID = 314 ( int2 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "23" _null_ _null_ _null_ _null_ i4toi2 _null_ _null_ _null_ ));
DESCR("convert int4 to int2");
DATA(insert OID = 315 ( int2vectoreq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "22 22" _null_ _null_ _null_ _null_ int2vectoreq _null_ _null_ _null_ ));
DESCR("equal");
DATA(insert OID = 319 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "700" _null_ _null_ _null_ _null_ ftoi4 _null_ _null_ _null_ ));
DESCR("convert float4 to int4");
-DATA(insert OID = 330 ( btgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ btgettuple _null_ _null_ _null_ ));
+DATA(insert OID = 330 ( btgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ btgettuple _null_ _null_ _null_ ));
DESCR("btree(internal)");
-DATA(insert OID = 636 ( btgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ btgetbitmap _null_ _null_ _null_ ));
+DATA(insert OID = 636 ( btgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ btgetbitmap _null_ _null_ _null_ ));
DESCR("btree(internal)");
DATA(insert OID = 331 ( btinsert PGNSP PGUID 12 1 0 0 f f f t f v 6 0 16 "2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ btinsert _null_ _null_ _null_ ));
DESCR("btree(internal)");
DESCR("btree(internal)");
DATA(insert OID = 334 ( btrescan PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ btrescan _null_ _null_ _null_ ));
DESCR("btree(internal)");
-DATA(insert OID = 335 ( btendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btendscan _null_ _null_ _null_ ));
+DATA(insert OID = 335 ( btendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btendscan _null_ _null_ _null_ ));
DESCR("btree(internal)");
-DATA(insert OID = 336 ( btmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btmarkpos _null_ _null_ _null_ ));
+DATA(insert OID = 336 ( btmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btmarkpos _null_ _null_ _null_ ));
DESCR("btree(internal)");
-DATA(insert OID = 337 ( btrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btrestrpos _null_ _null_ _null_ ));
+DATA(insert OID = 337 ( btrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ btrestrpos _null_ _null_ _null_ ));
DESCR("btree(internal)");
DATA(insert OID = 338 ( btbuild PGNSP PGUID 12 1 0 0 f f f t f v 3 0 2281 "2281 2281 2281" _null_ _null_ _null_ _null_ btbuild _null_ _null_ _null_ ));
DESCR("btree(internal)");
DESCR("btree(internal)");
DATA(insert OID = 972 ( btvacuumcleanup PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2281 "2281 2281" _null_ _null_ _null_ _null_ btvacuumcleanup _null_ _null_ _null_ ));
DESCR("btree(internal)");
-DATA(insert OID = 1268 ( btcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ btcostestimate _null_ _null_ _null_ ));
+DATA(insert OID = 1268 ( btcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ btcostestimate _null_ _null_ _null_ ));
DESCR("btree(internal)");
DATA(insert OID = 2785 ( btoptions PGNSP PGUID 12 1 0 0 f f f t f s 2 0 17 "1009 16" _null_ _null_ _null_ _null_ btoptions _null_ _null_ _null_ ));
DESCR("btree(internal)");
DESCR("is contained by?");
DATA(insert OID = 346 ( poly_overlap PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "604 604" _null_ _null_ _null_ _null_ poly_overlap _null_ _null_ _null_ ));
DESCR("overlaps");
-DATA(insert OID = 347 ( poly_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 604 "2275" _null_ _null_ _null_ _null_ poly_in _null_ _null_ _null_ ));
+DATA(insert OID = 347 ( poly_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 604 "2275" _null_ _null_ _null_ _null_ poly_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 348 ( poly_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "604" _null_ _null_ _null_ _null_ poly_out _null_ _null_ _null_ ));
+DATA(insert OID = 348 ( poly_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "604" _null_ _null_ _null_ _null_ poly_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 350 ( btint2cmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "21 21" _null_ _null_ _null_ _null_ btint2cmp _null_ _null_ _null_ ));
DATA(insert OID = 409 ( name PGNSP PGUID 12 1 0 0 f f f t f i 1 0 19 "1042" _null_ _null_ _null_ _null_ bpchar_name _null_ _null_ _null_ ));
DESCR("convert char(n) to name");
-DATA(insert OID = 440 ( hashgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ hashgettuple _null_ _null_ _null_ ));
+DATA(insert OID = 440 ( hashgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ hashgettuple _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 637 ( hashgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ hashgetbitmap _null_ _null_ _null_ ));
+DATA(insert OID = 637 ( hashgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ hashgetbitmap _null_ _null_ _null_ ));
DESCR("hash(internal)");
DATA(insert OID = 441 ( hashinsert PGNSP PGUID 12 1 0 0 f f f t f v 6 0 16 "2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ hashinsert _null_ _null_ _null_ ));
DESCR("hash(internal)");
DESCR("hash(internal)");
DATA(insert OID = 444 ( hashrescan PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ hashrescan _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 445 ( hashendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashendscan _null_ _null_ _null_ ));
+DATA(insert OID = 445 ( hashendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashendscan _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 446 ( hashmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashmarkpos _null_ _null_ _null_ ));
+DATA(insert OID = 446 ( hashmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashmarkpos _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 447 ( hashrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashrestrpos _null_ _null_ _null_ ));
+DATA(insert OID = 447 ( hashrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ hashrestrpos _null_ _null_ _null_ ));
DESCR("hash(internal)");
DATA(insert OID = 448 ( hashbuild PGNSP PGUID 12 1 0 0 f f f t f v 3 0 2281 "2281 2281 2281" _null_ _null_ _null_ _null_ hashbuild _null_ _null_ _null_ ));
DESCR("hash(internal)");
DESCR("hash(internal)");
DATA(insert OID = 425 ( hashvacuumcleanup PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2281 "2281 2281" _null_ _null_ _null_ _null_ hashvacuumcleanup _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 438 ( hashcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ hashcostestimate _null_ _null_ _null_ ));
+DATA(insert OID = 438 ( hashcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ hashcostestimate _null_ _null_ _null_ ));
DESCR("hash(internal)");
DATA(insert OID = 2786 ( hashoptions PGNSP PGUID 12 1 0 0 f f f t f s 2 0 17 "1009 16" _null_ _null_ _null_ _null_ hashoptions _null_ _null_ _null_ ));
DESCR("hash(internal)");
-DATA(insert OID = 449 ( hashint2 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "21" _null_ _null_ _null_ _null_ hashint2 _null_ _null_ _null_ ));
+DATA(insert OID = 449 ( hashint2 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "21" _null_ _null_ _null_ _null_ hashint2 _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 450 ( hashint4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ hashint4 _null_ _null_ _null_ ));
+DATA(insert OID = 450 ( hashint4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ hashint4 _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 949 ( hashint8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "20" _null_ _null_ _null_ _null_ hashint8 _null_ _null_ _null_ ));
+DATA(insert OID = 949 ( hashint8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "20" _null_ _null_ _null_ _null_ hashint8 _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 451 ( hashfloat4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "700" _null_ _null_ _null_ _null_ hashfloat4 _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 452 ( hashfloat8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "701" _null_ _null_ _null_ _null_ hashfloat8 _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 453 ( hashoid PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "26" _null_ _null_ _null_ _null_ hashoid _null_ _null_ _null_ ));
+DATA(insert OID = 453 ( hashoid PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "26" _null_ _null_ _null_ _null_ hashoid _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 454 ( hashchar PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "18" _null_ _null_ _null_ _null_ hashchar _null_ _null_ _null_ ));
+DATA(insert OID = 454 ( hashchar PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "18" _null_ _null_ _null_ _null_ hashchar _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 455 ( hashname PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "19" _null_ _null_ _null_ _null_ hashname _null_ _null_ _null_ ));
+DATA(insert OID = 455 ( hashname PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "19" _null_ _null_ _null_ _null_ hashname _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 400 ( hashtext PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ hashtext _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 456 ( hashvarlena PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "2281" _null_ _null_ _null_ _null_ hashvarlena _null_ _null_ _null_ ));
DESCR("hash any varlena type");
-DATA(insert OID = 457 ( hashoidvector PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "30" _null_ _null_ _null_ _null_ hashoidvector _null_ _null_ _null_ ));
+DATA(insert OID = 457 ( hashoidvector PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "30" _null_ _null_ _null_ _null_ hashoidvector _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 329 ( hash_aclitem PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1033" _null_ _null_ _null_ _null_ hash_aclitem _null_ _null_ _null_ ));
DESCR("hash");
-DATA(insert OID = 398 ( hashint2vector PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "22" _null_ _null_ _null_ _null_ hashint2vector _null_ _null_ _null_ ));
+DATA(insert OID = 398 ( hashint2vector PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "22" _null_ _null_ _null_ _null_ hashint2vector _null_ _null_ _null_ ));
DESCR("hash");
DATA(insert OID = 399 ( hashmacaddr PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "829" _null_ _null_ _null_ _null_ hashmacaddr _null_ _null_ _null_ ));
DESCR("hash");
DESCR("I/O");
DATA(insert OID = 461 ( int8out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "20" _null_ _null_ _null_ _null_ int8out _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 462 ( int8um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8um _null_ _null_ _null_ ));
+DATA(insert OID = 462 ( int8um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8um _null_ _null_ _null_ ));
DESCR("negate");
DATA(insert OID = 463 ( int8pl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 20" _null_ _null_ _null_ _null_ int8pl _null_ _null_ _null_ ));
DESCR("add");
DATA(insert OID = 717 ( oidle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "26 26" _null_ _null_ _null_ _null_ oidle _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
-DATA(insert OID = 720 ( octet_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "17" _null_ _null_ _null_ _null_ byteaoctetlen _null_ _null_ _null_ ));
+DATA(insert OID = 720 ( octet_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "17" _null_ _null_ _null_ _null_ byteaoctetlen _null_ _null_ _null_ ));
DESCR("octet length");
DATA(insert OID = 721 ( get_byte PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "17 23" _null_ _null_ _null_ _null_ byteaGetByte _null_ _null_ _null_ ));
DESCR("get byte");
DESCR("array dimensions");
DATA(insert OID = 750 ( array_in PGNSP PGUID 12 1 0 0 f f f t f s 3 0 2277 "2275 26 23" _null_ _null_ _null_ _null_ array_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 751 ( array_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "2277" _null_ _null_ _null_ _null_ array_out _null_ _null_ _null_ ));
+DATA(insert OID = 751 ( array_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "2277" _null_ _null_ _null_ _null_ array_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2091 ( array_lower PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "2277 23" _null_ _null_ _null_ _null_ array_lower _null_ _null_ _null_ ));
DESCR("array lower dimension");
DATA(insert OID = 2092 ( array_upper PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "2277 23" _null_ _null_ _null_ _null_ array_upper _null_ _null_ _null_ ));
DESCR("array upper dimension");
-DATA(insert OID = 2176 ( array_length PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "2277 23" _null_ _null_ _null_ _null_ array_length _null_ _null_ _null_ ));
+DATA(insert OID = 2176 ( array_length PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "2277 23" _null_ _null_ _null_ _null_ array_length _null_ _null_ _null_ ));
DESCR("array length");
DATA(insert OID = 378 ( array_append PGNSP PGUID 12 1 0 0 f f f f f i 2 0 2277 "2277 2283" _null_ _null_ _null_ _null_ array_push _null_ _null_ _null_ ));
DESCR("append element onto end of array");
DESCR("array_agg transition function");
DATA(insert OID = 2334 ( array_agg_finalfn PGNSP PGUID 12 1 0 0 f f f f f i 1 0 2277 "2281" _null_ _null_ _null_ _null_ array_agg_finalfn _null_ _null_ _null_ ));
DESCR("array_agg final function");
-DATA(insert OID = 2335 ( array_agg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 2277 "2283" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2335 ( array_agg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 2277 "2283" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("concatenate aggregate input into an array");
-DATA(insert OID = 760 ( smgrin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 210 "2275" _null_ _null_ _null_ _null_ smgrin _null_ _null_ _null_ ));
+DATA(insert OID = 760 ( smgrin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 210 "2275" _null_ _null_ _null_ _null_ smgrin _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 761 ( smgrout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "210" _null_ _null_ _null_ _null_ smgrout _null_ _null_ _null_ ));
+DATA(insert OID = 761 ( smgrout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "210" _null_ _null_ _null_ _null_ smgrout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 762 ( smgreq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "210 210" _null_ _null_ _null_ _null_ smgreq _null_ _null_ _null_ ));
DESCR("storage manager");
DATA(insert OID = 763 ( smgrne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "210 210" _null_ _null_ _null_ _null_ smgrne _null_ _null_ _null_ ));
DESCR("storage manager");
-DATA(insert OID = 764 ( lo_import PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "25" _null_ _null_ _null_ _null_ lo_import _null_ _null_ _null_ ));
+DATA(insert OID = 764 ( lo_import PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "25" _null_ _null_ _null_ _null_ lo_import _null_ _null_ _null_ ));
DESCR("large object import");
DATA(insert OID = 767 ( lo_import PGNSP PGUID 12 1 0 0 f f f t f v 2 0 26 "25 26" _null_ _null_ _null_ _null_ lo_import_with_oid _null_ _null_ _null_ ));
DESCR("large object import");
DATA(insert OID = 765 ( lo_export PGNSP PGUID 12 1 0 0 f f f t f v 2 0 23 "26 25" _null_ _null_ _null_ _null_ lo_export _null_ _null_ _null_ ));
DESCR("large object export");
-DATA(insert OID = 766 ( int4inc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4inc _null_ _null_ _null_ ));
+DATA(insert OID = 766 ( int4inc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4inc _null_ _null_ _null_ ));
DESCR("increment");
DATA(insert OID = 768 ( int4larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "23 23" _null_ _null_ _null_ _null_ int4larger _null_ _null_ _null_ ));
DESCR("larger of two");
DATA(insert OID = 771 ( int2smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 21 "21 21" _null_ _null_ _null_ _null_ int2smaller _null_ _null_ _null_ ));
DESCR("smaller of two");
-DATA(insert OID = 774 ( gistgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ gistgettuple _null_ _null_ _null_ ));
+DATA(insert OID = 774 ( gistgettuple PGNSP PGUID 12 1 0 0 f f f t f v 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ gistgettuple _null_ _null_ _null_ ));
DESCR("gist(internal)");
-DATA(insert OID = 638 ( gistgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ gistgetbitmap _null_ _null_ _null_ ));
+DATA(insert OID = 638 ( gistgetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ gistgetbitmap _null_ _null_ _null_ ));
DESCR("gist(internal)");
DATA(insert OID = 775 ( gistinsert PGNSP PGUID 12 1 0 0 f f f t f v 6 0 16 "2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gistinsert _null_ _null_ _null_ ));
DESCR("gist(internal)");
DESCR("gist(internal)");
DATA(insert OID = 778 ( gistrescan PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ gistrescan _null_ _null_ _null_ ));
DESCR("gist(internal)");
-DATA(insert OID = 779 ( gistendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistendscan _null_ _null_ _null_ ));
+DATA(insert OID = 779 ( gistendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistendscan _null_ _null_ _null_ ));
DESCR("gist(internal)");
-DATA(insert OID = 780 ( gistmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistmarkpos _null_ _null_ _null_ ));
+DATA(insert OID = 780 ( gistmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistmarkpos _null_ _null_ _null_ ));
DESCR("gist(internal)");
-DATA(insert OID = 781 ( gistrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistrestrpos _null_ _null_ _null_ ));
+DATA(insert OID = 781 ( gistrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ gistrestrpos _null_ _null_ _null_ ));
DESCR("gist(internal)");
DATA(insert OID = 782 ( gistbuild PGNSP PGUID 12 1 0 0 f f f t f v 3 0 2281 "2281 2281 2281" _null_ _null_ _null_ _null_ gistbuild _null_ _null_ _null_ ));
DESCR("gist(internal)");
DESCR("gist(internal)");
DATA(insert OID = 2561 ( gistvacuumcleanup PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2281 "2281 2281" _null_ _null_ _null_ _null_ gistvacuumcleanup _null_ _null_ _null_ ));
DESCR("gist(internal)");
-DATA(insert OID = 772 ( gistcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gistcostestimate _null_ _null_ _null_ ));
+DATA(insert OID = 772 ( gistcostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gistcostestimate _null_ _null_ _null_ ));
DESCR("gist(internal)");
DATA(insert OID = 2787 ( gistoptions PGNSP PGUID 12 1 0 0 f f f t f s 2 0 17 "1009 16" _null_ _null_ _null_ _null_ gistoptions _null_ _null_ _null_ ));
DESCR("gist(internal)");
DATA(insert OID = 861 ( current_database PGNSP PGUID 12 1 0 0 f f f t f s 0 0 19 "" _null_ _null_ _null_ _null_ current_database _null_ _null_ _null_ ));
DESCR("returns the current database");
-DATA(insert OID = 817 ( current_query PGNSP PGUID 12 1 0 0 f f f f f v 0 0 25 "" _null_ _null_ _null_ _null_ current_query _null_ _null_ _null_ ));
+DATA(insert OID = 817 ( current_query PGNSP PGUID 12 1 0 0 f f f f f v 0 0 25 "" _null_ _null_ _null_ _null_ current_query _null_ _null_ _null_ ));
DESCR("returns the currently executing query");
DATA(insert OID = 862 ( int4_mul_cash PGNSP PGUID 12 1 0 0 f f f t f i 2 0 790 "23 790" _null_ _null_ _null_ _null_ int4_mul_cash _null_ _null_ _null_ ));
DATA(insert OID = 867 ( cash_div_int2 PGNSP PGUID 12 1 0 0 f f f t f i 2 0 790 "790 21" _null_ _null_ _null_ _null_ cash_div_int2 _null_ _null_ _null_ ));
DESCR("divide");
-DATA(insert OID = 886 ( cash_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 790 "2275" _null_ _null_ _null_ _null_ cash_in _null_ _null_ _null_ ));
+DATA(insert OID = 886 ( cash_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 790 "2275" _null_ _null_ _null_ _null_ cash_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 887 ( cash_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "790" _null_ _null_ _null_ _null_ cash_out _null_ _null_ _null_ ));
+DATA(insert OID = 887 ( cash_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "790" _null_ _null_ _null_ _null_ cash_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 888 ( cash_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "790 790" _null_ _null_ _null_ _null_ cash_eq _null_ _null_ _null_ ));
DESCR("equal");
DATA(insert OID = 947 ( mod PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 20" _null_ _null_ _null_ _null_ int8mod _null_ _null_ _null_ ));
DESCR("modulus");
-DATA(insert OID = 944 ( char PGNSP PGUID 12 1 0 0 f f f t f i 1 0 18 "25" _null_ _null_ _null_ _null_ text_char _null_ _null_ _null_ ));
+DATA(insert OID = 944 ( char PGNSP PGUID 12 1 0 0 f f f t f i 1 0 18 "25" _null_ _null_ _null_ _null_ text_char _null_ _null_ _null_ ));
DESCR("convert text to char");
-DATA(insert OID = 946 ( text PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "18" _null_ _null_ _null_ _null_ char_text _null_ _null_ _null_ ));
+DATA(insert OID = 946 ( text PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "18" _null_ _null_ _null_ _null_ char_text _null_ _null_ _null_ ));
DESCR("convert char to text");
DATA(insert OID = 952 ( lo_open PGNSP PGUID 12 1 0 0 f f f t f v 2 0 23 "26 23" _null_ _null_ _null_ _null_ lo_open _null_ _null_ _null_ ));
DESCR("large object open");
-DATA(insert OID = 953 ( lo_close PGNSP PGUID 12 1 0 0 f f f t f v 1 0 23 "23" _null_ _null_ _null_ _null_ lo_close _null_ _null_ _null_ ));
+DATA(insert OID = 953 ( lo_close PGNSP PGUID 12 1 0 0 f f f t f v 1 0 23 "23" _null_ _null_ _null_ _null_ lo_close _null_ _null_ _null_ ));
DESCR("large object close");
DATA(insert OID = 954 ( loread PGNSP PGUID 12 1 0 0 f f f t f v 2 0 17 "23 23" _null_ _null_ _null_ _null_ loread _null_ _null_ _null_ ));
DESCR("large object read");
DESCR("large object write");
DATA(insert OID = 956 ( lo_lseek PGNSP PGUID 12 1 0 0 f f f t f v 3 0 23 "23 23 23" _null_ _null_ _null_ _null_ lo_lseek _null_ _null_ _null_ ));
DESCR("large object seek");
-DATA(insert OID = 957 ( lo_creat PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "23" _null_ _null_ _null_ _null_ lo_creat _null_ _null_ _null_ ));
+DATA(insert OID = 957 ( lo_creat PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "23" _null_ _null_ _null_ _null_ lo_creat _null_ _null_ _null_ ));
DESCR("large object create");
-DATA(insert OID = 715 ( lo_create PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "26" _null_ _null_ _null_ _null_ lo_create _null_ _null_ _null_ ));
+DATA(insert OID = 715 ( lo_create PGNSP PGUID 12 1 0 0 f f f t f v 1 0 26 "26" _null_ _null_ _null_ _null_ lo_create _null_ _null_ _null_ ));
DESCR("large object create");
-DATA(insert OID = 958 ( lo_tell PGNSP PGUID 12 1 0 0 f f f t f v 1 0 23 "23" _null_ _null_ _null_ _null_ lo_tell _null_ _null_ _null_ ));
+DATA(insert OID = 958 ( lo_tell PGNSP PGUID 12 1 0 0 f f f t f v 1 0 23 "23" _null_ _null_ _null_ _null_ lo_tell _null_ _null_ _null_ ));
DESCR("large object position");
DATA(insert OID = 1004 ( lo_truncate PGNSP PGUID 12 1 0 0 f f f t f v 2 0 23 "23 23" _null_ _null_ _null_ _null_ lo_truncate _null_ _null_ _null_ ));
DESCR("truncate large object");
DATA(insert OID = 1026 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "1186 1184" _null_ _null_ _null_ _null_ timestamptz_izone _null_ _null_ _null_ ));
DESCR("adjust timestamp to new time zone");
-DATA(insert OID = 1031 ( aclitemin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1033 "2275" _null_ _null_ _null_ _null_ aclitemin _null_ _null_ _null_ ));
+DATA(insert OID = 1031 ( aclitemin PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1033 "2275" _null_ _null_ _null_ _null_ aclitemin _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1032 ( aclitemout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1033" _null_ _null_ _null_ _null_ aclitemout _null_ _null_ _null_ ));
+DATA(insert OID = 1032 ( aclitemout PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1033" _null_ _null_ _null_ _null_ aclitemout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 1035 ( aclinsert PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1034 "1034 1033" _null_ _null_ _null_ _null_ aclinsert _null_ _null_ _null_ ));
DESCR("add/update ACL item");
DESCR("make ACL item");
DATA(insert OID = 1044 ( bpcharin PGNSP PGUID 12 1 0 0 f f f t f i 3 0 1042 "2275 26 23" _null_ _null_ _null_ _null_ bpcharin _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1045 ( bpcharout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1042" _null_ _null_ _null_ _null_ bpcharout _null_ _null_ _null_ ));
+DATA(insert OID = 1045 ( bpcharout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1042" _null_ _null_ _null_ _null_ bpcharout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2913 ( bpchartypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ bpchartypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DESCR("I/O typmod");
DATA(insert OID = 1046 ( varcharin PGNSP PGUID 12 1 0 0 f f f t f i 3 0 1043 "2275 26 23" _null_ _null_ _null_ _null_ varcharin _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1047 ( varcharout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1043" _null_ _null_ _null_ _null_ varcharout _null_ _null_ _null_ ));
+DATA(insert OID = 1047 ( varcharout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1043" _null_ _null_ _null_ _null_ varcharout _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2915 ( varchartypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ varchartypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DESCR("hash");
DATA(insert OID = 1081 ( format_type PGNSP PGUID 12 1 0 0 f f f f f s 2 0 25 "26 23" _null_ _null_ _null_ _null_ format_type _null_ _null_ _null_ ));
DESCR("format a type oid and atttypmod to canonical SQL");
-DATA(insert OID = 1084 ( date_in PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1082 "2275" _null_ _null_ _null_ _null_ date_in _null_ _null_ _null_ ));
+DATA(insert OID = 1084 ( date_in PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1082 "2275" _null_ _null_ _null_ _null_ date_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1085 ( date_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1082" _null_ _null_ _null_ _null_ date_out _null_ _null_ _null_ ));
+DATA(insert OID = 1085 ( date_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1082" _null_ _null_ _null_ _null_ date_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 1086 ( date_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1082 1082" _null_ _null_ _null_ _null_ date_eq _null_ _null_ _null_ ));
DESCR("equal");
DESCR("subtract");
DATA(insert OID = 1143 ( time_in PGNSP PGUID 12 1 0 0 f f f t f s 3 0 1083 "2275 26 23" _null_ _null_ _null_ _null_ time_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1144 ( time_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1083" _null_ _null_ _null_ _null_ time_out _null_ _null_ _null_ ));
+DATA(insert OID = 1144 ( time_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1083" _null_ _null_ _null_ _null_ time_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2909 ( timetypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ timetypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DATA(insert OID = 1150 ( timestamptz_in PGNSP PGUID 12 1 0 0 f f f t f s 3 0 1184 "2275 26 23" _null_ _null_ _null_ _null_ timestamptz_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1151 ( timestamptz_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1184" _null_ _null_ _null_ _null_ timestamptz_out _null_ _null_ _null_ ));
+DATA(insert OID = 1151 ( timestamptz_out PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "1184" _null_ _null_ _null_ _null_ timestamptz_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2907 ( timestamptztypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ timestamptztypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DESCR("greater-than");
DATA(insert OID = 1158 ( to_timestamp PGNSP PGUID 14 1 0 0 f f f t f i 1 0 1184 "701" _null_ _null_ _null_ _null_ "select (''epoch''::pg_catalog.timestamptz + $1 * ''1 second''::pg_catalog.interval)" _null_ _null_ _null_ ));
DESCR("convert UNIX epoch to timestamptz");
-DATA(insert OID = 1159 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "25 1184" _null_ _null_ _null_ _null_ timestamptz_zone _null_ _null_ _null_ ));
+DATA(insert OID = 1159 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "25 1184" _null_ _null_ _null_ _null_ timestamptz_zone _null_ _null_ _null_ ));
DESCR("adjust timestamp to new time zone");
DATA(insert OID = 1160 ( interval_in PGNSP PGUID 12 1 0 0 f f f t f s 3 0 1186 "2275 26 23" _null_ _null_ _null_ _null_ interval_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1161 ( interval_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1186" _null_ _null_ _null_ _null_ interval_out _null_ _null_ _null_ ));
+DATA(insert OID = 1161 ( interval_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1186" _null_ _null_ _null_ _null_ interval_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2903 ( intervaltypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ intervaltypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DESCR("greater-than-or-equal");
DATA(insert OID = 1167 ( interval_gt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1186 1186" _null_ _null_ _null_ _null_ interval_gt _null_ _null_ _null_ ));
DESCR("greater-than");
-DATA(insert OID = 1168 ( interval_um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_um _null_ _null_ _null_ ));
+DATA(insert OID = 1168 ( interval_um PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_um _null_ _null_ _null_ ));
DESCR("subtract");
DATA(insert OID = 1169 ( interval_pl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 1186" _null_ _null_ _null_ _null_ interval_pl _null_ _null_ _null_ ));
DESCR("add");
DESCR("extract field from interval");
DATA(insert OID = 1173 ( timestamptz PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1184 "702" _null_ _null_ _null_ _null_ abstime_timestamptz _null_ _null_ _null_ ));
DESCR("convert abstime to timestamp with time zone");
-DATA(insert OID = 1174 ( timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "1082" _null_ _null_ _null_ _null_ date_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 1174 ( timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "1082" _null_ _null_ _null_ _null_ date_timestamptz _null_ _null_ _null_ ));
DESCR("convert date to timestamp with time zone");
-DATA(insert OID = 2711 ( justify_interval PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_interval _null_ _null_ _null_ ));
+DATA(insert OID = 2711 ( justify_interval PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_interval _null_ _null_ _null_ ));
DESCR("promote groups of 24 hours to numbers of days and promote groups of 30 days to numbers of months");
-DATA(insert OID = 1175 ( justify_hours PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_hours _null_ _null_ _null_ ));
+DATA(insert OID = 1175 ( justify_hours PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_hours _null_ _null_ _null_ ));
DESCR("promote groups of 24 hours to numbers of days");
-DATA(insert OID = 1295 ( justify_days PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_days _null_ _null_ _null_ ));
+DATA(insert OID = 1295 ( justify_days PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ interval_justify_days _null_ _null_ _null_ ));
DESCR("promote groups of 30 days to numbers of months");
DATA(insert OID = 1176 ( timestamptz PGNSP PGUID 14 1 0 0 f f f t f s 2 0 1184 "1082 1083" _null_ _null_ _null_ _null_ "select cast(($1 + $2) as timestamp with time zone)" _null_ _null_ _null_ ));
DESCR("convert date and time to timestamp with time zone");
DATA(insert OID = 1177 ( interval PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "703" _null_ _null_ _null_ _null_ reltime_interval _null_ _null_ _null_ ));
DESCR("convert reltime to interval");
-DATA(insert OID = 1178 ( date PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1082 "1184" _null_ _null_ _null_ _null_ timestamptz_date _null_ _null_ _null_ ));
+DATA(insert OID = 1178 ( date PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1082 "1184" _null_ _null_ _null_ _null_ timestamptz_date _null_ _null_ _null_ ));
DESCR("convert timestamp with time zone to date");
DATA(insert OID = 1179 ( date PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1082 "702" _null_ _null_ _null_ _null_ abstime_date _null_ _null_ _null_ ));
DESCR("convert abstime to date");
DATA(insert OID = 1180 ( abstime PGNSP PGUID 12 1 0 0 f f f t f i 1 0 702 "1184" _null_ _null_ _null_ _null_ timestamptz_abstime _null_ _null_ _null_ ));
DESCR("convert timestamp with time zone to abstime");
-DATA(insert OID = 1181 ( age PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "28" _null_ _null_ _null_ _null_ xid_age _null_ _null_ _null_ ));
+DATA(insert OID = 1181 ( age PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "28" _null_ _null_ _null_ _null_ xid_age _null_ _null_ _null_ ));
DESCR("age of a transaction ID, in transactions before current transaction");
DATA(insert OID = 1188 ( timestamptz_mi PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1184 1184" _null_ _null_ _null_ _null_ timestamp_mi _null_ _null_ _null_ ));
DESCR("subtract");
-DATA(insert OID = 1189 ( timestamptz_pl_interval PGNSP PGUID 12 1 0 0 f f f t f s 2 0 1184 "1184 1186" _null_ _null_ _null_ _null_ timestamptz_pl_interval _null_ _null_ _null_ ));
+DATA(insert OID = 1189 ( timestamptz_pl_interval PGNSP PGUID 12 1 0 0 f f f t f s 2 0 1184 "1184 1186" _null_ _null_ _null_ _null_ timestamptz_pl_interval _null_ _null_ _null_ ));
DESCR("plus");
-DATA(insert OID = 1190 ( timestamptz_mi_interval PGNSP PGUID 12 1 0 0 f f f t f s 2 0 1184 "1184 1186" _null_ _null_ _null_ _null_ timestamptz_mi_interval _null_ _null_ _null_ ));
+DATA(insert OID = 1190 ( timestamptz_mi_interval PGNSP PGUID 12 1 0 0 f f f t f s 2 0 1184 "1184 1186" _null_ _null_ _null_ _null_ timestamptz_mi_interval _null_ _null_ _null_ ));
DESCR("minus");
DATA(insert OID = 1194 ( reltime PGNSP PGUID 12 1 0 0 f f f t f i 1 0 703 "1186" _null_ _null_ _null_ _null_ interval_reltime _null_ _null_ _null_ ));
DESCR("convert interval to reltime");
-DATA(insert OID = 1195 ( timestamptz_smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1184 1184" _null_ _null_ _null_ _null_ timestamp_smaller _null_ _null_ _null_ ));
+DATA(insert OID = 1195 ( timestamptz_smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1184 1184" _null_ _null_ _null_ _null_ timestamp_smaller _null_ _null_ _null_ ));
DESCR("smaller of two");
-DATA(insert OID = 1196 ( timestamptz_larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1184 1184" _null_ _null_ _null_ _null_ timestamp_larger _null_ _null_ _null_ ));
+DATA(insert OID = 1196 ( timestamptz_larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1184 1184" _null_ _null_ _null_ _null_ timestamp_larger _null_ _null_ _null_ ));
DESCR("larger of two");
DATA(insert OID = 1197 ( interval_smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 1186" _null_ _null_ _null_ _null_ interval_smaller _null_ _null_ _null_ ));
DESCR("smaller of two");
/* OIDS 1200 - 1299 */
-DATA(insert OID = 1200 ( interval PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 23" _null_ _null_ _null_ _null_ interval_scale _null_ _null_ _null_ ));
+DATA(insert OID = 1200 ( interval PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 23" _null_ _null_ _null_ _null_ interval_scale _null_ _null_ _null_ ));
DESCR("adjust interval precision");
DATA(insert OID = 1215 ( obj_description PGNSP PGUID 14 100 0 0 f f f t f s 2 0 25 "26 19" _null_ _null_ _null_ _null_ "select description from pg_catalog.pg_description where objoid = $1 and classoid = (select oid from pg_catalog.pg_class where relname = $2 and relnamespace = PGNSP) and objsubid = 0" _null_ _null_ _null_ ));
DATA(insert OID = 1218 ( date_trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "25 1186" _null_ _null_ _null_ _null_ interval_trunc _null_ _null_ _null_ ));
DESCR("truncate interval to specified units");
-DATA(insert OID = 1219 ( int8inc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8inc _null_ _null_ _null_ ));
+DATA(insert OID = 1219 ( int8inc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8inc _null_ _null_ _null_ ));
DESCR("increment");
DATA(insert OID = 2804 ( int8inc_any PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 2276" _null_ _null_ _null_ _null_ int8inc_any _null_ _null_ _null_ ));
DESCR("increment, ignores second argument");
-DATA(insert OID = 1230 ( int8abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8abs _null_ _null_ _null_ ));
+DATA(insert OID = 1230 ( int8abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8abs _null_ _null_ _null_ ));
DESCR("absolute value");
DATA(insert OID = 1236 ( int8larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 20" _null_ _null_ _null_ _null_ int8larger _null_ _null_ _null_ ));
DATA(insert OID = 1241 ( nameicregexne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameicregexne _null_ _null_ _null_ ));
DESCR("does not match regex., case-insensitive");
-DATA(insert OID = 1251 ( int4abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4abs _null_ _null_ _null_ ));
+DATA(insert OID = 1251 ( int4abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 1253 ( int2abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2abs _null_ _null_ _null_ ));
+DATA(insert OID = 1253 ( int2abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2abs _null_ _null_ _null_ ));
DESCR("absolute value");
DATA(insert OID = 1271 ( overlaps PGNSP PGUID 12 1 0 0 f f f f f i 4 0 16 "1266 1266 1266 1266" _null_ _null_ _null_ _null_ overlaps_timetz _null_ _null_ _null_ ));
DATA(insert OID = 948 ( int28div PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "21 20" _null_ _null_ _null_ _null_ int28div _null_ _null_ _null_ ));
DESCR("divide");
-DATA(insert OID = 1287 ( oid PGNSP PGUID 12 1 0 0 f f f t f i 1 0 26 "20" _null_ _null_ _null_ _null_ i8tooid _null_ _null_ _null_ ));
+DATA(insert OID = 1287 ( oid PGNSP PGUID 12 1 0 0 f f f t f i 1 0 26 "20" _null_ _null_ _null_ _null_ i8tooid _null_ _null_ _null_ ));
DESCR("convert int8 to oid");
-DATA(insert OID = 1288 ( int8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "26" _null_ _null_ _null_ _null_ oidtoi8 _null_ _null_ _null_ ));
+DATA(insert OID = 1288 ( int8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "26" _null_ _null_ _null_ _null_ oidtoi8 _null_ _null_ _null_ ));
DESCR("convert oid to int8");
DATA(insert OID = 1291 ( suppress_redundant_updates_trigger PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ suppress_redundant_updates_trigger _null_ _null_ _null_ ));
DESCR("convert date and time with time zone to timestamp with time zone");
DATA(insert OID = 1298 ( timetzdate_pl PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1184 "1266 1082" _null_ _null_ _null_ _null_ "select ($2 + $1)" _null_ _null_ _null_ ));
DESCR("convert time with time zone and date to timestamp with time zone");
-DATA(insert OID = 1299 ( now PGNSP PGUID 12 1 0 0 f f f t f s 0 0 1184 "" _null_ _null_ _null_ _null_ now _null_ _null_ _null_ ));
+DATA(insert OID = 1299 ( now PGNSP PGUID 12 1 0 0 f f f t f s 0 0 1184 "" _null_ _null_ _null_ _null_ now _null_ _null_ _null_ ));
DESCR("current transaction time");
DATA(insert OID = 2647 ( transaction_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 0 0 1184 "" _null_ _null_ _null_ _null_ now _null_ _null_ _null_ ));
DESCR("current transaction time");
DATA(insert OID = 1317 ( length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textlen _null_ _null_ _null_ ));
DESCR("length");
-DATA(insert OID = 1318 ( length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharlen _null_ _null_ _null_ ));
+DATA(insert OID = 1318 ( length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharlen _null_ _null_ _null_ ));
DESCR("character length");
DATA(insert OID = 1319 ( xideqint4 PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "28 23" _null_ _null_ _null_ _null_ xideq _null_ _null_ _null_ ));
DATA(insert OID = 1326 ( interval_div PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 701" _null_ _null_ _null_ _null_ interval_div _null_ _null_ _null_ ));
DESCR("divide");
-DATA(insert OID = 1339 ( dlog10 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog10 _null_ _null_ _null_ ));
+DATA(insert OID = 1339 ( dlog10 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog10 _null_ _null_ _null_ ));
DESCR("base 10 logarithm");
-DATA(insert OID = 1340 ( log PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog10 _null_ _null_ _null_ ));
+DATA(insert OID = 1340 ( log PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog10 _null_ _null_ _null_ ));
DESCR("base 10 logarithm");
-DATA(insert OID = 1341 ( ln PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog1 _null_ _null_ _null_ ));
+DATA(insert OID = 1341 ( ln PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dlog1 _null_ _null_ _null_ ));
DESCR("natural logarithm");
-DATA(insert OID = 1342 ( round PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dround _null_ _null_ _null_ ));
+DATA(insert OID = 1342 ( round PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dround _null_ _null_ _null_ ));
DESCR("round to nearest integer");
-DATA(insert OID = 1343 ( trunc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dtrunc _null_ _null_ _null_ ));
+DATA(insert OID = 1343 ( trunc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dtrunc _null_ _null_ _null_ ));
DESCR("truncate to integer");
-DATA(insert OID = 1344 ( sqrt PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dsqrt _null_ _null_ _null_ ));
+DATA(insert OID = 1344 ( sqrt PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dsqrt _null_ _null_ _null_ ));
DESCR("square root");
-DATA(insert OID = 1345 ( cbrt PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dcbrt _null_ _null_ _null_ ));
+DATA(insert OID = 1345 ( cbrt PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dcbrt _null_ _null_ _null_ ));
DESCR("cube root");
-DATA(insert OID = 1346 ( pow PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ dpow _null_ _null_ _null_ ));
+DATA(insert OID = 1346 ( pow PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ dpow _null_ _null_ _null_ ));
DESCR("exponentiation");
-DATA(insert OID = 1368 ( power PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ dpow _null_ _null_ _null_ ));
+DATA(insert OID = 1368 ( power PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ dpow _null_ _null_ _null_ ));
DESCR("exponentiation");
-DATA(insert OID = 1347 ( exp PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dexp _null_ _null_ _null_ ));
+DATA(insert OID = 1347 ( exp PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ dexp _null_ _null_ _null_ ));
DESCR("exponential");
/*
* This form of obj_description is now deprecated, since it will fail if
* OIDs are not unique across system catalogs. Use the other forms instead.
*/
-DATA(insert OID = 1348 ( obj_description PGNSP PGUID 14 100 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ "select description from pg_catalog.pg_description where objoid = $1 and objsubid = 0" _null_ _null_ _null_ ));
+DATA(insert OID = 1348 ( obj_description PGNSP PGUID 14 100 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ "select description from pg_catalog.pg_description where objoid = $1 and objsubid = 0" _null_ _null_ _null_ ));
DESCR("get description for object id (deprecated)");
DATA(insert OID = 1349 ( oidvectortypes PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "30" _null_ _null_ _null_ _null_ oidvectortypes _null_ _null_ _null_ ));
DESCR("print type names of oidvector field");
DATA(insert OID = 1350 ( timetz_in PGNSP PGUID 12 1 0 0 f f f t f s 3 0 1266 "2275 26 23" _null_ _null_ _null_ _null_ timetz_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1351 ( timetz_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1266" _null_ _null_ _null_ _null_ timetz_out _null_ _null_ _null_ ));
+DATA(insert OID = 1351 ( timetz_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1266" _null_ _null_ _null_ _null_ timetz_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2911 ( timetztypmodin PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1263" _null_ _null_ _null_ _null_ timetztypmodin _null_ _null_ _null_ ));
DESCR("I/O typmod");
DATA(insert OID = 1359 ( timestamptz PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1082 1266" _null_ _null_ _null_ _null_ datetimetz_timestamptz _null_ _null_ _null_ ));
DESCR("convert date and time with time zone to timestamp with time zone");
-DATA(insert OID = 1364 ( time PGNSP PGUID 14 1 0 0 f f f t f s 1 0 1083 "702" _null_ _null_ _null_ _null_ "select cast(cast($1 as timestamp without time zone) as pg_catalog.time)" _null_ _null_ _null_ ));
+DATA(insert OID = 1364 ( time PGNSP PGUID 14 1 0 0 f f f t f s 1 0 1083 "702" _null_ _null_ _null_ _null_ "select cast(cast($1 as timestamp without time zone) as pg_catalog.time)" _null_ _null_ _null_ ));
DESCR("convert abstime to time");
DATA(insert OID = 1367 ( character_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharlen _null_ _null_ _null_ ));
DATA(insert OID = 1370 ( interval PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1083" _null_ _null_ _null_ _null_ time_interval _null_ _null_ _null_ ));
DESCR("convert time to interval");
-DATA(insert OID = 1372 ( char_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharlen _null_ _null_ _null_ ));
+DATA(insert OID = 1372 ( char_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharlen _null_ _null_ _null_ ));
DESCR("character length");
DATA(insert OID = 1374 ( octet_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textoctetlen _null_ _null_ _null_ ));
DESCR("octet length");
-DATA(insert OID = 1375 ( octet_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharoctetlen _null_ _null_ _null_ ));
+DATA(insert OID = 1375 ( octet_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1042" _null_ _null_ _null_ _null_ bpcharoctetlen _null_ _null_ _null_ ));
DESCR("octet length");
DATA(insert OID = 1377 ( time_larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1083 "1083 1083" _null_ _null_ _null_ _null_ time_larger _null_ _null_ _null_ ));
DATA(insert OID = 1380 ( timetz_smaller PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1266 "1266 1266" _null_ _null_ _null_ _null_ timetz_smaller _null_ _null_ _null_ ));
DESCR("smaller of two");
-DATA(insert OID = 1381 ( char_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textlen _null_ _null_ _null_ ));
+DATA(insert OID = 1381 ( char_length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "25" _null_ _null_ _null_ _null_ textlen _null_ _null_ _null_ ));
DESCR("character length");
DATA(insert OID = 1382 ( date_part PGNSP PGUID 14 1 0 0 f f f t f s 2 0 701 "25 702" _null_ _null_ _null_ _null_ "select pg_catalog.date_part($1, cast($2 as timestamp with time zone))" _null_ _null_ _null_ ));
DESCR("extract field from date");
DATA(insert OID = 1385 ( date_part PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "25 1083" _null_ _null_ _null_ _null_ time_part _null_ _null_ _null_ ));
DESCR("extract field from time");
-DATA(insert OID = 1386 ( age PGNSP PGUID 14 1 0 0 f f f t f s 1 0 1186 "1184" _null_ _null_ _null_ _null_ "select pg_catalog.age(cast(current_date as timestamp with time zone), $1)" _null_ _null_ _null_ ));
+DATA(insert OID = 1386 ( age PGNSP PGUID 14 1 0 0 f f f t f s 1 0 1186 "1184" _null_ _null_ _null_ _null_ "select pg_catalog.age(cast(current_date as timestamp with time zone), $1)" _null_ _null_ _null_ ));
DESCR("date difference from today preserving months and years");
-DATA(insert OID = 1388 ( timetz PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1266 "1184" _null_ _null_ _null_ _null_ timestamptz_timetz _null_ _null_ _null_ ));
+DATA(insert OID = 1388 ( timetz PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1266 "1184" _null_ _null_ _null_ _null_ timestamptz_timetz _null_ _null_ _null_ ));
DESCR("convert timestamptz to timetz");
DATA(insert OID = 1373 ( isfinite PGNSP PGUID 12 1 0 0 f f f t f i 1 0 16 "1082" _null_ _null_ _null_ _null_ date_finite _null_ _null_ _null_ ));
DESCR("absolute value");
DATA(insert OID = 1395 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ float8abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 1396 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8abs _null_ _null_ _null_ ));
+DATA(insert OID = 1396 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 1397 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4abs _null_ _null_ _null_ ));
+DATA(insert OID = 1397 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4abs _null_ _null_ _null_ ));
DESCR("absolute value");
-DATA(insert OID = 1398 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2abs _null_ _null_ _null_ ));
+DATA(insert OID = 1398 ( abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2abs _null_ _null_ _null_ ));
DESCR("absolute value");
/* OIDS 1400 - 1499 */
DATA(insert OID = 1404 ( overlay PGNSP PGUID 14 1 0 0 f f f t f i 4 0 25 "25 25 23 23" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, 1, ($3 - 1)) || $2 || pg_catalog.substring($1, ($3 + $4))" _null_ _null_ _null_ ));
DESCR("substitute portion of string");
-DATA(insert OID = 1405 ( overlay PGNSP PGUID 14 1 0 0 f f f t f i 3 0 25 "25 25 23" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, 1, ($3 - 1)) || $2 || pg_catalog.substring($1, ($3 + pg_catalog.char_length($2)))" _null_ _null_ _null_ ));
+DATA(insert OID = 1405 ( overlay PGNSP PGUID 14 1 0 0 f f f t f i 3 0 25 "25 25 23" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, 1, ($3 - 1)) || $2 || pg_catalog.substring($1, ($3 + pg_catalog.char_length($2)))" _null_ _null_ _null_ ));
DESCR("substitute portion of string");
DATA(insert OID = 1406 ( isvertical PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "600 600" _null_ _null_ _null_ _null_ point_vert _null_ _null_ _null_ ));
DATA(insert OID = 1449 ( polygon PGNSP PGUID 12 1 0 0 f f f t f i 1 0 604 "602" _null_ _null_ _null_ _null_ path_poly _null_ _null_ _null_ ));
DESCR("convert path to polygon");
-DATA(insert OID = 1450 ( circle_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 718 "2275" _null_ _null_ _null_ _null_ circle_in _null_ _null_ _null_ ));
+DATA(insert OID = 1450 ( circle_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 718 "2275" _null_ _null_ _null_ _null_ circle_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1451 ( circle_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "718" _null_ _null_ _null_ _null_ circle_out _null_ _null_ _null_ ));
+DATA(insert OID = 1451 ( circle_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "718" _null_ _null_ _null_ _null_ circle_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 1452 ( circle_same PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "718 718" _null_ _null_ _null_ _null_ circle_same _null_ _null_ _null_ ));
DESCR("same as?");
DATA(insert OID = 1489 ( close_lseg PGNSP PGUID 12 1 0 0 f f f t f i 2 0 600 "601 601" _null_ _null_ _null_ _null_ close_lseg _null_ _null_ _null_ ));
DESCR("closest point to line segment on line segment");
-DATA(insert OID = 1490 ( line_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 628 "2275" _null_ _null_ _null_ _null_ line_in _null_ _null_ _null_ ));
+DATA(insert OID = 1490 ( line_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 628 "2275" _null_ _null_ _null_ _null_ line_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1491 ( line_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "628" _null_ _null_ _null_ _null_ line_out _null_ _null_ _null_ ));
+DATA(insert OID = 1491 ( line_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "628" _null_ _null_ _null_ _null_ line_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 1492 ( line_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "628 628" _null_ _null_ _null_ _null_ line_eq _null_ _null_ _null_ ));
DESCR("lines equal?");
DATA(insert OID = 2920 ( bittypmodout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "23" _null_ _null_ _null_ _null_ bittypmodout _null_ _null_ _null_ ));
DESCR("I/O typmod");
-DATA(insert OID = 1569 ( like PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ textlike _null_ _null_ _null_ ));
+DATA(insert OID = 1569 ( like PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ textlike _null_ _null_ _null_ ));
DESCR("matches LIKE expression");
-DATA(insert OID = 1570 ( notlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ textnlike _null_ _null_ _null_ ));
+DATA(insert OID = 1570 ( notlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ textnlike _null_ _null_ _null_ ));
DESCR("does not match LIKE expression");
-DATA(insert OID = 1571 ( like PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ namelike _null_ _null_ _null_ ));
+DATA(insert OID = 1571 ( like PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ namelike _null_ _null_ _null_ ));
DESCR("matches LIKE expression");
-DATA(insert OID = 1572 ( notlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ namenlike _null_ _null_ _null_ ));
+DATA(insert OID = 1572 ( notlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ namenlike _null_ _null_ _null_ ));
DESCR("does not match LIKE expression");
DATA(insert OID = 2921 ( varbittypmodout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "23" _null_ _null_ _null_ _null_ varbittypmodout _null_ _null_ _null_ ));
DESCR("I/O typmod");
-DATA(insert OID = 1581 ( biteq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ biteq _null_ _null_ _null_ ));
+DATA(insert OID = 1581 ( biteq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ biteq _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 1582 ( bitne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitne _null_ _null_ _null_ ));
+DATA(insert OID = 1582 ( bitne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitne _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 1592 ( bitge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitge _null_ _null_ _null_ ));
+DATA(insert OID = 1592 ( bitge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitge _null_ _null_ _null_ ));
DESCR("greater than or equal");
-DATA(insert OID = 1593 ( bitgt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitgt _null_ _null_ _null_ ));
+DATA(insert OID = 1593 ( bitgt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitgt _null_ _null_ _null_ ));
DESCR("greater than");
-DATA(insert OID = 1594 ( bitle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitle _null_ _null_ _null_ ));
+DATA(insert OID = 1594 ( bitle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitle _null_ _null_ _null_ ));
DESCR("less than or equal");
-DATA(insert OID = 1595 ( bitlt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitlt _null_ _null_ _null_ ));
+DATA(insert OID = 1595 ( bitlt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1560 1560" _null_ _null_ _null_ _null_ bitlt _null_ _null_ _null_ ));
DESCR("less than");
-DATA(insert OID = 1596 ( bitcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1560 1560" _null_ _null_ _null_ _null_ bitcmp _null_ _null_ _null_ ));
+DATA(insert OID = 1596 ( bitcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1560 1560" _null_ _null_ _null_ _null_ bitcmp _null_ _null_ _null_ ));
DESCR("compare");
-DATA(insert OID = 1598 ( random PGNSP PGUID 12 1 0 0 f f f t f v 0 0 701 "" _null_ _null_ _null_ _null_ drandom _null_ _null_ _null_ ));
+DATA(insert OID = 1598 ( random PGNSP PGUID 12 1 0 0 f f f t f v 0 0 701 "" _null_ _null_ _null_ _null_ drandom _null_ _null_ _null_ ));
DESCR("random value");
DATA(insert OID = 1599 ( setseed PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "701" _null_ _null_ _null_ _null_ setseed _null_ _null_ _null_ ));
DESCR("set random seed");
DESCR("radians to degrees");
DATA(insert OID = 1609 ( radians PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "701" _null_ _null_ _null_ _null_ radians _null_ _null_ _null_ ));
DESCR("degrees to radians");
-DATA(insert OID = 1610 ( pi PGNSP PGUID 12 1 0 0 f f f t f i 0 0 701 "" _null_ _null_ _null_ _null_ dpi _null_ _null_ _null_ ));
+DATA(insert OID = 1610 ( pi PGNSP PGUID 12 1 0 0 f f f t f i 0 0 701 "" _null_ _null_ _null_ _null_ dpi _null_ _null_ _null_ ));
DESCR("PI");
DATA(insert OID = 1618 ( interval_mul PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1186 701" _null_ _null_ _null_ _null_ interval_mul _null_ _null_ _null_ ));
DESCR("convert first char to int4");
DATA(insert OID = 1621 ( chr PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "23" _null_ _null_ _null_ _null_ chr _null_ _null_ _null_ ));
DESCR("convert int4 to char");
-DATA(insert OID = 1622 ( repeat PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 23" _null_ _null_ _null_ _null_ repeat _null_ _null_ _null_ ));
+DATA(insert OID = 1622 ( repeat PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 23" _null_ _null_ _null_ _null_ repeat _null_ _null_ _null_ ));
DESCR("replicate string int4 times");
DATA(insert OID = 1623 ( similar_escape PGNSP PGUID 12 1 0 0 f f f f f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ similar_escape _null_ _null_ _null_ ));
DESCR("matches LIKE expression, case-insensitive");
DATA(insert OID = 1634 ( texticnlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ texticnlike _null_ _null_ _null_ ));
DESCR("does not match LIKE expression, case-insensitive");
-DATA(insert OID = 1635 ( nameiclike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameiclike _null_ _null_ _null_ ));
+DATA(insert OID = 1635 ( nameiclike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameiclike _null_ _null_ _null_ ));
DESCR("matches LIKE expression, case-insensitive");
-DATA(insert OID = 1636 ( nameicnlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameicnlike _null_ _null_ _null_ ));
+DATA(insert OID = 1636 ( nameicnlike PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "19 25" _null_ _null_ _null_ _null_ nameicnlike _null_ _null_ _null_ ));
DESCR("does not match LIKE expression, case-insensitive");
DATA(insert OID = 1637 ( like_escape PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ like_escape _null_ _null_ _null_ ));
DESCR("convert LIKE pattern to use backslash escapes");
/* Oracle Compatibility Related Functions - By Edmund Mergl <E.Mergl@bawue.de> */
DATA(insert OID = 868 ( strpos PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "25 25" _null_ _null_ _null_ _null_ textpos _null_ _null_ _null_ ));
DESCR("find position of substring");
-DATA(insert OID = 870 ( lower PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ lower _null_ _null_ _null_ ));
+DATA(insert OID = 870 ( lower PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ lower _null_ _null_ _null_ ));
DESCR("lowercase");
-DATA(insert OID = 871 ( upper PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ upper _null_ _null_ _null_ ));
+DATA(insert OID = 871 ( upper PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ upper _null_ _null_ _null_ ));
DESCR("uppercase");
-DATA(insert OID = 872 ( initcap PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ initcap _null_ _null_ _null_ ));
+DATA(insert OID = 872 ( initcap PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ initcap _null_ _null_ _null_ ));
DESCR("capitalize each word");
DATA(insert OID = 873 ( lpad PGNSP PGUID 12 1 0 0 f f f t f i 3 0 25 "25 23 25" _null_ _null_ _null_ _null_ lpad _null_ _null_ _null_ ));
DESCR("left-pad string to length");
DESCR("left-pad string to length");
DATA(insert OID = 880 ( rpad PGNSP PGUID 14 1 0 0 f f f t f i 2 0 25 "25 23" _null_ _null_ _null_ _null_ "select pg_catalog.rpad($1, $2, '' '')" _null_ _null_ _null_ ));
DESCR("right-pad string to length");
-DATA(insert OID = 881 ( ltrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ ltrim1 _null_ _null_ _null_ ));
+DATA(insert OID = 881 ( ltrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ ltrim1 _null_ _null_ _null_ ));
DESCR("trim spaces from left end of string");
-DATA(insert OID = 882 ( rtrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ rtrim1 _null_ _null_ _null_ ));
+DATA(insert OID = 882 ( rtrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ rtrim1 _null_ _null_ _null_ ));
DESCR("trim spaces from right end of string");
DATA(insert OID = 883 ( substr PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 23" _null_ _null_ _null_ _null_ text_substr_no_len _null_ _null_ _null_ ));
DESCR("return portion of string");
DATA(insert OID = 884 ( btrim PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ btrim _null_ _null_ _null_ ));
DESCR("trim selected characters from both ends of string");
-DATA(insert OID = 885 ( btrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ btrim1 _null_ _null_ _null_ ));
+DATA(insert OID = 885 ( btrim PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ btrim1 _null_ _null_ _null_ ));
DESCR("trim spaces from both ends of string");
DATA(insert OID = 936 ( substring PGNSP PGUID 12 1 0 0 f f f t f i 3 0 25 "25 23 23" _null_ _null_ _null_ _null_ text_substr _null_ _null_ _null_ ));
DESCR("split string by pattern");
DATA(insert OID = 2768 ( regexp_split_to_array PGNSP PGUID 12 1 0 0 f f f t f i 3 0 1009 "25 25 25" _null_ _null_ _null_ _null_ regexp_split_to_array _null_ _null_ _null_ ));
DESCR("split string by pattern");
-DATA(insert OID = 2089 ( to_hex PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "23" _null_ _null_ _null_ _null_ to_hex32 _null_ _null_ _null_ ));
+DATA(insert OID = 2089 ( to_hex PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "23" _null_ _null_ _null_ _null_ to_hex32 _null_ _null_ _null_ ));
DESCR("convert int4 number to hex");
-DATA(insert OID = 2090 ( to_hex PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "20" _null_ _null_ _null_ _null_ to_hex64 _null_ _null_ _null_ ));
+DATA(insert OID = 2090 ( to_hex PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "20" _null_ _null_ _null_ _null_ to_hex64 _null_ _null_ _null_ ));
DESCR("convert int8 number to hex");
/* for character set encoding support */
DATA(insert OID = 1813 ( convert PGNSP PGUID 12 1 0 0 f f f t f s 3 0 17 "17 19 19" _null_ _null_ _null_ _null_ pg_convert _null_ _null_ _null_ ));
DESCR("convert string with specified encoding names");
-DATA(insert OID = 1264 ( pg_char_to_encoding PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "19" _null_ _null_ _null_ _null_ PG_char_to_encoding _null_ _null_ _null_ ));
+DATA(insert OID = 1264 ( pg_char_to_encoding PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "19" _null_ _null_ _null_ _null_ PG_char_to_encoding _null_ _null_ _null_ ));
DESCR("convert encoding name to encoding id");
-DATA(insert OID = 1597 ( pg_encoding_to_char PGNSP PGUID 12 1 0 0 f f f t f s 1 0 19 "23" _null_ _null_ _null_ _null_ PG_encoding_to_char _null_ _null_ _null_ ));
+DATA(insert OID = 1597 ( pg_encoding_to_char PGNSP PGUID 12 1 0 0 f f f t f s 1 0 19 "23" _null_ _null_ _null_ _null_ PG_encoding_to_char _null_ _null_ _null_ ));
DESCR("convert encoding id to encoding name");
DATA(insert OID = 1638 ( oidgt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "26 26" _null_ _null_ _null_ _null_ oidgt _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
/* System-view support functions */
-DATA(insert OID = 1573 ( pg_get_ruledef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_ruledef _null_ _null_ _null_ ));
+DATA(insert OID = 1573 ( pg_get_ruledef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_ruledef _null_ _null_ _null_ ));
DESCR("source text of a rule");
-DATA(insert OID = 1640 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "25" _null_ _null_ _null_ _null_ pg_get_viewdef_name _null_ _null_ _null_ ));
+DATA(insert OID = 1640 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "25" _null_ _null_ _null_ _null_ pg_get_viewdef_name _null_ _null_ _null_ ));
DESCR("select statement of a view");
-DATA(insert OID = 1641 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_viewdef _null_ _null_ _null_ ));
+DATA(insert OID = 1641 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_viewdef _null_ _null_ _null_ ));
DESCR("select statement of a view");
-DATA(insert OID = 1642 ( pg_get_userbyid PGNSP PGUID 12 1 0 0 f f f t f s 1 0 19 "26" _null_ _null_ _null_ _null_ pg_get_userbyid _null_ _null_ _null_ ));
+DATA(insert OID = 1642 ( pg_get_userbyid PGNSP PGUID 12 1 0 0 f f f t f s 1 0 19 "26" _null_ _null_ _null_ _null_ pg_get_userbyid _null_ _null_ _null_ ));
DESCR("role name by OID (with fallback)");
-DATA(insert OID = 1643 ( pg_get_indexdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_indexdef _null_ _null_ _null_ ));
+DATA(insert OID = 1643 ( pg_get_indexdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_indexdef _null_ _null_ _null_ ));
DESCR("index description");
-DATA(insert OID = 1662 ( pg_get_triggerdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_triggerdef _null_ _null_ _null_ ));
+DATA(insert OID = 1662 ( pg_get_triggerdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_triggerdef _null_ _null_ _null_ ));
DESCR("trigger description");
-DATA(insert OID = 1387 ( pg_get_constraintdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_constraintdef _null_ _null_ _null_ ));
+DATA(insert OID = 1387 ( pg_get_constraintdef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_constraintdef _null_ _null_ _null_ ));
DESCR("constraint description");
DATA(insert OID = 1716 ( pg_get_expr PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "25 26" _null_ _null_ _null_ _null_ pg_get_expr _null_ _null_ _null_ ));
DESCR("deparse an encoded expression");
-DATA(insert OID = 1665 ( pg_get_serial_sequence PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "25 25" _null_ _null_ _null_ _null_ pg_get_serial_sequence _null_ _null_ _null_ ));
+DATA(insert OID = 1665 ( pg_get_serial_sequence PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "25 25" _null_ _null_ _null_ _null_ pg_get_serial_sequence _null_ _null_ _null_ ));
DESCR("name of sequence for a serial column");
DATA(insert OID = 2098 ( pg_get_functiondef PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_functiondef _null_ _null_ _null_ ));
DESCR("definition of a function");
-DATA(insert OID = 2162 ( pg_get_function_arguments PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_arguments _null_ _null_ _null_ ));
+DATA(insert OID = 2162 ( pg_get_function_arguments PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_arguments _null_ _null_ _null_ ));
DESCR("argument list of a function");
-DATA(insert OID = 2232 ( pg_get_function_identity_arguments PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_identity_arguments _null_ _null_ _null_ ));
+DATA(insert OID = 2232 ( pg_get_function_identity_arguments PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_identity_arguments _null_ _null_ _null_ ));
DESCR("identity argument list of a function");
-DATA(insert OID = 2165 ( pg_get_function_result PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_result _null_ _null_ _null_ ));
+DATA(insert OID = 2165 ( pg_get_function_result PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "26" _null_ _null_ _null_ _null_ pg_get_function_result _null_ _null_ _null_ ));
DESCR("result type of a function");
DATA(insert OID = 1686 ( pg_get_keywords PGNSP PGUID 12 10 400 0 f f f t t s 0 0 2249 "" "{25,18,25}" "{o,o,o}" "{word,catcode,catdesc}" _null_ pg_get_keywords _null_ _null_ _null_ ));
DESCR("referential integrity ON DELETE SET DEFAULT");
DATA(insert OID = 1653 ( RI_FKey_setdefault_upd PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ RI_FKey_setdefault_upd _null_ _null_ _null_ ));
DESCR("referential integrity ON UPDATE SET DEFAULT");
-DATA(insert OID = 1654 ( RI_FKey_noaction_del PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ RI_FKey_noaction_del _null_ _null_ _null_ ));
+DATA(insert OID = 1654 ( RI_FKey_noaction_del PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ RI_FKey_noaction_del _null_ _null_ _null_ ));
DESCR("referential integrity ON DELETE NO ACTION");
-DATA(insert OID = 1655 ( RI_FKey_noaction_upd PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ RI_FKey_noaction_upd _null_ _null_ _null_ ));
+DATA(insert OID = 1655 ( RI_FKey_noaction_upd PGNSP PGUID 12 1 0 0 f f f t f v 0 0 2279 "" _null_ _null_ _null_ _null_ RI_FKey_noaction_upd _null_ _null_ _null_ ));
DESCR("referential integrity ON UPDATE NO ACTION");
-DATA(insert OID = 1666 ( varbiteq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ biteq _null_ _null_ _null_ ));
+DATA(insert OID = 1666 ( varbiteq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ biteq _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 1667 ( varbitne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitne _null_ _null_ _null_ ));
+DATA(insert OID = 1667 ( varbitne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitne _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 1668 ( varbitge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitge _null_ _null_ _null_ ));
+DATA(insert OID = 1668 ( varbitge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitge _null_ _null_ _null_ ));
DESCR("greater than or equal");
-DATA(insert OID = 1669 ( varbitgt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitgt _null_ _null_ _null_ ));
+DATA(insert OID = 1669 ( varbitgt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitgt _null_ _null_ _null_ ));
DESCR("greater than");
-DATA(insert OID = 1670 ( varbitle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitle _null_ _null_ _null_ ));
+DATA(insert OID = 1670 ( varbitle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitle _null_ _null_ _null_ ));
DESCR("less than or equal");
-DATA(insert OID = 1671 ( varbitlt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitlt _null_ _null_ _null_ ));
+DATA(insert OID = 1671 ( varbitlt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1562 1562" _null_ _null_ _null_ _null_ bitlt _null_ _null_ _null_ ));
DESCR("less than");
-DATA(insert OID = 1672 ( varbitcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1562 1562" _null_ _null_ _null_ _null_ bitcmp _null_ _null_ _null_ ));
+DATA(insert OID = 1672 ( varbitcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1562 1562" _null_ _null_ _null_ _null_ bitcmp _null_ _null_ _null_ ));
DESCR("compare");
DATA(insert OID = 1673 ( bitand PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1560 "1560 1560" _null_ _null_ _null_ _null_ bitand _null_ _null_ _null_ ));
DESCR("bitwise exclusive or");
DATA(insert OID = 1676 ( bitnot PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1560 "1560" _null_ _null_ _null_ _null_ bitnot _null_ _null_ _null_ ));
DESCR("bitwise not");
-DATA(insert OID = 1677 ( bitshiftleft PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ bitshiftleft _null_ _null_ _null_ ));
+DATA(insert OID = 1677 ( bitshiftleft PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ bitshiftleft _null_ _null_ _null_ ));
DESCR("bitwise left shift");
-DATA(insert OID = 1678 ( bitshiftright PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ bitshiftright _null_ _null_ _null_ ));
+DATA(insert OID = 1678 ( bitshiftright PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ bitshiftright _null_ _null_ _null_ ));
DESCR("bitwise right shift");
DATA(insert OID = 1679 ( bitcat PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1562 "1562 1562" _null_ _null_ _null_ _null_ bitcat _null_ _null_ _null_ ));
DESCR("bitwise concatenation");
DATA(insert OID = 1698 ( position PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1560 1560" _null_ _null_ _null_ _null_ bitposition _null_ _null_ _null_ ));
DESCR("return position of sub-bitstring");
-DATA(insert OID = 1699 ( substring PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, $2, -1)" _null_ _null_ _null_ ));
+DATA(insert OID = 1699 ( substring PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1560 "1560 23" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, $2, -1)" _null_ _null_ _null_ ));
DESCR("return portion of bitstring");
/* for mac type support */
-DATA(insert OID = 436 ( macaddr_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 829 "2275" _null_ _null_ _null_ _null_ macaddr_in _null_ _null_ _null_ ));
+DATA(insert OID = 436 ( macaddr_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 829 "2275" _null_ _null_ _null_ _null_ macaddr_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 437 ( macaddr_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "829" _null_ _null_ _null_ _null_ macaddr_out _null_ _null_ _null_ ));
+DATA(insert OID = 437 ( macaddr_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "829" _null_ _null_ _null_ _null_ macaddr_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 753 ( trunc PGNSP PGUID 12 1 0 0 f f f t f i 1 0 829 "829" _null_ _null_ _null_ _null_ macaddr_trunc _null_ _null_ _null_ ));
DESCR("less-equal-greater");
/* for inet type support */
-DATA(insert OID = 910 ( inet_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 869 "2275" _null_ _null_ _null_ _null_ inet_in _null_ _null_ _null_ ));
+DATA(insert OID = 910 ( inet_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 869 "2275" _null_ _null_ _null_ _null_ inet_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 911 ( inet_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "869" _null_ _null_ _null_ _null_ inet_out _null_ _null_ _null_ ));
+DATA(insert OID = 911 ( inet_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "869" _null_ _null_ _null_ _null_ inet_out _null_ _null_ _null_ ));
DESCR("I/O");
/* for cidr type support */
-DATA(insert OID = 1267 ( cidr_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 650 "2275" _null_ _null_ _null_ _null_ cidr_in _null_ _null_ _null_ ));
+DATA(insert OID = 1267 ( cidr_in PGNSP PGUID 12 1 0 0 f f f t f i 1 0 650 "2275" _null_ _null_ _null_ _null_ cidr_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 1427 ( cidr_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "650" _null_ _null_ _null_ _null_ cidr_out _null_ _null_ _null_ ));
+DATA(insert OID = 1427 ( cidr_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "650" _null_ _null_ _null_ _null_ cidr_out _null_ _null_ _null_ ));
DESCR("I/O");
/* these are used for both inet and cidr */
DATA(insert OID = 1715 ( cidr PGNSP PGUID 12 1 0 0 f f f t f i 1 0 650 "869" _null_ _null_ _null_ _null_ inet_to_cidr _null_ _null_ _null_ ));
DESCR("coerce inet to cidr");
-DATA(insert OID = 2196 ( inet_client_addr PGNSP PGUID 12 1 0 0 f f f f f s 0 0 869 "" _null_ _null_ _null_ _null_ inet_client_addr _null_ _null_ _null_ ));
+DATA(insert OID = 2196 ( inet_client_addr PGNSP PGUID 12 1 0 0 f f f f f s 0 0 869 "" _null_ _null_ _null_ _null_ inet_client_addr _null_ _null_ _null_ ));
DESCR("inet address of the client");
-DATA(insert OID = 2197 ( inet_client_port PGNSP PGUID 12 1 0 0 f f f f f s 0 0 23 "" _null_ _null_ _null_ _null_ inet_client_port _null_ _null_ _null_ ));
+DATA(insert OID = 2197 ( inet_client_port PGNSP PGUID 12 1 0 0 f f f f f s 0 0 23 "" _null_ _null_ _null_ _null_ inet_client_port _null_ _null_ _null_ ));
DESCR("client's port number for this connection");
-DATA(insert OID = 2198 ( inet_server_addr PGNSP PGUID 12 1 0 0 f f f f f s 0 0 869 "" _null_ _null_ _null_ _null_ inet_server_addr _null_ _null_ _null_ ));
+DATA(insert OID = 2198 ( inet_server_addr PGNSP PGUID 12 1 0 0 f f f f f s 0 0 869 "" _null_ _null_ _null_ _null_ inet_server_addr _null_ _null_ _null_ ));
DESCR("inet address of the server");
-DATA(insert OID = 2199 ( inet_server_port PGNSP PGUID 12 1 0 0 f f f f f s 0 0 23 "" _null_ _null_ _null_ _null_ inet_server_port _null_ _null_ _null_ ));
+DATA(insert OID = 2199 ( inet_server_port PGNSP PGUID 12 1 0 0 f f f f f s 0 0 23 "" _null_ _null_ _null_ _null_ inet_server_port _null_ _null_ _null_ ));
DESCR("server's port number for this connection");
DATA(insert OID = 2627 ( inetnot PGNSP PGUID 12 1 0 0 f f f t f i 1 0 869 "869" _null_ _null_ _null_ _null_ inetnot _null_ _null_ _null_ ));
DATA(insert OID = 1690 ( time_mi_time PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1083 1083" _null_ _null_ _null_ _null_ time_mi_time _null_ _null_ _null_ ));
DESCR("minus");
-DATA(insert OID = 1691 ( boolle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "16 16" _null_ _null_ _null_ _null_ boolle _null_ _null_ _null_ ));
+DATA(insert OID = 1691 ( boolle PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "16 16" _null_ _null_ _null_ _null_ boolle _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
-DATA(insert OID = 1692 ( boolge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "16 16" _null_ _null_ _null_ _null_ boolge _null_ _null_ _null_ ));
+DATA(insert OID = 1692 ( boolge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "16 16" _null_ _null_ _null_ _null_ boolge _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 1693 ( btboolcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "16 16" _null_ _null_ _null_ _null_ btboolcmp _null_ _null_ _null_ ));
+DATA(insert OID = 1693 ( btboolcmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "16 16" _null_ _null_ _null_ _null_ btboolcmp _null_ _null_ _null_ ));
DESCR("btree less-equal-greater");
DATA(insert OID = 1688 ( time_hash PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1083" _null_ _null_ _null_ _null_ time_hash _null_ _null_ _null_ ));
/* OID's 1700 - 1799 NUMERIC data type */
-DATA(insert OID = 1701 ( numeric_in PGNSP PGUID 12 1 0 0 f f f t f i 3 0 1700 "2275 26 23" _null_ _null_ _null_ _null_ numeric_in _null_ _null_ _null_ ));
+DATA(insert OID = 1701 ( numeric_in PGNSP PGUID 12 1 0 0 f f f t f i 3 0 1700 "2275 26 23" _null_ _null_ _null_ _null_ numeric_in _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 1702 ( numeric_out PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "1700" _null_ _null_ _null_ _null_ numeric_out _null_ _null_ _null_ ));
DESCR("I/O");
DESCR("I/O typmod");
DATA(insert OID = 2918 ( numerictypmodout PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2275 "23" _null_ _null_ _null_ _null_ numerictypmodout _null_ _null_ _null_ ));
DESCR("I/O typmod");
-DATA(insert OID = 1703 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric _null_ _null_ _null_ ));
+DATA(insert OID = 1703 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric _null_ _null_ _null_ ));
DESCR("adjust numeric to typmod precision/scale");
DATA(insert OID = 1704 ( numeric_abs PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_abs _null_ _null_ _null_ ));
DESCR("absolute value");
DESCR("absolute value");
DATA(insert OID = 1706 ( sign PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_sign _null_ _null_ _null_ ));
DESCR("sign of value");
-DATA(insert OID = 1707 ( round PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric_round _null_ _null_ _null_ ));
+DATA(insert OID = 1707 ( round PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric_round _null_ _null_ _null_ ));
DESCR("value rounded to 'scale'");
DATA(insert OID = 1708 ( round PGNSP PGUID 14 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ "select pg_catalog.round($1,0)" _null_ _null_ _null_ ));
DESCR("value rounded to 'scale' of zero");
-DATA(insert OID = 1709 ( trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric_trunc _null_ _null_ _null_ ));
+DATA(insert OID = 1709 ( trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 23" _null_ _null_ _null_ _null_ numeric_trunc _null_ _null_ _null_ ));
DESCR("value truncated to 'scale'");
DATA(insert OID = 1710 ( trunc PGNSP PGUID 14 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ "select pg_catalog.trunc($1,0)" _null_ _null_ _null_ ));
DESCR("value truncated to 'scale' of zero");
DESCR("smallest integer >= value");
DATA(insert OID = 1712 ( floor PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_floor _null_ _null_ _null_ ));
DESCR("largest integer <= value");
-DATA(insert OID = 1718 ( numeric_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_eq _null_ _null_ _null_ ));
+DATA(insert OID = 1718 ( numeric_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_eq _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 1719 ( numeric_ne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_ne _null_ _null_ _null_ ));
+DATA(insert OID = 1719 ( numeric_ne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_ne _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 1720 ( numeric_gt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_gt _null_ _null_ _null_ ));
+DATA(insert OID = 1720 ( numeric_gt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_gt _null_ _null_ _null_ ));
DESCR("greater-than");
-DATA(insert OID = 1721 ( numeric_ge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_ge _null_ _null_ _null_ ));
+DATA(insert OID = 1721 ( numeric_ge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_ge _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 1722 ( numeric_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_lt _null_ _null_ _null_ ));
+DATA(insert OID = 1722 ( numeric_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_lt _null_ _null_ _null_ ));
DESCR("less-than");
-DATA(insert OID = 1723 ( numeric_le PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_le _null_ _null_ _null_ ));
+DATA(insert OID = 1723 ( numeric_le PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1700 1700" _null_ _null_ _null_ _null_ numeric_le _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
DATA(insert OID = 1724 ( numeric_add PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 1700" _null_ _null_ _null_ _null_ numeric_add _null_ _null_ _null_ ));
DESCR("add");
DESCR("(internal)");
DATA(insert OID = 1741 ( log PGNSP PGUID 14 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ "select pg_catalog.log(10, $1)" _null_ _null_ _null_ ));
DESCR("logarithm base 10 of n");
-DATA(insert OID = 1742 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "700" _null_ _null_ _null_ _null_ float4_numeric _null_ _null_ _null_ ));
+DATA(insert OID = 1742 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "700" _null_ _null_ _null_ _null_ float4_numeric _null_ _null_ _null_ ));
DESCR("(internal)");
-DATA(insert OID = 1743 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "701" _null_ _null_ _null_ _null_ float8_numeric _null_ _null_ _null_ ));
+DATA(insert OID = 1743 ( numeric PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "701" _null_ _null_ _null_ _null_ float8_numeric _null_ _null_ _null_ ));
DESCR("(internal)");
DATA(insert OID = 1744 ( int4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "1700" _null_ _null_ _null_ _null_ numeric_int4 _null_ _null_ _null_ ));
DESCR("(internal)");
-DATA(insert OID = 1745 ( float4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "1700" _null_ _null_ _null_ _null_ numeric_float4 _null_ _null_ _null_ ));
+DATA(insert OID = 1745 ( float4 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "1700" _null_ _null_ _null_ _null_ numeric_float4 _null_ _null_ _null_ ));
DESCR("(internal)");
-DATA(insert OID = 1746 ( float8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "1700" _null_ _null_ _null_ _null_ numeric_float8 _null_ _null_ _null_ ));
+DATA(insert OID = 1746 ( float8 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "1700" _null_ _null_ _null_ _null_ numeric_float8 _null_ _null_ _null_ ));
DESCR("(internal)");
DATA(insert OID = 1973 ( div PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 1700" _null_ _null_ _null_ _null_ numeric_div_trunc _null_ _null_ _null_ ));
DESCR("trunc(x/y)");
DATA(insert OID = 1980 ( numeric_div_trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 1700" _null_ _null_ _null_ _null_ numeric_div_trunc _null_ _null_ _null_ ));
DESCR("trunc(x/y)");
-DATA(insert OID = 2170 ( width_bucket PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "1700 1700 1700 23" _null_ _null_ _null_ _null_ width_bucket_numeric _null_ _null_ _null_ ));
+DATA(insert OID = 2170 ( width_bucket PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "1700 1700 1700 23" _null_ _null_ _null_ _null_ width_bucket_numeric _null_ _null_ _null_ ));
DESCR("bucket number of operand in equidepth histogram");
DATA(insert OID = 1747 ( time_pl_interval PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1083 "1083 1186" _null_ _null_ _null_ _null_ time_pl_interval _null_ _null_ _null_ ));
DESCR("smaller of two numbers");
DATA(insert OID = 1767 ( numeric_larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1700 "1700 1700" _null_ _null_ _null_ _null_ numeric_larger _null_ _null_ _null_ ));
DESCR("larger of two numbers");
-DATA(insert OID = 1769 ( numeric_cmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1700 1700" _null_ _null_ _null_ _null_ numeric_cmp _null_ _null_ _null_ ));
+DATA(insert OID = 1769 ( numeric_cmp PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "1700 1700" _null_ _null_ _null_ _null_ numeric_cmp _null_ _null_ _null_ ));
DESCR("compare two numbers");
DATA(insert OID = 1771 ( numeric_uminus PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ numeric_uminus _null_ _null_ _null_ ));
DESCR("negate");
DESCR("length in bits");
/* Selectivity estimators for LIKE and related operators */
-DATA(insert OID = 1814 ( iclikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ iclikesel _null_ _null_ _null_ ));
+DATA(insert OID = 1814 ( iclikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ iclikesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of ILIKE");
-DATA(insert OID = 1815 ( icnlikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icnlikesel _null_ _null_ _null_ ));
+DATA(insert OID = 1815 ( icnlikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icnlikesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of NOT ILIKE");
DATA(insert OID = 1816 ( iclikejoinsel PGNSP PGUID 12 1 0 0 f f f t f s 5 0 701 "2281 26 2281 21 2281" _null_ _null_ _null_ _null_ iclikejoinsel _null_ _null_ _null_ ));
DESCR("join selectivity of ILIKE");
DATA(insert OID = 1817 ( icnlikejoinsel PGNSP PGUID 12 1 0 0 f f f t f s 5 0 701 "2281 26 2281 21 2281" _null_ _null_ _null_ _null_ icnlikejoinsel _null_ _null_ _null_ ));
DESCR("join selectivity of NOT ILIKE");
-DATA(insert OID = 1818 ( regexeqsel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ regexeqsel _null_ _null_ _null_ ));
+DATA(insert OID = 1818 ( regexeqsel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ regexeqsel _null_ _null_ _null_ ));
DESCR("restriction selectivity of regex match");
-DATA(insert OID = 1819 ( likesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ likesel _null_ _null_ _null_ ));
+DATA(insert OID = 1819 ( likesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ likesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of LIKE");
-DATA(insert OID = 1820 ( icregexeqsel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icregexeqsel _null_ _null_ _null_ ));
+DATA(insert OID = 1820 ( icregexeqsel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icregexeqsel _null_ _null_ _null_ ));
DESCR("restriction selectivity of case-insensitive regex match");
-DATA(insert OID = 1821 ( regexnesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ regexnesel _null_ _null_ _null_ ));
+DATA(insert OID = 1821 ( regexnesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ regexnesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of regex non-match");
-DATA(insert OID = 1822 ( nlikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ nlikesel _null_ _null_ _null_ ));
+DATA(insert OID = 1822 ( nlikesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ nlikesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of NOT LIKE");
-DATA(insert OID = 1823 ( icregexnesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icregexnesel _null_ _null_ _null_ ));
+DATA(insert OID = 1823 ( icregexnesel PGNSP PGUID 12 1 0 0 f f f t f s 4 0 701 "2281 26 2281 23" _null_ _null_ _null_ _null_ icregexnesel _null_ _null_ _null_ ));
DESCR("restriction selectivity of case-insensitive regex non-match");
DATA(insert OID = 1824 ( regexeqjoinsel PGNSP PGUID 12 1 0 0 f f f t f s 5 0 701 "2281 26 2281 21 2281" _null_ _null_ _null_ _null_ regexeqjoinsel _null_ _null_ _null_ ));
DESCR("join selectivity of regex match");
DESCR("aggregate transition function");
DATA(insert OID = 2746 ( int8_avg_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1231 "1231 20" _null_ _null_ _null_ _null_ int8_avg_accum _null_ _null_ _null_ ));
DESCR("aggregate transition function");
-DATA(insert OID = 1837 ( numeric_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_avg _null_ _null_ _null_ ));
+DATA(insert OID = 1837 ( numeric_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_avg _null_ _null_ _null_ ));
DESCR("AVG aggregate final function");
-DATA(insert OID = 2514 ( numeric_var_pop PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_var_pop _null_ _null_ _null_ ));
+DATA(insert OID = 2514 ( numeric_var_pop PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_var_pop _null_ _null_ _null_ ));
DESCR("VAR_POP aggregate final function");
-DATA(insert OID = 1838 ( numeric_var_samp PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_var_samp _null_ _null_ _null_ ));
+DATA(insert OID = 1838 ( numeric_var_samp PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_var_samp _null_ _null_ _null_ ));
DESCR("VAR_SAMP aggregate final function");
DATA(insert OID = 2596 ( numeric_stddev_pop PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1231" _null_ _null_ _null_ _null_ numeric_stddev_pop _null_ _null_ _null_ ));
DESCR("STDDEV_POP aggregate final function");
DESCR("SUM(int8) transition function");
DATA(insert OID = 1843 ( interval_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1187 "1187 1186" _null_ _null_ _null_ _null_ interval_accum _null_ _null_ _null_ ));
DESCR("aggregate transition function");
-DATA(insert OID = 1844 ( interval_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1187" _null_ _null_ _null_ _null_ interval_avg _null_ _null_ _null_ ));
+DATA(insert OID = 1844 ( interval_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1186 "1187" _null_ _null_ _null_ _null_ interval_avg _null_ _null_ _null_ ));
DESCR("AVG aggregate final function");
DATA(insert OID = 1962 ( int2_avg_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1016 "1016 21" _null_ _null_ _null_ _null_ int2_avg_accum _null_ _null_ _null_ ));
DESCR("AVG(int2) transition function");
DATA(insert OID = 1963 ( int4_avg_accum PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1016 "1016 23" _null_ _null_ _null_ _null_ int4_avg_accum _null_ _null_ _null_ ));
DESCR("AVG(int4) transition function");
-DATA(insert OID = 1964 ( int8_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1016" _null_ _null_ _null_ _null_ int8_avg _null_ _null_ _null_ ));
+DATA(insert OID = 1964 ( int8_avg PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1700 "1016" _null_ _null_ _null_ _null_ int8_avg _null_ _null_ _null_ ));
DESCR("AVG(int) aggregate final function");
DATA(insert OID = 2805 ( int8inc_float8_float8 PGNSP PGUID 12 1 0 0 f f f t f i 3 0 20 "20 701 701" _null_ _null_ _null_ _null_ int8inc_float8_float8 _null_ _null_ _null_ ));
DESCR("REGR_COUNT(double, double) transition function");
DESCR("bitwise or");
DATA(insert OID = 1894 ( int2xor PGNSP PGUID 12 1 0 0 f f f t f i 2 0 21 "21 21" _null_ _null_ _null_ _null_ int2xor _null_ _null_ _null_ ));
DESCR("bitwise xor");
-DATA(insert OID = 1895 ( int2not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2not _null_ _null_ _null_ ));
+DATA(insert OID = 1895 ( int2not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "21" _null_ _null_ _null_ _null_ int2not _null_ _null_ _null_ ));
DESCR("bitwise not");
DATA(insert OID = 1896 ( int2shl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 21 "21 23" _null_ _null_ _null_ _null_ int2shl _null_ _null_ _null_ ));
DESCR("bitwise shift left");
DESCR("bitwise or");
DATA(insert OID = 1900 ( int4xor PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "23 23" _null_ _null_ _null_ _null_ int4xor _null_ _null_ _null_ ));
DESCR("bitwise xor");
-DATA(insert OID = 1901 ( int4not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4not _null_ _null_ _null_ ));
+DATA(insert OID = 1901 ( int4not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "23" _null_ _null_ _null_ _null_ int4not _null_ _null_ _null_ ));
DESCR("bitwise not");
DATA(insert OID = 1902 ( int4shl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "23 23" _null_ _null_ _null_ _null_ int4shl _null_ _null_ _null_ ));
DESCR("bitwise shift left");
DESCR("bitwise or");
DATA(insert OID = 1906 ( int8xor PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 20" _null_ _null_ _null_ _null_ int8xor _null_ _null_ _null_ ));
DESCR("bitwise xor");
-DATA(insert OID = 1907 ( int8not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8not _null_ _null_ _null_ ));
+DATA(insert OID = 1907 ( int8not PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "20" _null_ _null_ _null_ _null_ int8not _null_ _null_ _null_ ));
DESCR("bitwise not");
DATA(insert OID = 1908 ( int8shl PGNSP PGUID 12 1 0 0 f f f t f i 2 0 20 "20 23" _null_ _null_ _null_ _null_ int8shl _null_ _null_ _null_ ));
DESCR("bitwise shift left");
DESCR("statistics: current query of backend");
DATA(insert OID = 2853 ( pg_stat_get_backend_waiting PGNSP PGUID 12 1 0 0 f f f t f s 1 0 16 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_waiting _null_ _null_ _null_ ));
DESCR("statistics: is backend currently waiting for a lock");
-DATA(insert OID = 2094 ( pg_stat_get_backend_activity_start PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_activity_start _null_ _null_ _null_ ));
+DATA(insert OID = 2094 ( pg_stat_get_backend_activity_start PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_activity_start _null_ _null_ _null_ ));
DESCR("statistics: start time for current query of backend");
-DATA(insert OID = 2857 ( pg_stat_get_backend_xact_start PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_xact_start _null_ _null_ _null_ ));
+DATA(insert OID = 2857 ( pg_stat_get_backend_xact_start PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_xact_start _null_ _null_ _null_ ));
DESCR("statistics: start time for backend's current transaction");
DATA(insert OID = 1391 ( pg_stat_get_backend_start PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1184 "23" _null_ _null_ _null_ _null_ pg_stat_get_backend_start _null_ _null_ _null_ ));
DESCR("statistics: start time for current backend session");
DATA(insert OID = 2274 ( pg_stat_reset PGNSP PGUID 12 1 0 0 f f f f f v 0 0 2278 "" _null_ _null_ _null_ _null_ pg_stat_reset _null_ _null_ _null_ ));
DESCR("statistics: reset collected statistics for current database");
-DATA(insert OID = 1946 ( encode PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "17 25" _null_ _null_ _null_ _null_ binary_encode _null_ _null_ _null_ ));
+DATA(insert OID = 1946 ( encode PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "17 25" _null_ _null_ _null_ _null_ binary_encode _null_ _null_ _null_ ));
DESCR("convert bytea value into some ascii-only text string");
-DATA(insert OID = 1947 ( decode PGNSP PGUID 12 1 0 0 f f f t f i 2 0 17 "25 25" _null_ _null_ _null_ _null_ binary_decode _null_ _null_ _null_ ));
+DATA(insert OID = 1947 ( decode PGNSP PGUID 12 1 0 0 f f f t f i 2 0 17 "25 25" _null_ _null_ _null_ _null_ binary_decode _null_ _null_ _null_ ));
DESCR("convert ascii-encoded text string into bytea value");
DATA(insert OID = 1948 ( byteaeq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "17 17" _null_ _null_ _null_ _null_ byteaeq _null_ _null_ _null_ ));
DESCR("does not match LIKE expression");
DATA(insert OID = 2009 ( like_escape PGNSP PGUID 12 1 0 0 f f f t f i 2 0 17 "17 17" _null_ _null_ _null_ _null_ like_escape_bytea _null_ _null_ _null_ ));
DESCR("convert LIKE pattern to use backslash escapes");
-DATA(insert OID = 2010 ( length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "17" _null_ _null_ _null_ _null_ byteaoctetlen _null_ _null_ _null_ ));
+DATA(insert OID = 2010 ( length PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "17" _null_ _null_ _null_ _null_ byteaoctetlen _null_ _null_ _null_ ));
DESCR("octet length");
DATA(insert OID = 2011 ( byteacat PGNSP PGUID 12 1 0 0 f f f t f i 2 0 17 "17 17" _null_ _null_ _null_ _null_ byteacat _null_ _null_ _null_ ));
DESCR("concatenate");
DATA(insert OID = 2019 ( time PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1083 "1184" _null_ _null_ _null_ _null_ timestamptz_time _null_ _null_ _null_ ));
DESCR("convert timestamptz to time");
-DATA(insert OID = 2020 ( date_trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "25 1114" _null_ _null_ _null_ _null_ timestamp_trunc _null_ _null_ _null_ ));
+DATA(insert OID = 2020 ( date_trunc PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "25 1114" _null_ _null_ _null_ _null_ timestamp_trunc _null_ _null_ _null_ ));
DESCR("truncate timestamp to specified units");
DATA(insert OID = 2021 ( date_part PGNSP PGUID 12 1 0 0 f f f t f i 2 0 701 "25 1114" _null_ _null_ _null_ _null_ timestamp_part _null_ _null_ _null_ ));
DESCR("extract field from timestamp");
-DATA(insert OID = 2023 ( timestamp PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1114 "702" _null_ _null_ _null_ _null_ abstime_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2023 ( timestamp PGNSP PGUID 12 1 0 0 f f f t f s 1 0 1114 "702" _null_ _null_ _null_ _null_ abstime_timestamp _null_ _null_ _null_ ));
DESCR("convert abstime to timestamp");
DATA(insert OID = 2024 ( timestamp PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1114 "1082" _null_ _null_ _null_ _null_ date_timestamp _null_ _null_ _null_ ));
DESCR("convert date to timestamp");
DESCR("smaller of two");
DATA(insert OID = 2036 ( timestamp_larger PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "1114 1114" _null_ _null_ _null_ _null_ timestamp_larger _null_ _null_ _null_ ));
DESCR("larger of two");
-DATA(insert OID = 2037 ( timezone PGNSP PGUID 12 1 0 0 f f f t f v 2 0 1266 "25 1266" _null_ _null_ _null_ _null_ timetz_zone _null_ _null_ _null_ ));
+DATA(insert OID = 2037 ( timezone PGNSP PGUID 12 1 0 0 f f f t f v 2 0 1266 "25 1266" _null_ _null_ _null_ _null_ timetz_zone _null_ _null_ _null_ ));
DESCR("adjust time with time zone to new zone");
DATA(insert OID = 2038 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1266 "1186 1266" _null_ _null_ _null_ _null_ timetz_izone _null_ _null_ _null_ ));
DESCR("adjust time with time zone to new zone");
DESCR("finite timestamp?");
DATA(insert OID = 2049 ( to_char PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "1114 25" _null_ _null_ _null_ _null_ timestamp_to_char _null_ _null_ _null_ ));
DESCR("format timestamp to text");
-DATA(insert OID = 2052 ( timestamp_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_eq _null_ _null_ _null_ ));
+DATA(insert OID = 2052 ( timestamp_eq PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_eq _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 2053 ( timestamp_ne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_ne _null_ _null_ _null_ ));
+DATA(insert OID = 2053 ( timestamp_ne PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_ne _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 2054 ( timestamp_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_lt _null_ _null_ _null_ ));
+DATA(insert OID = 2054 ( timestamp_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_lt _null_ _null_ _null_ ));
DESCR("less-than");
-DATA(insert OID = 2055 ( timestamp_le PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_le _null_ _null_ _null_ ));
+DATA(insert OID = 2055 ( timestamp_le PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_le _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
-DATA(insert OID = 2056 ( timestamp_ge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_ge _null_ _null_ _null_ ));
+DATA(insert OID = 2056 ( timestamp_ge PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_ge _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 2057 ( timestamp_gt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_gt _null_ _null_ _null_ ));
+DATA(insert OID = 2057 ( timestamp_gt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "1114 1114" _null_ _null_ _null_ _null_ timestamp_gt _null_ _null_ _null_ ));
DESCR("greater-than");
DATA(insert OID = 2058 ( age PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1186 "1114 1114" _null_ _null_ _null_ _null_ timestamp_age _null_ _null_ _null_ ));
DESCR("date difference preserving months and years");
DATA(insert OID = 2059 ( age PGNSP PGUID 14 1 0 0 f f f t f s 1 0 1186 "1114" _null_ _null_ _null_ _null_ "select pg_catalog.age(cast(current_date as timestamp without time zone), $1)" _null_ _null_ _null_ ));
DESCR("date difference from today preserving months and years");
-DATA(insert OID = 2069 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "25 1114" _null_ _null_ _null_ _null_ timestamp_zone _null_ _null_ _null_ ));
+DATA(insert OID = 2069 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "25 1114" _null_ _null_ _null_ _null_ timestamp_zone _null_ _null_ _null_ ));
DESCR("adjust timestamp to new time zone");
DATA(insert OID = 2070 ( timezone PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1184 "1186 1114" _null_ _null_ _null_ _null_ timestamp_izone _null_ _null_ _null_ ));
DESCR("adjust timestamp to new time zone");
DATA(insert OID = 2072 ( date_mi_interval PGNSP PGUID 12 1 0 0 f f f t f i 2 0 1114 "1082 1186" _null_ _null_ _null_ _null_ date_mi_interval _null_ _null_ _null_ ));
DESCR("subtract");
-DATA(insert OID = 2073 ( substring PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ textregexsubstr _null_ _null_ _null_ ));
+DATA(insert OID = 2073 ( substring PGNSP PGUID 12 1 0 0 f f f t f i 2 0 25 "25 25" _null_ _null_ _null_ _null_ textregexsubstr _null_ _null_ _null_ ));
DESCR("extracts text matching regular expression");
DATA(insert OID = 2074 ( substring PGNSP PGUID 14 1 0 0 f f f t f i 3 0 25 "25 25 25" _null_ _null_ _null_ _null_ "select pg_catalog.substring($1, pg_catalog.similar_escape($2, $3))" _null_ _null_ _null_ ));
DESCR("extracts text matching SQL99 regular expression");
/* Aggregates (moved here from pg_aggregate for 7.3) */
-DATA(insert OID = 2100 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2100 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as numeric of all bigint values");
-DATA(insert OID = 2101 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2101 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as numeric of all integer values");
-DATA(insert OID = 2102 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2102 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as numeric of all smallint values");
DATA(insert OID = 2103 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as numeric of all numeric values");
-DATA(insert OID = 2104 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2104 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as float8 of all float4 values");
-DATA(insert OID = 2105 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2105 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as float8 of all float8 values");
DATA(insert OID = 2106 ( avg PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("the average (arithmetic mean) as interval of all interval values");
-DATA(insert OID = 2107 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2107 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as numeric across all bigint input values");
DATA(insert OID = 2108 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 20 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as bigint across all integer input values");
DATA(insert OID = 2109 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 20 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as bigint across all smallint input values");
-DATA(insert OID = 2110 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2110 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as float4 across all float4 input values");
-DATA(insert OID = 2111 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2111 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as float8 across all float8 input values");
-DATA(insert OID = 2112 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2112 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as money across all money input values");
DATA(insert OID = 2113 ( sum PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1186 "1186" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum as interval across all interval input values");
DESCR("maximum value of all smallint input values");
DATA(insert OID = 2118 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 26 "26" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all oid input values");
-DATA(insert OID = 2119 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2119 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all float4 input values");
-DATA(insert OID = 2120 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2120 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all float8 input values");
-DATA(insert OID = 2121 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 702 "702" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2121 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 702 "702" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all abstime input values");
DATA(insert OID = 2122 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1082 "1082" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all date input values");
DESCR("maximum value of all time input values");
DATA(insert OID = 2124 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1266 "1266" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all time with time zone input values");
-DATA(insert OID = 2125 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2125 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all money input values");
DATA(insert OID = 2126 ( max PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1114 "1114" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("maximum value of all timestamp input values");
DESCR("minimum value of all smallint input values");
DATA(insert OID = 2134 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 26 "26" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all oid input values");
-DATA(insert OID = 2135 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2135 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 700 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all float4 input values");
-DATA(insert OID = 2136 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2136 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all float8 input values");
-DATA(insert OID = 2137 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 702 "702" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2137 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 702 "702" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all abstime input values");
DATA(insert OID = 2138 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1082 "1082" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all date input values");
DESCR("minimum value of all time input values");
DATA(insert OID = 2140 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1266 "1266" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all time with time zone input values");
-DATA(insert OID = 2141 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2141 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 790 "790" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all money input values");
DATA(insert OID = 2142 ( min PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1114 "1114" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("minimum value of all timestamp input values");
DESCR("minimum value of all tid input values");
/* count has two forms: count(any) and count(*) */
-DATA(insert OID = 2147 ( count PGNSP PGUID 12 1 0 0 t f f f f i 1 0 20 "2276" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2147 ( count PGNSP PGUID 12 1 0 0 t f f f f i 1 0 20 "2276" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("number of input rows for which the input expression is not null");
-DATA(insert OID = 2803 ( count PGNSP PGUID 12 1 0 0 t f f f f i 0 0 20 "" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2803 ( count PGNSP PGUID 12 1 0 0 t f f f f i 0 0 20 "" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("number of input rows");
-DATA(insert OID = 2718 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2718 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of bigint input values (square of the population standard deviation)");
-DATA(insert OID = 2719 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2719 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of integer input values (square of the population standard deviation)");
-DATA(insert OID = 2720 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2720 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of smallint input values (square of the population standard deviation)");
-DATA(insert OID = 2721 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2721 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of float4 input values (square of the population standard deviation)");
-DATA(insert OID = 2722 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2722 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of float8 input values (square of the population standard deviation)");
DATA(insert OID = 2723 ( var_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population variance of numeric input values (square of the population standard deviation)");
-DATA(insert OID = 2641 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2641 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of bigint input values (square of the sample standard deviation)");
-DATA(insert OID = 2642 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2642 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of integer input values (square of the sample standard deviation)");
-DATA(insert OID = 2643 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2643 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of smallint input values (square of the sample standard deviation)");
-DATA(insert OID = 2644 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2644 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of float4 input values (square of the sample standard deviation)");
-DATA(insert OID = 2645 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2645 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of float8 input values (square of the sample standard deviation)");
DATA(insert OID = 2646 ( var_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample variance of numeric input values (square of the sample standard deviation)");
-DATA(insert OID = 2148 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2148 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
-DATA(insert OID = 2149 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2149 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
-DATA(insert OID = 2150 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2150 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
-DATA(insert OID = 2151 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2151 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
-DATA(insert OID = 2152 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2152 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
DATA(insert OID = 2153 ( variance PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for var_samp");
-DATA(insert OID = 2724 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2724 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of bigint input values");
-DATA(insert OID = 2725 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2725 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of integer input values");
-DATA(insert OID = 2726 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2726 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of smallint input values");
-DATA(insert OID = 2727 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2727 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of float4 input values");
-DATA(insert OID = 2728 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2728 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of float8 input values");
DATA(insert OID = 2729 ( stddev_pop PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population standard deviation of numeric input values");
-DATA(insert OID = 2712 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2712 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of bigint input values");
-DATA(insert OID = 2713 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2713 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of integer input values");
-DATA(insert OID = 2714 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2714 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of smallint input values");
-DATA(insert OID = 2715 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2715 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of float4 input values");
-DATA(insert OID = 2716 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2716 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of float8 input values");
DATA(insert OID = 2717 ( stddev_samp PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample standard deviation of numeric input values");
-DATA(insert OID = 2154 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2154 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "20" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
-DATA(insert OID = 2155 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2155 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "23" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
-DATA(insert OID = 2156 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2156 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "21" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
-DATA(insert OID = 2157 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2157 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
-DATA(insert OID = 2158 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2158 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 701 "701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
DATA(insert OID = 2159 ( stddev PGNSP PGUID 12 1 0 0 t f f f f i 1 0 1700 "1700" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("historical alias for stddev_samp");
DATA(insert OID = 2818 ( regr_count PGNSP PGUID 12 1 0 0 t f f f f i 2 0 20 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("number of input rows in which both expressions are nonnull");
-DATA(insert OID = 2819 ( regr_sxx PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2819 ( regr_sxx PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum of squares of the independent variable (sum(X^2) - sum(X)^2/N)");
-DATA(insert OID = 2820 ( regr_syy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2820 ( regr_syy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum of squares of the dependent variable (sum(Y^2) - sum(Y)^2/N)");
-DATA(insert OID = 2821 ( regr_sxy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2821 ( regr_sxy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sum of products of independent times dependent variable (sum(X*Y) - sum(X) * sum(Y)/N)");
-DATA(insert OID = 2822 ( regr_avgx PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2822 ( regr_avgx PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("average of the independent variable (sum(X)/N)");
-DATA(insert OID = 2823 ( regr_avgy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2823 ( regr_avgy PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("average of the dependent variable (sum(Y)/N)");
-DATA(insert OID = 2824 ( regr_r2 PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2824 ( regr_r2 PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("square of the correlation coefficient");
-DATA(insert OID = 2825 ( regr_slope PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2825 ( regr_slope PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("slope of the least-squares-fit linear equation determined by the (X, Y) pairs");
-DATA(insert OID = 2826 ( regr_intercept PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2826 ( regr_intercept PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("y-intercept of the least-squares-fit linear equation determined by the (X, Y) pairs");
-DATA(insert OID = 2827 ( covar_pop PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2827 ( covar_pop PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("population covariance");
-DATA(insert OID = 2828 ( covar_samp PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2828 ( covar_samp PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("sample covariance");
-DATA(insert OID = 2829 ( corr PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
+DATA(insert OID = 2829 ( corr PGNSP PGUID 12 1 0 0 t f f f f i 2 0 701 "701 701" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("correlation coefficient");
DATA(insert OID = 2160 ( text_pattern_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "25 25" _null_ _null_ _null_ _null_ text_pattern_lt _null_ _null_ _null_ ));
DATA(insert OID = 2710 ( pg_has_role PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "26 25" _null_ _null_ _null_ _null_ pg_has_role_id _null_ _null_ _null_ ));
DESCR("current user privilege on role by role oid");
-DATA(insert OID = 1269 ( pg_column_size PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "2276" _null_ _null_ _null_ _null_ pg_column_size _null_ _null_ _null_ ));
+DATA(insert OID = 1269 ( pg_column_size PGNSP PGUID 12 1 0 0 f f f t f s 1 0 23 "2276" _null_ _null_ _null_ _null_ pg_column_size _null_ _null_ _null_ ));
DESCR("bytes required to store the value, perhaps with compression");
DATA(insert OID = 2322 ( pg_tablespace_size PGNSP PGUID 12 1 0 0 f f f t f v 1 0 20 "26" _null_ _null_ _null_ _null_ pg_tablespace_size_oid _null_ _null_ _null_ ));
DESCR("total disk space usage for the specified tablespace");
DESCR("I/O");
/* cryptographic */
-DATA(insert OID = 2311 ( md5 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ md5_text _null_ _null_ _null_ ));
+DATA(insert OID = 2311 ( md5 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "25" _null_ _null_ _null_ _null_ md5_text _null_ _null_ _null_ ));
DESCR("calculates md5 hash");
-DATA(insert OID = 2321 ( md5 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "17" _null_ _null_ _null_ _null_ md5_bytea _null_ _null_ _null_ ));
+DATA(insert OID = 2321 ( md5 PGNSP PGUID 12 1 0 0 f f f t f i 1 0 25 "17" _null_ _null_ _null_ _null_ md5_bytea _null_ _null_ _null_ ));
DESCR("calculates md5 hash");
/* crosstype operations for date vs. timestamp and timestamptz */
DESCR("less-equal-greater");
/* crosstype operations for timestamp vs. timestamptz */
-DATA(insert OID = 2520 ( timestamp_lt_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_lt_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2520 ( timestamp_lt_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_lt_timestamptz _null_ _null_ _null_ ));
DESCR("less-than");
-DATA(insert OID = 2521 ( timestamp_le_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_le_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2521 ( timestamp_le_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_le_timestamptz _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
-DATA(insert OID = 2522 ( timestamp_eq_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_eq_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2522 ( timestamp_eq_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_eq_timestamptz _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 2523 ( timestamp_gt_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_gt_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2523 ( timestamp_gt_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_gt_timestamptz _null_ _null_ _null_ ));
DESCR("greater-than");
-DATA(insert OID = 2524 ( timestamp_ge_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_ge_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2524 ( timestamp_ge_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_ge_timestamptz _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 2525 ( timestamp_ne_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_ne_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2525 ( timestamp_ne_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1114 1184" _null_ _null_ _null_ _null_ timestamp_ne_timestamptz _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 2526 ( timestamp_cmp_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 23 "1114 1184" _null_ _null_ _null_ _null_ timestamp_cmp_timestamptz _null_ _null_ _null_ ));
+DATA(insert OID = 2526 ( timestamp_cmp_timestamptz PGNSP PGUID 12 1 0 0 f f f t f s 2 0 23 "1114 1184" _null_ _null_ _null_ _null_ timestamp_cmp_timestamptz _null_ _null_ _null_ ));
DESCR("less-equal-greater");
-DATA(insert OID = 2527 ( timestamptz_lt_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_lt_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2527 ( timestamptz_lt_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_lt_timestamp _null_ _null_ _null_ ));
DESCR("less-than");
-DATA(insert OID = 2528 ( timestamptz_le_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_le_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2528 ( timestamptz_le_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_le_timestamp _null_ _null_ _null_ ));
DESCR("less-than-or-equal");
-DATA(insert OID = 2529 ( timestamptz_eq_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_eq_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2529 ( timestamptz_eq_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_eq_timestamp _null_ _null_ _null_ ));
DESCR("equal");
-DATA(insert OID = 2530 ( timestamptz_gt_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_gt_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2530 ( timestamptz_gt_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_gt_timestamp _null_ _null_ _null_ ));
DESCR("greater-than");
-DATA(insert OID = 2531 ( timestamptz_ge_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_ge_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2531 ( timestamptz_ge_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_ge_timestamp _null_ _null_ _null_ ));
DESCR("greater-than-or-equal");
-DATA(insert OID = 2532 ( timestamptz_ne_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_ne_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2532 ( timestamptz_ne_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 16 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_ne_timestamp _null_ _null_ _null_ ));
DESCR("not equal");
-DATA(insert OID = 2533 ( timestamptz_cmp_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 23 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_cmp_timestamp _null_ _null_ _null_ ));
+DATA(insert OID = 2533 ( timestamptz_cmp_timestamp PGNSP PGUID 12 1 0 0 f f f t f s 2 0 23 "1184 1114" _null_ _null_ _null_ _null_ timestamptz_cmp_timestamp _null_ _null_ _null_ ));
DESCR("less-equal-greater");
DESCR("I/O");
DATA(insert OID = 2404 ( int2recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 21 "2281" _null_ _null_ _null_ _null_ int2recv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2405 ( int2send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "21" _null_ _null_ _null_ _null_ int2send _null_ _null_ _null_ ));
+DATA(insert OID = 2405 ( int2send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "21" _null_ _null_ _null_ _null_ int2send _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2406 ( int4recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 23 "2281" _null_ _null_ _null_ _null_ int4recv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2407 ( int4send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "23" _null_ _null_ _null_ _null_ int4send _null_ _null_ _null_ ));
+DATA(insert OID = 2407 ( int4send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "23" _null_ _null_ _null_ _null_ int4send _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2408 ( int8recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 20 "2281" _null_ _null_ _null_ _null_ int8recv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2409 ( int8send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "20" _null_ _null_ _null_ _null_ int8send _null_ _null_ _null_ ));
+DATA(insert OID = 2409 ( int8send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "20" _null_ _null_ _null_ _null_ int8send _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2410 ( int2vectorrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 22 "2281" _null_ _null_ _null_ _null_ int2vectorrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2411 ( int2vectorsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "22" _null_ _null_ _null_ _null_ int2vectorsend _null_ _null_ _null_ ));
+DATA(insert OID = 2411 ( int2vectorsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "22" _null_ _null_ _null_ _null_ int2vectorsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2412 ( bytearecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2281" _null_ _null_ _null_ _null_ bytearecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2413 ( byteasend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "17" _null_ _null_ _null_ _null_ byteasend _null_ _null_ _null_ ));
+DATA(insert OID = 2413 ( byteasend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "17" _null_ _null_ _null_ _null_ byteasend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2414 ( textrecv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 25 "2281" _null_ _null_ _null_ _null_ textrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2415 ( textsend PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "25" _null_ _null_ _null_ _null_ textsend _null_ _null_ _null_ ));
+DATA(insert OID = 2415 ( textsend PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "25" _null_ _null_ _null_ _null_ textsend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2416 ( unknownrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 705 "2281" _null_ _null_ _null_ _null_ unknownrecv _null_ _null_ _null_ ));
+DATA(insert OID = 2416 ( unknownrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 705 "2281" _null_ _null_ _null_ _null_ unknownrecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2417 ( unknownsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "705" _null_ _null_ _null_ _null_ unknownsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2418 ( oidrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 26 "2281" _null_ _null_ _null_ _null_ oidrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2419 ( oidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "26" _null_ _null_ _null_ _null_ oidsend _null_ _null_ _null_ ));
+DATA(insert OID = 2419 ( oidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "26" _null_ _null_ _null_ _null_ oidsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2420 ( oidvectorrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 30 "2281" _null_ _null_ _null_ _null_ oidvectorrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2421 ( oidvectorsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "30" _null_ _null_ _null_ _null_ oidvectorsend _null_ _null_ _null_ ));
+DATA(insert OID = 2421 ( oidvectorsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "30" _null_ _null_ _null_ _null_ oidvectorsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2422 ( namerecv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 19 "2281" _null_ _null_ _null_ _null_ namerecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2423 ( namesend PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "19" _null_ _null_ _null_ _null_ namesend _null_ _null_ _null_ ));
+DATA(insert OID = 2423 ( namesend PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "19" _null_ _null_ _null_ _null_ namesend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2424 ( float4recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "2281" _null_ _null_ _null_ _null_ float4recv _null_ _null_ _null_ ));
+DATA(insert OID = 2424 ( float4recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 700 "2281" _null_ _null_ _null_ _null_ float4recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2425 ( float4send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "700" _null_ _null_ _null_ _null_ float4send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2426 ( float8recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "2281" _null_ _null_ _null_ _null_ float8recv _null_ _null_ _null_ ));
+DATA(insert OID = 2426 ( float8recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 701 "2281" _null_ _null_ _null_ _null_ float8recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2427 ( float8send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "701" _null_ _null_ _null_ _null_ float8send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2428 ( point_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 600 "2281" _null_ _null_ _null_ _null_ point_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2428 ( point_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 600 "2281" _null_ _null_ _null_ _null_ point_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2429 ( point_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "600" _null_ _null_ _null_ _null_ point_send _null_ _null_ _null_ ));
DESCR("I/O");
DESCR("I/O");
DATA(insert OID = 2434 ( charrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 18 "2281" _null_ _null_ _null_ _null_ charrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2435 ( charsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "18" _null_ _null_ _null_ _null_ charsend _null_ _null_ _null_ ));
+DATA(insert OID = 2435 ( charsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "18" _null_ _null_ _null_ _null_ charsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2436 ( boolrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 16 "2281" _null_ _null_ _null_ _null_ boolrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2437 ( boolsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "16" _null_ _null_ _null_ _null_ boolsend _null_ _null_ _null_ ));
+DATA(insert OID = 2437 ( boolsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "16" _null_ _null_ _null_ _null_ boolsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2438 ( tidrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 27 "2281" _null_ _null_ _null_ _null_ tidrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2439 ( tidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "27" _null_ _null_ _null_ _null_ tidsend _null_ _null_ _null_ ));
+DATA(insert OID = 2439 ( tidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "27" _null_ _null_ _null_ _null_ tidsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2440 ( xidrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 28 "2281" _null_ _null_ _null_ _null_ xidrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2441 ( xidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "28" _null_ _null_ _null_ _null_ xidsend _null_ _null_ _null_ ));
+DATA(insert OID = 2441 ( xidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "28" _null_ _null_ _null_ _null_ xidsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2442 ( cidrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 29 "2281" _null_ _null_ _null_ _null_ cidrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2443 ( cidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "29" _null_ _null_ _null_ _null_ cidsend _null_ _null_ _null_ ));
+DATA(insert OID = 2443 ( cidsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "29" _null_ _null_ _null_ _null_ cidsend _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2444 ( regprocrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 24 "2281" _null_ _null_ _null_ _null_ regprocrecv _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2445 ( regprocsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "24" _null_ _null_ _null_ _null_ regprocsend _null_ _null_ _null_ ));
+DATA(insert OID = 2445 ( regprocsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "24" _null_ _null_ _null_ _null_ regprocsend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2446 ( regprocedurerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2202 "2281" _null_ _null_ _null_ _null_ regprocedurerecv _null_ _null_ _null_ ));
+DATA(insert OID = 2446 ( regprocedurerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2202 "2281" _null_ _null_ _null_ _null_ regprocedurerecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2447 ( regproceduresend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2202" _null_ _null_ _null_ _null_ regproceduresend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2448 ( regoperrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2203 "2281" _null_ _null_ _null_ _null_ regoperrecv _null_ _null_ _null_ ));
+DATA(insert OID = 2448 ( regoperrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2203 "2281" _null_ _null_ _null_ _null_ regoperrecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2449 ( regopersend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2203" _null_ _null_ _null_ _null_ regopersend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2450 ( regoperatorrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2204 "2281" _null_ _null_ _null_ _null_ regoperatorrecv _null_ _null_ _null_ ));
+DATA(insert OID = 2450 ( regoperatorrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2204 "2281" _null_ _null_ _null_ _null_ regoperatorrecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2451 ( regoperatorsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2204" _null_ _null_ _null_ _null_ regoperatorsend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2452 ( regclassrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2205 "2281" _null_ _null_ _null_ _null_ regclassrecv _null_ _null_ _null_ ));
+DATA(insert OID = 2452 ( regclassrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2205 "2281" _null_ _null_ _null_ _null_ regclassrecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2453 ( regclasssend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2205" _null_ _null_ _null_ _null_ regclasssend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2454 ( regtyperecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2206 "2281" _null_ _null_ _null_ _null_ regtyperecv _null_ _null_ _null_ ));
+DATA(insert OID = 2454 ( regtyperecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 2206 "2281" _null_ _null_ _null_ _null_ regtyperecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2455 ( regtypesend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "2206" _null_ _null_ _null_ _null_ regtypesend _null_ _null_ _null_ ));
DESCR("I/O");
DESCR("I/O");
DATA(insert OID = 2461 ( numeric_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "1700" _null_ _null_ _null_ _null_ numeric_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2462 ( abstimerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 702 "2281" _null_ _null_ _null_ _null_ abstimerecv _null_ _null_ _null_ ));
+DATA(insert OID = 2462 ( abstimerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 702 "2281" _null_ _null_ _null_ _null_ abstimerecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2463 ( abstimesend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "702" _null_ _null_ _null_ _null_ abstimesend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2464 ( reltimerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 703 "2281" _null_ _null_ _null_ _null_ reltimerecv _null_ _null_ _null_ ));
+DATA(insert OID = 2464 ( reltimerecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 703 "2281" _null_ _null_ _null_ _null_ reltimerecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2465 ( reltimesend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "703" _null_ _null_ _null_ _null_ reltimesend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2466 ( tintervalrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 704 "2281" _null_ _null_ _null_ _null_ tintervalrecv _null_ _null_ _null_ ));
+DATA(insert OID = 2466 ( tintervalrecv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 704 "2281" _null_ _null_ _null_ _null_ tintervalrecv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2467 ( tintervalsend PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "704" _null_ _null_ _null_ _null_ tintervalsend _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2468 ( date_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1082 "2281" _null_ _null_ _null_ _null_ date_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2468 ( date_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 1082 "2281" _null_ _null_ _null_ _null_ date_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2469 ( date_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "1082" _null_ _null_ _null_ _null_ date_send _null_ _null_ _null_ ));
DESCR("I/O");
DESCR("I/O");
DATA(insert OID = 2479 ( interval_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "1186" _null_ _null_ _null_ _null_ interval_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2480 ( lseg_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 601 "2281" _null_ _null_ _null_ _null_ lseg_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2480 ( lseg_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 601 "2281" _null_ _null_ _null_ _null_ lseg_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2481 ( lseg_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "601" _null_ _null_ _null_ _null_ lseg_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2482 ( path_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 602 "2281" _null_ _null_ _null_ _null_ path_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2482 ( path_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 602 "2281" _null_ _null_ _null_ _null_ path_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2483 ( path_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "602" _null_ _null_ _null_ _null_ path_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2484 ( box_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 603 "2281" _null_ _null_ _null_ _null_ box_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2484 ( box_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 603 "2281" _null_ _null_ _null_ _null_ box_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2485 ( box_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "603" _null_ _null_ _null_ _null_ box_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2486 ( poly_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 604 "2281" _null_ _null_ _null_ _null_ poly_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2486 ( poly_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 604 "2281" _null_ _null_ _null_ _null_ poly_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2487 ( poly_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "604" _null_ _null_ _null_ _null_ poly_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2488 ( line_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 628 "2281" _null_ _null_ _null_ _null_ line_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2488 ( line_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 628 "2281" _null_ _null_ _null_ _null_ line_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2489 ( line_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "628" _null_ _null_ _null_ _null_ line_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2490 ( circle_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 718 "2281" _null_ _null_ _null_ _null_ circle_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2490 ( circle_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 718 "2281" _null_ _null_ _null_ _null_ circle_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2491 ( circle_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "718" _null_ _null_ _null_ _null_ circle_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2492 ( cash_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 790 "2281" _null_ _null_ _null_ _null_ cash_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2492 ( cash_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 790 "2281" _null_ _null_ _null_ _null_ cash_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2493 ( cash_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "790" _null_ _null_ _null_ _null_ cash_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2494 ( macaddr_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 829 "2281" _null_ _null_ _null_ _null_ macaddr_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2494 ( macaddr_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 829 "2281" _null_ _null_ _null_ _null_ macaddr_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2495 ( macaddr_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "829" _null_ _null_ _null_ _null_ macaddr_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2496 ( inet_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 869 "2281" _null_ _null_ _null_ _null_ inet_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2496 ( inet_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 869 "2281" _null_ _null_ _null_ _null_ inet_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2497 ( inet_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "869" _null_ _null_ _null_ _null_ inet_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2498 ( cidr_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 650 "2281" _null_ _null_ _null_ _null_ cidr_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2498 ( cidr_recv PGNSP PGUID 12 1 0 0 f f f t f i 1 0 650 "2281" _null_ _null_ _null_ _null_ cidr_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2499 ( cidr_send PGNSP PGUID 12 1 0 0 f f f t f i 1 0 17 "650" _null_ _null_ _null_ _null_ cidr_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2500 ( cstring_recv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "2281" _null_ _null_ _null_ _null_ cstring_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2500 ( cstring_recv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2275 "2281" _null_ _null_ _null_ _null_ cstring_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2501 ( cstring_send PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "2275" _null_ _null_ _null_ _null_ cstring_send _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 2502 ( anyarray_recv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2277 "2281" _null_ _null_ _null_ _null_ anyarray_recv _null_ _null_ _null_ ));
+DATA(insert OID = 2502 ( anyarray_recv PGNSP PGUID 12 1 0 0 f f f t f s 1 0 2277 "2281" _null_ _null_ _null_ _null_ anyarray_recv _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2503 ( anyarray_send PGNSP PGUID 12 1 0 0 f f f t f s 1 0 17 "2277" _null_ _null_ _null_ _null_ anyarray_send _null_ _null_ _null_ ));
DESCR("I/O");
/* System-view support functions with pretty-print option */
-DATA(insert OID = 2504 ( pg_get_ruledef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_ruledef_ext _null_ _null_ _null_ ));
+DATA(insert OID = 2504 ( pg_get_ruledef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_ruledef_ext _null_ _null_ _null_ ));
DESCR("source text of a rule with pretty-print option");
-DATA(insert OID = 2505 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "25 16" _null_ _null_ _null_ _null_ pg_get_viewdef_name_ext _null_ _null_ _null_ ));
+DATA(insert OID = 2505 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "25 16" _null_ _null_ _null_ _null_ pg_get_viewdef_name_ext _null_ _null_ _null_ ));
DESCR("select statement of a view with pretty-print option");
-DATA(insert OID = 2506 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_viewdef_ext _null_ _null_ _null_ ));
+DATA(insert OID = 2506 ( pg_get_viewdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_viewdef_ext _null_ _null_ _null_ ));
DESCR("select statement of a view with pretty-print option");
DATA(insert OID = 2507 ( pg_get_indexdef PGNSP PGUID 12 1 0 0 f f f t f s 3 0 25 "26 23 16" _null_ _null_ _null_ _null_ pg_get_indexdef_ext _null_ _null_ _null_ ));
DESCR("index description (full create statement or single expression) with pretty-print option");
-DATA(insert OID = 2508 ( pg_get_constraintdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_constraintdef_ext _null_ _null_ _null_ ));
+DATA(insert OID = 2508 ( pg_get_constraintdef PGNSP PGUID 12 1 0 0 f f f t f s 2 0 25 "26 16" _null_ _null_ _null_ _null_ pg_get_constraintdef_ext _null_ _null_ _null_ ));
DESCR("constraint description with pretty-print option");
DATA(insert OID = 2509 ( pg_get_expr PGNSP PGUID 12 1 0 0 f f f t f s 3 0 25 "25 26 16" _null_ _null_ _null_ _null_ pg_get_expr_ext _null_ _null_ _null_ ));
DESCR("deparse an encoded expression with pretty-print option");
DATA(insert OID = 2547 ( interval_pl_timetz PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1266 "1186 1266" _null_ _null_ _null_ _null_ "select $2 + $1" _null_ _null_ _null_ ));
DATA(insert OID = 2548 ( interval_pl_timestamp PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1114 "1186 1114" _null_ _null_ _null_ _null_ "select $2 + $1" _null_ _null_ _null_ ));
DATA(insert OID = 2549 ( interval_pl_timestamptz PGNSP PGUID 14 1 0 0 f f f t f s 2 0 1184 "1186 1184" _null_ _null_ _null_ _null_ "select $2 + $1" _null_ _null_ _null_ ));
-DATA(insert OID = 2550 ( integer_pl_date PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1082 "23 1082" _null_ _null_ _null_ _null_ "select $2 + $1" _null_ _null_ _null_ ));
+DATA(insert OID = 2550 ( integer_pl_date PGNSP PGUID 14 1 0 0 f f f t f i 2 0 1082 "23 1082" _null_ _null_ _null_ _null_ "select $2 + $1" _null_ _null_ _null_ ));
DATA(insert OID = 2556 ( pg_tablespace_databases PGNSP PGUID 12 1 1000 0 f f f t t s 1 0 26 "26" _null_ _null_ _null_ _null_ pg_tablespace_databases _null_ _null_ _null_ ));
DESCR("returns database oids in a tablespace");
DESCR("GiST support");
/* GIN */
-DATA(insert OID = 2731 ( gingetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ gingetbitmap _null_ _null_ _null_ ));
+DATA(insert OID = 2731 ( gingetbitmap PGNSP PGUID 12 1 0 0 f f f t f v 2 0 20 "2281 2281" _null_ _null_ _null_ _null_ gingetbitmap _null_ _null_ _null_ ));
DESCR("gin(internal)");
DATA(insert OID = 2732 ( gininsert PGNSP PGUID 12 1 0 0 f f f t f v 6 0 16 "2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gininsert _null_ _null_ _null_ ));
DESCR("gin(internal)");
DESCR("gin(internal)");
DATA(insert OID = 2734 ( ginrescan PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ ginrescan _null_ _null_ _null_ ));
DESCR("gin(internal)");
-DATA(insert OID = 2735 ( ginendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginendscan _null_ _null_ _null_ ));
+DATA(insert OID = 2735 ( ginendscan PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginendscan _null_ _null_ _null_ ));
DESCR("gin(internal)");
-DATA(insert OID = 2736 ( ginmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginmarkpos _null_ _null_ _null_ ));
+DATA(insert OID = 2736 ( ginmarkpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginmarkpos _null_ _null_ _null_ ));
DESCR("gin(internal)");
-DATA(insert OID = 2737 ( ginrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginrestrpos _null_ _null_ _null_ ));
+DATA(insert OID = 2737 ( ginrestrpos PGNSP PGUID 12 1 0 0 f f f t f v 1 0 2278 "2281" _null_ _null_ _null_ _null_ ginrestrpos _null_ _null_ _null_ ));
DESCR("gin(internal)");
DATA(insert OID = 2738 ( ginbuild PGNSP PGUID 12 1 0 0 f f f t f v 3 0 2281 "2281 2281 2281" _null_ _null_ _null_ _null_ ginbuild _null_ _null_ _null_ ));
DESCR("gin(internal)");
DESCR("gin(internal)");
DATA(insert OID = 2740 ( ginvacuumcleanup PGNSP PGUID 12 1 0 0 f f f t f v 2 0 2281 "2281 2281" _null_ _null_ _null_ _null_ ginvacuumcleanup _null_ _null_ _null_ ));
DESCR("gin(internal)");
-DATA(insert OID = 2741 ( gincostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gincostestimate _null_ _null_ _null_ ));
+DATA(insert OID = 2741 ( gincostestimate PGNSP PGUID 12 1 0 0 f f f t f v 8 0 2278 "2281 2281 2281 2281 2281 2281 2281 2281" _null_ _null_ _null_ _null_ gincostestimate _null_ _null_ _null_ ));
DESCR("gin(internal)");
DATA(insert OID = 2788 ( ginoptions PGNSP PGUID 12 1 0 0 f f f t f s 2 0 17 "1009 16" _null_ _null_ _null_ _null_ ginoptions _null_ _null_ _null_ ));
DESCR("gin(internal)");
DESCR("GIN tsvector support");
DATA(insert OID = 3658 ( gin_tsquery_consistent PGNSP PGUID 12 1 0 0 f f f t f i 6 0 16 "2281 21 3615 23 2281 2281" _null_ _null_ _null_ _null_ gin_tsquery_consistent _null_ _null_ _null_ ));
DESCR("GIN tsvector support");
-DATA(insert OID = 3724 ( gin_cmp_tslexeme PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "25 25" _null_ _null_ _null_ _null_ gin_cmp_tslexeme _null_ _null_ _null_ ));
+DATA(insert OID = 3724 ( gin_cmp_tslexeme PGNSP PGUID 12 1 0 0 f f f t f i 2 0 23 "25 25" _null_ _null_ _null_ _null_ gin_cmp_tslexeme _null_ _null_ _null_ ));
DESCR("GIN tsvector support");
-DATA(insert OID = 2700 ( gin_cmp_prefix PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "25 25 21 2281" _null_ _null_ _null_ _null_ gin_cmp_prefix _null_ _null_ _null_ ));
+DATA(insert OID = 2700 ( gin_cmp_prefix PGNSP PGUID 12 1 0 0 f f f t f i 4 0 23 "25 25 21 2281" _null_ _null_ _null_ _null_ gin_cmp_prefix _null_ _null_ _null_ ));
DESCR("GIN tsvector support");
DATA(insert OID = 3662 ( tsquery_lt PGNSP PGUID 12 1 0 0 f f f t f i 2 0 16 "3615 3615" _null_ _null_ _null_ _null_ tsquery_lt _null_ _null_ _null_ ));
#define PROARGMODE_IN 'i'
#define PROARGMODE_OUT 'o'
#define PROARGMODE_INOUT 'b'
-#define PROARGMODE_VARIADIC 'v'
+#define PROARGMODE_VARIADIC 'v'
#define PROARGMODE_TABLE 't'
#endif /* PG_PROC_H */
/*-------------------------------------------------------------------------
*
* pg_proc_fn.h
- * prototypes for functions in catalog/pg_proc.c
+ * prototypes for functions in catalog/pg_proc.c
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
/*
* Identification of the independent (referenced) object. This is always
- * a shared object, so we need no database ID field. We don't bother
- * with a sub-object ID either.
+ * a shared object, so we need no database ID field. We don't bother with
+ * a sub-object ID either.
*/
Oid refclassid; /* OID of table containing object */
Oid refobjid; /* OID of object itself */
#define Anum_pg_shdepend_classid 2
#define Anum_pg_shdepend_objid 3
#define Anum_pg_shdepend_objsubid 4
-#define Anum_pg_shdepend_refclassid 5
+#define Anum_pg_shdepend_refclassid 5
#define Anum_pg_shdepend_refobjid 6
#define Anum_pg_shdepend_deptype 7
/*
* A "most common elements" slot is similar to a "most common values" slot,
* except that it stores the most common non-null *elements* of the column
- * values. This is useful when the column datatype is an array or some other
+ * values. This is useful when the column datatype is an array or some other
* type with identifiable elements (for instance, tsvector). staop contains
* the equality operator appropriate to the element type. stavalues contains
* the most common element values, and stanumbers their frequencies. Unlike
/*
* typcategory and typispreferred help the parser distinguish preferred
* and non-preferred coercions. The category can be any single ASCII
- * character (but not \0). The categories used for built-in types are
+ * character (but not \0). The categories used for built-in types are
* identified by the TYPCATEGORY macros below.
*/
char typcategory; /* arbitrary type classification */
- bool typispreferred; /* is type "preferred" within its category? */
+ bool typispreferred; /* is type "preferred" within its category? */
/*
* If typisdefined is false, the entry is only a placeholder (forward
#define TYPCATEGORY_GEOMETRIC 'G'
#define TYPCATEGORY_NETWORK 'I' /* think INET */
#define TYPCATEGORY_NUMERIC 'N'
-#define TYPCATEGORY_PSEUDOTYPE 'P'
+#define TYPCATEGORY_PSEUDOTYPE 'P'
#define TYPCATEGORY_STRING 'S'
#define TYPCATEGORY_TIMESPAN 'T'
#define TYPCATEGORY_USER 'U'
/*-------------------------------------------------------------------------
*
* pg_type_fn.h
- * prototypes for functions in catalog/pg_type.c
+ * prototypes for functions in catalog/pg_type.c
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
#include "nodes/nodes.h"
-extern Oid TypeShellMake(const char *typeName,
- Oid typeNamespace,
- Oid ownerId);
+extern Oid TypeShellMake(const char *typeName,
+ Oid typeNamespace,
+ Oid ownerId);
extern Oid TypeCreate(Oid newTypeOid,
const char *typeName,
bool rebuild);
extern void RenameTypeInternal(Oid typeOid, const char *newTypeName,
- Oid typeNamespace);
+ Oid typeNamespace);
extern char *makeArrayTypeName(const char *typeName, Oid typeNamespace);
CATALOG(pg_user_mapping,1418)
{
- Oid umuser; /* Id of the user, InvalidOid if PUBLIC is wanted */
- Oid umserver; /* server of this mapping */
+ Oid umuser; /* Id of the user, InvalidOid if PUBLIC is
+ * wanted */
+ Oid umserver; /* server of this mapping */
/*
* VARIABLE LENGTH FIELDS start here. These fields may be NULL, too.
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*
TupOutputState *tstate);
extern void ExplainOnePlan(PlannedStmt *plannedstmt, ExplainStmt *stmt,
- const char *queryString,
- ParamListInfo params,
- TupOutputState *tstate);
+ const char *queryString,
+ ParamListInfo params,
+ TupOutputState *tstate);
extern void ExplainPrintPlan(StringInfo str, QueryDesc *queryDesc,
- bool analyze, bool verbose);
+ bool analyze, bool verbose);
#endif /* EXPLAIN_H */
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*
extern void AlterTableInternal(Oid relid, List *cmds, bool recurse);
extern void AlterTableNamespace(RangeVar *relation, const char *newschema,
- ObjectType stmttype);
+ ObjectType stmttype);
extern void AlterRelationNamespaceInternal(Relation classRel, Oid relOid,
Oid oldNspOid, Oid newNspOid,
bool recursing);
extern void RenameRelation(Oid myrelid,
- const char *newrelname,
- ObjectType reltype);
+ const char *newrelname,
+ ObjectType reltype);
extern void RenameRelationInternal(Oid myrelid,
- const char *newrelname,
- Oid namespaceId);
+ const char *newrelname,
+ Oid namespaceId);
extern void find_composite_type_dependencies(Oid typeOid,
const char *origTblName,
} TriggerData;
/*
- * TriggerEvent bit flags
+ * TriggerEvent bit flags
*
* Note that we assume different event types (INSERT/DELETE/UPDATE/TRUNCATE)
* can't be OR'd together in a single TriggerEvent. This is unlike the
#define SESSION_REPLICATION_ROLE_ORIGIN 0
#define SESSION_REPLICATION_ROLE_REPLICA 1
#define SESSION_REPLICATION_ROLE_LOCAL 2
-extern PGDLLIMPORT int SessionReplicationRole;
+extern PGDLLIMPORT int SessionReplicationRole;
/*
* States at which a trigger can be fired. These are the
#define TRIGGER_FIRES_ON_REPLICA 'R'
#define TRIGGER_DISABLED 'D'
-extern Oid CreateTrigger(CreateTrigStmt *stmt, Oid constraintOid,
- bool checkPermissions);
+extern Oid CreateTrigger(CreateTrigStmt *stmt, Oid constraintOid,
+ bool checkPermissions);
extern void DropTrigger(Oid relid, const char *trigname,
DropBehavior behavior, bool missing_ok);
ItemPointer tupleid,
HeapTuple newtuple);
extern void ExecBSTruncateTriggers(EState *estate,
- ResultRelInfo *relinfo);
+ ResultRelInfo *relinfo);
extern void ExecASTruncateTriggers(EState *estate,
- ResultRelInfo *relinfo);
+ ResultRelInfo *relinfo);
extern void AfterTriggerBeginXact(void);
extern void AfterTriggerBeginQuery(void);
Datum *stavalues[STATISTIC_NUM_SLOTS];
/*
- * These fields describe the stavalues[n] element types. They will
- * be initialized to be the same as the column's that's underlying the
- * slot, but a custom typanalyze function might want to store an array of
+ * These fields describe the stavalues[n] element types. They will be
+ * initialized to be the same as the column's that's underlying the slot,
+ * but a custom typanalyze function might want to store an array of
* something other than the analyzed column's elements. It should then
* overwrite these fields.
*/
/* Hook for plugins to get control in ExecutorRun() */
typedef void (*ExecutorRun_hook_type) (QueryDesc *queryDesc,
- ScanDirection direction,
- long count);
+ ScanDirection direction,
+ long count);
extern PGDLLIMPORT ExecutorRun_hook_type ExecutorRun_hook;
/* Hook for plugins to get control in ExecutorEnd() */
extern void ExecutorStart(QueryDesc *queryDesc, int eflags);
extern void standard_ExecutorStart(QueryDesc *queryDesc, int eflags);
extern void ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction, long count);
+ ScanDirection direction, long count);
extern void standard_ExecutorRun(QueryDesc *queryDesc,
- ScanDirection direction, long count);
+ ScanDirection direction, long count);
extern void ExecutorEnd(QueryDesc *queryDesc);
extern void standard_ExecutorEnd(QueryDesc *queryDesc);
extern void ExecutorRewind(QueryDesc *queryDesc);
} HashSkewBucket;
#define SKEW_BUCKET_OVERHEAD MAXALIGN(sizeof(HashSkewBucket))
-#define INVALID_SKEW_BUCKET_NO (-1)
+#define INVALID_SKEW_BUCKET_NO (-1)
#define SKEW_WORK_MEM_PERCENT 2
#define SKEW_MIN_OUTER_FRACTION 0.01
HashSkewBucket **skewBucket; /* hashtable of skew buckets */
int skewBucketLen; /* size of skewBucket array (a power of 2!) */
int nSkewBuckets; /* number of active skew buckets */
- int *skewBucketNums; /* array indexes of active skew buckets */
+ int *skewBucketNums; /* array indexes of active skew buckets */
int nbatch; /* number of batches */
int curbatch; /* current batch #; 0 during 1st pass */
Size spaceUsed; /* memory space currently used by tuples */
Size spaceAllowed; /* upper limit for space used */
Size spaceUsedSkew; /* skew hash table's current space usage */
- Size spaceAllowedSkew; /* upper limit for skew hashtable */
+ Size spaceAllowedSkew; /* upper limit for skew hashtable */
MemoryContext hashCxt; /* context for whole-hash-join storage */
MemoryContext batchCxt; /* context for this-batch-only storage */
Snapshot snapshot,
Snapshot crosscheck_snapshot,
bool read_only, bool fire_triggers, long tcount);
-extern int SPI_execute_with_args(const char *src,
- int nargs, Oid *argtypes,
- Datum *Values, const char *Nulls,
- bool read_only, long tcount);
+extern int SPI_execute_with_args(const char *src,
+ int nargs, Oid *argtypes,
+ Datum *Values, const char *Nulls,
+ bool read_only, long tcount);
extern SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes);
extern SPIPlanPtr SPI_prepare_cursor(const char *src, int nargs, Oid *argtypes,
int cursorOptions);
extern Portal SPI_cursor_open(const char *name, SPIPlanPtr plan,
Datum *Values, const char *Nulls, bool read_only);
extern Portal SPI_cursor_open_with_args(const char *name,
- const char *src,
- int nargs, Oid *argtypes,
- Datum *Values, const char *Nulls,
- bool read_only, int cursorOptions);
+ const char *src,
+ int nargs, Oid *argtypes,
+ Datum *Values, const char *Nulls,
+ bool read_only, int cursorOptions);
extern Portal SPI_cursor_find(const char *name);
extern void SPI_cursor_fetch(Portal portal, bool forward, long count);
extern void SPI_cursor_move(Portal portal, bool forward, long count);
extern DestReceiver *CreateTuplestoreDestReceiver(void);
extern void SetTuplestoreDestReceiverParams(DestReceiver *self,
- Tuplestorestate *tStore,
- MemoryContext tContext,
- bool detoast);
+ Tuplestorestate *tStore,
+ MemoryContext tContext,
+ bool detoast);
#endif /* TSTORE_RECEIVER_H */
* has only a minimal and not also a regular physical tuple, then tts_tuple
* points at tts_minhdr and the fields of that struct are set correctly
* for access to the minimal tuple; in particular, tts_minhdr.t_data points
- * MINIMAL_TUPLE_OFFSET bytes before tts_mintuple. This allows column
+ * MINIMAL_TUPLE_OFFSET bytes before tts_mintuple. This allows column
* extraction to treat the case identically to regular physical tuples.
*
* tts_slow/tts_off are saved state for slot_deform_tuple, and should not
{
NodeTag type; /* vestigial ... allows IsA tests */
bool tts_isempty; /* true = slot is empty */
- bool tts_shouldFree; /* should pfree tts_tuple? */
+ bool tts_shouldFree; /* should pfree tts_tuple? */
bool tts_shouldFreeMin; /* should pfree tts_mintuple? */
bool tts_slow; /* saved state for slot_deform_tuple */
HeapTuple tts_tuple; /* physical tuple, or NULL if virtual */
* Generic option types for validation.
* NB! Thes are treated as flags, so use only powers of two here.
*/
-typedef enum {
+typedef enum
+{
ServerOpt = 1, /* options applicable to SERVER */
UserMappingOpt = 2, /* options for USER MAPPING */
FdwOpt = 4 /* options for FOREIGN DATA WRAPPER */
typedef struct ForeignDataWrapper
{
- Oid fdwid; /* FDW Oid */
- Oid owner; /* FDW owner user Oid */
- char *fdwname; /* Name of the FDW */
- Oid fdwvalidator;
- List *options; /* fdwoptions as DefElem list */
+ Oid fdwid; /* FDW Oid */
+ Oid owner; /* FDW owner user Oid */
+ char *fdwname; /* Name of the FDW */
+ Oid fdwvalidator;
+ List *options; /* fdwoptions as DefElem list */
} ForeignDataWrapper;
typedef struct ForeignServer
{
- Oid serverid; /* server Oid */
- Oid fdwid; /* foreign-data wrapper */
- Oid owner; /* server owner user Oid */
- char *servername; /* name of the server */
- char *servertype; /* server type, optional */
- char *serverversion; /* server version, optional */
- List *options; /* srvoptions as DefElem list */
+ Oid serverid; /* server Oid */
+ Oid fdwid; /* foreign-data wrapper */
+ Oid owner; /* server owner user Oid */
+ char *servername; /* name of the server */
+ char *servertype; /* server type, optional */
+ char *serverversion; /* server version, optional */
+ List *options; /* srvoptions as DefElem list */
} ForeignServer;
typedef struct UserMapping
{
- Oid userid; /* local user Oid */
- Oid serverid; /* server Oid */
- List *options; /* useoptions as DefElem list */
+ Oid userid; /* local user Oid */
+ Oid serverid; /* server Oid */
+ List *options; /* useoptions as DefElem list */
} UserMapping;
extern ForeignServer *GetForeignServer(Oid serverid);
extern ForeignServer *GetForeignServerByName(const char *name, bool missing_ok);
-extern Oid GetForeignServerOidByName(const char *name, bool missing_ok);
+extern Oid GetForeignServerOidByName(const char *name, bool missing_ok);
extern UserMapping *GetUserMapping(Oid userid, Oid serverid);
extern ForeignDataWrapper *GetForeignDataWrapper(Oid fdwid);
extern ForeignDataWrapper *GetForeignDataWrapperByName(const char *name,
- bool missing_ok);
-extern Oid GetForeignDataWrapperOidByName(const char *name, bool missing_ok);
+ bool missing_ok);
+extern Oid GetForeignDataWrapperOidByName(const char *name, bool missing_ok);
-#endif /* FOREIGN_H */
+#endif /* FOREIGN_H */
*
* tuple_desc is for use when returning tuples (i.e. composite data types)
* and is only needed if you are going to build the tuples with
- * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
+ * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
* the TupleDesc pointer stored here should usually have been run through
* BlessTupleDesc() first.
*/
ctHostNoSSL
} ConnType;
-typedef struct
+typedef struct
{
int linenumber;
ConnType conntype;
extern int hba_getauthmethod(hbaPort *port);
extern bool read_pg_database_line(FILE *fp, char *dbname, Oid *dboid,
Oid *dbtablespace, TransactionId *dbfrozenxid);
-extern int check_usermap(const char *usermap_name,
- const char *pg_role, const char *auth_user,
- bool case_sensitive);
+extern int check_usermap(const char *usermap_name,
+ const char *pg_role, const char *auth_user,
+ bool case_sensitive);
extern bool pg_isblank(const char c);
#endif /* HBA_H */
{
void *value;
int length;
-} gss_buffer_desc;
+} gss_buffer_desc;
#endif
#endif /* ENABLE_SSPI */
gss_ctx_id_t ctx; /* GSSAPI connection context */
gss_name_t name; /* GSSAPI client name */
#endif
-} pg_gssinfo;
+} pg_gssinfo;
#endif
/*
/*
* Information that needs to be held during the authentication cycle.
*/
- HbaLine *hba;
+ HbaLine *hba;
char md5Salt[4]; /* Password salt */
/*
extern int pg_mbstrlen(const char *mbstr);
extern int pg_mbstrlen_with_len(const char *mbstr, int len);
extern int pg_mbcliplen(const char *mbstr, int len, int limit);
-extern int pg_encoding_mbcliplen(int encoding, const char *mbstr,
- int len, int limit);
+extern int pg_encoding_mbcliplen(int encoding, const char *mbstr,
+ int len, int limit);
extern int pg_mbcharcliplen(const char *mbstr, int len, int imit);
extern int pg_encoding_max_length(int encoding);
extern int pg_database_encoding_max_length(void);
bool noError);
extern void check_encoding_conversion_args(int src_encoding,
- int dest_encoding,
- int len,
- int expected_src_encoding,
- int expected_dest_encoding);
+ int dest_encoding,
+ int len,
+ int expected_src_encoding,
+ int expected_dest_encoding);
extern void report_invalid_encoding(int encoding, const char *mbstr, int len);
extern void report_untranslatable_char(int src_encoding, int dest_encoding,
extern int DateStyle;
extern int DateOrder;
-
+
/*
* IntervalStyles
- * INTSTYLE_POSTGRES Like Postgres < 8.4 when DateStyle = 'iso'
- * INTSTYLE_POSTGRES_VERBOSE Like Postgres < 8.4 when DateStyle != 'iso'
- * INTSTYLE_SQL_STANDARD SQL standard interval literals
- * INTSTYLE_ISO_8601 ISO-8601-basic formatted intervals
+ * INTSTYLE_POSTGRES Like Postgres < 8.4 when DateStyle = 'iso'
+ * INTSTYLE_POSTGRES_VERBOSE Like Postgres < 8.4 when DateStyle != 'iso'
+ * INTSTYLE_SQL_STANDARD SQL standard interval literals
+ * INTSTYLE_ISO_8601 ISO-8601-basic formatted intervals
*/
#define INTSTYLE_POSTGRES 0
#define INTSTYLE_POSTGRES_VERBOSE 1
#include "access/heapam.h"
#include "access/skey.h"
#include "nodes/params.h"
-#include "nodes/plannodes.h"
-#include "nodes/tidbitmap.h"
+#include "nodes/plannodes.h"
+#include "nodes/tidbitmap.h"
#include "utils/hsearch.h"
#include "utils/rel.h"
#include "utils/snapshot.h"
ParamListInfo ecxt_param_list_info; /* for other param types */
/*
- * Values to substitute for Aggref nodes in the expressions of an Agg node,
- * or for WindowFunc nodes within a WindowAgg node.
+ * Values to substitute for Aggref nodes in the expressions of an Agg
+ * node, or for WindowFunc nodes within a WindowAgg node.
*/
Datum *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
bool *ecxt_aggnulls; /* null flags for aggs/windowfuncs */
/*
- * es_rowMarks is a list of these structs. See RowMarkClause for details
- * about rti and prti. toidAttno is not used in a "plain" rowmark.
+ * es_rowMarks is a list of these structs. See RowMarkClause for details
+ * about rti and prti. toidAttno is not used in a "plain" rowmark.
*/
typedef struct ExecRowMark
{
FmgrInfo func;
/*
- * For a set-returning function (SRF) that returns a tuplestore, we
- * keep the tuplestore here and dole out the result rows one at a time.
- * The slot holds the row currently being returned.
+ * For a set-returning function (SRF) that returns a tuplestore, we keep
+ * the tuplestore here and dole out the result rows one at a time. The
+ * slot holds the row currently being returned.
*/
Tuplestorestate *funcResultStore;
TupleTableSlot *funcResultSlot;
/*
* In some cases we need to compute a tuple descriptor for the function's
- * output. If so, it's stored here.
+ * output. If so, it's stored here.
*/
TupleDesc funcResultDesc;
- bool funcReturnsTuple; /* valid when funcResultDesc isn't NULL */
+ bool funcReturnsTuple; /* valid when funcResultDesc isn't
+ * NULL */
/*
* We need to store argument values across calls when evaluating a SRF
TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */
ExprContext *ps_ExprContext; /* node's expression-evaluation context */
ProjectionInfo *ps_ProjInfo; /* info for doing tuple projection */
- bool ps_TupFromTlist; /* state flag for processing set-valued
- * functions in targetlist */
+ bool ps_TupFromTlist;/* state flag for processing set-valued
+ * functions in targetlist */
} PlanState;
/* ----------------
FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
MemoryContext tempContext; /* short-term context for comparisons */
TupleHashTable hashtable; /* hash table for tuples already seen */
- MemoryContext tableContext; /* memory context containing hash table */
+ MemoryContext tableContext; /* memory context containing hash table */
} RecursiveUnionState;
/* ----------------
* tbmres current-page data
* prefetch_iterator iterator for prefetching ahead of current page
* prefetch_pages # pages prefetch iterator is ahead of current
- * prefetch_target target prefetch distance
+ * prefetch_target target prefetch distance
* ----------------
*/
typedef struct BitmapHeapScanState
/* Link to the "leader" CteScanState (possibly this same node) */
struct CteScanState *leader;
/* The remaining fields are only valid in the "leader" CteScanState */
- Tuplestorestate *cte_table; /* rows already read from the CTE query */
+ Tuplestorestate *cte_table; /* rows already read from the CTE query */
bool eof_cte; /* reached end of CTE query? */
} CteScanState;
* WorkTableScanState information
*
* WorkTableScan nodes are used to scan the work table created by
- * a RecursiveUnion node. We locate the RecursiveUnion node
+ * a RecursiveUnion node. We locate the RecursiveUnion node
* during executor startup.
* ----------------
*/
typedef struct WindowAggState
{
- ScanState ss; /* its first field is NodeTag */
+ ScanState ss; /* its first field is NodeTag */
/* these fields are filled in by ExecInitExpr: */
- List *funcs; /* all WindowFunc nodes in targetlist */
- int numfuncs; /* total number of window functions */
- int numaggs; /* number that are plain aggregates */
+ List *funcs; /* all WindowFunc nodes in targetlist */
+ int numfuncs; /* total number of window functions */
+ int numaggs; /* number that are plain aggregates */
- WindowStatePerFunc perfunc; /* per-window-function information */
- WindowStatePerAgg peragg; /* per-plain-aggregate information */
+ WindowStatePerFunc perfunc; /* per-window-function information */
+ WindowStatePerAgg peragg; /* per-plain-aggregate information */
FmgrInfo *partEqfunctions; /* equality funcs for partition columns */
- FmgrInfo *ordEqfunctions; /* equality funcs for ordering columns */
- Tuplestorestate *buffer; /* stores rows of current partition */
- int current_ptr; /* read pointer # for current */
- int agg_ptr; /* read pointer # for aggregates */
- int64 spooled_rows; /* total # of rows in buffer */
- int64 currentpos; /* position of current row in partition */
- int64 frametailpos; /* current frame tail position */
- int64 aggregatedupto; /* rows before this one are aggregated */
-
- MemoryContext wincontext; /* context for partition-lifespan data */
- ExprContext *tmpcontext; /* short-term evaluation context */
-
- bool all_done; /* true if the scan is finished */
- bool partition_spooled; /* true if all tuples in current partition
- * have been spooled into tuplestore */
- bool more_partitions; /* true if there's more partitions after
- * this one */
- bool frametail_valid; /* true if frametailpos is known up to date
- * for current row */
+ FmgrInfo *ordEqfunctions; /* equality funcs for ordering columns */
+ Tuplestorestate *buffer; /* stores rows of current partition */
+ int current_ptr; /* read pointer # for current */
+ int agg_ptr; /* read pointer # for aggregates */
+ int64 spooled_rows; /* total # of rows in buffer */
+ int64 currentpos; /* position of current row in partition */
+ int64 frametailpos; /* current frame tail position */
+ int64 aggregatedupto; /* rows before this one are aggregated */
+
+ MemoryContext wincontext; /* context for partition-lifespan data */
+ ExprContext *tmpcontext; /* short-term evaluation context */
+
+ bool all_done; /* true if the scan is finished */
+ bool partition_spooled; /* true if all tuples in current
+ * partition have been spooled into
+ * tuplestore */
+ bool more_partitions;/* true if there's more partitions after this
+ * one */
+ bool frametail_valid;/* true if frametailpos is known up to date
+ * for current row */
TupleTableSlot *first_part_slot; /* first tuple of current or next
* partition */
HeapTuple grp_firstTuple; /* copy of first tuple of current group */
/* these fields are used in SETOP_HASHED mode: */
TupleHashTable hashtable; /* hash table with one entry per group */
- MemoryContext tableContext; /* memory context containing hash table */
+ MemoryContext tableContext; /* memory context containing hash table */
bool table_filled; /* hash table filled yet? */
TupleHashIterator hashiter; /* for iterating through hash table */
} SetOpState;
extern DefElem *makeDefElem(char *name, Node *arg);
extern DefElem *makeDefElemExtended(char *namespace, char *name, Node *arg,
- DefElemAction defaction);
+ DefElemAction defaction);
#endif /* MAKEFUNC_H */
void *context, int flags);
extern bool raw_expression_tree_walker(Node *node, bool (*walker) (),
- void *context);
+ void *context);
#endif /* NODEFUNCS_H */
_result->type = (tag); \
_result; \
})
-
#else
/*
newNodeMacroHolder->type = (tag), \
newNodeMacroHolder \
)
-
#endif /* __GNUC__ */
typedef enum JoinType
{
/*
- * The canonical kinds of joins according to the SQL JOIN syntax.
- * Only these codes can appear in parser output (e.g., JoinExpr nodes).
+ * The canonical kinds of joins according to the SQL JOIN syntax. Only
+ * these codes can appear in parser output (e.g., JoinExpr nodes).
*/
JOIN_INNER, /* matching tuple pairs only */
JOIN_LEFT, /* pairs + unmatched LHS tuples */
JOIN_RIGHT, /* pairs + unmatched RHS tuples */
/*
- * Semijoins and anti-semijoins (as defined in relational theory) do
- * not appear in the SQL JOIN syntax, but there are standard idioms for
- * representing them (e.g., using EXISTS). The planner recognizes these
+ * Semijoins and anti-semijoins (as defined in relational theory) do not
+ * appear in the SQL JOIN syntax, but there are standard idioms for
+ * representing them (e.g., using EXISTS). The planner recognizes these
* cases and converts them to joins. So the planner and executor must
* support these codes. NOTE: in JOIN_SEMI output, it is unspecified
- * which matching RHS row is joined to. In JOIN_ANTI output, the row
- * is guaranteed to be null-extended.
+ * which matching RHS row is joined to. In JOIN_ANTI output, the row is
+ * guaranteed to be null-extended.
*/
JOIN_SEMI, /* 1 copy of each LHS row that has match(es) */
JOIN_ANTI, /* 1 copy of each LHS row that has no match */
/*
* OUTER joins are those for which pushed-down quals must behave differently
* from the join's own quals. This is in fact everything except INNER and
- * SEMI joins. However, this macro must also exclude the JOIN_UNIQUE symbols
+ * SEMI joins. However, this macro must also exclude the JOIN_UNIQUE symbols
* since those are temporary proxies for what will eventually be an INNER
* join.
*
#define ACL_REFERENCES (1<<5)
#define ACL_TRIGGER (1<<6)
#define ACL_EXECUTE (1<<7) /* for functions */
-#define ACL_USAGE (1<<8) /* for languages, namespaces, FDWs, and servers */
+#define ACL_USAGE (1<<8) /* for languages, namespaces, FDWs, and
+ * servers */
#define ACL_CREATE (1<<9) /* for namespaces and databases */
#define ACL_CREATE_TEMP (1<<10) /* for databases */
#define ACL_CONNECT (1<<11) /* for databases */
IntoClause *intoClause; /* target for SELECT INTO / CREATE TABLE AS */
bool hasAggs; /* has aggregates in tlist or havingQual */
- bool hasWindowFuncs; /* has window functions in tlist */
+ bool hasWindowFuncs; /* has window functions in tlist */
bool hasSubLinks; /* has subquery SubLink */
bool hasDistinctOn; /* distinctClause is from DISTINCT ON */
bool hasRecursive; /* WITH RECURSIVE was specified */
/*
* ColumnRef - specifies a reference to a column, or possibly a whole tuple
*
- * The "fields" list must be nonempty. It can contain string Value nodes
+ * The "fields" list must be nonempty. It can contain string Value nodes
* (representing names) and A_Star nodes (representing occurrence of a '*').
* Currently, A_Star must appear only as the last list element --- the grammar
* is responsible for enforcing this!
typedef struct WindowDef
{
NodeTag type;
- char *name; /* window's own name */
- char *refname; /* referenced window name, if any */
+ char *name; /* window's own name */
+ char *refname; /* referenced window name, if any */
List *partitionClause; /* PARTITION BY expression list */
- List *orderClause; /* ORDER BY (list of SortBy) */
- int frameOptions; /* frame_clause options, see below */
- int location; /* parse location, or -1 if none/unknown */
+ List *orderClause; /* ORDER BY (list of SortBy) */
+ int frameOptions; /* frame_clause options, see below */
+ int location; /* parse location, or -1 if none/unknown */
} WindowDef;
/*
* the convenience of gram.y, even though some of them are useless/invalid.
* We will need more bits (and fields) to cover the full SQL:2008 option set.
*/
-#define FRAMEOPTION_NONDEFAULT 0x00001 /* any specified? */
-#define FRAMEOPTION_RANGE 0x00002 /* RANGE behavior */
-#define FRAMEOPTION_ROWS 0x00004 /* ROWS behavior */
-#define FRAMEOPTION_BETWEEN 0x00008 /* BETWEEN given? */
-#define FRAMEOPTION_START_UNBOUNDED_PRECEDING 0x00010 /* start is U. P. */
-#define FRAMEOPTION_END_UNBOUNDED_PRECEDING 0x00020 /* (disallowed) */
-#define FRAMEOPTION_START_UNBOUNDED_FOLLOWING 0x00040 /* (disallowed) */
-#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING 0x00080 /* end is U. F. */
-#define FRAMEOPTION_START_CURRENT_ROW 0x00100 /* start is C. R. */
-#define FRAMEOPTION_END_CURRENT_ROW 0x00200 /* end is C. R. */
+#define FRAMEOPTION_NONDEFAULT 0x00001 /* any specified? */
+#define FRAMEOPTION_RANGE 0x00002 /* RANGE behavior */
+#define FRAMEOPTION_ROWS 0x00004 /* ROWS behavior */
+#define FRAMEOPTION_BETWEEN 0x00008 /* BETWEEN given? */
+#define FRAMEOPTION_START_UNBOUNDED_PRECEDING 0x00010 /* start is U. P. */
+#define FRAMEOPTION_END_UNBOUNDED_PRECEDING 0x00020 /* (disallowed) */
+#define FRAMEOPTION_START_UNBOUNDED_FOLLOWING 0x00040 /* (disallowed) */
+#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING 0x00080 /* end is U. F. */
+#define FRAMEOPTION_START_CURRENT_ROW 0x00100 /* start is C. R. */
+#define FRAMEOPTION_END_CURRENT_ROW 0x00200 /* end is C. R. */
#define FRAMEOPTION_DEFAULTS \
(FRAMEOPTION_RANGE | FRAMEOPTION_START_UNBOUNDED_PRECEDING | \
/*
* DefElem - a generic "name = value" option definition
*
- * In some contexts the name can be qualified. Also, certain SQL commands
+ * In some contexts the name can be qualified. Also, certain SQL commands
* allow a SET/ADD/DROP action to be attached to option settings, so it's
* convenient to carry a field for that too. (Note: currently, it is our
* practice that the grammar allows namespace and action only in statements
*/
char *ctename; /* name of the WITH list item */
Index ctelevelsup; /* number of query levels up */
- bool self_reference; /* is this a recursive self-reference? */
+ bool self_reference; /* is this a recursive self-reference? */
List *ctecoltypes; /* OID list of column type OIDs */
List *ctecoltypmods; /* integer list of column typmods */
* You might think that ORDER BY is only interested in defining ordering,
* and GROUP/DISTINCT are only interested in defining equality. However,
* one way to implement grouping is to sort and then apply a "uniq"-like
- * filter. So it's also interesting to keep track of possible sort operators
+ * filter. So it's also interesting to keep track of possible sort operators
* for GROUP/DISTINCT, and in particular to try to sort for the grouping
* in a way that will also yield a requested ORDER BY ordering. So we need
* to be able to compare ORDER BY and GROUP/DISTINCT lists, which motivates
* here, but it's cheap to get it along with the sortop, and requiring it
* to be valid eases comparisons to grouping items.)
*
- * In a grouping item, eqop must be valid. If the eqop is a btree equality
+ * In a grouping item, eqop must be valid. If the eqop is a btree equality
* operator, then sortop should be set to a compatible ordering operator.
* We prefer to set eqop/sortop/nulls_first to match any ORDER BY item that
- * the query presents for the same tlist item. If there is none, we just
+ * the query presents for the same tlist item. If there is none, we just
* use the default ordering op for the datatype.
*
* If the tlist item's type has a hash opclass but no btree opclass, then
{
NodeTag type;
Index tleSortGroupRef; /* reference into targetlist */
- Oid eqop; /* the equality operator ('=' op) */
- Oid sortop; /* the ordering operator ('<' op), or 0 */
- bool nulls_first; /* do NULLs come before normal values? */
+ Oid eqop; /* the equality operator ('=' op) */
+ Oid sortop; /* the ordering operator ('<' op), or 0 */
+ bool nulls_first; /* do NULLs come before normal values? */
} SortGroupClause;
/*
typedef struct WindowClause
{
NodeTag type;
- char *name; /* window name (NULL in an OVER clause) */
- char *refname; /* referenced window name, if any */
+ char *name; /* window name (NULL in an OVER clause) */
+ char *refname; /* referenced window name, if any */
List *partitionClause; /* PARTITION BY list */
- List *orderClause; /* ORDER BY list */
- int frameOptions; /* frame_clause options, see WindowDef */
- Index winref; /* ID referenced by window functions */
- bool copiedOrder; /* did we copy orderClause from refname? */
+ List *orderClause; /* ORDER BY list */
+ int frameOptions; /* frame_clause options, see WindowDef */
+ Index winref; /* ID referenced by window functions */
+ bool copiedOrder; /* did we copy orderClause from refname? */
} WindowClause;
/*
/*
* WithClause -
- * representation of WITH clause
+ * representation of WITH clause
*
* Note: WithClause does not propagate into the Query representation;
* but CommonTableExpr does.
/*
* CommonTableExpr -
- * representation of WITH list element
+ * representation of WITH list element
*
* We don't currently support the SEARCH or CYCLE clause.
*/
* range table. Its setOperations field shows the tree of set operations,
* with leaf SelectStmt nodes replaced by RangeTblRef nodes, and internal
* nodes replaced by SetOperationStmt nodes. Information about the output
- * column types is added, too. (Note that the child nodes do not necessarily
+ * column types is added, too. (Note that the child nodes do not necessarily
* produce these types directly, but we've checked that their output types
* can be coerced to the output column type.) Also, if it's not UNION ALL,
* information about the types' sort/group semantics is provided in the form
*
* Note: because of the parsing ambiguity with the GRANT <privileges>
* statement, granted_roles is a list of AccessPriv; the execution code
- * should complain if any column lists appear. grantee_roles is a list
+ * should complain if any column lists appear. grantee_roles is a list
* of role names, as Value strings.
* ----------------------
*/
bool analyze; /* do ANALYZE step */
bool verbose; /* print progress info */
int freeze_min_age; /* min freeze age, or -1 to use default */
- int freeze_table_age; /* age at which to scan whole table */
+ int freeze_table_age; /* age at which to scan whole table */
RangeVar *relation; /* single table to process, or NULL */
List *va_cols; /* list of column names, or NIL for all */
} VacuumStmt;
extern List *list_union_oid(List *list1, List *list2);
extern List *list_intersection(List *list1, List *list2);
+
/* currently, there's no need for list_intersection_int etc */
extern List *list_difference(List *list1, List *list2);
*
* We track the objects on which a PlannedStmt depends in two ways:
* relations are recorded as a simple list of OIDs, and everything else
- * is represented as a list of PlanInvalItems. A PlanInvalItem is designed
+ * is represented as a list of PlanInvalItems. A PlanInvalItem is designed
* to be used with the syscache invalidation mechanism, so it identifies a
* system catalog entry by cache ID and tuple TID.
*/
*
* Notice the arguments are given as a List. For NOT, of course the list
* must always have exactly one element. For AND and OR, the executor can
- * handle any number of arguments. The parser generally treats AND and OR
+ * handle any number of arguments. The parser generally treats AND and OR
* as binary and so it typically only produces two-element lists, but the
* optimizer will flatten trees of AND and OR nodes to produce longer lists
* when possible. There are also a few special cases where more arguments
char *plan_name; /* A name assigned during planning */
/* Extra data useful for determining subplan's output type: */
Oid firstColType; /* Type of first column of subplan result */
- int32 firstColTypmod; /* Typmod of first column of subplan result */
+ int32 firstColTypmod; /* Typmod of first column of subplan result */
/* Information about execution strategy: */
bool useHashTable; /* TRUE to store subselect output in a hash
* table (implies we are doing "IN") */
* risks confusing ExecGetJunkAttribute!
*
* ressortgroupref is used in the representation of ORDER BY, GROUP BY, and
- * DISTINCT items. Targetlist entries with ressortgroupref=0 are not
+ * DISTINCT items. Targetlist entries with ressortgroupref=0 are not
* sort/group items. If ressortgroupref>0, then this item is an ORDER BY,
- * GROUP BY, and/or DISTINCT target value. No two entries in a targetlist
+ * GROUP BY, and/or DISTINCT target value. No two entries in a targetlist
* may have the same nonzero ressortgroupref --- but there is no particular
* meaning to the nonzero values, except as tags. (For example, one must
* not assume that lower ressortgroupref means a more significant sort key.)
Index query_level; /* 1 at the outermost Query */
- struct PlannerInfo *parent_root; /* NULL at outermost Query */
+ struct PlannerInfo *parent_root; /* NULL at outermost Query */
/*
* simple_rel_array holds pointers to "base rels" and "other rels" (see
List *full_join_clauses; /* list of RestrictInfos for
* mergejoinable full join clauses */
- List *join_info_list; /* list of SpecialJoinInfos */
+ List *join_info_list; /* list of SpecialJoinInfos */
List *append_rel_list; /* list of AppendRelInfos */
- List *placeholder_list; /* list of PlaceHolderInfos */
+ List *placeholder_list; /* list of PlaceHolderInfos */
List *query_pathkeys; /* desired pathkeys for query_planner(), and
* actual pathkeys afterwards */
- List *group_pathkeys; /* groupClause pathkeys, if any */
+ List *group_pathkeys; /* groupClause pathkeys, if any */
List *window_pathkeys; /* pathkeys of bottom window, if any */
- List *distinct_pathkeys; /* distinctClause pathkeys, if any */
- List *sort_pathkeys; /* sortClause pathkeys, if any */
+ List *distinct_pathkeys; /* distinctClause pathkeys, if any */
+ List *sort_pathkeys; /* sortClause pathkeys, if any */
List *initial_rels; /* RelOptInfos we are now trying to join */
bool hasRecursion; /* true if planning a recursive WITH item */
/* These fields are used only when hasRecursion is true: */
- int wt_param_id; /* PARAM_EXEC ID for the work table */
+ int wt_param_id; /* PARAM_EXEC ID for the work table */
struct Plan *non_recursive_plan; /* plan for non-recursive term */
} PlannerInfo;
bool amoptionalkey; /* can query omit key for the first column? */
bool amsearchnulls; /* can AM search for NULL index entries? */
bool amhasgettuple; /* does AM have amgettuple interface? */
- bool amhasgetbitmap; /* does AM have amgetbitmap interface? */
+ bool amhasgetbitmap; /* does AM have amgetbitmap interface? */
} IndexOptInfo;
{
JoinPath jpath;
List *path_hashclauses; /* join clauses used for hashing */
- int num_batches; /* number of batches expected */
+ int num_batches; /* number of batches expected */
} HashPath;
/*
* if we decide that it can be pushed down into the nullable side of the join.
* In that case it acts as a plain filter qual for wherever it gets evaluated.
* (In short, is_pushed_down is only false for non-degenerate outer join
- * conditions. Possibly we should rename it to reflect that meaning?)
+ * conditions. Possibly we should rename it to reflect that meaning?)
*
* RestrictInfo nodes also contain an outerjoin_delayed flag, which is true
* if the clause's applicability must be delayed due to any outer joins
* forced null by some outer join below the clause. outerjoin_delayed = true
* is subtly different from nullable_relids != NULL: a clause might reference
* some nullable rels and yet not be outerjoin_delayed because it also
- * references all the other rels of the outer join(s). A clause that is not
+ * references all the other rels of the outer join(s). A clause that is not
* outerjoin_delayed can be enforced anywhere it is computable.
*
* In general, the referenced clause might be arbitrarily complex. The
bool is_pushed_down; /* TRUE if clause was pushed down in level */
- bool outerjoin_delayed; /* TRUE if delayed by lower outer join */
+ bool outerjoin_delayed; /* TRUE if delayed by lower outer join */
bool can_join; /* see comment above */
/* cache space for cost and selectivity */
QualCost eval_cost; /* eval cost of clause; -1 if not yet set */
Selectivity norm_selec; /* selectivity for "normal" (JOIN_INNER)
- * semantics; -1 if not yet set; >1 means
- * a redundant clause */
- Selectivity outer_selec; /* selectivity for outer join semantics;
- * -1 if not yet set */
+ * semantics; -1 if not yet set; >1 means a
+ * redundant clause */
+ Selectivity outer_selec; /* selectivity for outer join semantics; -1 if
+ * not yet set */
/* valid if clause is mergejoinable, else NIL */
List *mergeopfamilies; /* opfamilies containing clause operator */
/*
* Placeholder node for an expression to be evaluated below the top level
- * of a plan tree. This is used during planning to represent the contained
- * expression. At the end of the planning process it is replaced by either
+ * of a plan tree. This is used during planning to represent the contained
+ * expression. At the end of the planning process it is replaced by either
* the contained expression or a Var referring to a lower-level evaluation of
* the contained expression. Typically the evaluation occurs below an outer
* join, and Var references above the outer join might thereby yield NULL
* One-sided outer joins constrain the order of joining partially but not
* completely. We flatten such joins into the planner's top-level list of
* relations to join, but record information about each outer join in a
- * SpecialJoinInfo struct. These structs are kept in the PlannerInfo node's
+ * SpecialJoinInfo struct. These structs are kept in the PlannerInfo node's
* join_info_list.
*
* Similarly, semijoins and antijoins created by flattening IN (subselect)
* used to translate Vars referencing the parent rel into references to
* the child. A list element is NULL if it corresponds to a dropped
* column of the parent (this is only possible for inheritance cases, not
- * UNION ALL). The list elements are always simple Vars for inheritance
+ * UNION ALL). The list elements are always simple Vars for inheritance
* cases, but can be arbitrary expressions in UNION ALL cases.
*
* Notice we only store entries for user columns (attno > 0). Whole-row
* For each distinct placeholder expression generated during planning, we
* store a PlaceHolderInfo node in the PlannerInfo node's placeholder_list.
* This stores info that is needed centrally rather than in each copy of the
- * PlaceHolderVar. The phid fields identify which PlaceHolderInfo goes with
+ * PlaceHolderVar. The phid fields identify which PlaceHolderInfo goes with
* each PlaceHolderVar. Note that phid is unique throughout a planner run,
* not just within a query level --- this is so that we need not reassign ID's
* when pulling a subquery into its parent.
extern void tbm_free(TIDBitmap *tbm);
extern void tbm_add_tuples(TIDBitmap *tbm,
- const ItemPointer tids, int ntids,
- bool recheck);
+ const ItemPointer tids, int ntids,
+ bool recheck);
extern void tbm_add_page(TIDBitmap *tbm, BlockNumber pageno);
extern void tbm_union(TIDBitmap *a, const TIDBitmap *b);
typedef struct
{
- int numWindowFuncs; /* total number of WindowFuncs found */
+ int numWindowFuncs; /* total number of WindowFuncs found */
Index maxWinRef; /* windowFuncs[] is indexed 0 .. maxWinRef */
List **windowFuncs; /* lists of WindowFuncs for each winref */
} WindowFuncLists;
extern Node *estimate_expression_value(PlannerInfo *root, Node *node);
extern Query *inline_set_returning_function(PlannerInfo *root,
- RangeTblEntry *rte);
+ RangeTblEntry *rte);
#endif /* CLAUSES_H */
typedef enum
{
- CONSTRAINT_EXCLUSION_OFF, /* do not use c_e */
- CONSTRAINT_EXCLUSION_ON, /* apply c_e to all rels */
+ CONSTRAINT_EXCLUSION_OFF, /* do not use c_e */
+ CONSTRAINT_EXCLUSION_ON, /* apply c_e to all rels */
CONSTRAINT_EXCLUSION_PARTITION /* apply c_e to otherrels only */
} ConstraintExclusionType;
Cost input_startup_cost, Cost input_total_cost,
double input_tuples);
extern void cost_nestloop(NestPath *path, PlannerInfo *root,
- SpecialJoinInfo *sjinfo);
+ SpecialJoinInfo *sjinfo);
extern void cost_mergejoin(MergePath *path, PlannerInfo *root,
- SpecialJoinInfo *sjinfo);
+ SpecialJoinInfo *sjinfo);
extern void cost_hashjoin(HashPath *path, PlannerInfo *root,
- SpecialJoinInfo *sjinfo);
+ SpecialJoinInfo *sjinfo);
extern void cost_subplan(PlannerInfo *root, SubPlan *subplan, Plan *plan);
extern void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root);
extern void cost_qual_eval_node(QualCost *cost, Node *qual, PlannerInfo *root);
extern void set_function_size_estimates(PlannerInfo *root, RelOptInfo *rel);
extern void set_values_size_estimates(PlannerInfo *root, RelOptInfo *rel);
extern void set_cte_size_estimates(PlannerInfo *root, RelOptInfo *rel,
- Plan *cteplan);
+ Plan *cteplan);
/*
* prototypes for clausesel.c
RelOptInfo *parent_rel,
RelOptInfo *child_rel);
extern void mutate_eclass_expressions(PlannerInfo *root,
- Node *(*mutator) (),
- void *context);
+ Node *(*mutator) (),
+ void *context);
extern List *find_eclass_clauses_for_index_join(PlannerInfo *root,
RelOptInfo *rel,
Relids outer_relids);
extern PlaceHolderVar *make_placeholder_expr(PlannerInfo *root, Expr *expr,
- Relids phrels);
+ Relids phrels);
extern PlaceHolderInfo *find_placeholder_info(PlannerInfo *root,
- PlaceHolderVar *phv);
+ PlaceHolderVar *phv);
extern void fix_placeholder_eval_levels(PlannerInfo *root);
extern void add_placeholders_to_joinrel(PlannerInfo *root,
- RelOptInfo *joinrel);
+ RelOptInfo *joinrel);
#endif /* PLACEHOLDER_H */
bool inhparent, RelOptInfo *rel);
extern void estimate_rel_size(Relation rel, int32 *attr_widths,
- BlockNumber *pages, double *tuples);
+ BlockNumber *pages, double *tuples);
extern bool relation_excluded_by_constraints(PlannerInfo *root,
RelOptInfo *rel, RangeTblEntry *rte);
Index scanrelid, Plan *subplan, List *subrtable);
extern Append *make_append(List *appendplans, bool isTarget, List *tlist);
extern RecursiveUnion *make_recursive_union(List *tlist,
- Plan *lefttree, Plan *righttree, int wtParam,
- List *distinctList, long numGroups);
+ Plan *lefttree, Plan *righttree, int wtParam,
+ List *distinctList, long numGroups);
extern Sort *make_sort_from_pathkeys(PlannerInfo *root, Plan *lefttree,
List *pathkeys, double limit_tuples);
extern Sort *make_sort_from_sortclauses(PlannerInfo *root, List *sortcls,
extern void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
extern void record_plan_function_dependency(PlannerGlobal *glob, Oid funcid);
extern void extract_query_dependencies(List *queries,
- List **relationOids,
- List **invalItems);
+ List **relationOids,
+ List **invalItems);
#endif /* PLANMAIN_H */
extern void SS_process_ctes(PlannerInfo *root);
extern JoinExpr *convert_ANY_sublink_to_join(PlannerInfo *root,
- SubLink *sublink,
- Relids available_rels);
+ SubLink *sublink,
+ Relids available_rels);
extern JoinExpr *convert_EXISTS_sublink_to_join(PlannerInfo *root,
- SubLink *sublink,
- bool under_not,
- Relids available_rels);
+ SubLink *sublink,
+ bool under_not,
+ Relids available_rels);
extern Node *SS_replace_correlation_vars(PlannerInfo *root, Node *expr);
extern Node *SS_process_sublinks(PlannerInfo *root, Node *expr, bool isQual);
extern void SS_finalize_plan(PlannerInfo *root, Plan *plan,
- bool attach_initplans);
+ bool attach_initplans);
extern Param *SS_make_initplan_from_plan(PlannerInfo *root, Plan *plan,
Oid resulttype, int32 resulttypmod);
extern int SS_assign_worktable_param(PlannerInfo *root);
} BackslashQuoteType;
/* GUC variables in scan.l (every one of these is a bad idea :-() */
-extern int backslash_quote;
+extern int backslash_quote;
extern bool escape_string_warning;
extern bool standard_conforming_strings;
extern void transformAggregateCall(ParseState *pstate, Aggref *agg);
extern void transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
- WindowDef *windef);
+ WindowDef *windef);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
extern void parseCheckWindowFuncs(ParseState *pstate, Query *qry);
List **targetlist, bool resolveUnknown);
extern List *transformWindowDefinitions(ParseState *pstate,
- List *windowdefs,
- List **targetlist);
+ List *windowdefs,
+ List **targetlist);
extern List *transformDistinctClause(ParseState *pstate,
List **targetlist, List *sortClause);
extern List *transformDistinctOnClause(ParseState *pstate, List *distinctlist,
- List **targetlist, List *sortClause);
+ List **targetlist, List *sortClause);
extern Index assignSortGroupRef(TargetEntry *tle, List *tlist);
extern bool targetIsInSortList(TargetEntry *tle, Oid sortop, List *sortList);
Oid targetTypeId,
const char *constructName);
-extern int parser_coercion_errposition(ParseState *pstate,
- int coerce_location,
- Node *input_expr);
+extern int parser_coercion_errposition(ParseState *pstate,
+ int coerce_location,
+ Node *input_expr);
-extern Oid select_common_type(ParseState *pstate, List *exprs,
- const char *context, Node **which_expr);
+extern Oid select_common_type(ParseState *pstate, List *exprs,
+ const char *context, Node **which_expr);
extern Node *coerce_to_common_type(ParseState *pstate, Node *node,
Oid targetTypeId,
const char *context);
* to make an RTE before you can access a CTE.
*
* p_future_ctes: list of CommonTableExprs (WITH items) that are not yet
- * visible due to scope rules. This is used to help improve error messages.
+ * visible due to scope rules. This is used to help improve error messages.
*
* p_windowdefs: list of WindowDefs representing WINDOW and OVER clauses.
* We collect these while transforming expressions and then transform them
extern void cancel_parser_errposition_callback(ParseCallbackState *pcbstate);
extern Var *make_var(ParseState *pstate, RangeTblEntry *rte, int attrno,
- int location);
+ int location);
extern Oid transformArrayType(Oid arrayType);
extern ArrayRef *transformArraySubscripts(ParseState *pstate,
Node *arrayBase,
int location,
int *sublevels_up);
extern CommonTableExpr *scanNameSpaceForCTE(ParseState *pstate,
- const char *refname,
- Index *ctelevelsup);
+ const char *refname,
+ Index *ctelevelsup);
extern void checkNameSpaceConflicts(ParseState *pstate, List *namespace1,
List *namespace2);
extern int RTERangeTablePosn(ParseState *pstate,
int varno,
int sublevels_up);
extern CommonTableExpr *GetCTEForRTE(ParseState *pstate, RangeTblEntry *rte,
- int rtelevelsup);
+ int rtelevelsup);
extern Node *scanRTEForColumn(ParseState *pstate, RangeTblEntry *rte,
char *colname, int location);
extern Node *colNameToVar(ParseState *pstate, char *colname, bool localonly,
bool implicitRTEOK,
int location);
extern void markVarForSelectPriv(ParseState *pstate, Var *var,
- RangeTblEntry *rte);
+ RangeTblEntry *rte);
extern Relation parserOpenTable(ParseState *pstate, const RangeVar *relation,
- int lockmode);
+ int lockmode);
extern RangeTblEntry *addRangeTableEntry(ParseState *pstate,
RangeVar *relation,
Alias *alias,
/*
* Define this to cause palloc()'d memory to be filled with random data, to
* facilitate catching code that depends on the contents of uninitialized
- * memory. Caution: this is horrendously expensive.
+ * memory. Caution: this is horrendously expensive.
*/
/* #define RANDOMIZE_ALLOCATED_MEMORY */
typedef struct PgStat_MsgInquiry
{
- PgStat_MsgHdr m_hdr;
- TimestampTz inquiry_time; /* minimum acceptable file timestamp */
+ PgStat_MsgHdr m_hdr;
+ TimestampTz inquiry_time; /* minimum acceptable file timestamp */
} PgStat_MsgInquiry;
* usage statistics.
* ----------
*/
-#define PGSTAT_NUM_FUNCENTRIES \
+#define PGSTAT_NUM_FUNCENTRIES \
((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \
/ sizeof(PgStat_FunctionEntry))
TimestampTz last_autovac_time;
/*
- * tables and functions must be last in the struct, because we don't
- * write the pointers out to the stats file.
+ * tables and functions must be last in the struct, because we don't write
+ * the pointers out to the stats file.
*/
HTAB *tables;
HTAB *functions;
*/
typedef struct PgStat_GlobalStats
{
- TimestampTz stats_timestamp; /* time of stats file update */
+ TimestampTz stats_timestamp; /* time of stats file update */
PgStat_Counter timed_checkpoints;
PgStat_Counter requested_checkpoints;
PgStat_Counter buf_written_checkpoints;
/* NULL means we are not tracking the current function call */
PgStat_FunctionCounts *fs;
/* Total time previously charged to function, as of function start */
- instr_time save_f_time;
+ instr_time save_f_time;
/* Backend-wide total time as of function start */
- instr_time save_total;
+ instr_time save_total;
/* system clock as of function start */
- instr_time f_start;
+ instr_time f_start;
} PgStat_FunctionCallUsage;
extern bool pgstat_track_activities;
extern bool pgstat_track_counts;
extern int pgstat_track_functions;
-extern PGDLLIMPORT int pgstat_track_activity_query_size;
+extern PGDLLIMPORT int pgstat_track_activity_query_size;
extern char *pgstat_stat_tmpname;
extern char *pgstat_stat_filename;
extern void pgstat_update_heap_dead_tuples(Relation rel, int delta);
extern void pgstat_init_function_usage(FunctionCallInfoData *fcinfo,
- PgStat_FunctionCallUsage *fcu);
+ PgStat_FunctionCallUsage *fcu);
extern void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu,
- bool finalize);
+ bool finalize);
extern void AtEOXact_PgStat(bool isCommit);
extern void AtEOSubXact_PgStat(bool isCommit, int nestDepth);
extern bool rmtree(const char *path, bool rmtopdir);
-/*
+/*
* stat() is not guaranteed to set the st_size field on win32, so we
* redefine it to our own implementation that is.
*
*/
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(UNSAFE_STAT_OK)
#include <sys/stat.h>
-extern int pgwin32_safestat(const char *path, struct stat *buf);
+extern int pgwin32_safestat(const char *path, struct stat * buf);
+
#define stat(a,b) pgwin32_safestat(a,b)
#endif
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#define CLASS_CONFLICT
#define DISABLE_XOPEN_NLS
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
-
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* see src/backend/libpq/pqcomm.c */
#define SCO_ACCEPT_BUG
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
* sprintf() returns char *, not int, on SunOS 4.1.x */
#define SPRINTF_CHAR
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#define NOFIXADE
#define NEED_STRDUP
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
***************************************
* Define this if you are compiling with
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* see src/backend/libpq/pqcomm.c */
#define SCO_ACCEPT_BUG
extern void _dosmaperr(unsigned long);
/* in port/win32env.c */
-extern int pgwin32_putenv(const char *);
+extern int pgwin32_putenv(const char *);
extern void pgwin32_unsetenv(const char *);
+
#define putenv(x) pgwin32_putenv(x)
#define unsetenv(x) pgwin32_unsetenv(x)
/* Things that exist in MingW headers, but need to be added to MSVC & BCC */
#ifdef WIN32_ONLY_COMPILER
typedef long ssize_t;
+
#ifndef __BORLANDC__
typedef unsigned short mode_t;
#endif
#ifndef O_RANDOM
#define O_RANDOM 0x0010 /* File access is primarily random */
#define O_SEQUENTIAL 0x0020 /* File access is primarily sequential */
-#define O_TEMPORARY 0x0040 /* Temporary file bit */
+#define O_TEMPORARY 0x0040 /* Temporary file bit */
#define O_SHORT_LIVED 0x1000 /* Temporary storage file, try not to flush */
#define _O_SHORT_LIVED O_SHORT_LIVED
-#endif /* ifndef O_RANDOM */
-
-#endif /* __BORLANDC__ */
+#endif /* ifndef O_RANDOM */
+#endif /* __BORLANDC__ */
#endif
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
-
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
-
* high-precision-timing APIs on yet other platforms.
*
* The basic data type is instr_time, which all callers should treat as an
- * opaque typedef. instr_time can store either an absolute time (of
- * unspecified reference time) or an interval. The operations provided
+ * opaque typedef. instr_time can store either an absolute time (of
+ * unspecified reference time) or an interval. The operations provided
* for it are:
*
* INSTR_TIME_IS_ZERO(t) is t equal to zero?
#define INSTR_TIME_GET_MICROSEC(t) \
(((uint64) (t).tv_sec * (uint64) 1000000) + (uint64) (t).tv_usec)
-
-#else /* WIN32 */
+#else /* WIN32 */
typedef LARGE_INTEGER instr_time;
QueryPerformanceFrequency(&f);
return (double) f.QuadPart;
}
-
#endif /* WIN32 */
#endif /* INSTR_TIME_H */
extern void CheckpointWriteDelay(int flags, double progress);
extern bool ForwardFsyncRequest(RelFileNode rnode, ForkNumber forknum,
- BlockNumber segno);
+ BlockNumber segno);
extern void AbsorbFsyncRequests(void);
extern Size BgWriterShmemSize(void);
#define REG_INVARG 16 /* invalid argument to regex function */
#define REG_MIXED 17 /* character widths of regex and string differ */
#define REG_BADOPT 18 /* invalid embedded option */
-#define REG_ETOOBIG 19 /* nfa has too many states */
+#define REG_ETOOBIG 19 /* nfa has too many states */
/* two specials for debugging and testing */
#define REG_ATOI 101 /* convert error-code name to number */
#define REG_ITOA 102 /* convert error-code number to name */
/*
* guc configuration variables
*/
-extern int regex_flavor;
+extern int regex_flavor;
#endif /* _REGEX_H_ */
extern void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
int min_sublevels_up);
extern void IncrementVarSublevelsUp_rtable(List *rtable,
- int delta_sublevels_up, int min_sublevels_up);
+ int delta_sublevels_up, int min_sublevels_up);
extern bool rangeTableEntry_used(Node *node, int rt_index,
int sublevels_up);
/* localbuf.c */
extern void LocalPrefetchBuffer(SMgrRelation smgr, ForkNumber forkNum,
- BlockNumber blockNum);
+ BlockNumber blockNum);
extern BufferDesc *LocalBufferAlloc(SMgrRelation smgr, ForkNumber forkNum,
BlockNumber blockNum, bool *foundPtr);
extern void MarkLocalBufferDirty(Buffer buffer);
/* Possible modes for ReadBufferExtended() */
typedef enum
{
- RBM_NORMAL, /* Normal read */
- RBM_ZERO, /* Don't read from disk, caller will initialize */
- RBM_ZERO_ON_ERROR /* Read, but return an all-zeros page on error */
+ RBM_NORMAL, /* Normal read */
+ RBM_ZERO, /* Don't read from disk, caller will
+ * initialize */
+ RBM_ZERO_ON_ERROR /* Read, but return an all-zeros page on error */
} ReadBufferMode;
/* in globals.c ... this duplicates miscadmin.h */
* prototypes for functions in bufmgr.c
*/
extern void PrefetchBuffer(Relation reln, ForkNumber forkNum,
- BlockNumber blockNum);
+ BlockNumber blockNum);
extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
extern Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum,
- BlockNumber blockNum, ReadBufferMode mode,
- BufferAccessStrategy strategy);
+ BlockNumber blockNum, ReadBufferMode mode,
+ BufferAccessStrategy strategy);
extern Buffer ReadBufferWithoutRelcache(RelFileNode rnode, bool isTemp,
- ForkNumber forkNum, BlockNumber blockNum,
- ReadBufferMode mode, BufferAccessStrategy strategy);
+ ForkNumber forkNum, BlockNumber blockNum,
+ ReadBufferMode mode, BufferAccessStrategy strategy);
extern void ReleaseBuffer(Buffer buffer);
extern void UnlockReleaseBuffer(Buffer buffer);
extern void MarkBufferDirty(Buffer buffer);
extern void PrintPinnedBufs(void);
#endif
extern Size BufferShmemSize(void);
-extern void BufferGetTag(Buffer buffer, RelFileNode *rnode,
- ForkNumber *forknum, BlockNumber *blknum);
+extern void BufferGetTag(Buffer buffer, RelFileNode *rnode,
+ ForkNumber *forknum, BlockNumber *blknum);
extern void SetBufferCommitInfoNeedsSave(Buffer buffer);
Size oldSpaceAvail,
Size spaceNeeded);
extern void RecordPageWithFreeSpace(Relation rel, BlockNumber heapBlk,
- Size spaceAvail);
+ Size spaceAvail);
extern void XLogRecordPageWithFreeSpace(RelFileNode rnode, BlockNumber heapBlk,
- Size spaceAvail);
+ Size spaceAvail);
extern void FreeSpaceMapTruncateRel(Relation rel, BlockNumber nblocks);
extern void FreeSpaceMapVacuum(Relation rel);
typedef struct
{
/*
- * fsm_search_avail() tries to spread the load of multiple backends
- * by returning different pages to different backends in a round-robin
- * fashion. fp_next_slot points to the next slot to be returned
- * (assuming there's enough space on it for the request). It's defined
- * as an int, because it's updated without an exclusive lock. uint16
- * would be more appropriate, but int is more likely to be atomically
+ * fsm_search_avail() tries to spread the load of multiple backends by
+ * returning different pages to different backends in a round-robin
+ * fashion. fp_next_slot points to the next slot to be returned (assuming
+ * there's enough space on it for the request). It's defined as an int,
+ * because it's updated without an exclusive lock. uint16 would be more
+ * appropriate, but int is more likely to be atomically
* fetchable/storable.
*/
- int fp_next_slot;
+ int fp_next_slot;
/*
* fp_nodes contains the binary tree, stored in array. The first
* NonLeafNodesPerPage elements are upper nodes, and the following
* LeafNodesPerPage elements are leaf nodes. Unused nodes are zero.
*/
- uint8 fp_nodes[1];
+ uint8 fp_nodes[1];
} FSMPageData;
typedef FSMPageData *FSMPage;
/* Prototypes for functions in fsmpage.c */
extern int fsm_search_avail(Buffer buf, uint8 min_cat, bool advancenext,
- bool exclusive_lock_held);
+ bool exclusive_lock_held);
extern uint8 fsm_get_avail(Page page, int slot);
extern uint8 fsm_get_max_avail(Page page);
extern bool fsm_set_avail(Page page, int slot, uint8 value);
* Note: the macro arguments are multiply evaluated, so avoid side-effects.
*----------
*/
-#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \
+#define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \
do { \
on_shmem_exit(cleanup_function, arg); \
PG_TRY()
-#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \
+#define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \
cancel_shmem_exit(cleanup_function, arg); \
PG_CATCH(); \
{ \
LOCKMODE lockmode);
extern void LockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
- LOCKMODE lockmode);
+ LOCKMODE lockmode);
extern void UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid,
- LOCKMODE lockmode);
+ LOCKMODE lockmode);
/* Describe a locktag for error messages */
extern void DescribeLockTag(StringInfo buf, const LOCKTAG *tag);
typedef enum
{
PMSIGNAL_RECOVERY_STARTED, /* recovery has started */
- PMSIGNAL_RECOVERY_CONSISTENT, /* recovery has reached consistent state */
+ PMSIGNAL_RECOVERY_CONSISTENT, /* recovery has reached consistent
+ * state */
PMSIGNAL_PASSWORD_CHANGE, /* pg_auth file has changed */
PMSIGNAL_WAKEN_ARCHIVER, /* send a NOTIFY signal to xlog archiver */
PMSIGNAL_ROTATE_LOGFILE, /* send SIGUSR1 to syslogger to rotate logfile */
extern int CountDBBackends(Oid databaseid);
extern int CountUserBackends(Oid roleid);
extern bool CountOtherDBBackends(Oid databaseId,
- int *nbackends, int *nprepared);
+ int *nbackends, int *nprepared);
extern void XidCacheRemoveRunningXids(TransactionId xid,
int nxids, const TransactionId *xids,
MAIN_FORKNUM = 0,
FSM_FORKNUM,
VISIBILITYMAP_FORKNUM
+
/*
* NOTE: if you add a new fork, change MAX_FORKNUM below and update the
* forkNames array in catalog.c
typedef struct
{
char key[SHMEM_INDEX_KEYSIZE]; /* string name */
- void *location; /* location in shared mem */
- Size size; /* # bytes allocated for the structure */
+ void *location; /* location in shared mem */
+ Size size; /* # bytes allocated for the structure */
} ShmemIndexEnt;
/*
extern void SendSharedInvalidMessages(const SharedInvalidationMessage *msgs,
- int n);
+ int n);
extern void ReceiveSharedInvalidMessages(
void (*invalFunction) (SharedInvalidationMessage *msg),
void (*resetFunction) (void));
* must be delivered to all already-running backends before it can be
* forgotten. (If we run out of space, we instead deliver a "RESET"
* message to backends that have fallen too far behind.)
- *
+ *
* The struct type SharedInvalidationMessage, defining the contents of
* a single message, is defined in sinval.h.
*
extern bool BackendIdIsActive(int backendID);
extern void SIInsertDataEntries(const SharedInvalidationMessage *data, int n);
-extern int SIGetDataEntries(SharedInvalidationMessage *data, int datasize);
+extern int SIGetDataEntries(SharedInvalidationMessage *data, int datasize);
extern void SICleanupQueue(bool callerHasWriteLock, int minFree);
extern LocalTransactionId GetNextLocalTransactionId(void);
extern void smgrclosenode(RelFileNode rnode);
extern void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo);
extern void smgrdounlink(SMgrRelation reln, ForkNumber forknum,
- bool isTemp, bool isRedo);
-extern void smgrextend(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer, bool isTemp);
+ bool isTemp, bool isRedo);
+extern void smgrextend(SMgrRelation reln, ForkNumber forknum,
+ BlockNumber blocknum, char *buffer, bool isTemp);
extern void smgrprefetch(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum);
+ BlockNumber blocknum);
extern void smgrread(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer);
+ BlockNumber blocknum, char *buffer);
extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer, bool isTemp);
+ BlockNumber blocknum, char *buffer, bool isTemp);
extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
extern void smgrtruncate(SMgrRelation reln, ForkNumber forknum,
- BlockNumber nblocks, bool isTemp);
+ BlockNumber nblocks, bool isTemp);
extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
extern void smgrpreckpt(void);
extern void smgrsync(void);
extern bool mdexists(SMgrRelation reln, ForkNumber forknum);
extern void mdunlink(RelFileNode rnode, ForkNumber forknum, bool isRedo);
extern void mdextend(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer, bool isTemp);
+ BlockNumber blocknum, char *buffer, bool isTemp);
extern void mdprefetch(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum);
+ BlockNumber blocknum);
extern void mdread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
- char *buffer);
+ char *buffer);
extern void mdwrite(SMgrRelation reln, ForkNumber forknum,
- BlockNumber blocknum, char *buffer, bool isTemp);
+ BlockNumber blocknum, char *buffer, bool isTemp);
extern BlockNumber mdnblocks(SMgrRelation reln, ForkNumber forknum);
extern void mdtruncate(SMgrRelation reln, ForkNumber forknum,
- BlockNumber nblocks, bool isTemp);
+ BlockNumber nblocks, bool isTemp);
extern void mdimmedsync(SMgrRelation reln, ForkNumber forknum);
extern void mdpreckpt(void);
extern void mdsync(void);
extern void mdpostckpt(void);
extern void RememberFsyncRequest(RelFileNode rnode, ForkNumber forknum,
- BlockNumber segno);
+ BlockNumber segno);
extern void ForgetRelationFsyncRequests(RelFileNode rnode, ForkNumber forknum);
extern void ForgetDatabaseFsyncRequests(Oid dbid);
* destroyed by calling its rDestroy method.
*
* In some cases, receiver objects require additional parameters that must
- * be passed to them after calling CreateDestReceiver. Since the set of
+ * be passed to them after calling CreateDestReceiver. Since the set of
* parameters varies for different receiver types, this is not handled by
* this module, but by direct calls from the calling code to receiver type
* specific functions.
LOGSTMT_ALL /* log all statements */
} LogStmtLevel;
-extern int log_statement;
+extern int log_statement;
extern List *pg_parse_and_rewrite(const char *query_string,
Oid *paramTypes, int numParams);
extern char *lowerstr_with_len(const char *str, int len);
extern bool tsearch_readline_begin(tsearch_readline_state *stp,
- const char *filename);
+ const char *filename);
extern char *tsearch_readline(tsearch_readline_state *stp);
extern void tsearch_readline_end(tsearch_readline_state *stp);
char *fragdelim;
int2 startsellen;
int2 stopsellen;
- int2 fragdelimlen;
+ int2 fragdelimlen;
} HeadlineParsedText;
/*
int2 tokenweights, /* bitmap as described
* in QueryOperand
* struct */
- bool prefix);
+ bool prefix);
extern TSQuery parse_tsquery(char *buf,
PushFunction pushval,
*/
uint16 *apos;
} pos;
- uint16 flags; /* currently, only TSL_PREFIX */
+ uint16 flags; /* currently, only TSL_PREFIX */
char *word;
uint32 alen;
} ParsedWord;
extern void ExecGrantStmt_oids(InternalGrant *istmt);
extern AclMode pg_attribute_aclmask(Oid table_oid, AttrNumber attnum,
- Oid roleid, AclMode mask, AclMaskHow how);
+ Oid roleid, AclMode mask, AclMaskHow how);
extern AclMode pg_class_aclmask(Oid table_oid, Oid roleid,
AclMode mask, AclMaskHow how);
extern AclMode pg_database_aclmask(Oid db_oid, Oid roleid,
extern AclMode pg_tablespace_aclmask(Oid spc_oid, Oid roleid,
AclMode mask, AclMaskHow how);
extern AclMode pg_foreign_data_wrapper_aclmask(Oid fdw_oid, Oid roleid,
- AclMode mask, AclMaskHow how);
+ AclMode mask, AclMaskHow how);
extern AclMode pg_foreign_server_aclmask(Oid srv_oid, Oid roleid,
- AclMode mask, AclMaskHow how);
+ AclMode mask, AclMaskHow how);
extern AclResult pg_attribute_aclcheck(Oid table_oid, AttrNumber attnum,
- Oid roleid, AclMode mode);
+ Oid roleid, AclMode mode);
extern AclResult pg_attribute_aclcheck_all(Oid table_oid, Oid roleid,
- AclMode mode, AclMaskHow how);
+ AclMode mode, AclMaskHow how);
extern AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode);
extern AclResult pg_database_aclcheck(Oid db_oid, Oid roleid, AclMode mode);
extern AclResult pg_proc_aclcheck(Oid proc_oid, Oid roleid, AclMode mode);
const char *objectname);
extern void aclcheck_error_col(AclResult aclerr, AclObjectKind objectkind,
- const char *objectname, const char *colname);
+ const char *objectname, const char *colname);
/* ownercheck routines just return true (owner) or false (not) */
extern bool pg_class_ownercheck(Oid class_oid, Oid roleid);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* cash.h
#define DateADTGetDatum(X) Int32GetDatum(X)
#define TimeADTGetDatum(X) Int64GetDatum(X)
#define TimeTzADTPGetDatum(X) PointerGetDatum(X)
-
-#else /* !HAVE_INT64_TIMESTAMP */
+#else /* !HAVE_INT64_TIMESTAMP */
#define MAX_TIME_PRECISION 10
#define DateADTGetDatum(X) Int32GetDatum(X)
#define TimeADTGetDatum(X) Float8GetDatum(X)
#define TimeTzADTPGetDatum(X) PointerGetDatum(X)
-
#endif /* HAVE_INT64_TIMESTAMP */
#define PG_GETARG_DATEADT(n) DatumGetDateADT(PG_GETARG_DATUM(n))
extern int DecodeInterval(char **field, int *ftype, int nf, int range,
int *dtype, struct pg_tm * tm, fsec_t *fsec);
extern int DecodeISO8601Interval(char *str,
- int *dtype, struct pg_tm * tm, fsec_t *fsec);
+ int *dtype, struct pg_tm * tm, fsec_t *fsec);
extern void DateTimeParseError(int dterr, const char *str,
const char *datatype);
#define COMMERROR 16 /* Client communication problems; same as LOG
* for server reporting, but never sent to
* client. */
-#define INFO 17 /* Messages specifically requested by user
- * (eg VACUUM VERBOSE output); always sent to
+#define INFO 17 /* Messages specifically requested by user (eg
+ * VACUUM VERBOSE output); always sent to
* client regardless of client_min_messages,
* but by default not sent to server log. */
#define NOTICE 18 /* Helpful messages to users about query
- * operation; sent to client and server log
- * by default. */
+ * operation; sent to client and server log by
+ * default. */
#define WARNING 19 /* Warnings. NOTICE is for expected messages
* like implicit sequence creation by SERIAL.
* WARNING is for unexpected messages. */
extern int
errmsg_plural(const char *fmt_singular, const char *fmt_plural,
- unsigned long n, ...)
+ unsigned long n,...)
/* This extension allows gcc to check the format string for consistency with
the supplied arguments. */
__attribute__((format(printf, 1, 4)))
extern int
errdetail_plural(const char *fmt_singular, const char *fmt_plural,
- unsigned long n, ...)
+ unsigned long n,...)
/* This extension allows gcc to check the format string for consistency with
the supplied arguments. */
__attribute__((format(printf, 1, 4)))
struct config_enum_entry
{
const char *name;
- int val;
+ int val;
bool hidden;
};
GucShowHook show_hook);
extern void DefineCustomEnumVariable(
- const char *name,
- const char *short_desc,
- const char *long_desc,
- int *valueAddr,
- int bootValue,
- const struct config_enum_entry *options,
- GucContext context,
- int flags,
- GucEnumAssignHook assign_hook,
- GucShowHook show_hook);
+ const char *name,
+ const char *short_desc,
+ const char *long_desc,
+ int *valueAddr,
+ int bootValue,
+ const struct config_enum_entry * options,
+ GucContext context,
+ int flags,
+ GucEnumAssignHook assign_hook,
+ GucShowHook show_hook);
extern void EmitWarningsOnPlaceholders(const char *className);
extern void BeginReportingGUCOptions(void);
extern void ParseLongOption(const char *string, char **name, char **value);
extern bool parse_int(const char *value, int *result, int flags,
- const char **hintmsg);
+ const char **hintmsg);
extern bool parse_real(const char *value, double *result);
extern bool set_config_option(const char *name, const char *value,
GucContext context, GucSource source,
/* in access/transam/xlog.c */
extern bool assign_xlog_sync_method(int newval,
- bool doit, GucSource source);
+ bool doit, GucSource source);
#endif /* GUC_H */
GucSource reset_source; /* source of the reset_value */
GucSource source; /* source of the current actual value */
GucStack *stack; /* stacked prior values */
- char *sourcefile; /* file this settings is from (NULL if not file) */
+ char *sourcefile; /* file this settings is from (NULL if not
+ * file) */
int sourceline; /* line in source file */
};
extern void build_guc_variables(void);
/* search in enum options */
-extern const char *config_enum_lookup_by_value(struct config_enum *record, int val);
-extern bool config_enum_lookup_by_name(struct config_enum *record,
- const char *value, int *retval);
+extern const char *config_enum_lookup_by_value(struct config_enum * record, int val);
+extern bool config_enum_lookup_by_name(struct config_enum * record,
+ const char *value, int *retval);
#endif /* GUC_TABLES_H */
extern bool type_is_rowtype(Oid typid);
extern bool type_is_enum(Oid typid);
extern void get_type_category_preferred(Oid typid,
- char *typcategory,
- bool *typispreferred);
+ char *typcategory,
+ bool *typispreferred);
extern Oid get_typ_typrelid(Oid typid);
extern Oid get_element_type(Oid typid);
extern Oid get_array_type(Oid typid);
* InvalidBlockNumber */
int rd_refcnt; /* reference count */
bool rd_istemp; /* rel is a temporary relation */
- bool rd_islocaltemp; /* rel is a temp rel of this session */
+ bool rd_islocaltemp; /* rel is a temp rel of this session */
bool rd_isnailed; /* rel is nailed in cache */
bool rd_isvalid; /* relcache entry is valid */
char rd_indexvalid; /* state of rd_indexlist: 0 = not valid, 1 =
* sizes of the free space and visibility map forks, or InvalidBlockNumber
* if not known yet
*/
- BlockNumber rd_fsm_nblocks;
- BlockNumber rd_vm_nblocks;
+ BlockNumber rd_fsm_nblocks;
+ BlockNumber rd_vm_nblocks;
/* use "struct" here to avoid needing to include pgstat.h: */
struct PgStat_TableStatus *pgstat_info; /* statistics collection area */
/* autovacuum-related reloptions. */
typedef struct AutoVacOpts
{
- bool enabled;
- int vacuum_threshold;
- int analyze_threshold;
- int vacuum_cost_delay;
- int vacuum_cost_limit;
- int freeze_min_age;
- int freeze_max_age;
- int freeze_table_age;
- float8 vacuum_scale_factor;
- float8 analyze_scale_factor;
+ bool enabled;
+ int vacuum_threshold;
+ int analyze_threshold;
+ int vacuum_cost_delay;
+ int vacuum_cost_limit;
+ int freeze_min_age;
+ int freeze_max_age;
+ int freeze_table_age;
+ float8 vacuum_scale_factor;
+ float8 analyze_scale_factor;
} AutoVacOpts;
typedef struct StdRdOptions
{
int32 vl_len_; /* varlena header (do not touch directly!) */
int fillfactor; /* page fill factor in percent (0..100) */
- AutoVacOpts autovacuum; /* autovacuum-related options */
+ AutoVacOpts autovacuum; /* autovacuum-related options */
} StdRdOptions;
#define HEAP_MIN_FILLFACTOR 10
/* Hooks for plugins to get control when we ask for stats */
typedef bool (*get_relation_stats_hook_type) (PlannerInfo *root,
- RangeTblEntry *rte,
- AttrNumber attnum,
- VariableStatData *vardata);
+ RangeTblEntry *rte,
+ AttrNumber attnum,
+ VariableStatData *vardata);
extern PGDLLIMPORT get_relation_stats_hook_type get_relation_stats_hook;
typedef bool (*get_index_stats_hook_type) (PlannerInfo *root,
- Oid indexOid,
- AttrNumber indexattnum,
- VariableStatData *vardata);
+ Oid indexOid,
+ AttrNumber indexattnum,
+ VariableStatData *vardata);
extern PGDLLIMPORT get_index_stats_hook_type get_index_stats_hook;
extern void examine_variable(PlannerInfo *root, Node *node, int varRelid,
extern void AtEarlyCommit_Snapshot(void);
extern void AtEOXact_Snapshot(bool isCommit);
-#endif /* SNAPMGR_H */
+#endif /* SNAPMGR_H */
* function.
*/
typedef bool (*SnapshotSatisfiesFunc) (HeapTupleHeader tuple,
- Snapshot snapshot, Buffer buffer);
+ Snapshot snapshot, Buffer buffer);
typedef struct SnapshotData
{
HeapTupleBeingUpdated
} HTSU_Result;
-#endif /* SNAPSHOT_H */
+#endif /* SNAPSHOT_H */
typedef int64 TimestampTz;
typedef int64 TimeOffset;
typedef int32 fsec_t; /* fractional seconds (in microseconds) */
-
#else
typedef double Timestamp;
typedef double TimestampTz;
typedef double TimeOffset;
typedef double fsec_t; /* fractional seconds (in seconds) */
-
#endif
typedef struct
#define DT_NOBEGIN (-INT64CONST(0x7fffffffffffffff) - 1)
#define DT_NOEND (INT64CONST(0x7fffffffffffffff))
-
-#else /* !HAVE_INT64_TIMESTAMP */
+#else /* !HAVE_INT64_TIMESTAMP */
#define DatumGetTimestamp(X) ((Timestamp) DatumGetFloat8(X))
#define DatumGetTimestampTz(X) ((TimestampTz) DatumGetFloat8(X))
#define DT_NOBEGIN (-DBL_MAX)
#define DT_NOEND (DBL_MAX)
#endif
-
#endif /* HAVE_INT64_TIMESTAMP */
/* Set at postmaster start */
extern TimestampTz PgStartTime;
+
/* Set at configuration reload */
extern TimestampTz PgReloadTime;
bool enforceUnique,
int workMem, bool randomAccess);
extern Tuplesortstate *tuplesort_begin_index_hash(Relation indexRel,
- uint32 hash_mask,
- int workMem, bool randomAccess);
+ uint32 hash_mask,
+ int workMem, bool randomAccess);
extern Tuplesortstate *tuplesort_begin_datum(Oid datumType,
Oid sortOperator, bool nullsFirstFlag,
int workMem, bool randomAccess);
TupleTableSlot *slot);
extern void tuplestore_puttuple(Tuplestorestate *state, HeapTuple tuple);
extern void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc,
- Datum *values, bool *isnull);
+ Datum *values, bool *isnull);
/* tuplestore_donestoring() used to be required, but is no longer used */
#define tuplestore_donestoring(state) ((void) 0)
extern void tuplestore_select_read_pointer(Tuplestorestate *state, int ptr);
extern void tuplestore_copy_read_pointer(Tuplestorestate *state,
- int srcptr, int destptr);
+ int srcptr, int destptr);
extern void tuplestore_trim(Tuplestorestate *state);
XMLBINARY_HEX
} XmlBinaryType;
-extern int xmlbinary; /* XmlBinaryType, but int for guc enum */
+extern int xmlbinary; /* XmlBinaryType, but int for guc enum */
-extern int xmloption; /* XmlOptionType, but int for guc enum */
+extern int xmloption; /* XmlOptionType, but int for guc enum */
#endif /* XML_H */
extern bool WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2);
extern Datum WinGetFuncArgInPartition(WindowObject winobj, int argno,
- int relpos, int seektype, bool set_mark,
- bool *isnull, bool *isout);
+ int relpos, int seektype, bool set_mark,
+ bool *isnull, bool *isout);
extern Datum WinGetFuncArgInFrame(WindowObject winobj, int argno,
- int relpos, int seektype, bool set_mark,
- bool *isnull, bool *isout);
+ int relpos, int seektype, bool set_mark,
+ bool *isnull, bool *isout);
extern Datum WinGetFuncArgCurrent(WindowObject winobj, int argno,
- bool *isnull);
+ bool *isnull);
#endif /* WINDOWAPI_H */
ecpg_strndup(const char *str, size_t len)
{
int real_len = strlen(str);
- int use_len = (real_len > len) ? (int)len : real_len;
+ int use_len = (real_len > len) ? (int) len : real_len;
char *new = malloc(use_len + 1);
struct sqlca_t *sqlca = ECPGget_sqlca();
enum COMPAT_MODE compat = c;
struct connection *this;
- int i;
+ int i;
char *dbname = name ? ecpg_strdup(name, lineno) : NULL,
*host = NULL,
*tmp,
options ? "with options " : "", options ? options : "",
user ? "for user " : "", user ? user : "");
- connect_string = ecpg_alloc( strlen_or_null(host)
- + strlen_or_null(port)
- + strlen_or_null(options)
- + strlen_or_null(realname)
- + strlen_or_null(user)
- + strlen_or_null(passwd)
- + sizeof(" host = port = dbname = user = password ="), lineno);
+ connect_string = ecpg_alloc(strlen_or_null(host)
+ + strlen_or_null(port)
+ + strlen_or_null(options)
+ + strlen_or_null(realname)
+ + strlen_or_null(user)
+ + strlen_or_null(passwd)
+ + sizeof(" host = port = dbname = user = password ="), lineno);
- if (options) /* replace '&' if tehre are any */
+ if (options) /* replace '&' if tehre are any */
for (i = 0; options[i]; i++)
if (options[i] == '&')
options[i] = ' ';
- sprintf(connect_string,"%s%s %s%s %s%s %s%s %s%s %s",
- realname ? "dbname=" : "", realname ? realname : "",
- host ? "host=" : "", host ? host : "",
- port ? "port=" : "", port ? port : "",
- user ? "user=" : "", user ? user : "",
- passwd ? "password=" : "", passwd ? passwd : "",
- options ? options : "");
-
- /* this is deprecated
- * this->connection = PQsetdbLogin(host, port, options, NULL, realname, user, passwd);*/
+ sprintf(connect_string, "%s%s %s%s %s%s %s%s %s%s %s",
+ realname ? "dbname=" : "", realname ? realname : "",
+ host ? "host=" : "", host ? host : "",
+ port ? "port=" : "", port ? port : "",
+ user ? "user=" : "", user ? user : "",
+ passwd ? "password=" : "", passwd ? passwd : "",
+ options ? options : "");
+
+ /*
+ * this is deprecated this->connection = PQsetdbLogin(host, port, options,
+ * NULL, realname, user, passwd);
+ */
this->connection = PQconnectdb(connect_string);
ecpg_free(connect_string);
return true;
}
-PGconn* ECPGget_PGconn(const char *connection_name)
+PGconn *
+ECPGget_PGconn(const char *connection_name)
{
- struct connection * con;
+ struct connection *con;
- con=ecpg_get_connection(connection_name);
- if (con==NULL) return NULL;
+ con = ecpg_get_connection(connection_name);
+ if (con == NULL)
+ return NULL;
return con->connection;
}
for (;;)
{
enum ECPGdtype itemtype;
- char *tobeinserted = NULL;
+ char *tobeinserted = NULL;
itemtype = va_arg(args, enum ECPGdtype);
{
case ECPG_NOT_FOUND:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("no data found on line %d"), line);
break;
case ECPG_OUT_OF_MEMORY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("out of memory on line %d"), line);
break;
case ECPG_UNSUPPORTED:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("unsupported type \"%s\" on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("unsupported type \"%s\" on line %d"), str, line);
break;
case ECPG_TOO_MANY_ARGUMENTS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("too many arguments on line %d"), line);
break;
case ECPG_TOO_FEW_ARGUMENTS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("too few arguments on line %d"), line);
break;
case ECPG_INT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("invalid input syntax for type int: \"%s\", on line %d"), str, line);
break;
case ECPG_UINT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("invalid input syntax for type unsigned int: \"%s\", on line %d"), str, line);
break;
case ECPG_FLOAT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("invalid input syntax for floating-point type: \"%s\", on line %d"), str, line);
break;
case ECPG_CONVERT_BOOL:
if (str)
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("invalid syntax for type boolean: \"%s\", on line %d"), str, line);
else
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("could not convert boolean value: size mismatch, on line %d"), line);
break;
case ECPG_EMPTY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("empty query on line %d"), line);
break;
case ECPG_MISSING_INDICATOR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("null value without indicator on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("null value without indicator on line %d"), line);
break;
case ECPG_NO_ARRAY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("variable does not have an array type on line %d"), line);
break;
case ECPG_DATA_NOT_ARRAY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
ecpg_gettext("data read from server is not an array on line %d"), line);
break;
case ECPG_ARRAY_INSERT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("inserting an array of variables is not supported on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("inserting an array of variables is not supported on line %d"), line);
break;
case ECPG_NO_CONN:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("connection \"%s\" does not exist on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("connection \"%s\" does not exist on line %d"), str, line);
break;
case ECPG_NOT_CONN:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("not connected to connection \"%s\" on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("not connected to connection \"%s\" on line %d"), str, line);
break;
case ECPG_INVALID_STMT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("invalid statement name \"%s\" on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("invalid statement name \"%s\" on line %d"), str, line);
break;
case ECPG_UNKNOWN_DESCRIPTOR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("descriptor \"%s\" not found on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("descriptor \"%s\" not found on line %d"), str, line);
break;
case ECPG_INVALID_DESCRIPTOR_INDEX:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("descriptor index out of range on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("descriptor index out of range on line %d"), line);
break;
case ECPG_UNKNOWN_DESCRIPTOR_ITEM:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("unrecognized descriptor item \"%s\" on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("unrecognized descriptor item \"%s\" on line %d"), str, line);
break;
case ECPG_VAR_NOT_NUMERIC:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("variable does not have a numeric type on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("variable does not have a numeric type on line %d"), line);
break;
case ECPG_VAR_NOT_CHAR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("variable does not have a character type on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("variable does not have a character type on line %d"), line);
break;
case ECPG_TRANS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("error in transaction processing on line %d"), line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("error in transaction processing on line %d"), line);
break;
case ECPG_CONNECT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("could not connect to database \"%s\" on line %d"), str, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("could not connect to database \"%s\" on line %d"), str, line);
break;
default:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- /* translator: this string will be truncated at 149
- characters expanded. */
- ecpg_gettext("SQL error %d on line %d"), code, line);
+
+ /*
+ * translator: this string will be truncated at 149 characters
+ * expanded.
+ */
+ ecpg_gettext("SQL error %d on line %d"), code, line);
break;
}
int i;
for (i = p + 1; isdigit((unsigned char) text[i]); i++)
- /* empty loop body */ ;
+ /* empty loop body */ ;
if (!isalpha((unsigned char) text[i]) &&
- isascii((unsigned char) text[i]) && text[i] != '_')
+ isascii((unsigned char) text[i]) &&text[i] != '_')
/* not dollar delimited quote */
return p;
}
{
int len = 0;
- if (!PQfformat(results, act_field))
+ if (!PQfformat(results, act_field))
{
switch (var->type)
{
/* special mode for handling char**foo=0 */
for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
len += strlen(PQgetvalue(results, act_tuple, act_field)) + 1;
- len *= var->offset; /* should be 1, but YMNK */
+ len *= var->offset; /* should be 1, but YMNK */
len += (ntuples + 1) * sizeof(char *);
}
else
case ECPGt_unsigned_char:
{
/* set slen to string length if type is char * */
- int slen = (var->varcharsize == 0) ? strlen((char *) var->value) : (unsigned int)var->varcharsize;
+ int slen = (var->varcharsize == 0) ? strlen((char *) var->value) : (unsigned int) var->varcharsize;
if (!(newcopy = ecpg_alloc(slen + 1, lineno)))
return false;
static bool
insert_tobeinserted(int position, int ph_len, struct statement * stmt, char *tobeinserted)
{
- char *newcopy;
+ char *newcopy;
if (!(newcopy = (char *) ecpg_alloc(strlen(stmt->command)
+ strlen(tobeinserted)
strcpy(newcopy + position - 1, tobeinserted);
/*
- * The strange thing in the second argument is the rest of the
- * string from the old string
+ * The strange thing in the second argument is the rest of the string from
+ * the old string
*/
strcat(newcopy,
stmt->command
var = stmt->inlist;
while (var)
{
- char *tobeinserted;
+ char *tobeinserted;
int counter = 1;
tobeinserted = NULL;
if ((position = next_insert(stmt->command, position, stmt->questionmarks) + 1) == 0)
{
/*
- * We have an argument but we dont have the matched up
- * placeholder in the string
+ * We have an argument but we dont have the matched up placeholder
+ * in the string
*/
ecpg_raise(stmt->lineno, ECPG_TOO_MANY_ARGUMENTS,
- ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS,
+ ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS,
NULL);
free_params(paramValues, nParams, false, stmt->lineno);
return false;
}
- /*
+ /*
* if var->type=ECPGt_char_variable we have a dynamic cursor we have
* to simulate a dynamic cursor because there is no backend
* functionality for it
*/
if (var->type == ECPGt_char_variable)
{
- int ph_len = (stmt->command[position] == '?') ? strlen("?") : strlen("$1");
+ int ph_len = (stmt->command[position] == '?') ? strlen("?") : strlen("$1");
if (!insert_tobeinserted(position, ph_len, stmt, tobeinserted))
{
}
tobeinserted = NULL;
}
+
/*
* if the placeholder is '$0' we have to replace it on the client side
- * this is for places we want to support variables at that are not supported in the backend
+ * this is for places we want to support variables at that are not
+ * supported in the backend
*/
- else if (stmt->command[position] == '0' )
+ else if (stmt->command[position] == '0')
{
if (!insert_tobeinserted(position, 2, stmt, tobeinserted))
{
desc->result = results;
clear_result = false;
ecpg_log("ecpg_execute on line %d: putting result (%d tuples) into descriptor %s\n",
- stmt->lineno, PQntuples(results), (const char *) var->pointer);
+ stmt->lineno, PQntuples(results), (const char *) var->pointer);
}
var = var->next;
}
ecpg_log(const char *format,...)
{
va_list ap;
- struct sqlca_t *sqlca = ECPGget_sqlca();
+ struct sqlca_t *sqlca = ECPGget_sqlca();
const char *intl_format;
int bufsize;
- char *fmt;
+ char *fmt;
if (!simple_debug)
return;
intl_format = ecpg_gettext(format);
/*
- * Insert PID into the format, unless ecpg_internal_regression_mode is
- * set (regression tests want unchanging output).
+ * Insert PID into the format, unless ecpg_internal_regression_mode is set
+ * (regression tests want unchanging output).
*/
bufsize = strlen(intl_format) + 100;
fmt = (char *) malloc(bufsize);
{
if (mutex->handle == NULL)
{
- while (InterlockedExchange((LONG *) & mutex->initlock, 1) == 1)
+ while (InterlockedExchange((LONG *) &mutex->initlock, 1) == 1)
Sleep(0);
if (mutex->handle == NULL)
mutex->handle = CreateMutex(NULL, FALSE, NULL);
- InterlockedExchange((LONG *) & mutex->initlock, 0);
+ InterlockedExchange((LONG *) &mutex->initlock, 0);
}
}
}
}
#endif /* ENABLE_THREAD_SAFETY */
-
#endif /* WIN32 */
#ifdef ENABLE_NLS
{
stmtCacheEntry *entry;
struct connection *con;
- struct prepared_statement *this, *prev;
+ struct prepared_statement *this,
+ *prev;
entry = &stmtCacheEntries[entNo];
if (!entry->stmtID[0]) /* return if the entry isn't in use */
con = ecpg_get_connection(entry->connection);
- /* free the 'prepared_statement' list entry */
+ /* free the 'prepared_statement' list entry */
this = find_prepared_statement(entry->stmtID, con, &prev);
if (this && !deallocate_one(lineno, compat, con, prev, this))
return (-1);
AddStmtToCache(int lineno, /* line # of statement */
char *stmtID, /* statement ID */
const char *connection, /* connection */
- int compat, /* compatibility level */
+ int compat, /* compatibility level */
const char *ecpgQuery) /* query */
{
int ix,
#include <ecpg_informix.h>
-#ifndef _ECPGLIB_H /* source created by ecpg which defines these symbols */
+#ifndef _ECPGLIB_H /* source created by ecpg which defines these
+ * symbols */
typedef timestamp dtime_t;
typedef interval intrvl_t;
-#endif /* ndef _ECPGLIB_H */
+#endif /* ndef _ECPGLIB_H */
#endif /* ndef _ECPG_DATETIME_H */
#include <ecpg_informix.h>
-#ifndef _ECPGLIB_H /* source created by ecpg which defines this symbol */
-typedef decimal dec_t;
-#endif /* ndef _ECPGLIB_H */
+#ifndef _ECPGLIB_H /* source created by ecpg which defines this
+ * symbol */
+typedef decimal dec_t;
+#endif /* ndef _ECPGLIB_H */
#endif /* ndef _ECPG_DECIMAL_H */
ecpg_gettext(const char *msgid)
__attribute__((format_arg(1)));
#else
-#define ecpg_gettext(x) (x)
+#define ecpg_gettext(x) (x)
#endif
#ifndef __cplusplus
bool ECPGprepare(int, const char *, const bool, const char *, const char *);
bool ECPGdeallocate(int, int, const char *, const char *);
bool ECPGdeallocate_all(int, int, const char *);
-char *ECPGprepared_statement(const char *, const char *, int);
-PGconn *ECPGget_PGconn(const char *);
+char *ECPGprepared_statement(const char *, const char *, int);
+PGconn *ECPGget_PGconn(const char *);
-char *ECPGerrmsg(void);
+char *ECPGerrmsg(void);
/* print an error message */
void sqlprint(void);
/* define this for simplicity as well as compatibility */
#define SQLCODE sqlca.sqlcode
-#define SQLSTATE sqlca.sqlstate
+#define SQLSTATE sqlca.sqlstate
/* dynamic SQL */
bool ECPGdeallocate_desc(int, const char *);
bool ECPGallocate_desc(int, const char *);
bool ECPGget_desc_header(int, const char *, int *);
-bool ECPGget_desc(int, const char *, int, ...);
+bool ECPGget_desc(int, const char *, int,...);
bool ECPGset_desc_header(int, const char *, int);
-bool ECPGset_desc(int, const char *, int, ...);
+bool ECPGset_desc(int, const char *, int,...);
void ECPGset_noind_null(enum ECPGttype, void *);
bool ECPGis_noind_null(enum ECPGttype, void *);
-bool ECPGdescribe(int, bool, const char *, ...);
+bool ECPGdescribe(int, bool, const char *,...);
/* dynamic result allocation */
void ECPGfree_auto_mem(void);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
-
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef ECPG_SQLTYPES_H
#define ECPG_SQLTYPES_H
char *fmt_ystart,
*fmt_mstart,
*fmt_dstart;
- unsigned int i;
+ unsigned int i;
int reading_digit;
int token_count;
char *str_copy;
#define USE_SQL_DATES 2
#define USE_GERMAN_DATES 3
-#define INTSTYLE_POSTGRES 0
-#define INTSTYLE_POSTGRES_VERBOSE 1
-#define INTSTYLE_SQL_STANDARD 2
-#define INTSTYLE_ISO_8601 3
+#define INTSTYLE_POSTGRES 0
+#define INTSTYLE_POSTGRES_VERBOSE 1
+#define INTSTYLE_SQL_STANDARD 2
+#define INTSTYLE_ISO_8601 3
#define INTERVAL_FULL_RANGE (0x7FFF)
#define INTERVAL_MASK(b) (1 << (b))
*/
/* Copy&pasted these values from src/include/utils/datetime.h */
#define DTK_M(t) (0x01 << (t))
-#define DTK_ALL_SECS_M (DTK_M(SECOND) | DTK_M(MILLISECOND) | DTK_M(MICROSECOND))
+#define DTK_ALL_SECS_M (DTK_M(SECOND) | DTK_M(MILLISECOND) | DTK_M(MICROSECOND))
#define DTK_DATE_M (DTK_M(YEAR) | DTK_M(MONTH) | DTK_M(DAY))
#define DTK_TIME_M (DTK_M(HOUR) | DTK_M(MINUTE) | DTK_M(SECOND))
int DecodeUnits(int field, char *lowtoken, int *val);
bool CheckDateTokenTables(void);
int EncodeDateOnly(struct tm *, int, char *, bool);
-int GetEpochTime(struct tm *);
+int GetEpochTime(struct tm *);
int ParseDateTime(char *, char *, char **, int *, int *, char **);
int DecodeDateTime(char **, int *, int, int *, struct tm *, fsec_t *, bool);
void j2date(int, int *, int *, int *);
*/
static int
DecodeNumberField(int len, char *str, int fmask,
- int *tmask, struct tm * tm, fsec_t *fsec, int *is2digits)
+ int *tmask, struct tm * tm, fsec_t *fsec, int *is2digits)
{
char *cp;
*/
int
ParseDateTime(char *timestr, char *lowstr,
- char **field, int *ftype, int *numfields, char **endstr)
+ char **field, int *ftype, int *numfields, char **endstr)
{
int nf = 0;
char *lp = lowstr;
* time
*/
if ((ftype[i] = DecodeNumberField(strlen(field[i]), field[i], fmask,
- &tmask, tm, fsec, &is2digits)) < 0)
+ &tmask, tm, fsec, &is2digits)) < 0)
return -1;
/*
case DTK_TIME:
/* previous field was "t" for ISO time */
if ((ftype[i] = DecodeNumberField(strlen(field[i]), field[i], (fmask | DTK_DATE_M),
- &tmask, tm, fsec, &is2digits)) < 0)
+ &tmask, tm, fsec, &is2digits)) < 0)
return -1;
if (tmask != DTK_TIME_M)
* Example: 20011223 or 040506
*/
if ((ftype[i] = DecodeNumberField(flen, field[i], fmask,
- &tmask, tm, fsec, &is2digits)) < 0)
+ &tmask, tm, fsec, &is2digits)) < 0)
return -1;
}
else if (flen > 4)
{
if ((ftype[i] = DecodeNumberField(flen, field[i], fmask,
- &tmask, tm, fsec, &is2digits)) < 0)
+ &tmask, tm, fsec, &is2digits)) < 0)
return -1;
}
/* otherwise it is a single date/time field... */
int scan_type;
char *pstr,
- *pfmt,
- *tmp;
- int err = 1;
- unsigned int j;
+ *pfmt,
+ *tmp;
+ int err = 1;
+ unsigned int j;
struct tm tm;
pfmt = fmt;
static int
strtoi(const char *nptr, char **endptr, int base)
{
- long val;
+ long val;
val = strtol(nptr, endptr, base);
#ifdef HAVE_LONG_INT_64
return (int) val;
}
-/* copy&pasted from .../src/backend/utils/adt/datetime.c
+/* copy&pasted from .../src/backend/utils/adt/datetime.c
* and changesd struct pg_tm to struct tm
*/
static void
-AdjustFractSeconds(double frac, struct /*pg_*/tm * tm, fsec_t *fsec, int scale)
+AdjustFractSeconds(double frac, struct /* pg_ */ tm * tm, fsec_t *fsec, int scale)
{
- int sec;
+ int sec;
if (frac == 0)
return;
- frac *= scale;
- sec = (int) frac;
+ frac *= scale;
+ sec = (int) frac;
tm->tm_sec += sec;
- frac -= sec;
+ frac -= sec;
#ifdef HAVE_INT64_TIMESTAMP
- *fsec += rint(frac * 1000000);
+ *fsec += rint(frac * 1000000);
#else
- *fsec += frac;
+ *fsec += frac;
#endif
}
-/* copy&pasted from .../src/backend/utils/adt/datetime.c
+/* copy&pasted from .../src/backend/utils/adt/datetime.c
* and changesd struct pg_tm to struct tm
*/
static void
-AdjustFractDays(double frac, struct /*pg_*/tm * tm, fsec_t *fsec, int scale)
+AdjustFractDays(double frac, struct /* pg_ */ tm * tm, fsec_t *fsec, int scale)
{
- int extra_days;
+ int extra_days;
if (frac == 0)
return;
- frac *= scale;
- extra_days = (int) frac;
+ frac *= scale;
+ extra_days = (int) frac;
tm->tm_mday += extra_days;
- frac -= extra_days;
+ frac -= extra_days;
AdjustFractSeconds(frac, tm, fsec, SECS_PER_DAY);
}
}
-/* copy&pasted from .../src/backend/utils/adt/datetime.c
+/* copy&pasted from .../src/backend/utils/adt/datetime.c
* and changesd struct pg_tm to struct tm
*/
-static inline void
-ClearPgTm(struct /*pg_*/tm *tm, fsec_t *fsec)
+static inline void
+ClearPgTm(struct /* pg_ */ tm * tm, fsec_t *fsec)
{
tm->tm_year = 0;
- tm->tm_mon = 0;
+ tm->tm_mon = 0;
tm->tm_mday = 0;
tm->tm_hour = 0;
- tm->tm_min = 0;
- tm->tm_sec = 0;
- *fsec = 0;
+ tm->tm_min = 0;
+ tm->tm_sec = 0;
+ *fsec = 0;
}
-/* copy&pasted from .../src/backend/utils/adt/datetime.c
- *
+/* copy&pasted from .../src/backend/utils/adt/datetime.c
+ *
* * changesd struct pg_tm to struct tm
- *
+ *
* * Made the function static
*/
static int
DecodeISO8601Interval(char *str,
- int *dtype, struct /*pg_*/tm * tm, fsec_t *fsec)
+ int *dtype, struct /* pg_ */ tm * tm, fsec_t *fsec)
{
- bool datepart = true;
- bool havefield = false;
+ bool datepart = true;
+ bool havefield = false;
*dtype = DTK_DELTA;
ClearPgTm(tm, fsec);
str++;
while (*str)
{
- char *fieldstart;
- int val;
- double fval;
- char unit;
- int dterr;
+ char *fieldstart;
+ int val;
+ double fval;
+ char unit;
+ int dterr;
- if (*str == 'T') /* T indicates the beginning of the time part */
+ if (*str == 'T') /* T indicates the beginning of the time part */
{
datepart = false;
havefield = false;
return dterr;
/*
- * Note: we could step off the end of the string here. Code below
+ * Note: we could step off the end of the string here. Code below
* *must* exit the loop if unit == '\0'.
*/
unit = *str++;
if (datepart)
{
- switch (unit) /* before T: Y M W D */
+ switch (unit) /* before T: Y M W D */
{
case 'Y':
tm->tm_year += val;
tm->tm_mday += val;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_DAY);
break;
- case 'T': /* ISO 8601 4.4.3.3 Alternative Format / Basic */
+ case 'T': /* ISO 8601 4.4.3.3 Alternative Format / Basic */
case '\0':
if (ISO8601IntegerWidth(fieldstart) == 8 && !havefield)
{
tm->tm_year += val / 10000;
- tm->tm_mon += (val / 100) % 100;
+ tm->tm_mon += (val / 100) % 100;
tm->tm_mday += val % 100;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_DAY);
if (unit == '\0')
continue;
}
/* Else fall through to extended alternative format */
- case '-': /* ISO 8601 4.4.3.3 Alternative Format, Extended */
+ case '-': /* ISO 8601 4.4.3.3 Alternative Format,
+ * Extended */
if (havefield)
return DTERR_BAD_FORMAT;
tm->tm_year += val;
- tm->tm_mon += (fval * 12);
+ tm->tm_mon += (fval * 12);
if (unit == '\0')
return 0;
if (unit == 'T')
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_mon += val;
+ tm->tm_mon += val;
AdjustFractDays(fval, tm, fsec, DAYS_PER_MONTH);
if (*str == '\0')
return 0;
if (*str != '-')
return DTERR_BAD_FORMAT;
str++;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
}
else
{
- switch (unit) /* after T: H M S */
+ switch (unit) /* after T: H M S */
{
case 'H':
tm->tm_hour += val;
tm->tm_sec += val;
AdjustFractSeconds(fval, tm, fsec, 1);
break;
- case '\0': /* ISO 8601 4.4.3.3 Alternative Format */
- if (ISO8601IntegerWidth(fieldstart) == 6 && !havefield)
+ case '\0': /* ISO 8601 4.4.3.3 Alternative Format */
+ if (ISO8601IntegerWidth(fieldstart) == 6 && !havefield)
{
tm->tm_hour += val / 10000;
- tm->tm_min += (val / 100) % 100;
- tm->tm_sec += val % 100;
+ tm->tm_min += (val / 100) % 100;
+ tm->tm_sec += val % 100;
AdjustFractSeconds(fval, tm, fsec, 1);
return 0;
}
/* Else fall through to extended alternative format */
- case ':': /* ISO 8601 4.4.3.3 Alternative Format, Extended */
+ case ':': /* ISO 8601 4.4.3.3 Alternative Format,
+ * Extended */
if (havefield)
return DTERR_BAD_FORMAT;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_HOUR);
if (unit == '\0')
return 0;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_min += val;
+ tm->tm_min += val;
AdjustFractSeconds(fval, tm, fsec, SECS_PER_MINUTE);
if (*str == '\0')
return 0;
if (*str != ':')
return DTERR_BAD_FORMAT;
str++;
-
+
dterr = ParseISO8601Number(str, &str, &val, &fval);
if (dterr)
return dterr;
- tm->tm_sec += val;
+ tm->tm_sec += val;
AdjustFractSeconds(fval, tm, fsec, 1);
if (*str == '\0')
return 0;
/* copy&pasted from .../src/backend/utils/adt/datetime.c
* with 3 exceptions
*
- * * changesd struct pg_tm to struct tm
+ * * changesd struct pg_tm to struct tm
*
- * * ECPG code called this without a 'range' parameter
- * removed 'int range' from the argument list and
- * places where DecodeTime is called; and added
- * int range = INTERVAL_FULL_RANGE;
+ * * ECPG code called this without a 'range' parameter
+ * removed 'int range' from the argument list and
+ * places where DecodeTime is called; and added
+ * int range = INTERVAL_FULL_RANGE;
*
- * * ECPG semes not to have a global IntervalStyle
- * so added
- * int IntervalStyle = INTSTYLE_POSTGRES;
+ * * ECPG semes not to have a global IntervalStyle
+ * so added
+ * int IntervalStyle = INTSTYLE_POSTGRES;
*
- * * Assert wasn't available so removed it.
+ * * Assert wasn't available so removed it.
*/
int
-DecodeInterval(char **field, int *ftype, int nf, /*int range,*/
- int *dtype, struct /*pg_*/tm * tm, fsec_t *fsec)
+DecodeInterval(char **field, int *ftype, int nf, /* int range, */
+ int *dtype, struct /* pg_ */ tm * tm, fsec_t *fsec)
{
- int IntervalStyle = INTSTYLE_POSTGRES_VERBOSE;
- int range = INTERVAL_FULL_RANGE;
+ int IntervalStyle = INTSTYLE_POSTGRES_VERBOSE;
+ int range = INTERVAL_FULL_RANGE;
bool is_before = FALSE;
char *cp;
int fmask = 0,
*dtype = DTK_DELTA;
type = IGNORE_DTF;
- ClearPgTm(tm,fsec);
+ ClearPgTm(tm, fsec);
/* read through list backwards to pick up units before values */
for (i = nf - 1; i >= 0; i--)
switch (ftype[i])
{
case DTK_TIME:
- dterr = DecodeTime(field[i], /* range, */
+ dterr = DecodeTime(field[i], /* range, */
&tmask, tm, fsec);
if (dterr)
return dterr;
case DTK_TZ:
/*
- * Timezone is a token with a leading sign character and
- * at least one digit; there could be ':', '.', '-'
- * embedded in it as well.
+ * Timezone is a token with a leading sign character and at
+ * least one digit; there could be ':', '.', '-' embedded in
+ * it as well.
*/
/* Assert(*field[i] == '-' || *field[i] == '+'); */
/*
* Try for hh:mm or hh:mm:ss. If not, fall through to
- * DTK_NUMBER case, which can handle signed float numbers
- * and signed year-month values.
+ * DTK_NUMBER case, which can handle signed float numbers and
+ * signed year-month values.
*/
if (strchr(field[i] + 1, ':') != NULL &&
- DecodeTime(field[i] + 1, /* INTERVAL_FULL_RANGE, */
+ DecodeTime(field[i] + 1, /* INTERVAL_FULL_RANGE, */
&tmask, tm, fsec) == 0)
{
if (*field[i] == '-')
if (*cp == '-')
{
/* SQL "years-months" syntax */
- int val2;
+ int val2;
val2 = strtoi(cp + 1, &cp, 10);
if (errno == ERANGE || val2 < 0 || val2 >= MONTHS_PER_YEAR)
/*----------
* The SQL standard defines the interval literal
- * '-1 1:00:00'
+ * '-1 1:00:00'
* to mean "negative 1 days and negative 1 hours", while Postgres
* traditionally treats this as meaning "negative 1 days and positive
* 1 hours". In SQL_STANDARD intervalstyle, we apply the leading sign
* This protects us against misinterpreting postgres-style dump output,
* since the postgres-style output code has always put an explicit sign on
* all fields following a negative field. But note that SQL-spec output
- * is ambiguous and can be misinterpreted on load! (So it's best practice
+ * is ambiguous and can be misinterpreted on load! (So it's best practice
* to dump in postgres style, not SQL style.)
*----------
*/
if (IntervalStyle == INTSTYLE_SQL_STANDARD && *field[0] == '-')
{
/* Check for additional explicit signs */
- bool more_signs = false;
+ bool more_signs = false;
for (i = 1; i < nf; i++)
{
if (!more_signs)
{
/*
- * Rather than re-determining which field was field[0], just
- * force 'em all negative.
+ * Rather than re-determining which field was field[0], just force
+ * 'em all negative.
*/
if (*fsec > 0)
*fsec = -(*fsec);
value,
units,
(value != 1) ? "s" : "");
+
/*
- * Each nonzero field sets is_before for (only) the next one. This is
- * a tad bizarre but it's how it worked before...
+ * Each nonzero field sets is_before for (only) the next one. This is a
+ * tad bizarre but it's how it worked before...
*/
*is_before = (value < 0);
*is_zero = FALSE;
/* copy&pasted from .../src/backend/utils/adt/datetime.c
- *
+ *
* Change pg_tm to tm
*/
int
-EncodeInterval(struct /*pg_*/tm * tm, fsec_t fsec, int style, char *str)
+EncodeInterval(struct /* pg_ */ tm * tm, fsec_t fsec, int style, char *str)
{
char *cp = str;
int year = tm->tm_year;
- int mon = tm->tm_mon;
+ int mon = tm->tm_mon;
int mday = tm->tm_mday;
int hour = tm->tm_hour;
- int min = tm->tm_min;
- int sec = tm->tm_sec;
+ int min = tm->tm_min;
+ int sec = tm->tm_sec;
bool is_before = FALSE;
bool is_zero = TRUE;
*/
switch (style)
{
- /* SQL Standard interval format */
+ /* SQL Standard interval format */
case INTSTYLE_SQL_STANDARD:
{
- bool has_negative = year < 0 || mon < 0 ||
- mday < 0 || hour < 0 ||
- min < 0 || sec < 0 || fsec < 0;
- bool has_positive = year > 0 || mon > 0 ||
- mday > 0 || hour > 0 ||
- min > 0 || sec > 0 || fsec > 0;
- bool has_year_month = year != 0 || mon != 0;
- bool has_day_time = mday != 0 || hour != 0 ||
- min != 0 || sec != 0 || fsec != 0;
- bool has_day = mday != 0;
- bool sql_standard_value = !(has_negative && has_positive) &&
- !(has_year_month && has_day_time);
+ bool has_negative = year < 0 || mon < 0 ||
+ mday < 0 || hour < 0 ||
+ min < 0 || sec < 0 || fsec < 0;
+ bool has_positive = year > 0 || mon > 0 ||
+ mday > 0 || hour > 0 ||
+ min > 0 || sec > 0 || fsec > 0;
+ bool has_year_month = year != 0 || mon != 0;
+ bool has_day_time = mday != 0 || hour != 0 ||
+ min != 0 || sec != 0 || fsec != 0;
+ bool has_day = mday != 0;
+ bool sql_standard_value = !(has_negative && has_positive) &&
+ !(has_year_month && has_day_time);
/*
* SQL Standard wants only 1 "<sign>" preceding the whole
{
*cp++ = '-';
year = -year;
- mon = -mon;
+ mon = -mon;
mday = -mday;
hour = -hour;
- min = -min;
- sec = -sec;
+ min = -min;
+ sec = -sec;
fsec = -fsec;
}
else if (!sql_standard_value)
{
/*
- * For non sql-standard interval values,
- * force outputting the signs to avoid
- * ambiguities with intervals with mixed
- * sign components.
+ * For non sql-standard interval values, force outputting
+ * the signs to avoid ambiguities with intervals with
+ * mixed sign components.
*/
- char year_sign = (year < 0 || mon < 0) ? '-' : '+';
- char day_sign = (mday < 0) ? '-' : '+';
- char sec_sign = (hour < 0 || min < 0 ||
- sec < 0 || fsec < 0) ? '-' : '+';
+ char year_sign = (year < 0 || mon < 0) ? '-' : '+';
+ char day_sign = (mday < 0) ? '-' : '+';
+ char sec_sign = (hour < 0 || min < 0 ||
+ sec < 0 || fsec < 0) ? '-' : '+';
sprintf(cp, "%c%d-%d %c%d %c%d:%02d:",
year_sign, abs(year), abs(mon),
}
break;
- /* ISO 8601 "time-intervals by duration only" */
+ /* ISO 8601 "time-intervals by duration only" */
case INTSTYLE_ISO_8601:
/* special-case zero to avoid printing nothing */
if (year == 0 && mon == 0 && mday == 0 &&
- hour == 0 && min == 0 && sec == 0 && fsec == 0)
+ hour == 0 && min == 0 && sec == 0 && fsec == 0)
{
sprintf(cp, "PT0S");
break;
}
*cp++ = 'P';
cp = AddISO8601IntPart(cp, year, 'Y');
- cp = AddISO8601IntPart(cp, mon , 'M');
+ cp = AddISO8601IntPart(cp, mon, 'M');
cp = AddISO8601IntPart(cp, mday, 'D');
if (hour != 0 || min != 0 || sec != 0 || fsec != 0)
*cp++ = 'T';
cp = AddISO8601IntPart(cp, hour, 'H');
- cp = AddISO8601IntPart(cp, min , 'M');
+ cp = AddISO8601IntPart(cp, min, 'M');
if (sec != 0 || fsec != 0)
{
if (sec < 0 || fsec < 0)
}
break;
- /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
+ /* Compatible with postgresql < 8.4 when DateStyle = 'iso' */
case INTSTYLE_POSTGRES:
cp = AddPostgresIntPart(cp, year, "year", &is_zero, &is_before);
cp = AddPostgresIntPart(cp, mon, "mon", &is_zero, &is_before);
cp = AddPostgresIntPart(cp, mday, "day", &is_zero, &is_before);
if (is_zero || hour != 0 || min != 0 || sec != 0 || fsec != 0)
{
- bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
+ bool minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
sprintf(cp, "%s%s%02d:%02d:",
is_zero ? "" : " ",
}
break;
- /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
+ /* Compatible with postgresql < 8.4 when DateStyle != 'iso' */
case INTSTYLE_POSTGRES_VERBOSE:
default:
strcpy(cp, "@");
*tm = &tt;
fsec_t fsec;
char buf[MAXDATELEN + 1];
- int IntervalStyle = INTSTYLE_POSTGRES_VERBOSE;
+ int IntervalStyle = INTSTYLE_POSTGRES_VERBOSE;
if (interval2tm(*span, tm, &fsec) != 0)
{
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#include "postgres_fe.h"
*/
static const ScanKeyword ScanCKeywords[] = {
/* name, value, category */
- /* category is not needed in ecpg, it is only here so we can share
- * the data structure with the backend */
+
+ /*
+ * category is not needed in ecpg, it is only here so we can share the
+ * data structure with the backend
+ */
{"VARCHAR", VARCHAR, 0},
{"auto", S_AUTO, 0},
{"bool", SQL_BOOL, 0},
printf(_("%s is the PostgreSQL embedded SQL preprocessor for C programs.\n\n"),
progname);
printf(_("Usage:\n"
- " %s [OPTION]... FILE...\n\n"),
+ " %s [OPTION]... FILE...\n\n"),
progname);
printf(_("Options:\n"));
printf(_(" -c automatically generate C code from embedded SQL code;\n"
printf(_(" -I DIRECTORY search DIRECTORY for include files\n"));
printf(_(" -o OUTFILE write result to OUTFILE\n"));
printf(_(" -r OPTION specify run-time behavior; OPTION can be:\n"
- " \"no_indicator\", \"prepare\", \"questionmarks\"\n"));
+ " \"no_indicator\", \"prepare\", \"questionmarks\"\n"));
printf(_(" --regression run in regression testing mode\n"));
printf(_(" -t turn on autocommit of transactions\n"));
printf(_(" --help show this help, then exit\n"));
printf(_(" --version output version information, then exit\n"));
printf(_("\nIf no output file is specified, the name is formed by adding .c to the\n"
- "input file name, after stripping off .pgc if present.\n"));
+ "input file name, after stripping off .pgc if present.\n"));
printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
}
/* and parse the source */
base_yyparse();
- /*
- * Check whether all cursors were indeed opened. It
- * does not really make sense to declare a cursor but
- * not open it.
+ /*
+ * Check whether all cursors were indeed opened. It does not
+ * really make sense to declare a cursor but not open it.
*/
for (ptr = cur; ptr != NULL; ptr = ptr->next)
if (!(ptr->opened))
*/
static const ScanKeyword ScanECPGKeywords[] = {
/* name, value, category */
- /* category is not needed in ecpg, it is only here so we can share
- * the data structure with the backend */
+
+ /*
+ * category is not needed in ecpg, it is only here so we can share the
+ * data structure with the backend
+ */
{"allocate", SQL_ALLOCATE, 0},
{"autocommit", SQL_AUTOCOMMIT, 0},
{"bool", SQL_BOOL, 0},
{"section", SQL_SECTION, 0},
{"short", SQL_SHORT, 0},
{"signed", SQL_SIGNED, 0},
- {"sql", SQL_SQL, 0}, /* strange thing, used for into sql descriptor
+ {"sql", SQL_SQL, 0}, /* strange thing, used for into sql descriptor
* MYDESC; */
{"sqlerror", SQL_SQLERROR, 0},
{"sqlprint", SQL_SQLPRINT, 0},
extern void base_yyerror(const char *);
extern void *mm_alloc(size_t), *mm_realloc(void *, size_t);
extern char *mm_strdup(const char *);
-extern void mmerror(int, enum errortype, const char *, ...)
+extern void
+mmerror(int, enum errortype, const char *,...)
/* This extension allows gcc to check the format string */
__attribute__((format(printf, 3, 4)));
extern void output_get_descr_header(char *);
fputs("\\\n", yyout);
else if (str[i] == '\\')
{
- int j = i;
-
- /* check whether this is a continuation line
- * if it is, do not output anything because newlines are escaped anyway */
+ int j = i;
+
+ /*
+ * check whether this is a continuation line if it is, do not
+ * output anything because newlines are escaped anyway
+ */
/* accept blanks after the '\' as some other compilers do too */
- do { j++; } while (str[j] == ' ' || str[j] == '\t');
+ do
+ {
+ j++;
+ } while (str[j] == ' ' || str[j] == '\t');
- if ((str[j] != '\n') && (str[j] != '\r' || str[j + 1] != '\n')) /* not followed by a newline */
+ if ((str[j] != '\n') && (str[j] != '\r' || str[j + 1] != '\n')) /* not followed by a
+ * newline */
fputs("\\\\", yyout);
}
else if (str[i] == '\r' && str[i + 1] == '\n')
switch (type->u.element->type)
{
case ECPGt_array:
- mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* array of array */
+ mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* array of array */
break;
case ECPGt_struct:
case ECPGt_union:
fprintf(o, "\n\tECPGt_descriptor, %s, 0L, 0L, 0L, ", name);
else
{
- char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
- char *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1 + strlen(varcharsize) + sizeof(int) * CHAR_BIT * 10 / 3);
- char *var_name, *ptr;
+ char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
+ char *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1 + strlen(varcharsize) + sizeof(int) * CHAR_BIT * 10 / 3);
+ char *var_name,
+ *ptr;
switch (type)
{
/* remove trailing [] is name is array element */
var_name = mm_strdup(name);
ptr = strchr(var_name, '[');
- if (ptr) *ptr = '\0';
+ if (ptr)
+ *ptr = '\0';
if (lineno)
sprintf(offset, "sizeof(struct varchar_%s_%d)", var_name, lineno);
else
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef _ECPG_PREPROC_TYPE_H
#define _ECPG_PREPROC_TYPE_H
if (pointer_len > 2)
mmerror(PARSE_ERROR, ET_FATAL, ngettext("multilevel pointers (more than 2 levels) are not supported; found %d level",
- "multilevel pointers (more than 2 levels) are not supported; found %d levels", pointer_len),
- pointer_len);
+ "multilevel pointers (more than 2 levels) are not supported; found %d levels", pointer_len),
+ pointer_len);
if (pointer_len > 1 && type_enum != ECPGt_char && type_enum != ECPGt_unsigned_char)
mmerror(PARSE_ERROR, ET_FATAL, "pointer to pointer is not supported for this data type");
}
/*
- * If the negotiation is complete, there may be zero bytes to send. The server is
- * at this point not expecting any more data, so don't send it.
+ * If the negotiation is complete, there may be zero bytes to send.
+ * The server is at this point not expecting any more data, so don't
+ * send it.
*/
if (outbuf.pBuffers[0].cbBuffer > 0)
{
if (pqPacketSend(conn, 'p',
- outbuf.pBuffers[0].pvBuffer, outbuf.pBuffers[0].cbBuffer))
+ outbuf.pBuffers[0].pvBuffer, outbuf.pBuffers[0].cbBuffer))
{
FreeContextBuffer(outbuf.pBuffers[0].pvBuffer);
return STATUS_ERROR;
case AUTH_REQ_CRYPT:
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("Crypt authentication not supported\n"));
+ libpq_gettext("Crypt authentication not supported\n"));
return STATUS_ERROR;
case AUTH_REQ_MD5:
#endif
/*
- * Some users are using configure
- * --enable-thread-safety-force, so we might as well do the locking within
- * our library to protect pqGetpwuid(). In fact, application developers
- * can use getpwuid() in their application if they use the locking call we
- * provide, or install their own locking function using
- * PQregisterThreadLock().
+ * Some users are using configure --enable-thread-safety-force, so we
+ * might as well do the locking within our library to protect
+ * pqGetpwuid(). In fact, application developers can use getpwuid() in
+ * their application if they use the locking call we provide, or install
+ * their own locking function using PQregisterThreadLock().
*/
pglock_thread();
/*
* ssl options are allowed even without client SSL support because the
- * client can still handle SSL modes "disable" and "allow". Other parameters
- * have no effect on non-SSL connections, so there is no reason to exclude them
- * since none of them are mandatory.
+ * client can still handle SSL modes "disable" and "allow". Other
+ * parameters have no effect on non-SSL connections, so there is no reason
+ * to exclude them since none of them are mandatory.
*/
{"sslmode", "PGSSLMODE", DefaultSSLMode, NULL,
"SSL-Mode", "", 8}, /* sizeof("disable") == 8 */
*
* Parse an empty string like PQconnectdb() would do and return the
* resulting connection options array, ie, all the default values that are
- * available from the environment etc. On error (eg out of memory),
+ * available from the environment etc. On error (eg out of memory),
* NULL is returned.
*
* Using this function, an application may determine all possible options
switch (flag)
{
case PGRES_POLLING_OK:
- /* Reset stored error messages since we now have a working connection */
+
+ /*
+ * Reset stored error messages since we now have a working
+ * connection
+ */
resetPQExpBuffer(&conn->errorMessage);
return 1; /* success! */
EnvironmentOptions);
if (!startpacket)
{
- /* will not appendbuffer here, since it's likely to also run out of memory */
+ /*
+ * will not appendbuffer here, since it's likely to also
+ * run out of memory
+ */
printfPQExpBuffer(&conn->errorMessage,
libpq_gettext("out of memory\n"));
goto error_return;
else if (SSLok == 'N')
{
if (conn->sslmode[0] == 'r' || /* "require" */
- conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
+ conn->sslmode[0] == 'v') /* "verify-ca" or
+ * "verify-full" */
{
/* Require SSL, but server does not want it */
appendPQExpBuffer(&conn->errorMessage,
if (conn->Pfdebug)
fprintf(conn->Pfdebug, "received error from server, attempting fallback to pre-7.0\n");
if (conn->sslmode[0] == 'r' || /* "require" */
- conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
+ conn->sslmode[0] == 'v') /* "verify-ca" or
+ * "verify-full" */
{
/* Require SSL, but server is too old */
appendPQExpBuffer(&conn->errorMessage,
* - properly close a connection to the backend
*
* This should reset or release all transient state, but NOT the connection
- * parameters. On exit, the PGconn should be in condition to start a fresh
+ * parameters. On exit, the PGconn should be in condition to start a fresh
* connection with the same parameters (see PQreset()).
*/
static void
if (connectDBStart(conn) && connectDBComplete(conn))
{
/*
- * Notify event procs of successful reset. We treat an event
- * proc failure as disabling the connection ... good idea?
+ * Notify event procs of successful reset. We treat an event proc
+ * failure as disabling the connection ... good idea?
*/
- int i;
+ int i;
for (i = 0; i < conn->nEvents; i++)
{
if (status == PGRES_POLLING_OK)
{
/*
- * Notify event procs of successful reset. We treat an event
- * proc failure as disabling the connection ... good idea?
+ * Notify event procs of successful reset. We treat an event proc
+ * failure as disabling the connection ... good idea?
*/
- int i;
+ int i;
for (i = 0; i < conn->nEvents; i++)
{
* PQconninfoParse
*
* Parse a string like PQconnectdb() would do and return the
- * resulting connection options array. NULL is returned on failure.
+ * resulting connection options array. NULL is returned on failure.
* The result contains only options specified directly in the string,
* not any possible default values.
*
static PGresult *PQexecFinish(PGconn *conn);
static int PQsendDescribe(PGconn *conn, char desc_type,
const char *desc_target);
-static int check_field_number(const PGresult *res, int field_num);
+static int check_field_number(const PGresult *res, int field_num);
/* ----------------
int
PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs)
{
- int i;
+ int i;
/* If attrs already exist, they cannot be overwritten. */
if (!res || res->numAttributes > 0)
* Returns a deep copy of the provided 'src' PGresult, which cannot be NULL.
* The 'flags' argument controls which portions of the result will or will
* NOT be copied. The created result is always put into the
- * PGRES_TUPLES_OK status. The source result error message is not copied,
+ * PGRES_TUPLES_OK status. The source result error message is not copied,
* although cmdStatus is.
*
- * To set custom attributes, use PQsetResultAttrs. That function requires
+ * To set custom attributes, use PQsetResultAttrs. That function requires
* that there are no attrs contained in the result, so to use that
* function you cannot use the PG_COPYRES_ATTRS or PG_COPYRES_TUPLES
* options with this function.
*
* Options:
- * PG_COPYRES_ATTRS - Copy the source result's attributes
+ * PG_COPYRES_ATTRS - Copy the source result's attributes
*
- * PG_COPYRES_TUPLES - Copy the source result's tuples. This implies
- * copying the attrs, seeeing how the attrs are needed by the tuples.
+ * PG_COPYRES_TUPLES - Copy the source result's tuples. This implies
+ * copying the attrs, seeeing how the attrs are needed by the tuples.
*
- * PG_COPYRES_EVENTS - Copy the source result's events.
+ * PG_COPYRES_EVENTS - Copy the source result's events.
*
- * PG_COPYRES_NOTICEHOOKS - Copy the source result's notice hooks.
+ * PG_COPYRES_NOTICEHOOKS - Copy the source result's notice hooks.
*/
PGresult *
PQcopyResult(const PGresult *src, int flags)
{
- PGresult *dest;
- int i;
+ PGresult *dest;
+ int i;
if (!src)
return NULL;
if (!dest)
return NULL;
- /* Always copy these over. Is cmdStatus really useful here? */
+ /* Always copy these over. Is cmdStatus really useful here? */
dest->client_encoding = src->client_encoding;
strcpy(dest->cmdStatus, src->cmdStatus);
/* Wants to copy tuples? */
if (flags & PG_COPYRES_TUPLES)
{
- int tup, field;
+ int tup,
+ field;
for (tup = 0; tup < src->ntups; tup++)
{
static PGEvent *
dupEvents(PGEvent *events, int count)
{
- PGEvent *newEvents;
- int i;
+ PGEvent *newEvents;
+ int i;
if (!events || count <= 0)
return NULL;
/* need to grow the tuple table? */
if (res->ntups >= res->tupArrSize)
{
- int n = res->tupArrSize ? res->tupArrSize * 2 : 128;
+ int n = res->tupArrSize ? res->tupArrSize * 2 : 128;
PGresAttValue **tups;
if (res->tuples)
if (tup_num == res->ntups && !res->tuples[tup_num])
{
PGresAttValue *tup;
- int i;
+ int i;
tup = (PGresAttValue *)
pqResultAlloc(res, res->numAttributes * sizeof(PGresAttValue),
PQclear(PGresult *res)
{
PGresult_data *block;
- int i;
+ int i;
if (!res)
return;
if (res)
{
- int i;
+ int i;
for (i = 0; i < res->nEvents; i++)
{
{
if (*vp < 0x20 || *vp > 0x7e)
{
- int val = *vp;
+ int val = *vp;
if (!std_strings)
*rp++ = '\\';
(ISOCTDIGIT(strtext[i + 1])) &&
(ISOCTDIGIT(strtext[i + 2])))
{
- int byte;
+ int byte;
byte = OCTVAL(strtext[i++]);
- byte = (byte << 3) + OCTVAL(strtext[i++]);
- byte = (byte << 3) + OCTVAL(strtext[i++]);
+ byte = (byte <<3) +OCTVAL(strtext[i++]);
+ byte = (byte <<3) +OCTVAL(strtext[i++]);
buffer[j++] = byte;
}
}
static int lo_initialize(PGconn *conn);
static Oid
-lo_import_internal(PGconn *conn, const char *filename, const Oid oid);
+ lo_import_internal(PGconn *conn, const char *filename, const Oid oid);
/*
* lo_open
#ifndef WIN32
sent = pqsecure_write(conn, ptr, len);
#else
+
/*
- * Windows can fail on large sends, per KB article Q201213. The failure-point
- * appears to be different in different versions of Windows, but 64k should
- * always be safe.
+ * Windows can fail on large sends, per KB article Q201213. The
+ * failure-point appears to be different in different versions of
+ * Windows, but 64k should always be safe.
*/
sent = pqsecure_write(conn, ptr, Min(len, 65536));
#endif
FD_ZERO(&output_mask);
FD_ZERO(&except_mask);
if (forRead)
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
+
if (forWrite)
- FD_SET(sock, &output_mask);
- FD_SET(sock, &except_mask);
+ FD_SET (sock, &output_mask);
+ FD_SET (sock, &except_mask);
/* Compute appropriate timeout interval */
if (end_time == ((time_t) -1))
if (conn->result == NULL)
{
conn->result = PQmakeEmptyPGresult(conn,
- PGRES_COMMAND_OK);
+ PGRES_COMMAND_OK);
if (!conn->result)
return;
}
for (;;)
{
/*
- * Collect the next input message. To make life simpler for async
+ * Collect the next input message. To make life simpler for async
* callers, we keep returning 0 until the next message is fully
* available, even if it is not Copy Data.
*/
{
/*
* On end-of-copy, exit COPY_OUT mode and let caller read status
- * with PQgetResult(). The normal case is that it's Copy Done,
- * but we let parseInput read that. If error, we expect the
- * state was already changed.
+ * with PQgetResult(). The normal case is that it's Copy Done,
+ * but we let parseInput read that. If error, we expect the state
+ * was already changed.
*/
if (msgLength == -1)
conn->asyncStatus = PGASYNC_BUSY;
- return msgLength; /* end-of-copy or error */
+ return msgLength; /* end-of-copy or error */
}
if (msgLength == 0)
{
static pthread_mutex_t ssl_config_mutex = NULL;
static long win32_ssl_create_mutex = 0;
#endif
-
-#endif /* ENABLE_THREAD_SAFETY */
-
-#endif /* SSL */
+#endif /* ENABLE_THREAD_SAFETY */
+#endif /* SSL */
/*
#define RESTORE_SIGPIPE() \
pq_reset_sigpipe(&osigmask, sigpipe_pending, got_epipe)
-
-#else /* !ENABLE_THREAD_SAFETY */
+#else /* !ENABLE_THREAD_SAFETY */
#define DISABLE_SIGPIPE(failaction) \
pqsigfunc oldsighandler = pqsignal(SIGPIPE, SIG_IGN)
#define RESTORE_SIGPIPE() \
pqsignal(SIGPIPE, oldsighandler)
-
-#endif /* ENABLE_THREAD_SAFETY */
-#else /* WIN32 */
+#endif /* ENABLE_THREAD_SAFETY */
+#else /* WIN32 */
#define DISABLE_SIGPIPE(failaction)
#define REMEMBER_EPIPE(cond)
#define RESTORE_SIGPIPE()
-
-#endif /* WIN32 */
+#endif /* WIN32 */
/* ------------------------------------------------------------ */
/* Procedures common to all secure sessions */
* Exported function to allow application to tell us it's already
* initialized OpenSSL and/or libcrypto.
*/
-void
+void
PQinitOpenSSL(int do_ssl, int do_crypto)
{
#ifdef USE_SSL
#ifdef ENABLE_THREAD_SAFETY
+
/*
- * Disallow changing the flags while we have open connections, else
- * we'd get completely confused.
+ * Disallow changing the flags while we have open connections, else we'd
+ * get completely confused.
*/
if (ssl_open_connections != 0)
return;
* Check if a wildcard certificate matches the server hostname.
*
* The rule for this is:
- * 1. We only match the '*' character as wildcard
- * 2. We match only wildcards at the start of the string
- * 3. The '*' character does *not* match '.', meaning that we match only
- * a single pathname component.
- * 4. We don't support more than one '*' in a single pattern.
+ * 1. We only match the '*' character as wildcard
+ * 2. We match only wildcards at the start of the string
+ * 3. The '*' character does *not* match '.', meaning that we match only
+ * a single pathname component.
+ * 4. We don't support more than one '*' in a single pattern.
*
* This is roughly in line with RFC2818, but contrary to what most browsers
* appear to be implementing (point 3 being the difference)
static int
wildcard_certificate_match(const char *pattern, const char *string)
{
- int lenpat = strlen(pattern);
- int lenstr = strlen(string);
+ int lenpat = strlen(pattern);
+ int lenstr = strlen(string);
/* If we don't start with a wildcard, it's not a match (rule 1 & 2) */
if (lenpat < 3 ||
/* If pattern is longer than the string, we can never match */
return 0;
- if (pg_strcasecmp(pattern+1, string+lenstr-lenpat+1) != 0)
- /* If string does not end in pattern (minus the wildcard), we don't match */
+ if (pg_strcasecmp(pattern + 1, string + lenstr - lenpat + 1) != 0)
+
+ /*
+ * If string does not end in pattern (minus the wildcard), we don't
+ * match
+ */
return 0;
- if (strchr(string, '.') < string+lenstr-lenpat)
- /* If there is a dot left of where the pattern started to match, we don't match (rule 3) */
+ if (strchr(string, '.') < string + lenstr - lenpat)
+
+ /*
+ * If there is a dot left of where the pattern started to match, we
+ * don't match (rule 3)
+ */
return 0;
/* String ended with pattern, and didn't have a dot before, so we match */
verify_peer_name_matches_certificate(PGconn *conn)
{
/*
- * If told not to verify the peer name, don't do it. Return
- * 0 indicating that the verification was successful.
+ * If told not to verify the peer name, don't do it. Return 0 indicating
+ * that the verification was successful.
*/
if (strcmp(conn->sslmode, "verify-full") != 0)
return true;
BIO_free(bio);
/*
- * Read the SSL key. If a key is specified, treat it as an engine:key combination
- * if there is colon present - we don't support files with colon in the name. The
- * exception is if the second character is a colon, in which case it can be a Windows
- * filename with drive specification.
+ * Read the SSL key. If a key is specified, treat it as an engine:key
+ * combination if there is colon present - we don't support files with
+ * colon in the name. The exception is if the second character is a colon,
+ * in which case it can be a Windows filename with drive specification.
*/
if (conn->sslkey && strlen(conn->sslkey) > 0)
{
#ifdef WIN32
&& conn->sslkey[1] != ':'
#endif
- )
+ )
{
/* Colon, but not in second character, treat as engine:key */
ENGINE *engine_ptr;
char *engine_str = strdup(conn->sslkey);
char *engine_colon = strchr(engine_str, ':');
- *engine_colon = '\0'; /* engine_str now has engine name */
- engine_colon++; /* engine_colon now has key name */
+ *engine_colon = '\0'; /* engine_str now has engine name */
+ engine_colon++; /* engine_colon now has key name */
engine_ptr = ENGINE_by_id(engine_str);
if (engine_ptr == NULL)
char *err = SSLerrmessage();
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("could not load SSL engine \"%s\": %s\n"),
+ libpq_gettext("could not load SSL engine \"%s\": %s\n"),
engine_str, err);
SSLerrfree(err);
free(engine_str);
}
free(engine_str);
- fnbuf[0] = '\0'; /* indicate we're not going to load from a file */
+ fnbuf[0] = '\0'; /* indicate we're not going to load from a
+ * file */
}
else
-#endif /* support for SSL engines */
+#endif /* support for SSL engines */
{
/* PGSSLKEY is not an engine, treat it as a filename */
strncpy(fnbuf, conn->sslkey, sizeof(fnbuf));
if (!S_ISREG(buf.st_mode) || buf.st_mode & (S_IRWXG | S_IRWXO))
{
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n"),
+ libpq_gettext("private key file \"%s\" has group or world access; permissions should be u=rw (0600) or less\n"),
fnbuf);
ERR_pop_to_mark();
return 0;
*/
if (pq_lockarray == NULL)
{
- int i;
+ int i;
pq_lockarray = malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());
if (!pq_lockarray)
CRYPTO_set_locking_callback(pq_lockingcallback);
}
}
-#endif /* ENABLE_THREAD_SAFETY */
+#endif /* ENABLE_THREAD_SAFETY */
if (!SSL_context)
{
CRYPTO_set_id_callback(NULL);
/*
- * We don't free the lock array. If we get another connection
- * in this process, we will just re-use it with the existing
- * mutexes.
+ * We don't free the lock array. If we get another connection in this
+ * process, we will just re-use it with the existing mutexes.
*
- * This means we leak a little memory on repeated load/unload
- * of the library.
+ * This means we leak a little memory on repeated load/unload of the
+ * library.
*/
}
* verification. If set to "verify-full" we will also do further
* verification after the connection has been completed.
*
- * If we are going to look for either root certificate or CRL in the home directory,
- * we need pqGetHomeDirectory() to succeed. In other cases, we don't need to
- * get the home directory explicitly.
+ * If we are going to look for either root certificate or CRL in the home
+ * directory, we need pqGetHomeDirectory() to succeed. In other cases, we
+ * don't need to get the home directory explicitly.
*/
if (!conn->sslrootcert || !conn->sslcrl)
{
if (!pqGetHomeDirectory(homedir, sizeof(homedir)))
{
- if (conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
+ if (conn->sslmode[0] == 'v') /* "verify-ca" or
+ * "verify-full" */
{
printfPQExpBuffer(&conn->errorMessage,
libpq_gettext("could not get home directory to locate root certificate file"));
/* OpenSSL 0.96 does not support X509_V_FLAG_CRL_CHECK */
#ifdef X509_V_FLAG_CRL_CHECK
X509_STORE_set_flags(cvstore,
- X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
+ X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
/* if not found, silently ignore; we do not require CRL */
#else
{
else
{
/* stat() failed; assume cert file doesn't exist */
- if (conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
+ if (conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
{
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("root certificate file \"%s\" does not exist\n"
+ libpq_gettext("root certificate file \"%s\" does not exist\n"
"Either provide the file or change sslmode to disable server certificate verification.\n"), fnbuf);
return -1;
}
}
/*
- * We already checked the server certificate in initialize_SSL()
- * using SSL_CTX_set_verify() if root.crt exists.
+ * We already checked the server certificate in initialize_SSL() using
+ * SSL_CTX_set_verify() if root.crt exists.
*/
/* pull out server distinguished and common names */
PQregisterEventProc(PGconn *conn, PGEventProc proc,
const char *name, void *passThrough)
{
- int i;
+ int i;
PGEventRegister regevt;
if (!proc || !conn || !name || !*name)
if (conn->nEvents >= conn->eventArraySize)
{
- PGEvent *e;
- int newSize;
+ PGEvent *e;
+ int newSize;
newSize = conn->eventArraySize ? conn->eventArraySize * 2 : 8;
if (conn->events)
int
PQsetInstanceData(PGconn *conn, PGEventProc proc, void *data)
{
- int i;
+ int i;
if (!conn || !proc)
return FALSE;
void *
PQinstanceData(const PGconn *conn, PGEventProc proc)
{
- int i;
+ int i;
if (!conn || !proc)
return NULL;
int
PQresultSetInstanceData(PGresult *result, PGEventProc proc, void *data)
{
- int i;
+ int i;
if (!result || !proc)
return FALSE;
void *
PQresultInstanceData(const PGresult *result, PGEventProc proc)
{
- int i;
+ int i;
if (!result || !proc)
return NULL;
int
PQfireResultCreateEvents(PGconn *conn, PGresult *res)
{
- int i;
+ int i;
if (!res)
return FALSE;
#endif
/* Callback Event Ids */
-typedef enum
+ typedef enum
{
PGEVT_REGISTER,
PGEVT_CONNRESET,
typedef struct
{
- PGconn *conn;
+ PGconn *conn;
} PGEventRegister;
typedef struct
{
- PGconn *conn;
+ PGconn *conn;
} PGEventConnReset;
typedef struct
{
- PGconn *conn;
+ PGconn *conn;
} PGEventConnDestroy;
typedef struct
{
- PGconn *conn;
- PGresult *result;
+ PGconn *conn;
+ PGresult *result;
} PGEventResultCreate;
typedef struct
{
const PGresult *src;
- PGresult *dest;
+ PGresult *dest;
} PGEventResultCopy;
typedef struct
{
- PGresult *result;
+ PGresult *result;
} PGEventResultDestroy;
typedef int (*PGEventProc) (PGEventId evtId, void *evtInfo, void *passThrough);
/* Registers an event proc with the given PGconn. */
-extern int PQregisterEventProc(PGconn *conn, PGEventProc proc,
- const char *name, void *passThrough);
+extern int PQregisterEventProc(PGconn *conn, PGEventProc proc,
+ const char *name, void *passThrough);
/* Sets the PGconn instance data for the provided proc to data. */
extern int PQsetInstanceData(PGconn *conn, PGEventProc proc, void *data);
}
#endif
-#endif /* LIBPQ_EVENTS_H */
+#endif /* LIBPQ_EVENTS_H */
/*
* Option flags for PQcopyResult
*/
-#define PG_COPYRES_ATTRS 0x01
-#define PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */
-#define PG_COPYRES_EVENTS 0x04
-#define PG_COPYRES_NOTICEHOOKS 0x08
+#define PG_COPYRES_ATTRS 0x01
+#define PG_COPYRES_TUPLES 0x02 /* Implies PG_COPYRES_ATTRS */
+#define PG_COPYRES_EVENTS 0x04
+#define PG_COPYRES_NOTICEHOOKS 0x08
/* Application-visible enum types */
/* Create and manipulate PGresults */
extern PGresult *PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status);
extern PGresult *PQcopyResult(const PGresult *src, int flags);
-extern int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs);
+extern int PQsetResultAttrs(PGresult *res, int numAttributes, PGresAttDesc *attDescs);
extern void *PQresultAlloc(PGresult *res, size_t nBytes);
-extern int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len);
+extern int PQsetvalue(PGresult *res, int tup_num, int field_num, char *value, int len);
/* Quoting strings before inclusion in queries. */
extern size_t PQescapeStringConn(PGconn *conn,
{
void *value;
int length;
-} gss_buffer_desc;
+} gss_buffer_desc;
#endif
#endif /* ENABLE_SSPI */
typedef struct PGEvent
{
- PGEventProc proc; /* the function to call on events */
+ PGEventProc proc; /* the function to call on events */
char *name; /* used only for error messages */
void *passThrough; /* pointer supplied at registration time */
void *data; /* optional state (instance) data */
- bool resultInitialized; /* T if RESULTCREATE/COPY succeeded */
+ bool resultInitialized; /* T if RESULTCREATE/COPY succeeded */
} PGEvent;
struct pg_result
* on the PGresult don't have to reference the PGconn.
*/
PGNoticeHooks noticeHooks;
- PGEvent *events;
+ PGEvent *events;
int nEvents;
int client_encoding; /* encoding id */
PGNoticeHooks noticeHooks;
/* Event procs registered via PQregisterEventProc */
- PGEvent *events; /* expandable array of event data */
+ PGEvent *events; /* expandable array of event data */
int nEvents; /* number of active events */
- int eventArraySize; /* allocated array size */
+ int eventArraySize; /* allocated array size */
/* Status indicators */
ConnStatusType status;
{
if (str->data != oom_buffer)
free(str->data);
+
/*
- * Casting away const here is a bit ugly, but it seems preferable to
- * not marking oom_buffer const. We want to do that to encourage the
- * compiler to put oom_buffer in read-only storage, so that anyone who
- * tries to scribble on a broken PQExpBuffer will get a failure.
+ * Casting away const here is a bit ugly, but it seems preferable to not
+ * marking oom_buffer const. We want to do that to encourage the compiler
+ * to put oom_buffer in read-only storage, so that anyone who tries to
+ * scribble on a broken PQExpBuffer will get a failure.
*/
str->data = (char *) oom_buffer;
str->len = 0;
if (str->data != oom_buffer)
free(str->data);
/* just for luck, make the buffer validly empty. */
- str->data = (char *) oom_buffer; /* see comment above */
+ str->data = (char *) oom_buffer; /* see comment above */
str->maxlen = 0;
str->len = 0;
}
* Make sure there is enough space for 'needed' more bytes in the buffer
* ('needed' does not include the terminating null).
*
- * Returns 1 if OK, 0 if failed to enlarge buffer. (In the latter case
+ * Returns 1 if OK, 0 if failed to enlarge buffer. (In the latter case
* the buffer is left in "broken" state.)
*/
int
* more space. We must always have maxlen > len.
*
* An exception occurs if we failed to allocate enough memory for the string
- * buffer. In that case data points to a statically allocated empty string,
+ * buffer. In that case data points to a statically allocated empty string,
* and len = maxlen = 0.
*-------------------------
*/
* are no-ops.
*------------------------
*/
-#define PQExpBufferBroken(str) \
+#define PQExpBufferBroken(str) \
((str) == NULL || (str)->maxlen == 0)
/*------------------------
* Make sure there is enough space for 'needed' more bytes in the buffer
* ('needed' does not include the terminating null).
*
- * Returns 1 if OK, 0 if failed to enlarge buffer. (In the latter case
+ * Returns 1 if OK, 0 if failed to enlarge buffer. (In the latter case
* the buffer is left in "broken" state.)
*/
extern int enlargePQExpBuffer(PQExpBuffer str, size_t needed);
int
pthread_mutex_init(pthread_mutex_t *mp, void *attr)
{
- *mp = (CRITICAL_SECTION *)malloc(sizeof(CRITICAL_SECTION));
+ *mp = (CRITICAL_SECTION *) malloc(sizeof(CRITICAL_SECTION));
if (!*mp)
return 1;
InitializeCriticalSection(*mp);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* FILE
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
#ifndef __win32_h_included
#define __win32_h_included
pg_bindtextdomain(TEXTDOMAIN);
DefineCustomBoolVariable("plperl.use_strict",
- gettext_noop("If true, trusted and untrusted Perl code will be compiled in strict mode."),
+ gettext_noop("If true, trusted and untrusted Perl code will be compiled in strict mode."),
NULL,
&plperl_use_strict,
false,
#define SAFE_MODULE \
"require Safe; $Safe::VERSION"
-/*
+/*
* The temporary enabling of the caller opcode here is to work around a
* bug in perl 5.10, which unkindly changed the way its Safe.pm works, without
* notice. It is quite safe, as caller is informational only, and in any case
static char *embedding[3] = {
"", "-e", PERLBOOT
};
- int nargs = 3;
+ int nargs = 3;
#ifdef WIN32
/* only call this the first time through, as per perlembed man page */
if (interp_state == INTERP_NONE)
{
- char *dummy_env[1] = { NULL };
+ char *dummy_env[1] = {NULL};
PERL_SYS_INIT3(&nargs, (char ***) &embedding, (char ***) &dummy_env);
}
eval_pv(SAFE_OK, FALSE);
if (GetDatabaseEncoding() == PG_UTF8)
{
- /*
- * Fill in just enough information to set up this perl
- * function in the safe container and call it.
- * For some reason not entirely clear, it prevents errors that
- * can arise from the regex code later trying to load
- * utf8 modules.
+ /*
+ * Fill in just enough information to set up this perl function in
+ * the safe container and call it. For some reason not entirely
+ * clear, it prevents errors that can arise from the regex code
+ * later trying to load utf8 modules.
*/
- plperl_proc_desc desc;
+ plperl_proc_desc desc;
FunctionCallInfoData fcinfo;
- SV *ret;
- SV *func;
+ SV *ret;
+ SV *func;
/* make sure we don't call ourselves recursively */
plperl_safe_init_done = true;
fcinfo.arg[0] = CStringGetTextDatum("a");
fcinfo.argnull[0] = false;
-
+
/* and make the call */
ret = plperl_call_perl_func(&desc, &fcinfo);
}
{
ereport(WARNING,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
- errmsg("ignoring modified row in DELETE trigger")));
+ errmsg("ignoring modified row in DELETE trigger")));
trv = NULL;
}
}
{
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
- errmsg("result of PL/Perl trigger function must be undef, "
- "\"SKIP\", or \"MODIFY\"")));
+ errmsg("result of PL/Perl trigger function must be undef, "
+ "\"SKIP\", or \"MODIFY\"")));
trv = NULL;
}
retval = PointerGetDatum(trv);
if (prodesc->fn_retistuple)
{
- HeapTuple tuple;
+ HeapTuple tuple;
tuple = plperl_build_tuple_result((HV *) SvRV(sv),
current_call_data->attinmeta);
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* This kludge is necessary because of the conflicting
argdtype->ttype != PLPGSQL_TTYPE_ROW)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("PL/pgSQL functions cannot accept type %s",
- format_type_be(argtypeid))));
+ errmsg("PL/pgSQL functions cannot accept type %s",
+ format_type_be(argtypeid))));
/* Build variable and add to datum list */
argvariable = plpgsql_build_variable(buf, 0,
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("PL/pgSQL functions cannot return type %s",
- format_type_be(rettypeid))));
+ errmsg("PL/pgSQL functions cannot return type %s",
+ format_type_be(rettypeid))));
}
if (typeStruct->typrelid != InvalidOid ||
plpgsql_convert_ident(word, cp, 1);
/*
- * Recognize tg_argv when compiling triggers
- * (XXX this sucks, it should be a regular variable in the namestack)
+ * Recognize tg_argv when compiling triggers (XXX this sucks, it should be
+ * a regular variable in the namestack)
*/
if (plpgsql_curr_compile->fn_is_trigger)
{
plpgsql_convert_ident(word, cp, 3);
/*
- * Do a lookup on the compiler's namestack.
- * Must find a qualified reference.
+ * Do a lookup on the compiler's namestack. Must find a qualified
+ * reference.
*/
ns = plpgsql_ns_lookup(cp[0], cp[1], cp[2], &nnames);
if (ns == NULL || nnames != 2)
pfree(cp[2]);
/*
- * Do a lookup on the compiler's namestack. Ensure we scan all levels.
- * We don't need to check number of names matched, because we will only
+ * Do a lookup on the compiler's namestack. Ensure we scan all levels. We
+ * don't need to check number of names matched, because we will only
* consider scalar variables.
*/
old_nsstate = plpgsql_ns_setlocal(false);
}
/*
- * plpgsql_recognize_err_condition
- * Check condition name and translate it to SQLSTATE.
+ * plpgsql_recognize_err_condition
+ * Check condition name and translate it to SQLSTATE.
*
* Note: there are some cases where the same condition name has multiple
* entries in the table. We arbitrarily return the first match.
* creates its own "eval_econtext" ExprContext within this estate for
* per-evaluation workspace. eval_econtext is freed at normal function exit,
* and the EState is freed at transaction end (in case of error, we assume
- * that the abort mechanisms clean it all up). Furthermore, any exception
+ * that the abort mechanisms clean it all up). Furthermore, any exception
* block within a function has to have its own eval_econtext separate from
* the containing function's, so that we can clean up ExprContext callbacks
* properly at subtransaction exit. We maintain a stack that tracks the
*/
typedef struct SimpleEcontextStackEntry
{
- ExprContext *stack_econtext; /* a stacked econtext */
- SubTransactionId xact_subxid; /* ID for current subxact */
- struct SimpleEcontextStackEntry *next; /* next stack entry up */
+ ExprContext *stack_econtext; /* a stacked econtext */
+ SubTransactionId xact_subxid; /* ID for current subxact */
+ struct SimpleEcontextStackEntry *next; /* next stack entry up */
} SimpleEcontextStackEntry;
static EState *simple_eval_estate = NULL;
static int exec_stmt_if(PLpgSQL_execstate *estate,
PLpgSQL_stmt_if *stmt);
static int exec_stmt_case(PLpgSQL_execstate *estate,
- PLpgSQL_stmt_case *stmt);
+ PLpgSQL_stmt_case *stmt);
static int exec_stmt_loop(PLpgSQL_execstate *estate,
PLpgSQL_stmt_loop *stmt);
static int exec_stmt_while(PLpgSQL_execstate *estate,
static int exec_run_select(PLpgSQL_execstate *estate,
PLpgSQL_expr *expr, long maxtuples, Portal *portalP);
static int exec_for_query(PLpgSQL_execstate *estate, PLpgSQL_stmt_forq *stmt,
- Portal portal, bool prefetch_ok);
+ Portal portal, bool prefetch_ok);
static void eval_expr_params(PLpgSQL_execstate *estate,
PLpgSQL_expr *expr, Datum **p_values, char **p_nulls);
static void exec_move_row(PLpgSQL_execstate *estate,
static void free_var(PLpgSQL_var *var);
static void assign_text_var(PLpgSQL_var *var, const char *str);
static PreparedParamsData *exec_eval_using_params(PLpgSQL_execstate *estate,
- List *params);
+ List *params);
static void free_params_data(PreparedParamsData *ppd);
static Portal exec_dynquery_with_params(PLpgSQL_execstate *estate,
- PLpgSQL_expr *query, List *params);
+ PLpgSQL_expr *query, List *params);
/* ----------
* sure it is labeled with the caller-supplied tuple type.
*/
estate.retval =
- PointerGetDatum(SPI_returntuple((HeapTuple)DatumGetPointer(estate.retval),
+ PointerGetDatum(SPI_returntuple((HeapTuple) DatumGetPointer(estate.retval),
tupdesc));
}
else
*/
if (estate->err_stmt != NULL)
{
- /* translator: last %s is a phrase such as "during statement block local variable initialization" */
+ /*
+ * translator: last %s is a phrase such as "during statement block
+ * local variable initialization"
+ */
errcontext("PL/pgSQL function \"%s\" line %d %s",
estate->err_func->fn_name,
estate->err_stmt->lineno,
}
else
{
- /* translator: last %s is a phrase such as "while storing call arguments into local variables" */
+ /*
+ * translator: last %s is a phrase such as "while storing call
+ * arguments into local variables"
+ */
errcontext("PL/pgSQL function \"%s\" %s",
estate->err_func->fn_name,
_(estate->err_text));
CurrentResourceOwner = oldowner;
/*
- * Revert to outer eval_econtext. (The inner one was automatically
- * cleaned up during subxact exit.)
+ * Revert to outer eval_econtext. (The inner one was
+ * automatically cleaned up during subxact exit.)
*/
estate->eval_econtext = old_eval_econtext;
return rc;
case PLPGSQL_RC_EXIT:
+
/*
* This is intentionally different from the handling of RC_EXIT
* for loops: to match a block, we require a match by label.
if (stmt->t_expr != NULL)
{
/* simple case */
- Datum t_val;
- Oid t_oid;
+ Datum t_val;
+ Oid t_oid;
t_val = exec_eval_expr(estate, stmt->t_expr, &isnull, &t_oid);
t_var = (PLpgSQL_var *) estate->datums[stmt->t_varno];
/*
- * When expected datatype is different from real, change it.
- * Note that what we're modifying here is an execution copy
- * of the datum, so this doesn't affect the originally stored
- * function parse tree.
+ * When expected datatype is different from real, change it. Note that
+ * what we're modifying here is an execution copy of the datum, so
+ * this doesn't affect the originally stored function parse tree.
*/
if (t_var->datatype->typoid != t_oid)
t_var->datatype = plpgsql_build_datatype(t_oid, -1);
foreach(l, stmt->case_when_list)
{
PLpgSQL_case_when *cwt = (PLpgSQL_case_when *) lfirst(l);
- bool value;
+ bool value;
value = exec_eval_boolean(estate, cwt->expr, &isnull);
exec_eval_cleanup(estate);
if (curvar->cursor_explicit_argrow < 0)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("arguments given for cursor without arguments")));
+ errmsg("arguments given for cursor without arguments")));
memset(&set_args, 0, sizeof(set_args));
set_args.cmd_type = PLPGSQL_STMT_EXECSQL;
estate->retval =
PointerGetDatum(make_tuple_from_row(estate, row,
row->rowtupdesc));
- if (DatumGetPointer(estate->retval) == NULL) /* should not happen */
+ if (DatumGetPointer(estate->retval) == NULL) /* should not happen */
elog(ERROR, "row not compatible with its own tupdesc");
estate->rettupdesc = row->rowtupdesc;
estate->retisnull = false;
exec_stmt_return_next(PLpgSQL_execstate *estate,
PLpgSQL_stmt_return_next *stmt)
{
- TupleDesc tupdesc;
- int natts;
- MemoryContext oldcxt;
- HeapTuple tuple = NULL;
- bool free_tuple = false;
+ TupleDesc tupdesc;
+ int natts;
+ MemoryContext oldcxt;
+ HeapTuple tuple = NULL;
+ bool free_tuple = false;
if (!estate->retisset)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("record \"%s\" is not assigned yet",
rec->refname),
- errdetail("The tuple structure of a not-yet-assigned"
- " record is indeterminate.")));
+ errdetail("The tuple structure of a not-yet-assigned"
+ " record is indeterminate.")));
validate_tupdesc_compat(tupdesc, rec->tupdesc,
- "wrong record type supplied in RETURN NEXT");
+ "wrong record type supplied in RETURN NEXT");
tuple = rec->tup;
}
break;
PLpgSQL_stmt_return_query *stmt)
{
Portal portal;
- uint32 processed = 0;
+ uint32 processed = 0;
if (!estate->retisset)
ereport(ERROR,
}
validate_tupdesc_compat(estate->rettupdesc, portal->tupDesc,
- "structure of query does not match function result type");
+ "structure of query does not match function result type");
while (true)
{
if (current_param == NULL)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("too few parameters specified for RAISE")));
+ errmsg("too few parameters specified for RAISE")));
paramvalue = exec_eval_expr(estate,
- (PLpgSQL_expr *) lfirst(current_param),
+ (PLpgSQL_expr *) lfirst(current_param),
¶misnull,
¶mtypeid);
case SPI_OK_REWRITTEN:
Assert(!stmt->mod_stmt);
+
/*
* The command was rewritten into another kind of command. It's
* not clear what FOUND would mean in that case (and SPI doesn't
if (*ptr == 'S' || *ptr == 's')
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("EXECUTE of SELECT ... INTO is not implemented")));
+ errmsg("EXECUTE of SELECT ... INTO is not implemented")));
break;
}
/*
* Get the number of the records field to change and the
- * number of attributes in the tuple. Note: disallow
- * system column names because the code below won't cope.
+ * number of attributes in the tuple. Note: disallow system
+ * column names because the code below won't cope.
*/
fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
if (fno <= 0)
elog(ERROR, "unsupported target");
/*
- * Fetch the initial tuple(s). If prefetching is allowed then we grab
- * a few more rows to avoid multiple trips through executor startup
+ * Fetch the initial tuple(s). If prefetching is allowed then we grab a
+ * few more rows to avoid multiple trips through executor startup
* overhead.
*/
SPI_cursor_fetch(portal, true, prefetch_ok ? 10 : 1);
n = SPI_processed;
/*
- * If the query didn't return any rows, set the target to NULL and
- * fall through with found = false.
+ * If the query didn't return any rows, set the target to NULL and fall
+ * through with found = false.
*/
if (n <= 0)
exec_move_row(estate, rec, row, NULL, tuptab->tupdesc);
* attributes of the tuple to the variables the row points to.
*
* NOTE: this code used to demand row->nfields ==
- * HeapTupleHeaderGetNatts(tup->t_data), but that's wrong. The tuple might
- * have more fields than we expected if it's from an inheritance-child
- * table of the current table, or it might have fewer if the table has had
- * columns added by ALTER TABLE. Ignore extra columns and assume NULL for
- * missing columns, the same as heap_getattr would do. We also have to
- * skip over dropped columns in either the source or destination.
+ * HeapTupleHeaderGetNatts(tup->t_data), but that's wrong. The tuple
+ * might have more fields than we expected if it's from an
+ * inheritance-child table of the current table, or it might have fewer if
+ * the table has had columns added by ALTER TABLE. Ignore extra columns
+ * and assume NULL for missing columns, the same as heap_getattr would do.
+ * We also have to skip over dropped columns in either the source or
+ * destination.
*
* If we have no tuple data at all, we'll assign NULL to all columns of
* the row variable.
static void
validate_tupdesc_compat(TupleDesc expected, TupleDesc returned, const char *msg)
{
- int i;
+ int i;
const char *dropped_column_type = gettext_noop("N/A (dropped column)");
if (!expected || !returned)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("%s", _(msg)),
- errdetail("Returned type %s does not match expected type "
- "%s in column \"%s\".",
- OidIsValid(returned->attrs[i]->atttypid) ?
- format_type_be(returned->attrs[i]->atttypid) :
- _(dropped_column_type),
- OidIsValid(expected->attrs[i]->atttypid) ?
- format_type_be(expected->attrs[i]->atttypid) :
- _(dropped_column_type),
- NameStr(expected->attrs[i]->attname))));
+ errdetail("Returned type %s does not match expected type "
+ "%s in column \"%s\".",
+ OidIsValid(returned->attrs[i]->atttypid) ?
+ format_type_be(returned->attrs[i]->atttypid) :
+ _(dropped_column_type),
+ OidIsValid(expected->attrs[i]->atttypid) ?
+ format_type_be(expected->attrs[i]->atttypid) :
+ _(dropped_column_type),
+ NameStr(expected->attrs[i]->attname))));
}
/* ----------
foreach(lc, params)
{
PLpgSQL_expr *param = (PLpgSQL_expr *) lfirst(lc);
- bool isnull;
+ bool isnull;
ppd->values[i] = exec_eval_expr(estate, param,
&isnull,
/* pass-by-ref non null values must be copied into plpgsql context */
if (!isnull)
{
- int16 typLen;
- bool typByVal;
+ int16 typLen;
+ bool typByVal;
get_typlenbyval(ppd->types[i], &typLen, &typByVal);
if (!typByVal)
static void
free_params_data(PreparedParamsData *ppd)
{
- int i;
+ int i;
for (i = 0; i < ppd->nargs; i++)
{
char *querystr;
/*
- * Evaluate the string expression after the EXECUTE keyword. Its result
- * is the querystring we have to execute.
+ * Evaluate the string expression after the EXECUTE keyword. Its result is
+ * the querystring we have to execute.
*/
query = exec_eval_expr(estate, dynquery, &isnull, &restype);
if (isnull)
exec_eval_cleanup(estate);
/*
- * Open an implicit cursor for the query. We use SPI_cursor_open_with_args
- * even when there are no params, because this avoids making and freeing
- * one copy of the plan.
+ * Open an implicit cursor for the query. We use
+ * SPI_cursor_open_with_args even when there are no params, because this
+ * avoids making and freeing one copy of the plan.
*/
if (params)
{
*
* Note that this only searches for variables, not labels.
*
- * name1 must be non-NULL. Pass NULL for name2 and/or name3 if parsing a name
+ * name1 must be non-NULL. Pass NULL for name2 and/or name3 if parsing a name
* with fewer than three components.
*
* If names_used isn't NULL, *names_used receives the number of names
if (*s != '"') /* should not happen if lexer checked */
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("unterminated \" in identifier: %s", sstart)));
+ errmsg("unterminated \" in identifier: %s", sstart)));
s++;
*cp = '\0';
/* Truncate to NAMEDATALEN */
static void
dump_case(PLpgSQL_stmt_case *stmt)
{
- ListCell *l;
+ ListCell *l;
dump_ind();
printf("CASE %d ", stmt->t_varno);
dump_forc(PLpgSQL_stmt_forc *stmt)
{
dump_ind();
- printf("FORC %s ", stmt->rec->refname);
+ printf("FORC %s ", stmt->rec->refname);
printf("curvar=%d\n", stmt->curvar);
dump_indent += 2;
int lineno;
PLpgSQL_expr *t_expr; /* test expression, or NULL if none */
int t_varno; /* var to store test expression value into */
- List *case_when_list; /* List of PLpgSQL_case_when structs */
+ List *case_when_list; /* List of PLpgSQL_case_when structs */
bool have_else; /* flag needed because list could be empty */
List *else_stmts; /* List of statements */
} PLpgSQL_stmt_case;
typedef struct
{ /* RAISE statement option */
- int opt_type;
+ int opt_type;
PLpgSQL_expr *expr;
} PLpgSQL_raise_option;
PLpgSQL_type *dtype,
bool add2namespace);
extern PLpgSQL_rec *plpgsql_build_record(const char *refname, int lineno,
- bool add2namespace);
-extern int plpgsql_recognize_err_condition(const char *condname,
- bool allow_sqlstate);
+ bool add2namespace);
+extern int plpgsql_recognize_err_condition(const char *condname,
+ bool allow_sqlstate);
extern PLpgSQL_condition *plpgsql_parse_err_condition(char *condname);
extern void plpgsql_adddatum(PLpgSQL_datum *new);
extern int plpgsql_add_initdatums(int **varnos);
extern void plpgsql_ns_pop(void);
extern void plpgsql_ns_additem(int itemtype, int itemno, const char *name);
extern PLpgSQL_nsitem *plpgsql_ns_lookup(const char *name1, const char *name2,
- const char *name3, int *names_used);
+ const char *name3, int *names_used);
extern PLpgSQL_nsitem *plpgsql_ns_lookup_label(const char *name);
extern void plpgsql_ns_rename(char *oldname, char *newname);
Oid typoid; /* The OID of the type */
Oid typioparam;
bool typbyval;
-} PLyDatumToOb;
+} PLyDatumToOb;
typedef struct PLyTupleToOb
{
PLyDatumToOb *atts;
int natts;
-} PLyTupleToOb;
+} PLyTupleToOb;
typedef union PLyTypeInput
{
PLyDatumToOb d;
PLyTupleToOb r;
-} PLyTypeInput;
+} PLyTypeInput;
/* convert PyObject to a Postgresql Datum or tuple.
* output from Python
Oid typoid; /* The OID of the type */
Oid typioparam;
bool typbyval;
-} PLyObToDatum;
+} PLyObToDatum;
typedef struct PLyObToTuple
{
PLyObToDatum *atts;
int natts;
-} PLyObToTuple;
+} PLyObToTuple;
typedef union PLyTypeOutput
{
PLyObToDatum d;
PLyObToTuple r;
-} PLyTypeOutput;
+} PLyTypeOutput;
/* all we need to move Postgresql data to Python objects,
* and vis versa
* is_rowtype can be: -1 not known yet (initial state) 0 scalar datatype
* 1 rowtype 2 rowtype, but I/O functions not set up yet
*/
-} PLyTypeInfo;
+} PLyTypeInfo;
/* cached procedure data */
PyObject *globals; /* data saved across calls, global scope */
PyObject *me; /* PyCObject containing pointer to this
* PLyProcedure */
-} PLyProcedure;
+} PLyProcedure;
/* Python objects */
Oid *types;
Datum *values;
PLyTypeInfo *args;
-} PLyPlanObject;
+} PLyPlanObject;
typedef struct PLyResultObject
{
PyObject_HEAD
/* HeapTuple *tuples; */
- PyObject * nrows; /* number of rows returned by query */
+ PyObject *nrows; /* number of rows returned by query */
PyObject *rows; /* data rows, or None if no data returned */
PyObject *status; /* query status, SPI_OK_*, or SPI_ERR_* */
-} PLyResultObject;
+} PLyResultObject;
/* function declarations */
static void PLy_init_plpy(void);
/* call PyErr_SetString with a vprint interface and translation support */
-static void PLy_exception_set(PyObject *, const char *,...)
+static void
+PLy_exception_set(PyObject *, const char *,...)
__attribute__((format(printf, 2, 3)));
+
/* same, with pluralized message */
-static void PLy_exception_set_plural(PyObject *, const char *, const char *,
- unsigned long n,...)
+static void
+PLy_exception_set_plural(PyObject *, const char *, const char *,
+ unsigned long n,...)
__attribute__((format(printf, 2, 5)))
__attribute__((format(printf, 3, 5)));
static char *PLy_procedure_name(PLyProcedure *);
/* some utility functions */
-static void PLy_elog(int, const char *,...)
+static void
+PLy_elog(int, const char *,...)
__attribute__((format(printf, 2, 3)));
static char *PLy_traceback(int *);
Oid tgreloid);
static PLyProcedure *PLy_procedure_create(HeapTuple procTup, Oid tgreloid,
- char *key);
+ char *key);
static void PLy_procedure_compile(PLyProcedure *, const char *);
static char *PLy_procedure_munge_source(const char *, const char *);
* to take no arguments and return an argument of type trigger.
*/
static HeapTuple
-PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure * proc)
+PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure *proc)
{
HeapTuple rv = NULL;
PyObject *volatile plargs = NULL;
}
static HeapTuple
-PLy_modify_tuple(PLyProcedure * proc, PyObject * pltd, TriggerData *tdata,
+PLy_modify_tuple(PLyProcedure *proc, PyObject *pltd, TriggerData *tdata,
HeapTuple otup)
{
PyObject *volatile plntup;
PG_TRY();
{
if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
- ereport(ERROR,
+ ereport(ERROR,
(errmsg("TD[\"new\"] deleted, cannot modify row")));
if (!PyDict_Check(plntup))
ereport(ERROR,
}
static PyObject *
-PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure * proc, HeapTuple *rv)
+PLy_trigger_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc, HeapTuple *rv)
{
TriggerData *tdata = (TriggerData *) fcinfo->context;
PyObject *pltname,
/* function handler and friends */
static Datum
-PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure * proc)
+PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure *proc)
{
Datum rv;
PyObject *volatile plargs = NULL;
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("returned object cannot be iterated"),
- errdetail("PL/Python set-returning functions must return an iterable object.")));
+ errdetail("PL/Python set-returning functions must return an iterable object.")));
}
/* Fetch next from iterator */
if (plrv != Py_None)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("PL/Python function with return type \"void\" did not return None")));
+ errmsg("PL/Python function with return type \"void\" did not return None")));
fcinfo->isnull = false;
rv = (Datum) 0;
}
static PyObject *
-PLy_procedure_call(PLyProcedure * proc, char *kargs, PyObject * vargs)
+PLy_procedure_call(PLyProcedure *proc, char *kargs, PyObject *vargs)
{
PyObject *rv;
}
static PyObject *
-PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure * proc)
+PLy_function_build_args(FunctionCallInfo fcinfo, PLyProcedure *proc)
{
PyObject *volatile arg = NULL;
PyObject *volatile args = NULL;
PLy_elog(ERROR, "PyList_SetItem() failed for PL/Python function \"%s\" while setting up arguments", proc->proname);
if (proc->argnames && proc->argnames[i] &&
- PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
+ PyDict_SetItemString(proc->globals, proc->argnames[i], arg) == -1)
PLy_elog(ERROR, "PyDict_SetItemString() failed for PL/Python function \"%s\" while setting up arguments", proc->proname);
arg = NULL;
}
static void
-PLy_function_delete_args(PLyProcedure * proc)
+PLy_function_delete_args(PLyProcedure *proc)
{
int i;
{
/*
* Input/output conversion for trigger tuples. Use the result
- * TypeInfo variable to store the tuple conversion info. We
- * do this over again on each call to cover the possibility that
- * the relation's tupdesc changed since the trigger was last called.
+ * TypeInfo variable to store the tuple conversion info. We do this
+ * over again on each call to cover the possibility that the
+ * relation's tupdesc changed since the trigger was last called.
* PLy_input_tuple_funcs and PLy_output_tuple_funcs are responsible
* for not doing repetitive work.
*/
else
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("PL/Python functions cannot return type %s",
- format_type_be(procStruct->prorettype))));
+ errmsg("PL/Python functions cannot return type %s",
+ format_type_be(procStruct->prorettype))));
}
if (rvTypeStruct->typtype == TYPTYPE_COMPOSITE)
/*
* Now get information required for input conversion of the
- * procedure's arguments. Note that we ignore output arguments
- * here --- since we don't support returning record, and that was
- * already checked above, there's no need to worry about multiple
- * output arguments.
+ * procedure's arguments. Note that we ignore output arguments here
+ * --- since we don't support returning record, and that was already
+ * checked above, there's no need to worry about multiple output
+ * arguments.
*/
if (procStruct->pronargs)
{
- Oid *types;
- char **names,
- *modes;
- int i,
- pos,
- total;
+ Oid *types;
+ char **names,
+ *modes;
+ int i,
+ pos,
+ total;
/* extract argument type info from the pg_proc tuple */
total = get_func_arg_info(procTup, &types, &names, &modes);
/* Disallow pseudotype argument */
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("PL/Python functions cannot accept type %s",
+ errmsg("PL/Python functions cannot accept type %s",
format_type_be(types[i]))));
break;
case TYPTYPE_COMPOSITE:
}
static void
-PLy_procedure_compile(PLyProcedure * proc, const char *src)
+PLy_procedure_compile(PLyProcedure *proc, const char *src)
{
PyObject *crv = NULL;
char *msrc;
}
static void
-PLy_procedure_delete(PLyProcedure * proc)
+PLy_procedure_delete(PLyProcedure *proc)
{
int i;
* PostgreSQL, and vice versa.
*/
static void
-PLy_input_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
+PLy_input_tuple_funcs(PLyTypeInfo *arg, TupleDesc desc)
{
int i;
}
static void
-PLy_output_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
+PLy_output_tuple_funcs(PLyTypeInfo *arg, TupleDesc desc)
{
int i;
}
static void
-PLy_output_datum_func(PLyTypeInfo * arg, HeapTuple typeTup)
+PLy_output_datum_func(PLyTypeInfo *arg, HeapTuple typeTup)
{
if (arg->is_rowtype > 0)
elog(ERROR, "PLyTypeInfo struct is initialized for a Tuple");
}
static void
-PLy_output_datum_func2(PLyObToDatum * arg, HeapTuple typeTup)
+PLy_output_datum_func2(PLyObToDatum *arg, HeapTuple typeTup)
{
Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
}
static void
-PLy_input_datum_func(PLyTypeInfo * arg, Oid typeOid, HeapTuple typeTup)
+PLy_input_datum_func(PLyTypeInfo *arg, Oid typeOid, HeapTuple typeTup)
{
if (arg->is_rowtype > 0)
elog(ERROR, "PLyTypeInfo struct is initialized for Tuple");
}
static void
-PLy_input_datum_func2(PLyDatumToOb * arg, Oid typeOid, HeapTuple typeTup)
+PLy_input_datum_func2(PLyDatumToOb *arg, Oid typeOid, HeapTuple typeTup)
{
Form_pg_type typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
}
static void
-PLy_typeinfo_init(PLyTypeInfo * arg)
+PLy_typeinfo_init(PLyTypeInfo *arg)
{
arg->is_rowtype = -1;
arg->in.r.natts = arg->out.r.natts = 0;
}
static void
-PLy_typeinfo_dealloc(PLyTypeInfo * arg)
+PLy_typeinfo_dealloc(PLyTypeInfo *arg)
{
if (arg->is_rowtype == 1)
{
}
static PyObject *
-PLyDict_FromTuple(PLyTypeInfo * info, HeapTuple tuple, TupleDesc desc)
+PLyDict_FromTuple(PLyTypeInfo *info, HeapTuple tuple, TupleDesc desc)
{
PyObject *volatile dict;
int i;
static HeapTuple
-PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
+PLyMapping_ToTuple(PLyTypeInfo *info, PyObject *mapping)
{
TupleDesc desc;
HeapTuple tuple;
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("key \"%s\" not found in mapping", key),
errhint("To return null in a column, "
- "add the value None to the mapping with the key named after the column.")));
+ "add the value None to the mapping with the key named after the column.")));
Py_XDECREF(value);
value = NULL;
static HeapTuple
-PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
+PLySequence_ToTuple(PLyTypeInfo *info, PyObject *sequence)
{
TupleDesc desc;
HeapTuple tuple;
if (PySequence_Length(sequence) != desc->natts)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("length of returned sequence did not match number of columns in row")));
+ errmsg("length of returned sequence did not match number of columns in row")));
if (info->is_rowtype == 2)
PLy_output_tuple_funcs(info, desc);
static HeapTuple
-PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
+PLyObject_ToTuple(PLyTypeInfo *info, PyObject *object)
{
TupleDesc desc;
HeapTuple tuple;
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("attribute \"%s\" does not exist in Python object", key),
errhint("To return null in a column, "
- "let the returned object have an attribute named "
+ "let the returned object have an attribute named "
"after column with value None.")));
Py_XDECREF(value);
static void
-PLy_plan_dealloc(PyObject * arg)
+PLy_plan_dealloc(PyObject *arg)
{
PLyPlanObject *ob = (PLyPlanObject *) arg;
static PyObject *
-PLy_plan_getattr(PyObject * self, char *name)
+PLy_plan_getattr(PyObject *self, char *name)
{
return Py_FindMethod(PLy_plan_methods, self, name);
}
static PyObject *
-PLy_plan_status(PyObject * self, PyObject * args)
+PLy_plan_status(PyObject *self, PyObject *args)
{
if (PyArg_ParseTuple(args, ""))
{
}
static void
-PLy_result_dealloc(PyObject * arg)
+PLy_result_dealloc(PyObject *arg)
{
PLyResultObject *ob = (PLyResultObject *) arg;
}
static PyObject *
-PLy_result_getattr(PyObject * self, char *name)
+PLy_result_getattr(PyObject *self, char *name)
{
return Py_FindMethod(PLy_result_methods, self, name);
}
static PyObject *
-PLy_result_nrows(PyObject * self, PyObject * args)
+PLy_result_nrows(PyObject *self, PyObject *args)
{
PLyResultObject *ob = (PLyResultObject *) self;
}
static PyObject *
-PLy_result_status(PyObject * self, PyObject * args)
+PLy_result_status(PyObject *self, PyObject *args)
{
PLyResultObject *ob = (PLyResultObject *) self;
}
static Py_ssize_t
-PLy_result_length(PyObject * arg)
+PLy_result_length(PyObject *arg)
{
PLyResultObject *ob = (PLyResultObject *) arg;
}
static PyObject *
-PLy_result_item(PyObject * arg, Py_ssize_t idx)
+PLy_result_item(PyObject *arg, Py_ssize_t idx)
{
PyObject *rv;
PLyResultObject *ob = (PLyResultObject *) arg;
}
static int
-PLy_result_ass_item(PyObject * arg, Py_ssize_t idx, PyObject * item)
+PLy_result_ass_item(PyObject *arg, Py_ssize_t idx, PyObject *item)
{
int rv;
PLyResultObject *ob = (PLyResultObject *) arg;
}
static PyObject *
-PLy_result_slice(PyObject * arg, Py_ssize_t lidx, Py_ssize_t hidx)
+PLy_result_slice(PyObject *arg, Py_ssize_t lidx, Py_ssize_t hidx)
{
PyObject *rv;
PLyResultObject *ob = (PLyResultObject *) arg;
}
static int
-PLy_result_ass_slice(PyObject * arg, Py_ssize_t lidx, Py_ssize_t hidx, PyObject * slice)
+PLy_result_ass_slice(PyObject *arg, Py_ssize_t lidx, Py_ssize_t hidx, PyObject *slice)
{
int rv;
PLyResultObject *ob = (PLyResultObject *) arg;
/* SPI interface */
static PyObject *
-PLy_spi_prepare(PyObject * self, PyObject * args)
+PLy_spi_prepare(PyObject *self, PyObject *args)
{
PLyPlanObject *plan;
PyObject *list = NULL;
if (list && (!PySequence_Check(list)))
{
PLy_exception_set(PLy_exc_spi_error,
- "second argument of plpy.prepare must be a sequence");
+ "second argument of plpy.prepare must be a sequence");
return NULL;
}
* execute(plan=plan, values=(foo, bar), limit=5)
*/
static PyObject *
-PLy_spi_execute(PyObject * self, PyObject * args)
+PLy_spi_execute(PyObject *self, PyObject *args)
{
char *query;
PyObject *plan;
}
static PyObject *
-PLy_spi_execute_plan(PyObject * ob, PyObject * list, long limit)
+PLy_spi_execute_plan(PyObject *ob, PyObject *list, long limit)
{
volatile int nargs;
int i,
PLy_procedure_name(PLy_curr_procedure));
sv = PyString_AsString(so);
PLy_exception_set_plural(PLy_exc_spi_error,
- "Expected sequence of %d argument, got %d: %s",
- "Expected sequence of %d arguments, got %d: %s",
+ "Expected sequence of %d argument, got %d: %s",
+ "Expected sequence of %d arguments, got %d: %s",
plan->nargs,
plan->nargs, nargs, sv);
Py_DECREF(so);
FlushErrorState();
if (!PyErr_Occurred())
PLy_exception_set(PLy_exc_error,
- "unrecognized error in PLy_spi_execute_fetch_result");
+ "unrecognized error in PLy_spi_execute_fetch_result");
Py_DECREF(result);
PLy_typeinfo_dealloc(&args);
return NULL;
static PyObject *PLy_output(volatile int, PyObject *, PyObject *);
static PyObject *
-PLy_debug(PyObject * self, PyObject * args)
+PLy_debug(PyObject *self, PyObject *args)
{
return PLy_output(DEBUG2, self, args);
}
static PyObject *
-PLy_log(PyObject * self, PyObject * args)
+PLy_log(PyObject *self, PyObject *args)
{
return PLy_output(LOG, self, args);
}
static PyObject *
-PLy_info(PyObject * self, PyObject * args)
+PLy_info(PyObject *self, PyObject *args)
{
return PLy_output(INFO, self, args);
}
static PyObject *
-PLy_notice(PyObject * self, PyObject * args)
+PLy_notice(PyObject *self, PyObject *args)
{
return PLy_output(NOTICE, self, args);
}
static PyObject *
-PLy_warning(PyObject * self, PyObject * args)
+PLy_warning(PyObject *self, PyObject *args)
{
return PLy_output(WARNING, self, args);
}
static PyObject *
-PLy_error(PyObject * self, PyObject * args)
+PLy_error(PyObject *self, PyObject *args)
{
return PLy_output(ERROR, self, args);
}
static PyObject *
-PLy_fatal(PyObject * self, PyObject * args)
+PLy_fatal(PyObject *self, PyObject *args)
{
return PLy_output(FATAL, self, args);
}
static PyObject *
-PLy_output(volatile int level, PyObject * self, PyObject * args)
+PLy_output(volatile int level, PyObject *self, PyObject *args)
{
PyObject *so;
char *volatile sv;
* NB: this returns the SQL name, not the internal Python procedure name
*/
static char *
-PLy_procedure_name(PLyProcedure * proc)
+PLy_procedure_name(PLyProcedure *proc)
{
if (proc == NULL)
return "<unknown procedure>";
* Call PyErr_SetString with a vprint interface and translation support
*/
static void
-PLy_exception_set(PyObject * exc, const char *fmt,...)
+PLy_exception_set(PyObject *exc, const char *fmt,...)
{
char buf[1024];
va_list ap;
{
UTF_BEGIN;
retval = InputFunctionCall(&prodesc->result_in_func,
- UTF_U2E((char *) Tcl_GetStringResult(interp)),
+ UTF_U2E((char *) Tcl_GetStringResult(interp)),
prodesc->result_typioparam,
-1);
UTF_END;
{
/*
* Caution is needed here because Tcl_GetVar could overwrite the
- * interpreter result (even though it's not really supposed to),
- * and we can't control the order of evaluation of ereport arguments.
- * Hence, make real sure we have our own copy of the result string
- * before invoking Tcl_GetVar.
+ * interpreter result (even though it's not really supposed to), and we
+ * can't control the order of evaluation of ereport arguments. Hence, make
+ * real sure we have our own copy of the result string before invoking
+ * Tcl_GetVar.
*/
char *emsg;
char *econtext;
free(prodesc);
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("PL/Tcl functions cannot return composite types")));
+ errmsg("PL/Tcl functions cannot return composite types")));
}
perm_fmgr_info(typeStruct->typinput, &(prodesc->result_in_func));
if (level == ERROR)
{
/*
- * We just pass the error back to Tcl. If it's not caught,
- * it'll eventually get converted to a PG error when we reach
- * the call handler.
+ * We just pass the error back to Tcl. If it's not caught, it'll
+ * eventually get converted to a PG error when we reach the call
+ * handler.
*/
Tcl_SetResult(interp, (char *) argv[2], TCL_VOLATILE);
return TCL_ERROR;
}
/*
- * For non-error messages, just pass 'em to elog(). We do not expect
- * that this will fail, but just on the off chance it does, report the
- * error back to Tcl. Note we are assuming that elog() can't have any
- * internal failures that are so bad as to require a transaction abort.
+ * For non-error messages, just pass 'em to elog(). We do not expect that
+ * this will fail, but just on the off chance it does, report the error
+ * back to Tcl. Note we are assuming that elog() can't have any internal
+ * failures that are so bad as to require a transaction abort.
*
* This path is also used for FATAL errors, which aren't going to come
* back to us at all.
#if defined(B64)
B64 b64;
#endif
-} C_block;
+} C_block;
/*
* Convert twenty-four-bit long in host-order
WORD PrintNameOffset;
WORD PrintNameLength;
WCHAR PathBuffer[1];
-} REPARSE_JUNCTION_DATA_BUFFER;
+} REPARSE_JUNCTION_DATA_BUFFER;
#define REPARSE_JUNCTION_DATA_BUFFER_HEADER_SIZE \
FIELD_OFFSET(REPARSE_JUNCTION_DATA_BUFFER, SubstituteNameOffset)
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
- (LPSTR) & msg, 0, NULL);
+ (LPSTR) &msg, 0, NULL);
#ifndef FRONTEND
ereport(ERROR,
(errcode_for_file_access(),
* must call pgfnames_cleanup later to free the memory allocated by this
* function.
*/
-char **
+char **
pgfnames(const char *path)
{
DIR *dir;
* delete it anyway.
*
* This is not an academic possibility. One scenario where this
- * happens is when bgwriter has a pending unlink request for a file
- * in a database that's being dropped. In dropdb(), we call
+ * happens is when bgwriter has a pending unlink request for a file in
+ * a database that's being dropped. In dropdb(), we call
* ForgetDatabaseFsyncRequests() to flush out any such pending unlink
- * requests, but because that's asynchronous, it's not guaranteed
- * that the bgwriter receives the message in time.
+ * requests, but because that's asynchronous, it's not guaranteed that
+ * the bgwriter receives the message in time.
*/
if (lstat(pathbuf, &statbuf) != 0)
{
* field when run. So we define our own version that uses the Win32 API
* to update this field.
*/
-int
-pgwin32_safestat(const char *path, struct stat *buf)
+int
+pgwin32_safestat(const char *path, struct stat * buf)
{
- int r;
+ int r;
WIN32_FILE_ATTRIBUTE_DATA attr;
r = stat(path, buf);
}
/*
- * XXX no support for large files here, but we don't do that in
- * general on Win32 yet.
+ * XXX no support for large files here, but we don't do that in general on
+ * Win32 yet.
*/
buf->st_size = attr.nFileSizeLow;
static char *pipe_read_line(char *cmd, char *line, int maxsize);
#ifdef WIN32
-static BOOL GetUserSid(PSID * ppSidUser, HANDLE hToken);
+static BOOL GetUserSid(PSID *ppSidUser, HANDLE hToken);
#endif
/*
}
/* Get the ACL info */
- if (!GetAclInformation(ptdd->DefaultDacl, (LPVOID) & asi,
+ if (!GetAclInformation(ptdd->DefaultDacl, (LPVOID) &asi,
(DWORD) sizeof(ACL_SIZE_INFORMATION),
AclSizeInformation))
{
}
/* Figure out the size of the new ACL */
- dwNewAclSize = asi.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(psidUser) - sizeof(DWORD);
+ dwNewAclSize = asi.AclBytesInUse + sizeof(ACCESS_ALLOWED_ACE) + GetLengthSid(psidUser) -sizeof(DWORD);
/* Allocate the ACL buffer & initialize it */
pacl = (PACL) LocalAlloc(LPTR, dwNewAclSize);
/* Loop through the existing ACEs, and build the new ACL */
for (i = 0; i < (int) asi.AceCount; i++)
{
- if (!GetAce(ptdd->DefaultDacl, i, (LPVOID *) & pace))
+ if (!GetAce(ptdd->DefaultDacl, i, (LPVOID *) &pace))
{
log_error("could not get ACE: %lu", GetLastError());
goto cleanup;
/* Set the new DACL in the token */
tddNew.DefaultDacl = pacl;
- if (!SetTokenInformation(hToken, tic, (LPVOID) & tddNew, dwNewAclSize))
+ if (!SetTokenInformation(hToken, tic, (LPVOID) &tddNew, dwNewAclSize))
{
log_error("could not set token information: %lu", GetLastError());
goto cleanup;
* Get the SID for the current user
*/
static BOOL
-GetUserSid(PSID * ppSidUser, HANDLE hToken)
+GetUserSid(PSID *ppSidUser, HANDLE hToken)
{
DWORD dwLength;
PTOKEN_USER pTokenUser = NULL;
optind = 1, /* index into parent argv vector */
optopt; /* character checked for validity */
char *optarg; /* argument associated with option */
-
#else
extern int opterr;
extern int optind;
extern int optopt;
extern char *optarg;
-
#endif
#ifndef HAVE_INT_OPTRESET
#ifndef HAVE_INT_OPTRESET
int optreset;
+
/* else the "extern" was provided by getopt_long.h */
#endif
errno = EINVAL;
return -1;
}
-
+
if (rusage == (struct rusage *) NULL)
{
errno = EFAULT;
((fileFlags & O_WRONLY) ? GENERIC_WRITE : GENERIC_READ),
/* These flags allow concurrent rename/unlink */
(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE),
- &sa,
- openFlagsToCreateFileFlags(fileFlags),
- FILE_ATTRIBUTE_NORMAL |
+ &sa,
+ openFlagsToCreateFileFlags(fileFlags),
+ FILE_ATTRIBUTE_NORMAL |
((fileFlags & O_RANDOM) ? FILE_FLAG_RANDOM_ACCESS : 0) |
((fileFlags & O_SEQUENTIAL) ? FILE_FLAG_SEQUENTIAL_SCAN : 0) |
((fileFlags & _O_SHORT_LIVED) ? FILE_ATTRIBUTE_TEMPORARY : 0) |
((fileFlags & O_TEMPORARY) ? FILE_FLAG_DELETE_ON_CLOSE : 0) |
((fileFlags & O_DIRECT) ? FILE_FLAG_NO_BUFFERING : 0) |
- ((fileFlags & O_DSYNC) ? FILE_FLAG_WRITE_THROUGH : 0),
- NULL)) == INVALID_HANDLE_VALUE)
+ ((fileFlags & O_DSYNC) ? FILE_FLAG_WRITE_THROUGH : 0),
+ NULL)) == INVALID_HANDLE_VALUE)
{
/*
* Sharing violation or locking error can indicate antivirus, backup
- * or similar software that's locking the file. Try again for 30 seconds
- * before giving up.
+ * or similar software that's locking the file. Try again for 30
+ * seconds before giving up.
*/
- DWORD err = GetLastError();
- if (err == ERROR_SHARING_VIOLATION ||
+ DWORD err = GetLastError();
+
+ if (err == ERROR_SHARING_VIOLATION ||
err == ERROR_LOCK_VIOLATION)
{
pg_usleep(100000);
#ifndef FRONTEND
if (loops == 50)
ereport(LOG,
- (errmsg("could not open file \"%s\": %s", fileName,
- (err == ERROR_SHARING_VIOLATION)?_("sharing violation"):_("lock violation")),
- errdetail("Continuing to retry for 30 seconds."),
- errhint("You might have antivirus, backup, or similar software interfering with the database system.")));
+ (errmsg("could not open file \"%s\": %s", fileName,
+ (err == ERROR_SHARING_VIOLATION) ? _("sharing violation") : _("lock violation")),
+ errdetail("Continuing to retry for 30 seconds."),
+ errhint("You might have antivirus, backup, or similar software interfering with the database system.")));
#endif
if (loops < 300)
#ifndef WIN32
*s1 != *s2
#else
- /* On windows, paths are case-insensitive */
+ /* On windows, paths are case-insensitive */
pg_tolower((unsigned char) *s1) != pg_tolower((unsigned char) *s2)
#endif
&& !(IS_DIR_SEP(*s1) && IS_DIR_SEP(*s2)))
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(0);
serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- if (bind(s, (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
+ if (bind(s, (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
{
ereport(LOG, (errmsg_internal("pgpipe failed to bind: %ui", WSAGetLastError())));
closesocket(s);
closesocket(s);
return -1;
}
- if (getsockname(s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR)
+ if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
{
ereport(LOG, (errmsg_internal("pgpipe failed to getsockname: %ui", WSAGetLastError())));
closesocket(s);
return -1;
}
- if (connect(handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
+ if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
{
ereport(LOG, (errmsg_internal("pgpipe failed to connect socket: %ui", WSAGetLastError())));
closesocket(s);
return -1;
}
- if ((handles[0] = accept(s, (SOCKADDR *) & serv_addr, &len)) == INVALID_SOCKET)
+ if ((handles[0] = accept(s, (SOCKADDR *) &serv_addr, &len)) == INVALID_SOCKET)
{
ereport(LOG, (errmsg_internal("pgpipe failed to accept socket: %ui", WSAGetLastError())));
closesocket(handles[1]);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*/
#ifndef __PTHREAD_H
#define __PTHREAD_H
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*-------------------------------------------------------------------------
*
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
* $OpenBSD$ */
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* Copyright (c) 1990, 1993
/*-------------------------------------------------------------------------
*
* win32env.c
- * putenv() and unsetenv() for win32, that updates both process
- * environment and the cached versions in (potentially multiple)
- * MSVCRT.
+ * putenv() and unsetenv() for win32, that updates both process
+ * environment and the cached versions in (potentially multiple)
+ * MSVCRT.
*
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
int
pgwin32_putenv(const char *envval)
{
- char *envcpy;
- char *cp;
+ char *envcpy;
+ char *cp;
/*
* Each version of MSVCRT has its own _putenv() call in the runtime
* library.
*
- * If we're in VC 7.0 or later (means != mingw), update in
- * the 6.0 MSVCRT.DLL environment as well, to work with third party
- * libraries linked against it (such as gnuwin32 libraries).
+ * If we're in VC 7.0 or later (means != mingw), update in the 6.0
+ * MSVCRT.DLL environment as well, to work with third party libraries
+ * linked against it (such as gnuwin32 libraries).
*/
#if defined(_MSC_VER) && (_MSC_VER >= 1300)
- typedef int (_cdecl *PUTENVPROC)(const char *);
- HMODULE hmodule;
- static PUTENVPROC putenvFunc = NULL;
- int ret;
+ typedef int (_cdecl * PUTENVPROC) (const char *);
+ HMODULE hmodule;
+ static PUTENVPROC putenvFunc = NULL;
+ int ret;
if (putenvFunc == NULL)
{
hmodule = GetModuleHandle("msvcrt");
if (hmodule == NULL)
return 1;
- putenvFunc = (PUTENVPROC)GetProcAddress(hmodule, "_putenv");
+ putenvFunc = (PUTENVPROC) GetProcAddress(hmodule, "_putenv");
if (putenvFunc == NULL)
return 1;
}
ret = putenvFunc(envval);
if (ret != 0)
return ret;
-#endif /* _MSC_VER >= 1300 */
+#endif /* _MSC_VER >= 1300 */
/*
- * Update the process environment - to make modifications visible
- * to child processes.
+ * Update the process environment - to make modifications visible to child
+ * processes.
*
* Need a copy of the string so we can modify it.
*/
{
/*
* Only call SetEnvironmentVariable() when we are adding a variable,
- * not when removing it. Calling it on both crashes on at least certain
- * versions of MingW.
+ * not when removing it. Calling it on both crashes on at least
+ * certain versions of MingW.
*/
if (!SetEnvironmentVariable(envcpy, cp))
{
void
pgwin32_unsetenv(const char *name)
{
- char *envbuf;
+ char *envbuf;
- envbuf = (char *) malloc(strlen(name)+2);
+ envbuf = (char *) malloc(strlen(name) + 2);
if (!envbuf)
return;
pgwin32_putenv(envbuf);
free(envbuf);
}
-
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* testlibpq.c
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* testlibpq2.c
break; /* shouldn't happen */
FD_ZERO(&input_mask);
- FD_SET(sock, &input_mask);
+ FD_SET (sock, &input_mask);
if (select(sock + 1, &input_mask, NULL, NULL, NULL) < 0)
{
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* testlibpq3.c
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
*
* testlibpq4.c
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*/
/*
__attribute__((format(printf, 2, 3)));
#ifdef WIN32
-typedef BOOL(WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
+typedef BOOL (WINAPI * __CreateRestrictedToken) (HANDLE, DWORD, DWORD, PSID_AND_ATTRIBUTES, DWORD, PLUID_AND_ATTRIBUTES, DWORD, PSID_AND_ATTRIBUTES, PHANDLE);
/* Windows API define missing from MingW headers */
#define DISABLE_MAX_PRIVILEGE 0x1
{
fprintf(stderr, _("\n%s: could not stop postmaster: exit code was %d\n"),
progname, r);
- exit(2); /* not exit_nicely(), that would be recursive */
+ exit(2); /* not exit_nicely(), that would be recursive */
}
postmaster_running = false;
{
char testtablespace[MAXPGPATH];
char indir[MAXPGPATH];
- struct stat st;
+ struct stat st;
int ret;
char **name;
char **names;
if (ret != 0 || !S_ISDIR(st.st_mode))
{
/*
- * No warning, to avoid noise in tests that do not have
- * these directories; for example, ecpg, contrib and src/pl.
+ * No warning, to avoid noise in tests that do not have these
+ * directories; for example, ecpg, contrib and src/pl.
*/
return;
}
snprintf(testtablespace, MAXPGPATH, "%s/testtablespace", outputdir);
#ifdef WIN32
+
/*
* On Windows only, clean out the test tablespace dir, or create it if it
- * doesn't exist. On other platforms we expect the Makefile to take
- * care of that. (We don't migrate that functionality in here because
- * it'd be harder to cope with platform-specific issues such as SELinux.)
+ * doesn't exist. On other platforms we expect the Makefile to take care
+ * of that. (We don't migrate that functionality in here because it'd be
+ * harder to cope with platform-specific issues such as SELinux.)
*
* XXX it would be better if pg_regress.c had nothing at all to do with
* testtablespace, and this were handled by a .BAT file or similar on
}
/*
- * Set translation-related settings to English; otherwise psql
- * will produce translated messages and produce diffs. (XXX If we
- * ever support translation of pg_regress, this needs to be moved
- * elsewhere, where psql is actually called.)
+ * Set translation-related settings to English; otherwise psql will
+ * produce translated messages and produce diffs. (XXX If we ever support
+ * translation of pg_regress, this needs to be moved elsewhere, where psql
+ * is actually called.)
*/
unsetenv("LANGUAGE");
unsetenv("LC_ALL");
putenv("PGDATESTYLE=Postgres, MDY");
/*
- * Likewise set intervalstyle to ensure consistent results. This is a
- * bit more painful because we must use PGOPTIONS, and we want to preserve
- * the user's ability to set other variables through that.
+ * Likewise set intervalstyle to ensure consistent results. This is a bit
+ * more painful because we must use PGOPTIONS, and we want to preserve the
+ * user's ability to set other variables through that.
*/
{
const char *my_pgoptions = "-c intervalstyle=postgres_verbose";
const char *old_pgoptions = getenv("PGOPTIONS");
- char *new_pgoptions;
+ char *new_pgoptions;
if (!old_pgoptions)
old_pgoptions = "";
sprintf(cmdline2, "cmd /c %s", cmdline);
if (!CreateProcessAsUser(restrictedToken,
- NULL,
- cmdline2,
- NULL,
- NULL,
- TRUE,
- CREATE_SUSPENDED,
- NULL,
- NULL,
- &si,
- &pi))
+ NULL,
+ cmdline2,
+ NULL,
+ NULL,
+ TRUE,
+ CREATE_SUSPENDED,
+ NULL,
+ NULL,
+ &si,
+ &pi))
{
fprintf(stderr, _("could not start process for \"%s\": %lu\n"),
cmdline2, GetLastError());
free(cmdline2);
- ResumeThread(pi.hThread);
+ ResumeThread(pi.hThread);
CloseHandle(pi.hThread);
return pi.hProcess;
#endif
* Note: it's OK to scribble on the pids array, but not on the names array
*/
static void
-wait_for_tests(PID_TYPE *pids, int *statuses, char **names, int num_tests)
+wait_for_tests(PID_TYPE * pids, int *statuses, char **names, int num_tests)
{
int tests_left;
int i;
#ifndef WIN32
int exit_status;
+
p = wait(&exit_status);
if (p == INVALID_PID)
static char *
make_absolute_path(const char *in)
{
- char *result;
+ char *result;
if (is_absolute_path(in))
result = strdup(in);
else
{
- static char cwdbuf[MAXPGPATH];
+ static char cwdbuf[MAXPGPATH];
if (!cwdbuf[0])
{
}
if (temp_install && !port_specified_by_user)
+
/*
- * To reduce chances of interference with parallel
- * installations, use a port number starting in the private
- * range (49152-65535) calculated from the version number.
+ * To reduce chances of interference with parallel installations, use
+ * a port number starting in the private range (49152-65535)
+ * calculated from the version number.
*/
port = 0xC000 | (PG_VERSION_NUM & 0x3FFF);
}
/*
- * Adjust the default postgresql.conf as needed for regression testing.
- * The user can specify a file to be appended; in any case we set
- * max_prepared_transactions to enable testing of prepared xacts.
+ * Adjust the default postgresql.conf as needed for regression
+ * testing. The user can specify a file to be appended; in any case we
+ * set max_prepared_transactions to enable testing of prepared xacts.
* (Note: to reduce the probability of unexpected shmmax failures,
- * don't set max_prepared_transactions any higher than actually
- * needed by the prepared_xacts regression test.)
+ * don't set max_prepared_transactions any higher than actually needed
+ * by the prepared_xacts regression test.)
*/
snprintf(buf, sizeof(buf), "%s/data/postgresql.conf", temp_install);
pg_conf = fopen(buf, "a");
exit_nicely(2);
}
- fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port+1);
+ fprintf(stderr, _("port %d apparently in use, trying %d\n"), port, port + 1);
port++;
sprintf(s, "%d", port);
doputenv("PGPORT", s);
char psql_cmd[MAXPGPATH * 3];
/*
- * Look for files in the output dir first, consistent with a vpath
- * search. This is mainly to create more reasonable error
- * messages if the file is not found. It also allows local test
- * overrides when running pg_regress outside of the source tree.
+ * Look for files in the output dir first, consistent with a vpath search.
+ * This is mainly to create more reasonable error messages if the file is
+ * not found. It also allows local test overrides when running pg_regress
+ * outside of the source tree.
*/
snprintf(infile, sizeof(infile), "%s/sql/%s.sql",
outputdir, testname);
static long detzcode(const char *codep);
static pg_time_t detzcode64(const char *codep);
-static int differ_by_repeat(pg_time_t t1, pg_time_t t0);
+static int differ_by_repeat(pg_time_t t1, pg_time_t t0);
static const char *getzname(const char *strp);
static const char *getqzname(const char *strp, int delim);
static const char *getnum(const char *strp, int *nump, int min, int max);
static const char *getoffset(const char *strp, long *offsetp);
static const char *getrule(const char *strp, struct rule * rulep);
static void gmtload(struct state * sp);
-static struct pg_tm *gmtsub(const pg_time_t *timep, long offset,
- struct pg_tm *tmp);
-static struct pg_tm *localsub(const pg_time_t *timep, long offset,
- struct pg_tm *tmp, const pg_tz *tz);
-static int increment_overflow(int *number, int delta);
+static struct pg_tm *gmtsub(const pg_time_t *timep, long offset,
+ struct pg_tm * tmp);
+static struct pg_tm *localsub(const pg_time_t *timep, long offset,
+ struct pg_tm * tmp, const pg_tz *tz);
+static int increment_overflow(int *number, int delta);
static pg_time_t transtime(pg_time_t janfirst, int year,
- const struct rule *rulep, long offset);
-static int typesequiv(const struct state *sp, int a, int b);
+ const struct rule * rulep, long offset);
+static int typesequiv(const struct state * sp, int a, int b);
static struct pg_tm *timesub(const pg_time_t *timep, long offset,
- const struct state *sp, struct pg_tm *tmp);
+ const struct state * sp, struct pg_tm * tmp);
/* GMT timezone */
static struct state gmtmem;
static pg_time_t
detzcode64(const char *codep)
{
- pg_time_t result;
- int i;
+ pg_time_t result;
+ int i;
- result = (codep[0] & 0x80) ? (~(int64) 0) : 0;
+ result = (codep[0] & 0x80) ? (~(int64) 0) : 0;
for (i = 0; i < 8; ++i)
result = result * 256 + (codep[i] & 0xff);
return result;
differ_by_repeat(pg_time_t t1, pg_time_t t0)
{
if (TYPE_INTEGRAL(pg_time_t) &&
- TYPE_BIT(pg_time_t) - TYPE_SIGNED(pg_time_t) < SECSPERREPEAT_BITS)
+ TYPE_BIT(pg_time_t) -TYPE_SIGNED(pg_time_t) <SECSPERREPEAT_BITS)
return 0;
return t1 - t0 == SECSPERREPEAT;
}
{
struct tzhead tzhead;
char buf[2 * sizeof(struct tzhead) +
- 2 * sizeof *sp +
- 4 * TZ_MAX_TIMES];
- } u;
+ 2 * sizeof *sp +
+ 4 * TZ_MAX_TIMES];
+ } u;
if (name == NULL && (name = TZDEFAULT) == NULL)
return -1;
(ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
return -1;
if (nread - (p - u.buf) <
- sp->timecnt * stored + /* ats */
+ sp->timecnt * stored + /* ats */
sp->timecnt + /* types */
- sp->typecnt * 6 + /* ttinfos */
+ sp->typecnt * 6 + /* ttinfos */
sp->charcnt + /* chars */
sp->leapcnt * (stored + 4) + /* lsinfos */
ttisstdcnt + /* ttisstds */
return -1;
}
}
+
/*
- * Out-of-sort ats should mean we're running on a
- * signed time_t system but using a data file with
- * unsigned values (or vice versa).
+ * Out-of-sort ats should mean we're running on a signed time_t system
+ * but using a data file with unsigned values (or vice versa).
*/
for (i = 0; i < sp->timecnt - 2; ++i)
if (sp->ats[i] > sp->ats[i + 1])
/*
* Ignore the beginning (harder).
*/
- int j;
-
+ int j;
+
for (j = 0; j + i < sp->timecnt; ++j)
{
sp->ats[j] = sp->ats[j + i];
}
break;
}
+
/*
* If this is an old file, we're done.
*/
nread -= p - u.buf;
for (i = 0; i < nread; ++i)
u.buf[i] = p[i];
+
/*
* If this is a narrow integer time_t system, we're done.
*/
u.buf[0] == '\n' && u.buf[nread - 1] == '\n' &&
sp->typecnt + 2 <= TZ_MAX_TYPES)
{
- struct state ts;
- int result;
-
+ struct state ts;
+ int result;
+
u.buf[nread - 1] = '\0';
result = tzparse(&u.buf[1], &ts, FALSE);
if (result == 0 && ts.typecnt == 2 &&
}
static int
-typesequiv(const struct state *sp, int a, int b)
+typesequiv(const struct state * sp, int a, int b)
{
- int result;
+ int result;
if (sp == NULL ||
a < 0 || a >= sp->typecnt ||
static const char *
getqzname(const char *strp, int delim)
{
- int c;
+ int c;
while ((c = *strp) != '\0' && c != delim)
++strp;
sp->timecnt + 2 <= TZ_MAX_TIMES;
++year)
{
- pg_time_t newfirst;
+ pg_time_t newfirst;
starttime = transtime(janfirst, year, &start,
stdoffset);
*/
static struct pg_tm *
localsub(const pg_time_t *timep, long offset,
- struct pg_tm *tmp, const pg_tz *tz)
+ struct pg_tm * tmp, const pg_tz *tz)
{
const struct state *sp;
const struct ttinfo *ttisp;
pg_time_t seconds;
pg_time_t tcycles;
int64 icycles;
-
+
if (t < sp->ats[0])
seconds = sp->ats[0] - t;
- else seconds = t - sp->ats[sp->timecnt - 1];
+ else
+ seconds = t - sp->ats[sp->timecnt - 1];
--seconds;
tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
++tcycles;
seconds *= AVGSECSPERYEAR;
if (t < sp->ats[0])
newt += seconds;
- else newt -= seconds;
+ else
+ newt -= seconds;
if (newt < sp->ats[0] ||
newt > sp->ats[sp->timecnt - 1])
- return NULL; /* "cannot happen" */
+ return NULL; /* "cannot happen" */
result = localsub(&newt, offset, tmp, tz);
if (result == tmp)
{
- pg_time_t newy;
+ pg_time_t newy;
newy = tmp->tm_year;
if (t < sp->ats[0])
newy -= icycles * YEARSPERREPEAT;
- else newy += icycles * YEARSPERREPEAT;
+ else
+ newy += icycles * YEARSPERREPEAT;
tmp->tm_year = newy;
if (tmp->tm_year != newy)
return NULL;
}
else
{
- int lo = 1;
- int hi = sp->timecnt;
-
+ int lo = 1;
+ int hi = sp->timecnt;
+
while (lo < hi)
{
- int mid = (lo + hi) >> 1;
-
+ int mid = (lo + hi) >> 1;
+
if (t < sp->ats[mid])
hi = mid;
- else lo = mid + 1;
+ else
+ lo = mid + 1;
}
i = (int) sp->types[lo - 1];
}
* gmtsub is to gmtime as localsub is to localtime.
*/
static struct pg_tm *
-gmtsub(const pg_time_t *timep, long offset, struct pg_tm *tmp)
+gmtsub(const pg_time_t *timep, long offset, struct pg_tm * tmp)
{
struct pg_tm *result;
static struct pg_tm *
timesub(const pg_time_t *timep, long offset,
- const struct state *sp, struct pg_tm *tmp)
+ const struct state * sp, struct pg_tm * tmp)
{
const struct lsinfo *lp;
pg_time_t tdays;
- int idays; /* unsigned would be so 2003 */
+ int idays; /* unsigned would be so 2003 */
long rem;
int y;
const int *ip;
rem = *timep - tdays * SECSPERDAY;
while (tdays < 0 || tdays >= year_lengths[isleap(y)])
{
- int newy;
+ int newy;
pg_time_t tdelta;
- int idelta;
- int leapdays;
-
+ int idelta;
+ int leapdays;
+
tdelta = tdays / DAYSPERLYEAR;
idelta = tdelta;
if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
y = newy;
}
{
- long seconds;
-
+ long seconds;
+
seconds = tdays * SECSPERDAY + 0.5;
tdays = seconds / SECSPERDAY;
rem += seconds - tdays * SECSPERDAY;
}
+
/*
* Given the range, we can now fearlessly cast...
*/
if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
return NULL;
tmp->tm_yday = idays;
+
/*
* The "extra" mods below avoid overflow problems.
*/
static int
increment_overflow(int *number, int delta)
{
- int number0;
+ int number0;
number0 = *number;
*number += delta;
pg_time_t tcycles;
int64 icycles;
int result;
-
+
if (t < sp->ats[0])
seconds = sp->ats[0] - t;
- else seconds = t - sp->ats[sp->timecnt - 1];
+ else
+ seconds = t - sp->ats[sp->timecnt - 1];
--seconds;
tcycles = seconds / YEARSPERREPEAT / AVGSECSPERYEAR;
++tcycles;
seconds *= AVGSECSPERYEAR;
if (t < sp->ats[0])
newt += seconds;
- else newt -= seconds;
+ else
+ newt -= seconds;
if (newt < sp->ats[0] ||
newt > sp->ats[sp->timecnt - 1])
- return -1; /* "cannot happen" */
+ return -1; /* "cannot happen" */
result = pg_next_dst_boundary(&newt, before_gmtoff,
before_isdst,
}
/* Else search to find the containing segment */
{
- int lo = 1;
- int hi = sp->timecnt;
-
+ int lo = 1;
+ int hi = sp->timecnt;
+
while (lo < hi)
{
- int mid = (lo + hi) >> 1;
-
+ int mid = (lo + hi) >> 1;
+
if (t < sp->ats[mid])
hi = mid;
- else lo = mid + 1;
+ else
+ lo = mid + 1;
}
i = lo;
}
* enough to identify DST transition rules, since everybody switches on
* Sundays.) This is sufficient to cover most of the Unix time_t range,
* and we don't want to look further than that since many systems won't
- * have sane TZ behavior further back anyway. The further
- * back the zone matches, the better we score it. This may seem like a
- * rather random way of doing things, but experience has shown that
- * system-supplied timezone definitions are likely to have DST behavior
- * that is right for the recent past and not so accurate further back.
- * Scoring in this way allows us to recognize zones that have some
- * commonality with the zic database, without insisting on exact match.
- * (Note: we probe Thursdays, not Sundays, to avoid triggering
- * DST-transition bugs in localtime itself.)
+ * have sane TZ behavior further back anyway. The further back the zone
+ * matches, the better we score it. This may seem like a rather random
+ * way of doing things, but experience has shown that system-supplied
+ * timezone definitions are likely to have DST behavior that is right for
+ * the recent past and not so accurate further back. Scoring in this way
+ * allows us to recognize zones that have some commonality with the zic
+ * database, without insisting on exact match. (Note: we probe Thursdays,
+ * not Sundays, to avoid triggering DST-transition bugs in localtime
+ * itself.)
*/
tnow = time(NULL);
tm = localtime(&tnow);
thisyear = tm->tm_year + 1900;
t = build_time_t(thisyear, 1, 15);
+
/*
* Round back to GMT midnight Thursday. This depends on the knowledge
* that the time_t origin is Thu Jan 01 1970. (With a different origin
"Central Standard Time (Mexico)", "Central Daylight Time (Mexico)",
"America/Mexico_City"
}, /* (GMT-06:00) Guadalajara, Mexico City,
- Monterrey - New */
+ * Monterrey - New */
{
"China Standard Time", "China Daylight Time",
"Asia/Hong_Kong"
{
"Mountain Standard Time (Mexico)", "Mountain Daylight Time (Mexico)",
"America/Chihuahua"
- }, /* (GMT-07:00) Chihuahua, La Paz,
- Mazatlan - New */
+ }, /* (GMT-07:00) Chihuahua, La Paz, Mazatlan -
+ * New */
{
"Myanmar Standard Time", "Myanmar Daylight Time",
"Asia/Rangoon"
"Australia/Perth"
}, /* (GMT+08:00) Perth */
/* {"W. Central Africa Standard Time", "W. Central Africa Daylight Time",
- * * * * * * * ""}, Could not find a match for this one. Excluded for now. *//* (
+ * * * * * * * * ""}, Could not find a match for this one. Excluded for now. *//* (
* G MT+01:00) West Central Africa */
{
"W. Europe Standard Time", "W. Europe Daylight Time",
* Load this timezone using tzload() not pg_tzset(), so we don't fill
* the cache
*/
- if (tzload(fullname + dir->baselen, dir->tz.TZname, &dir->tz.state,
+ if (tzload(fullname + dir->baselen, dir->tz.TZname, &dir->tz.state,
TRUE) != 0)
{
/* Zone could not be loaded, ignore it */
extern int pg_open_tzfile(const char *name, char *canonname);
/* in localtime.c */
-extern int tzload(const char *name, char *canonname, struct state * sp,
- int doextend);
+extern int tzload(const char *name, char *canonname, struct state * sp,
+ int doextend);
extern int tzparse(const char *name, struct state * sp, int lastditch);
#endif /* _PGTZ_H */
#ifndef TYPE_INTEGRAL
#define TYPE_INTEGRAL(type) (((type) 0.5) != 0.5)
-#endif /* !defined TYPE_INTEGRAL */
+#endif /* !defined TYPE_INTEGRAL */
#ifndef INT_STRLEN_MAXIMUM
/*
#define _(msgid) (msgid)
#ifndef YEARSPERREPEAT
-#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */
-#endif /* !defined YEARSPERREPEAT */
+#define YEARSPERREPEAT 400 /* years before a Gregorian repeat */
+#endif /* !defined YEARSPERREPEAT */
/*
** The Gregorian year averages 365.2425 days, which is 31556952 seconds.
*/
#ifndef AVGSECSPERYEAR
-#define AVGSECSPERYEAR 31556952L
-#endif /* !defined AVGSECSPERYEAR */
+#define AVGSECSPERYEAR 31556952L
+#endif /* !defined AVGSECSPERYEAR */
#ifndef SECSPERREPEAT
-#define SECSPERREPEAT ((int64) YEARSPERREPEAT * (int64) AVGSECSPERYEAR)
-#endif /* !defined SECSPERREPEAT */
+#define SECSPERREPEAT ((int64) YEARSPERREPEAT * (int64) AVGSECSPERYEAR)
+#endif /* !defined SECSPERREPEAT */
#ifndef SECSPERREPEAT_BITS
-#define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */
-#endif /* !defined SECSPERREPEAT_BITS */
+#define SECSPERREPEAT_BITS 34 /* ceil(log2(SECSPERREPEAT)) */
+#endif /* !defined SECSPERREPEAT_BITS */
/*
* UNIX was a registered trademark of The Open Group in 2003.
static char *_conv(int, const char *, char *, const char *);
static char *_fmt(const char *, const struct pg_tm *, char *,
const char *, int *);
-static char * _yconv(const int, const int, const int, const int,
- char *, const char * const);
+static char *_yconv(const int, const int, const int, const int,
+ char *, const char *const);
#define IN_NONE 0
#define IN_SOME 1
{
*warnp = IN_ALL;
pt = _yconv(year, base, 0, 1,
- pt, ptlim);
+ pt, ptlim);
}
else
pt = _yconv(year, base, 1, 1,
- pt, ptlim);
+ pt, ptlim);
}
continue;
case 'v':
* with more only if necessary.
*/
static char *
-_yconv(const int a, const int b, const int convert_top,
- const int convert_yy, char *pt, const char * const ptlim)
+_yconv(const int a, const int b, const int convert_top,
+ const int convert_yy, char *pt, const char *const ptlim)
{
- int lead;
- int trail;
-
-#define DIVISOR 100
+ int lead;
+ int trail;
+
+#define DIVISOR 100
trail = a % DIVISOR + b % DIVISOR;
lead = a / DIVISOR + b / DIVISOR + trail / DIVISOR;
trail %= DIVISOR;
{
if (lead == 0 && trail < 0)
pt = _add("-0", pt, ptlim);
- else pt = _conv(lead, "%02d", pt, ptlim);
+ else
+ pt = _conv(lead, "%02d", pt, ptlim);
}
if (convert_yy)
pt = _conv(((trail < 0) ? -trail : trail), "%02d", pt, ptlim);
return pt;
}
-
/*
* Since everything in isleap is modulo 400 (or a factor of 400), we know that
- * isleap(y) == isleap(y % 400)
+ * isleap(y) == isleap(y % 400)
* and so
- * isleap(a + b) == isleap((a + b) % 400)
+ * isleap(a + b) == isleap((a + b) % 400)
* or
- * isleap(a + b) == isleap(a % 400 + b % 400)
+ * isleap(a + b) == isleap(a % 400 + b % 400)
* This is true even if % means modulo rather than Fortran remainder
* (which is allowed by C89 but not C99).
* We use this to avoid addition overflow problems.
*/
-#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)
+#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)
#endif /* !defined TZFILE_H */
#include "pgtz.h"
#include "tzfile.h"
-#define ZIC_VERSION '2'
+#define ZIC_VERSION '2'
-typedef int64 zic_t;
+typedef int64 zic_t;
#ifndef ZIC_MAX_ABBR_LEN_WO_WARN
-#define ZIC_MAX_ABBR_LEN_WO_WARN 6
-#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
+#define ZIC_MAX_ABBR_LEN_WO_WARN 6
+#endif /* !defined ZIC_MAX_ABBR_LEN_WO_WARN */
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#define OFFSET_STRLEN_MAXIMUM (7 + INT_STRLEN_MAXIMUM(long))
-#define RULE_STRLEN_MAXIMUM 8 /* "Mdd.dd.d" */
+#define RULE_STRLEN_MAXIMUM 8 /* "Mdd.dd.d" */
-#define end(cp) (strchr((cp), '\0'))
+#define end(cp) (strchr((cp), '\0'))
struct rule
{
int z_nrules;
struct rule z_untilrule;
- zic_t z_untiltime;
+ zic_t z_untiltime;
};
extern int link(const char *fromname, const char *toname);
static struct attype
{
- zic_t at;
+ zic_t at;
unsigned char type;
} attypes[TZ_MAX_TIMES];
static long gmtoffs[TZ_MAX_TYPES];
(void) umask(umask(S_IWGRP | S_IWOTH) | (S_IWGRP | S_IWOTH));
#endif /* !WIN32 */
progname = argv[0];
- if (TYPE_BIT(zic_t) < 64) {
+ if (TYPE_BIT(zic_t) < 64)
+ {
(void) fprintf(stderr, "%s: %s\n", progname,
- _("wild compilation-time specification of zic_t"));
+ _("wild compilation-time specification of zic_t"));
exit(EXIT_FAILURE);
}
for (i = 1; i < argc; ++i)
static void
setboundaries(void)
{
- int i;
-
+ int i;
+
min_time = -1;
for (i = 0; i < TIME_T_BITS_IN_FILE - 1; ++i)
min_time *= 2;
error(errstring);
return 0;
}
- if (LONG_MAX / SECSPERHOUR < hh) {
+ if (LONG_MAX / SECSPERHOUR < hh)
+ {
error(_("time overflow"));
return 0;
}
static void
convert64(zic_t val, char *buf)
{
- int i;
- int shift;
-
+ int i;
+ int shift;
+
for (i = 0, shift = 56; i < 8; ++i, shift -= 8)
buf[i] = val >> shift;
}
static void
puttzcode64(zic_t val, FILE *fp)
{
- char buf[8];
-
+ char buf[8];
+
convert64(val, buf);
(void) fwrite((void *) buf, (size_t) sizeof buf, (size_t) 1, fp);
}
static int
atcomp(const void *avp, const void *bvp)
{
- const zic_t a = ((const struct attype *) avp)->at;
- const zic_t b = ((const struct attype *) bvp)->at;
-
+ const zic_t a = ((const struct attype *) avp)->at;
+ const zic_t b = ((const struct attype *) bvp)->at;
+
return (a < b) ? -1 : (a > b);
}
FILE *fp;
int i,
j;
- int leapcnt32, leapi32;
- int timecnt32, timei32;
+ int leapcnt32,
+ leapi32;
+ int timecnt32,
+ timei32;
int pass;
static char *fullname;
static const struct tzhead tzh0;
ats[i] = attypes[i].at;
types[i] = attypes[i].type;
}
+
/*
* Correct for leap seconds.
*/
- for (i = 0; i < timecnt; ++i) {
+ for (i = 0; i < timecnt; ++i)
+ {
j = leapcnt;
while (--j >= 0)
- if (ats[i] > trans[j] - corr[j]) {
+ if (ats[i] > trans[j] - corr[j])
+ {
ats[i] = tadd(ats[i], corr[j]);
break;
}
}
+
/*
* Figure out 32-bit-limited starts and counts.
*/
exit(EXIT_FAILURE);
}
}
- for (pass = 1; pass <= 2; ++pass) {
- register int thistimei, thistimecnt;
- register int thisleapi, thisleapcnt;
- register int thistimelim, thisleaplim;
- int writetype[TZ_MAX_TIMES];
- int typemap[TZ_MAX_TYPES];
- register int thistypecnt;
+ for (pass = 1; pass <= 2; ++pass)
+ {
+ register int thistimei,
+ thistimecnt;
+ register int thisleapi,
+ thisleapcnt;
+ register int thistimelim,
+ thisleaplim;
+ int writetype[TZ_MAX_TIMES];
+ int typemap[TZ_MAX_TYPES];
+ register int thistypecnt;
char thischars[TZ_MAX_CHARS];
char thischarcnt;
- int indmap[TZ_MAX_CHARS];
+ int indmap[TZ_MAX_CHARS];
- if (pass == 1) {
+ if (pass == 1)
+ {
thistimei = timei32;
thistimecnt = timecnt32;
thisleapi = leapi32;
thisleapcnt = leapcnt32;
- } else {
+ }
+ else
+ {
thistimei = 0;
thistimecnt = timecnt;
thisleapi = 0;
thisleaplim = thisleapi + thisleapcnt;
for (i = 0; i < typecnt; ++i)
writetype[i] = thistimecnt == timecnt;
- if (thistimecnt == 0) {
+ if (thistimecnt == 0)
+ {
/*
- ** No transition times fall in the current
- ** (32- or 64-bit) window.
- */
+ * * No transition times fall in the current * (32- or 64-bit)
+ * window.
+ */
if (typecnt != 0)
writetype[typecnt - 1] = TRUE;
- } else {
+ }
+ else
+ {
for (i = thistimei - 1; i < thistimelim; ++i)
if (i >= 0)
writetype[types[i]] = TRUE;
+
/*
- ** For America/Godthab and Antarctica/Palmer
- */
+ * * For America/Godthab and Antarctica/Palmer
+ */
if (thistimei == 0)
writetype[0] = TRUE;
}
thistypecnt = 0;
for (i = 0; i < typecnt; ++i)
- typemap[i] = writetype[i] ? thistypecnt++ : -1;
+ typemap[i] = writetype[i] ? thistypecnt++ : -1;
for (i = 0; i < sizeof indmap / sizeof indmap[0]; ++i)
indmap[i] = -1;
thischarcnt = 0;
- for (i = 0; i < typecnt; ++i) {
- register char * thisabbr;
+ for (i = 0; i < typecnt; ++i)
+ {
+ register char *thisabbr;
if (!writetype[i])
continue;
for (j = 0; j < thischarcnt; ++j)
if (strcmp(&thischars[j], thisabbr) == 0)
break;
- if (j == thischarcnt) {
+ if (j == thischarcnt)
+ {
(void) strcpy(&thischars[(int) thischarcnt],
- thisabbr);
+ thisabbr);
thischarcnt += strlen(thisabbr) + 1;
}
indmap[abbrinds[i]] = j;
for (i = thistimei; i < thistimelim; ++i)
if (pass == 1)
puttzcode((long) ats[i], fp);
- else puttzcode64(ats[i], fp);
- for (i = thistimei; i < thistimelim; ++i) {
- unsigned char uc;
+ else
+ puttzcode64(ats[i], fp);
+ for (i = thistimei; i < thistimelim; ++i)
+ {
+ unsigned char uc;
uc = typemap[types[i]];
(void) fwrite((void *) &uc,
- (size_t) sizeof uc,
- (size_t) 1,
- fp);
+ (size_t) sizeof uc,
+ (size_t) 1,
+ fp);
}
for (i = 0; i < typecnt; ++i)
- if (writetype[i]) {
+ if (writetype[i])
+ {
puttzcode(gmtoffs[i], fp);
(void) putc(isdsts[i], fp);
(void) putc((unsigned char) indmap[abbrinds[i]], fp);
}
if (thischarcnt != 0)
(void) fwrite((void *) thischars,
- (size_t) sizeof thischars[0],
- (size_t) thischarcnt, fp);
- for (i = thisleapi; i < thisleaplim; ++i) {
- register zic_t todo;
+ (size_t) sizeof thischars[0],
+ (size_t) thischarcnt, fp);
+ for (i = thisleapi; i < thisleaplim; ++i)
+ {
+ register zic_t todo;
- if (roll[i]) {
- if (timecnt == 0 || trans[i] < ats[0]) {
+ if (roll[i])
+ {
+ if (timecnt == 0 || trans[i] < ats[0])
+ {
j = 0;
while (isdsts[j])
- if (++j >= typecnt) {
+ if (++j >= typecnt)
+ {
j = 0;
break;
}
- } else {
+ }
+ else
+ {
j = 1;
while (j < timecnt &&
- trans[i] >= ats[j])
- ++j;
+ trans[i] >= ats[j])
+ ++j;
j = types[j - 1];
}
todo = tadd(trans[i], -gmtoffs[j]);
- } else todo = trans[i];
+ }
+ else
+ todo = trans[i];
if (pass == 1)
puttzcode((long) todo, fp);
- else puttzcode64(todo, fp);
+ else
+ puttzcode64(todo, fp);
puttzcode(corr[i], fp);
}
for (i = 0; i < typecnt; ++i)
(void) putc(ttisgmts[i], fp);
}
(void) fprintf(fp, "\n%s\n", string);
- if (ferror(fp) || fclose(fp)) {
+ if (ferror(fp) || fclose(fp))
+ {
(void) fprintf(stderr, _("%s: Error writing %s\n"),
- progname, fullname);
+ progname, fullname);
exit(EXIT_FAILURE);
}
}
static void
-doabbr(char *abbr, const char *format, const char *letters, int isdst,
+doabbr(char *abbr, const char *format, const char *letters, int isdst,
int doquotes)
{
- char * cp;
- char * slashp;
- int len;
+ char *cp;
+ char *slashp;
+ int len;
slashp = strchr(format, '/');
if (slashp == NULL)
return;
abbr[len + 2] = '\0';
abbr[len + 1] = '>';
- for ( ; len > 0; --len)
+ for (; len > 0; --len)
abbr[len] = abbr[len - 1];
abbr[0] = '<';
}
static int
stringoffset(char *result, long offset)
{
- int hours;
- int minutes;
- int seconds;
+ int hours;
+ int minutes;
+ int seconds;
result[0] = '\0';
- if (offset < 0) {
+ if (offset < 0)
+ {
(void) strcpy(result, "-");
offset = -offset;
}
minutes = offset % MINSPERHOUR;
offset /= MINSPERHOUR;
hours = offset;
- if (hours >= HOURSPERDAY) {
+ if (hours >= HOURSPERDAY)
+ {
result[0] = '\0';
return -1;
}
(void) sprintf(end(result), "%d", hours);
- if (minutes != 0 || seconds != 0) {
+ if (minutes != 0 || seconds != 0)
+ {
(void) sprintf(end(result), ":%02d", minutes);
if (seconds != 0)
(void) sprintf(end(result), ":%02d", seconds);
}
static int
-stringrule(char *result, const struct rule *rp, long dstoff, long gmtoff)
+stringrule(char *result, const struct rule * rp, long dstoff, long gmtoff)
{
- long tod;
+ long tod;
result = end(result);
- if (rp->r_dycode == DC_DOM)
+ if (rp->r_dycode == DC_DOM)
{
- int month, total;
+ int month,
+ total;
if (rp->r_dayofmonth == 29 && rp->r_month == TM_FEBRUARY)
return -1;
}
else
{
- int week;
+ int week;
if (rp->r_dycode == DC_DOWGEQ)
{
{
if (rp->r_dayofmonth == len_months[1][rp->r_month])
week = 5;
- else {
+ else
+ {
week = 1 + rp->r_dayofmonth / DAYSPERWEEK;
if (week * DAYSPERWEEK - 1 != rp->r_dayofmonth)
return -1;
}
}
else
- return -1; /* "cannot happen" */
+ return -1; /* "cannot happen" */
(void) sprintf(result, "M%d.%d.%d",
rp->r_month + 1, week, rp->r_wday);
}
}
static void
-stringzone(char *result, const struct zone *zpfirst, int zonecount)
+stringzone(char *result, const struct zone * zpfirst, int zonecount)
{
- const struct zone * zp;
- struct rule * rp;
- struct rule * stdrp;
- struct rule * dstrp;
+ const struct zone *zp;
+ struct rule *rp;
+ struct rule *stdrp;
+ struct rule *dstrp;
int i;
- const char * abbrvar;
+ const char *abbrvar;
result[0] = '\0';
zp = zpfirst + zonecount - 1;
continue;
if (rp->r_yrtype != NULL)
continue;
- if (rp->r_stdoff == 0) {
+ if (rp->r_stdoff == 0)
+ {
if (stdrp == NULL)
stdrp = rp;
- else return;
+ else
+ return;
}
else
{
if (dstrp == NULL)
dstrp = rp;
- else return;
+ else
+ return;
}
}
if (stdrp == NULL && dstrp == NULL)
{
/*
- * There are no rules running through "max".
- * Let's find the latest rule.
+ * There are no rules running through "max". Let's find the latest
+ * rule.
*/
for (i = 0; i < zp->z_nrules; ++i)
{
rp = &zp->z_rules[i];
if (stdrp == NULL || rp->r_hiyear > stdrp->r_hiyear ||
(rp->r_hiyear == stdrp->r_hiyear &&
- rp->r_month > stdrp->r_month))
- stdrp = rp;
+ rp->r_month > stdrp->r_month))
+ stdrp = rp;
}
if (stdrp != NULL && stdrp->r_stdoff != 0)
- return; /* We end up in DST (a POSIX no-no). */
+ return; /* We end up in DST (a POSIX no-no). */
+
/*
- * Horrid special case: if year is 2037,
- * presume this is a zone handled on a year-by-year basis;
- * do not try to apply a rule to the zone.
+ * Horrid special case: if year is 2037, presume this is a zone
+ * handled on a year-by-year basis; do not try to apply a rule to the
+ * zone.
*/
if (stdrp != NULL && stdrp->r_hiyear == 2037)
return;
return;
abbrvar = (stdrp == NULL) ? "" : stdrp->r_abbrvar;
doabbr(result, zp->z_format, abbrvar, FALSE, TRUE);
- if (stringoffset(end(result), -zp->z_gmtoff) != 0) {
+ if (stringoffset(end(result), -zp->z_gmtoff) != 0)
+ {
result[0] = '\0';
return;
}
doabbr(end(result), zp->z_format, dstrp->r_abbrvar, TRUE, TRUE);
if (dstrp->r_stdoff != SECSPERMIN * MINSPERHOUR)
if (stringoffset(end(result),
- -(zp->z_gmtoff + dstrp->r_stdoff)) != 0) {
- result[0] = '\0';
- return;
+ -(zp->z_gmtoff + dstrp->r_stdoff)) != 0)
+ {
+ result[0] = '\0';
+ return;
}
(void) strcat(result, ",");
- if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+ if (stringrule(result, dstrp, dstrp->r_stdoff, zp->z_gmtoff) != 0)
+ {
result[0] = '\0';
return;
}
(void) strcat(result, ",");
- if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0) {
+ if (stringrule(result, stdrp, dstrp->r_stdoff, zp->z_gmtoff) != 0)
+ {
result[0] = '\0';
return;
}
charcnt = 0;
/*
- * Thanks to Earl Chew for noting the need to
- * unconditionally initialize startttisstd.
+ * Thanks to Earl Chew for noting the need to unconditionally initialize
+ * startttisstd.
*/
startttisstd = FALSE;
startttisgmt = FALSE;
updateminmax(rp->r_hiyear);
}
}
+
/*
* Generate lots of data if a rule can't cover all future times.
*/
stringzone(envvar, zpfirst, zonecount);
- if (noise && envvar[0] == '\0') {
- char * wp;
+ if (noise && envvar[0] == '\0')
+ {
+ char *wp;
wp = ecpyalloc(_("no POSIX environment variable for zone"));
wp = ecatalloc(wp, " ");
{
if (min_year >= INT_MIN + YEARSPERREPEAT)
min_year -= YEARSPERREPEAT;
- else min_year = INT_MIN;
+ else
+ min_year = INT_MIN;
if (max_year <= INT_MAX - YEARSPERREPEAT)
max_year += YEARSPERREPEAT;
- else max_year = INT_MAX;
+ else
+ max_year = INT_MAX;
}
+
/*
- * For the benefit of older systems,
- * generate data from 1900 through 2037.
+ * For the benefit of older systems, generate data from 1900 through 2037.
*/
if (min_year > 1900)
min_year = 1900;
FALSE);
continue;
}
- if (*startbuf == '\0' &&
+ if (*startbuf == '\0' &&
startoff == oadd(zp->z_gmtoff, stdoff))
{
doabbr(startbuf,
error(_("too many local time types"));
exit(EXIT_FAILURE);
}
- if (! (-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L)) {
+ if (!(-1L - 2147483647L <= gmtoff && gmtoff <= 2147483647L))
+ {
error(_("UTC offset out of range"));
exit(EXIT_FAILURE);
}
static zic_t
tadd(const zic_t t1, long t2)
{
- zic_t t;
+ zic_t t;
if (t1 == max_time && t2 > 0)
return max_time;
m,
i;
long dayoff; /* with a nod to Margaret O. */
- zic_t t;
+ zic_t t;
if (wantedy == INT_MIN)
return min_time;
if (dayoff > max_time / SECSPERDAY)
return max_time;
t = (zic_t) dayoff *SECSPERDAY;
+
return tadd(t, rp->r_tod);
}
if (strcmp(string, GRANDPARENTED) != 0)
{
- const char * cp;
- char * wp;
+ const char *cp;
+ char *wp;
/*
- * Want one to ZIC_MAX_ABBR_LEN_WO_WARN alphabetics
- * optionally followed by a + or - and a number from 1 to 14.
+ * Want one to ZIC_MAX_ABBR_LEN_WO_WARN alphabetics optionally
+ * followed by a + or - and a number from 1 to 14.
*/
cp = string;
wp = NULL;
wp = _("time zone abbreviation has more than 3 alphabetics");
if (cp - string > ZIC_MAX_ABBR_LEN_WO_WARN)
wp = _("time zone abbreviation has too many alphabetics");
- if (wp == NULL && (*cp == '+' || *cp == '-')) {
+ if (wp == NULL && (*cp == '+' || *cp == '-'))
+ {
++cp;
if (isascii((unsigned char) *cp) &&
isdigit((unsigned char) *cp))
}
if (*cp != '\0')
wp = _("time zone abbreviation differs from POSIX standard");
- if (wp != NULL) {
+ if (wp != NULL)
+ {
wp = ecpyalloc(wp);
wp = ecatalloc(wp, " (");
wp = ecatalloc(wp, string);
/*
- * $PostgreSQL$
+ * $PostgreSQL$
*
*
* test_fsync.c
/*
- * $PostgreSQL:$
+ * $PostgreSQL$
*
******************************************************************************
This file contains routines that can be bound to a Postgres backend and
projects / users / simon / postgres.git / commitdiff