static GBT_VARKEY *
gbt_bit_l2n(GBT_VARKEY *leaf)
{
-
GBT_VARKEY *out = leaf;
GBT_VARKEY_R r = gbt_var_key_readable(leaf);
bytea *o;
Datum
gbt_bpchar_compress(PG_FUNCTION_ARGS)
{
-
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *retval;
Datum
gbt_ts_penalty(PG_FUNCTION_ARGS)
{
-
tsKEY *origentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key);
tsKEY *newentry = (tsKEY *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(1))->key);
float *result = (float *) PG_GETARG_POINTER(2);
bool
gbt_num_same(const GBT_NUMKEY *a, const GBT_NUMKEY *b, const gbtree_ninfo *tinfo)
{
-
GBT_NUMKEY_R b1,
b2;
void
gbt_num_bin_union(Datum *u, GBT_NUMKEY *e, const gbtree_ninfo *tinfo)
{
-
GBT_NUMKEY_R rd;
rd.lower = &e[0];
GBT_VARKEY_R
gbt_var_key_readable(const GBT_VARKEY *k)
{
-
GBT_VARKEY_R r;
r.lower = (bytea *) &(((char *) k)[VARHDRSZ]);
GISTENTRY *
gbt_var_compress(GISTENTRY *entry, const gbtree_vinfo *tinfo)
{
-
GISTENTRY *retval;
if (entry->leafkey)
gbt_var_union(const GistEntryVector *entryvec, int32 *size, Oid collation,
const gbtree_vinfo *tinfo)
{
-
int i = 0,
numranges = entryvec->n;
GBT_VARKEY *cur;
ereport(ERROR,
(errcode(ERRCODE_FDW_OUT_OF_MEMORY),
errmsg("out of memory"),
- errdetail("could not get libpq's default connection options")));
+ errdetail("could not get libpq's default connection options")));
}
/* Validate each supplied option. */
if (!is_valid_dblink_option(options, def->defname, context))
{
/*
- * Unknown option, or invalid option for the context specified,
- * so complain about it. Provide a hint with list of valid
- * options for the context.
+ * Unknown option, or invalid option for the context specified, so
+ * complain about it. Provide a hint with list of valid options
+ * for the context.
*/
StringInfoData buf;
const PQconninfoOption *opt;
char **filename, List **other_options);
static List *get_file_fdw_attribute_options(Oid relid);
static bool check_selective_binary_conversion(RelOptInfo *baserel,
- Oid foreigntableid,
- List **columns);
+ Oid foreigntableid,
+ List **columns);
static void estimate_size(PlannerInfo *root, RelOptInfo *baserel,
FileFdwPlanState *fdw_private);
static void estimate_costs(PlannerInfo *root, RelOptInfo *baserel,
&startup_cost, &total_cost);
/*
- * Create a ForeignPath node and add it as only possible path. We use the
+ * Create a ForeignPath node and add it as only possible path. We use the
* fdw_private list of the path to carry the convert_selectively option;
* it will be propagated into the fdw_private list of the Plan node.
*/
/* Add all the attributes used by restriction clauses. */
foreach(lc, baserel->baserestrictinfo)
{
- RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
+ RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
pull_varattnos((Node *) rinfo->clause, baserel->relid,
&attrs_used);
* digit as numeric - could be a zip code or similar
*/
if (src->len > 0 &&
- !(src->data[0] == '0' && isdigit((unsigned char) src->data[1])) &&
+ !(src->data[0] == '0' && isdigit((unsigned char) src->data[1])) &&
strspn(src->data, "+-0123456789Ee.") == src->len)
{
/*
* value. Ignore any actual parsed value.
*/
char *endptr = "junk";
- long lval;
+ long lval;
- lval = strtol(src->data, &endptr, 10);
+ lval = strtol(src->data, &endptr, 10);
(void) lval;
if (*endptr == '\0')
{
else
{
/* not an int - try a double */
- double dval;
+ double dval;
dval = strtod(src->data, &endptr);
(void) dval;
{
eary ->alloc *= 2;
eary ->array = (char **) pg_realloc(eary->array,
- eary->alloc * sizeof(char *));
+ eary->alloc * sizeof(char *));
}
eary ->array[eary->num] = pg_strdup(eltname);
dryrun = true;
break;
case 'x':
- additional_ext = strdup(optarg); /* Extension to remove from
- * xlogfile names */
+ additional_ext = strdup(optarg); /* Extension to remove
+ * from xlogfile names */
break;
default:
fprintf(stderr, "Try \"%s --help\" for more information.\n", progname);
* There's no way to trigger failover via signal on Windows.
*/
(void) pqsignal(SIGUSR1, sighandler);
- (void) pqsignal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
+ (void) pqsignal(SIGINT, sighandler); /* deprecated, use SIGUSR1 */
(void) pqsignal(SIGQUIT, sigquit_handler);
#endif
static void output(uint64 loop_count);
/* record duration in powers of 2 microseconds */
-int64 histogram[32];
+int64 histogram[32];
int
main(int argc, char *argv[])
uint64 total_time;
int64 time_elapsed = 0;
uint64 loop_count = 0;
- uint64 prev, cur;
- instr_time start_time, end_time, temp;
+ uint64 prev,
+ cur;
+ instr_time start_time,
+ end_time,
+ temp;
total_time = duration > 0 ? duration * 1000000 : 0;
while (time_elapsed < total_time)
{
- int32 diff, bits = 0;
+ int32 diff,
+ bits = 0;
prev = cur;
INSTR_TIME_SET_CURRENT(temp);
static void
output(uint64 loop_count)
{
- int64 max_bit = 31, i;
+ int64 max_bit = 31,
+ i;
/* find highest bit value */
while (max_bit > 0 && histogram[max_bit] == 0)
max_bit--;
-
+
printf("Histogram of timing durations:\n");
printf("%6s %10s %10s\n", "< usec", "% of total", "count");
/* lame hack to work around INT64_FORMAT deficiencies */
snprintf(buf, sizeof(buf), INT64_FORMAT, histogram[i]);
printf("%6ld %9.5f %10s\n", 1l << i,
- (double) histogram[i] * 100 / loop_count, buf);
+ (double) histogram[i] * 100 / loop_count, buf);
}
}
else
{
/*
- * Back up endword to the escape character when stopping at
- * an escaped char, so that subsequent get_wildcard_part will
+ * Back up endword to the escape character when stopping at an
+ * escaped char, so that subsequent get_wildcard_part will
* restart from the escape character. We assume here that
* escape chars are single-byte.
*/
* fix_path_separator
* For non-Windows, just return the argument.
* For Windows convert any forward slash to a backslash
- * such as is suitable for arguments to builtin commands
+ * such as is suitable for arguments to builtin commands
* like RMDIR and DEL.
*/
static char *
{
#ifdef WIN32
- char *result;
- char *c;
+ char *result;
+ char *c;
result = pg_strdup(path);
*c = '\\';
return result;
-
#else
return path;
-
#endif
}
check_is_super_user(&new_cluster);
/*
- * We don't restore our own user, so both clusters must match have
- * matching install-user oids.
+ * We don't restore our own user, so both clusters must match have
+ * matching install-user oids.
*/
if (old_cluster.install_role_oid != new_cluster.install_role_oid)
pg_log(PG_FATAL,
- "Old and new cluster install users have different values for pg_authid.oid.\n");
+ "Old and new cluster install users have different values for pg_authid.oid.\n");
/*
- * We only allow the install user in the new cluster because other
- * defined users might match users defined in the old cluster and
- * generate an error during pg_dump restore.
+ * We only allow the install user in the new cluster because other defined
+ * users might match users defined in the old cluster and generate an
+ * error during pg_dump restore.
*/
if (new_cluster.role_count != 1)
pg_log(PG_FATAL, "Only the install user can be defined in the new cluster.\n");
-
+
check_for_prepared_transactions(&new_cluster);
}
if (deletion_script_file_name)
pg_log(PG_REPORT,
- "Running this script will delete the old cluster's data files:\n"
+ "Running this script will delete the old cluster's data files:\n"
" %s\n",
deletion_script_file_name);
else
pg_log(PG_REPORT,
"Could not create a script to delete the old cluster's data\n"
- "files because user-defined tablespaces exist in the old cluster\n"
- "directory. The old cluster's contents must be deleted manually.\n");
+ "files because user-defined tablespaces exist in the old cluster\n"
+ "directory. The old cluster's contents must be deleted manually.\n");
}
/* We read the real port number for PG >= 9.1 */
if (live_check && GET_MAJOR_VERSION(old_cluster.major_version) < 901 &&
old_cluster.port == DEF_PGUPORT)
- pg_log(PG_FATAL, "When checking a pre-PG 9.1 live old server, "
- "you must specify the old server's port number.\n");
+ pg_log(PG_FATAL, "When checking a pre-PG 9.1 live old server, "
+ "you must specify the old server's port number.\n");
if (live_check && old_cluster.port == new_cluster.port)
pg_log(PG_FATAL, "When checking a live server, "
if (GET_MAJOR_VERSION(cluster->major_version) < 902)
{
/*
- * Pre-9.2 did not canonicalize the supplied locale names
- * to match what the system returns, while 9.2+ does, so
- * convert pre-9.2 to match.
+ * Pre-9.2 did not canonicalize the supplied locale names to match
+ * what the system returns, while 9.2+ does, so convert pre-9.2 to
+ * match.
*/
ctrl->lc_collate = get_canonical_locale_name(LC_COLLATE,
- pg_strdup(PQgetvalue(res, 0, i_datcollate)));
+ pg_strdup(PQgetvalue(res, 0, i_datcollate)));
ctrl->lc_ctype = get_canonical_locale_name(LC_CTYPE,
- pg_strdup(PQgetvalue(res, 0, i_datctype)));
- }
+ pg_strdup(PQgetvalue(res, 0, i_datctype)));
+ }
else
{
- ctrl->lc_collate = pg_strdup(PQgetvalue(res, 0, i_datcollate));
+ ctrl->lc_collate = pg_strdup(PQgetvalue(res, 0, i_datcollate));
ctrl->lc_ctype = pg_strdup(PQgetvalue(res, 0, i_datctype));
}
ControlData *newctrl)
{
/*
- * These are often defined with inconsistent case, so use pg_strcasecmp().
- * They also often use inconsistent hyphenation, which we cannot fix, e.g.
- * UTF-8 vs. UTF8, so at least we display the mismatching values.
+ * These are often defined with inconsistent case, so use pg_strcasecmp().
+ * They also often use inconsistent hyphenation, which we cannot fix, e.g.
+ * UTF-8 vs. UTF8, so at least we display the mismatching values.
*/
if (pg_strcasecmp(oldctrl->lc_collate, newctrl->lc_collate) != 0)
pg_log(PG_FATAL,
- "lc_collate cluster values do not match: old \"%s\", new \"%s\"\n",
+ "lc_collate cluster values do not match: old \"%s\", new \"%s\"\n",
oldctrl->lc_collate, newctrl->lc_collate);
if (pg_strcasecmp(oldctrl->lc_ctype, newctrl->lc_ctype) != 0)
pg_log(PG_FATAL,
- "lc_ctype cluster values do not match: old \"%s\", new \"%s\"\n",
+ "lc_ctype cluster values do not match: old \"%s\", new \"%s\"\n",
oldctrl->lc_ctype, newctrl->lc_ctype);
if (pg_strcasecmp(oldctrl->encoding, newctrl->encoding) != 0)
pg_log(PG_FATAL,
- "encoding cluster values do not match: old \"%s\", new \"%s\"\n",
+ "encoding cluster values do not match: old \"%s\", new \"%s\"\n",
oldctrl->encoding, newctrl->encoding);
}
SCRIPT_EXT);
/*
- * Some users (oddly) create tablespaces inside the cluster data
- * directory. We can't create a proper old cluster delete script
- * in that case.
+ * Some users (oddly) create tablespaces inside the cluster data
+ * directory. We can't create a proper old cluster delete script in that
+ * case.
*/
strlcpy(old_cluster_pgdata, old_cluster.pgdata, MAXPGPATH);
canonicalize_path(old_cluster_pgdata);
for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
{
char old_tablespace_dir[MAXPGPATH];
-
+
strlcpy(old_tablespace_dir, os_info.old_tablespaces[tblnum], MAXPGPATH);
canonicalize_path(old_tablespace_dir);
if (path_is_prefix_of_path(old_cluster_pgdata, old_tablespace_dir))
/* remove PG_VERSION? */
if (GET_MAJOR_VERSION(old_cluster.major_version) <= 804)
fprintf(script, RM_CMD " %s%s%cPG_VERSION\n",
- fix_path_separator(os_info.old_tablespaces[tblnum]),
+ fix_path_separator(os_info.old_tablespaces[tblnum]),
fix_path_separator(old_cluster.tablespace_suffix),
PATH_SEPARATOR);
* or a version-specific subdirectory.
*/
fprintf(script, RMDIR_CMD " %s%s\n",
- fix_path_separator(os_info.old_tablespaces[tblnum]),
+ fix_path_separator(os_info.old_tablespaces[tblnum]),
fix_path_separator(old_cluster.tablespace_suffix));
}
save = setlocale(category, NULL);
if (!save)
- pg_log(PG_FATAL, "failed to get the current locale\n");
+ pg_log(PG_FATAL, "failed to get the current locale\n");
/* 'save' may be pointing at a modifiable scratch variable, so copy it. */
save = pg_strdup(save);
res = setlocale(category, locale);
if (!res)
- pg_log(PG_FATAL, "failed to get system local name for \"%s\"\n", res);
+ pg_log(PG_FATAL, "failed to get system local name for \"%s\"\n", res);
res = pg_strdup(res);
/* restore old value. */
if (!setlocale(category, save))
- pg_log(PG_FATAL, "failed to restore old locale \"%s\"\n", save);
+ pg_log(PG_FATAL, "failed to restore old locale \"%s\"\n", save);
pg_free(save);
pg_free(lc_messages);
/*
- * Before 9.3, pg_resetxlog reported the xlogid and segno of the first
- * log file after reset as separate lines. Starting with 9.3, it reports
- * the WAL file name. If the old cluster is older than 9.3, we construct
- * the WAL file name from the xlogid and segno.
+ * Before 9.3, pg_resetxlog reported the xlogid and segno of the first log
+ * file after reset as separate lines. Starting with 9.3, it reports the
+ * WAL file name. If the old cluster is older than 9.3, we construct the
+ * WAL file name from the xlogid and segno.
*/
if (GET_MAJOR_VERSION(cluster->major_version) <= 902)
{
!got_date_is_int || !got_float8_pass_by_value || !got_data_checksum_version)
{
pg_log(PG_REPORT,
- "The %s cluster lacks some required control information:\n",
- CLUSTER_NAME(cluster));
+ "The %s cluster lacks some required control information:\n",
+ CLUSTER_NAME(cluster));
if (!got_xid)
pg_log(PG_REPORT, " checkpoint next XID\n");
{
if (oldctrl->align == 0 || oldctrl->align != newctrl->align)
pg_log(PG_FATAL,
- "old and new pg_controldata alignments are invalid or do not match\n"
+ "old and new pg_controldata alignments are invalid or do not match\n"
"Likely one cluster is a 32-bit install, the other 64-bit\n");
if (oldctrl->blocksz == 0 || oldctrl->blocksz != newctrl->blocksz)
"options.\n");
}
- /* We might eventually allow upgrades from checksum to no-checksum clusters. */
+ /*
+ * We might eventually allow upgrades from checksum to no-checksum
+ * clusters.
+ */
if (oldctrl->data_checksum_version != newctrl->data_checksum_version)
{
pg_log(PG_FATAL,
{
int result;
int written;
+
#define MAXCMDLEN (2 * MAXPGPATH)
char cmd[MAXCMDLEN];
mode_t old_umask = 0;
#ifdef WIN32
{
- /*
- * "pg_ctl -w stop" might have reported that the server has
- * stopped because the postmaster.pid file has been removed,
- * but "pg_ctl -w start" might still be in the process of
- * closing and might still be holding its stdout and -l log
- * file descriptors open. Therefore, try to open the log
- * file a few more times.
+ /*
+ * "pg_ctl -w stop" might have reported that the server has stopped
+ * because the postmaster.pid file has been removed, but "pg_ctl -w
+ * start" might still be in the process of closing and might still be
+ * holding its stdout and -l log file descriptors open. Therefore,
+ * try to open the log file a few more times.
*/
- int iter;
+ int iter;
+
for (iter = 0; iter < 4 && log == NULL; iter++)
{
sleep(1);
}
#ifndef WIN32
- /*
- * We can't do this on Windows because it will keep the "pg_ctl start"
- * output filename open until the server stops, so we do the \n\n above
- * on that platform. We use a unique filename for "pg_ctl start" that is
- * never reused while the server is running, so it works fine. We could
- * log these commands to a third file, but that just adds complexity.
+
+ /*
+ * We can't do this on Windows because it will keep the "pg_ctl start"
+ * output filename open until the server stops, so we do the \n\n above on
+ * that platform. We use a unique filename for "pg_ctl start" that is
+ * never reused while the server is running, so it works fine. We could
+ * log these commands to a third file, but that just adds complexity.
*/
if ((log = fopen_priv(log_file, "a")) == NULL)
pg_log(PG_FATAL, "cannot write to log file %s\n", log_file);
void
verify_directories(void)
{
-
#ifndef WIN32
if (access(".", R_OK | W_OK | X_OK) != 0)
#else
static int
copy_file(const char *srcfile, const char *dstfile, bool force)
{
-
#define COPY_BUF_SIZE (50 * BLCKSZ)
int src_fd;
int dest_fd;
char *buffer;
int ret = 0;
- int save_errno = 0;
+ int save_errno = 0;
if ((srcfile == NULL) || (dstfile == NULL))
return -1;
* table names change during ALTER TABLE ALTER COLUMN SET TYPE. In >=
* 9.0, TOAST relation names always use heap table oids, hence we
* cannot check relation names when upgrading from pre-9.0. Clusters
- * upgraded to 9.0 will get matching TOAST names.
- * If index names don't match primary key constraint names, this will
- * fail because pg_dump dumps constraint names and pg_upgrade checks
- * index names.
+ * upgraded to 9.0 will get matching TOAST names. If index names don't
+ * match primary key constraint names, this will fail because pg_dump
+ * dumps constraint names and pg_upgrade checks index names.
*/
if (strcmp(old_rel->nspname, new_rel->nspname) != 0 ||
((GET_MAJOR_VERSION(old_cluster.major_version) >= 900 ||
num_maps++;
}
- /* Do this check after the loop so hopefully we will produce a clearer error above */
+ /*
+ * Do this check after the loop so hopefully we will produce a clearer
+ * error above
+ */
if (old_db->rel_arr.nrels != new_db->rel_arr.nrels)
pg_log(PG_FATAL, "old and new databases \"%s\" have a different number of relations\n",
old_db->db_name);
"LEFT OUTER JOIN pg_catalog.pg_index i "
" ON c.oid = i.indexrelid "
"WHERE relkind IN ('r', 'm', 'i'%s) AND "
- /* pg_dump only dumps valid indexes; testing indisready is
- * necessary in 9.2, and harmless in earlier/later versions. */
+
+ /*
+ * pg_dump only dumps valid indexes; testing indisready is necessary in
+ * 9.2, and harmless in earlier/later versions.
+ */
" i.indisvalid IS DISTINCT FROM false AND "
" i.indisready IS DISTINCT FROM false AND "
/* exclude possible orphaned temp tables */
PQclear(executeQueryOrDie(conn, "%s", query));
/*
- * Get TOAST tables and indexes; we have to gather the TOAST tables in
- * later steps because we can't schema-qualify TOAST tables.
+ * Get TOAST tables and indexes; we have to gather the TOAST tables in
+ * later steps because we can't schema-qualify TOAST tables.
*/
PQclear(executeQueryOrDie(conn,
"INSERT INTO info_rels "
/* we preserve pg_class.oid so we sort by it to match old/new */
"ORDER BY 1;",
/* 9.2 removed the spclocation column */
- (GET_MAJOR_VERSION(cluster->major_version) <= 901) ?
- "t.spclocation" : "pg_catalog.pg_tablespace_location(t.oid) AS spclocation");
+ (GET_MAJOR_VERSION(cluster->major_version) <= 901) ?
+ "t.spclocation" : "pg_catalog.pg_tablespace_location(t.oid) AS spclocation");
res = executeQueryOrDie(conn, "%s", query);
for (relnum = 0; relnum < rel_arr->nrels; relnum++)
pg_log(PG_VERBOSE, "relname: %s.%s: reloid: %u reltblspace: %s\n",
rel_arr->rels[relnum].nspname, rel_arr->rels[relnum].relname,
- rel_arr->rels[relnum].reloid, rel_arr->rels[relnum].tablespace);
+ rel_arr->rels[relnum].reloid, rel_arr->rels[relnum].tablespace);
}
}
/*
- * Trim off any trailing path separators because we construct paths
- * by appending to this path.
+ * Trim off any trailing path separators because we construct paths by
+ * appending to this path.
*/
#ifndef WIN32
if ((*dirpath)[strlen(*dirpath) - 1] == '/')
get_sock_dir(ClusterInfo *cluster, bool live_check)
{
#ifdef HAVE_UNIX_SOCKETS
+
/*
- * sockdir and port were added to postmaster.pid in PG 9.1.
- * Pre-9.1 cannot process pg_ctl -w for sockets in non-default
- * locations.
+ * sockdir and port were added to postmaster.pid in PG 9.1. Pre-9.1 cannot
+ * process pg_ctl -w for sockets in non-default locations.
*/
if (GET_MAJOR_VERSION(cluster->major_version) >= 901)
{
else
{
/*
- * If we are doing a live check, we will use the old cluster's Unix
- * domain socket directory so we can connect to the live server.
+ * If we are doing a live check, we will use the old cluster's
+ * Unix domain socket directory so we can connect to the live
+ * server.
*/
unsigned short orig_port = cluster->port;
- char filename[MAXPGPATH], line[MAXPGPATH];
- FILE *fp;
+ char filename[MAXPGPATH],
+ line[MAXPGPATH];
+ FILE *fp;
int lineno;
-
+
snprintf(filename, sizeof(filename), "%s/postmaster.pid",
cluster->pgdata);
if ((fp = fopen(filename, "r")) == NULL)
pg_log(PG_FATAL, "Cannot open file %s: %m\n", filename);
-
+
for (lineno = 1;
- lineno <= Max(LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR);
+ lineno <= Max(LOCK_FILE_LINE_PORT, LOCK_FILE_LINE_SOCKET_DIR);
lineno++)
{
if (fgets(line, sizeof(line), fp) == NULL)
pg_log(PG_FATAL, "Cannot read line %d from %s: %m\n", lineno, filename);
-
+
/* potentially overwrite user-supplied value */
if (lineno == LOCK_FILE_LINE_PORT)
sscanf(line, "%hu", &old_cluster.port);
}
}
fclose(fp);
-
+
/* warn of port number correction */
if (orig_port != DEF_PGUPORT && old_cluster.port != orig_port)
pg_log(PG_WARNING, "User-supplied old port number %hu corrected to %hu\n",
- orig_port, cluster->port);
+ orig_port, cluster->port);
}
}
else
- /* Can't get sockdir and pg_ctl -w can't use a non-default, use default */
- cluster->sockdir = NULL;
-#else /* !HAVE_UNIX_SOCKETS */
+ /*
+ * Can't get sockdir and pg_ctl -w can't use a non-default, use
+ * default
+ */
+ cluster->sockdir = NULL;
+#else /* !HAVE_UNIX_SOCKETS */
cluster->sockdir = NULL;
#endif
}
if (newPageVersion != oldPageVersion)
{
/*
- * The clusters use differing page layouts, see if we can find a plugin
- * that knows how to convert from the old page layout to the new page
- * layout.
+ * The clusters use differing page layouts, see if we can find a
+ * plugin that knows how to convert from the old page layout to the
+ * new page layout.
*/
-
+
if ((converter = loadConverterPlugin(newPageVersion, oldPageVersion)) == NULL)
pg_log(PG_FATAL, "could not find plugin to convert from old page layout to new page layout\n");
}
}
-
-
#endif
#include
#endif
-static int parallel_jobs;
+static int parallel_jobs;
#ifdef WIN32
/*
* it can be passed to WaitForMultipleObjects(). We use two arrays
* so the thread_handles array can be passed to WaitForMultipleObjects().
*/
-HANDLE *thread_handles;
+HANDLE *thread_handles;
-typedef struct {
- char log_file[MAXPGPATH];
- char opt_log_file[MAXPGPATH];
- char cmd[MAX_STRING];
+typedef struct
+{
+ char log_file[MAXPGPATH];
+ char opt_log_file[MAXPGPATH];
+ char cmd[MAX_STRING];
} exec_thread_arg;
-typedef struct {
- DbInfoArr *old_db_arr;
- DbInfoArr *new_db_arr;
- char old_pgdata[MAXPGPATH];
- char new_pgdata[MAXPGPATH];
- char old_tablespace[MAXPGPATH];
+typedef struct
+{
+ DbInfoArr *old_db_arr;
+ DbInfoArr *new_db_arr;
+ char old_pgdata[MAXPGPATH];
+ char new_pgdata[MAXPGPATH];
+ char old_tablespace[MAXPGPATH];
} transfer_thread_arg;
exec_thread_arg **exec_thread_args;
transfer_thread_arg **transfer_thread_args;
/* track current thread_args struct so reap_child() can be used for all cases */
-void **cur_thread_args;
-
-DWORD win32_exec_prog(exec_thread_arg *args);
-DWORD win32_transfer_all_new_dbs(transfer_thread_arg *args);
+void **cur_thread_args;
+DWORD win32_exec_prog(exec_thread_arg *args);
+DWORD win32_transfer_all_new_dbs(transfer_thread_arg *args);
#endif
/*
{
va_list args;
char cmd[MAX_STRING];
+
#ifndef WIN32
pid_t child;
#else
HANDLE child;
- exec_thread_arg *new_arg;
+ exec_thread_arg *new_arg;
#endif
va_start(args, fmt);
{
/* parallel */
#ifdef WIN32
- cur_thread_args = (void **)exec_thread_args;
-#endif
+ cur_thread_args = (void **) exec_thread_args;
+#endif
/* harvest any dead children */
while (reap_child(false) == true)
;
/* must we wait for a dead child? */
if (parallel_jobs >= user_opts.jobs)
reap_child(true);
-
+
/* set this before we start the job */
parallel_jobs++;
-
+
/* Ensure stdio state is quiesced before forking */
fflush(NULL);
#else
if (thread_handles == NULL)
{
- int i;
+ int i;
thread_handles = pg_malloc(user_opts.jobs * sizeof(HANDLE));
exec_thread_args = pg_malloc(user_opts.jobs * sizeof(exec_thread_arg *));
/*
- * For safety and performance, we keep the args allocated during
- * the entire life of the process, and we don't free the args
- * in a thread different from the one that allocated it.
+ * For safety and performance, we keep the args allocated during
+ * the entire life of the process, and we don't free the args in a
+ * thread different from the one that allocated it.
*/
for (i = 0; i < user_opts.jobs; i++)
exec_thread_args[i] = pg_malloc(sizeof(exec_thread_arg));
}
/* use first empty array element */
- new_arg = exec_thread_args[parallel_jobs-1];
+ new_arg = exec_thread_args[parallel_jobs - 1];
/* Can only pass one pointer into the function, so use a struct */
strcpy(new_arg->log_file, log_file);
strcpy(new_arg->cmd, cmd);
child = (HANDLE) _beginthreadex(NULL, 0, (void *) win32_exec_prog,
- new_arg, 0, NULL);
+ new_arg, 0, NULL);
if (child == 0)
pg_log(PG_FATAL, "could not create worker thread: %s\n", strerror(errno));
- thread_handles[parallel_jobs-1] = child;
+ thread_handles[parallel_jobs - 1] = child;
#endif
}
DWORD
win32_exec_prog(exec_thread_arg *args)
{
- int ret;
+ int ret;
ret = !exec_prog(args->log_file, args->opt_log_file, true, "%s", args->cmd);
* This has the same API as transfer_all_new_dbs, except it does parallel execution
* by transfering multiple tablespaces in parallel
*/
-void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
- char *old_pgdata, char *new_pgdata,
- char *old_tablespace)
+void
+parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
+ char *old_pgdata, char *new_pgdata,
+ char *old_tablespace)
{
#ifndef WIN32
pid_t child;
#else
HANDLE child;
- transfer_thread_arg *new_arg;
+ transfer_thread_arg *new_arg;
#endif
if (user_opts.jobs <= 1)
{
/* parallel */
#ifdef WIN32
- cur_thread_args = (void **)transfer_thread_args;
+ cur_thread_args = (void **) transfer_thread_args;
#endif
/* harvest any dead children */
while (reap_child(false) == true)
/* must we wait for a dead child? */
if (parallel_jobs >= user_opts.jobs)
reap_child(true);
-
+
/* set this before we start the job */
parallel_jobs++;
-
+
/* Ensure stdio state is quiesced before forking */
fflush(NULL);
#else
if (thread_handles == NULL)
{
- int i;
+ int i;
thread_handles = pg_malloc(user_opts.jobs * sizeof(HANDLE));
transfer_thread_args = pg_malloc(user_opts.jobs * sizeof(transfer_thread_arg *));
/*
- * For safety and performance, we keep the args allocated during
- * the entire life of the process, and we don't free the args
- * in a thread different from the one that allocated it.
+ * For safety and performance, we keep the args allocated during
+ * the entire life of the process, and we don't free the args in a
+ * thread different from the one that allocated it.
*/
for (i = 0; i < user_opts.jobs; i++)
transfer_thread_args[i] = pg_malloc(sizeof(transfer_thread_arg));
}
/* use first empty array element */
- new_arg = transfer_thread_args[parallel_jobs-1];
+ new_arg = transfer_thread_args[parallel_jobs - 1];
/* Can only pass one pointer into the function, so use a struct */
new_arg->old_db_arr = old_db_arr;
strcpy(new_arg->old_tablespace, old_tablespace);
child = (HANDLE) _beginthreadex(NULL, 0, (void *) win32_exec_prog,
- new_arg, 0, NULL);
+ new_arg, 0, NULL);
if (child == 0)
pg_log(PG_FATAL, "could not create worker thread: %s\n", strerror(errno));
- thread_handles[parallel_jobs-1] = child;
+ thread_handles[parallel_jobs - 1] = child;
#endif
}
reap_child(bool wait_for_child)
{
#ifndef WIN32
- int work_status;
- int ret;
+ int work_status;
+ int ret;
#else
- int thread_num;
- DWORD res;
+ int thread_num;
+ DWORD res;
#endif
if (user_opts.jobs <= 1 || parallel_jobs == 0)
if (WEXITSTATUS(work_status) != 0)
pg_log(PG_FATAL, "child worker exited abnormally: %s\n", strerror(errno));
-
#else
/* wait for one to finish */
thread_num = WaitForMultipleObjects(parallel_jobs, thread_handles,
- false, wait_for_child ? INFINITE : 0);
+ false, wait_for_child ? INFINITE : 0);
if (thread_num == WAIT_TIMEOUT || thread_num == WAIT_FAILED)
return false;
/* compute thread index in active_threads */
thread_num -= WAIT_OBJECT_0;
-
+
/* get the result */
GetExitCodeThread(thread_handles[thread_num], &res);
if (res != 0)
/* dispose of handle to stop leaks */
CloseHandle(thread_handles[thread_num]);
- /* Move last slot into dead child's position */
+ /* Move last slot into dead child's position */
if (thread_num != parallel_jobs - 1)
{
- void *tmp_args;
-
+ void *tmp_args;
+
thread_handles[thread_num] = thread_handles[parallel_jobs - 1];
/*
- * We must swap the arg struct pointers because the thread we
- * just moved is active, and we must make sure it is not
- * reused by the next created thread. Instead, the new thread
- * will use the arg struct of the thread that just died.
+ * We must swap the arg struct pointers because the thread we just
+ * moved is active, and we must make sure it is not reused by the next
+ * created thread. Instead, the new thread will use the arg struct of
+ * the thread that just died.
*/
tmp_args = cur_thread_args[thread_num];
cur_thread_args[thread_num] = cur_thread_args[parallel_jobs - 1];
disable_old_cluster();
transfer_all_new_tablespaces(&old_cluster.dbarr, &new_cluster.dbarr,
- old_cluster.pgdata, new_cluster.pgdata);
+ old_cluster.pgdata, new_cluster.pgdata);
/*
* Assuming OIDs are only used in system tables, there is no need to
if (pid_lock_file_exists(old_cluster.pgdata))
{
/*
- * If we have a postmaster.pid file, try to start the server. If
- * it starts, the pid file was stale, so stop the server. If it
- * doesn't start, assume the server is running. If the pid file
- * is left over from a server crash, this also allows any committed
- * transactions stored in the WAL to be replayed so they are not
- * lost, because WAL files are not transfered from old to new
- * servers.
- */
+ * If we have a postmaster.pid file, try to start the server. If it
+ * starts, the pid file was stale, so stop the server. If it doesn't
+ * start, assume the server is running. If the pid file is left over
+ * from a server crash, this also allows any committed transactions
+ * stored in the WAL to be replayed so they are not lost, because WAL
+ * files are not transfered from old to new servers.
+ */
if (start_postmaster(&old_cluster, false))
stop_postmaster(false);
else
stop_postmaster(false);
else
pg_log(PG_FATAL, "There seems to be a postmaster servicing the new cluster.\n"
- "Please shutdown that postmaster and try again.\n");
+ "Please shutdown that postmaster and try again.\n");
}
/* get path to pg_upgrade executable */
prep_status("Adding support functions to new cluster");
/*
- * Technically, we only need to install these support functions in new
- * databases that also exist in the old cluster, but for completeness
- * we process all new databases.
+ * Technically, we only need to install these support functions in new
+ * databases that also exist in the old cluster, but for completeness we
+ * process all new databases.
*/
for (dbnum = 0; dbnum < new_cluster.dbarr.ndbs; dbnum++)
{
for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
{
- char sql_file_name[MAXPGPATH], log_file_name[MAXPGPATH];
- DbInfo *old_db = &old_cluster.dbarr.dbs[dbnum];
+ char sql_file_name[MAXPGPATH],
+ log_file_name[MAXPGPATH];
+ DbInfo *old_db = &old_cluster.dbarr.dbs[dbnum];
pg_log(PG_STATUS, "%s", old_db->db_name);
snprintf(sql_file_name, sizeof(sql_file_name), DB_DUMP_FILE_MASK, old_db->db_oid);
snprintf(log_file_name, sizeof(log_file_name), DB_DUMP_LOG_FILE_MASK, old_db->db_oid);
/*
- * pg_dump only produces its output at the end, so there is little
- * parallelism if using the pipe.
+ * pg_dump only produces its output at the end, so there is little
+ * parallelism if using the pipe.
*/
parallel_exec_prog(log_file_name, NULL,
- "\"%s/pg_restore\" %s --exit-on-error --verbose --dbname \"%s\" \"%s\"",
- new_cluster.bindir, cluster_conn_opts(&new_cluster),
- old_db->db_name, sql_file_name);
+ "\"%s/pg_restore\" %s --exit-on-error --verbose --dbname \"%s\" \"%s\"",
+ new_cluster.bindir, cluster_conn_opts(&new_cluster),
+ old_db->db_name, sql_file_name);
}
/* reap all children */
copy_subdir_files("pg_multixact/offsets");
copy_subdir_files("pg_multixact/members");
prep_status("Setting next multixact ID and offset for new cluster");
+
/*
* we preserve all files and contents, so we must preserve both "next"
* counters here and the oldest multi present on system.
else if (new_cluster.controldata.cat_ver >= MULTIXACT_FORMATCHANGE_CAT_VER)
{
prep_status("Setting oldest multixact ID on new cluster");
+
/*
* We don't preserve files in this case, but it's important that the
* oldest multi is set to the latest value used by the old system, so
static void
cleanup(void)
{
-
fclose(log_opts.internal);
/* Remove dump and log files? */
if (old_cluster.dbarr.dbs)
for (dbnum = 0; dbnum < old_cluster.dbarr.ndbs; dbnum++)
{
- char sql_file_name[MAXPGPATH], log_file_name[MAXPGPATH];
- DbInfo *old_db = &old_cluster.dbarr.dbs[dbnum];
+ char sql_file_name[MAXPGPATH],
+ log_file_name[MAXPGPATH];
+ DbInfo *old_db = &old_cluster.dbarr.dbs[dbnum];
snprintf(sql_file_name, sizeof(sql_file_name), DB_DUMP_FILE_MASK, old_db->db_oid);
unlink(sql_file_name);
#define pg_copy_file copy_file
#define pg_mv_file rename
#define pg_link_file link
-#define PATH_SEPARATOR '/'
+#define PATH_SEPARATOR '/'
#define RM_CMD "rm -f"
#define RMDIR_CMD "rm -rf"
#define SCRIPT_EXT "sh"
#define ECHO_QUOTE "'"
-#define ECHO_BLANK ""
+#define ECHO_BLANK ""
#else
#define pg_copy_file CopyFile
#define pg_mv_file pgrename
#define pg_link_file win32_pghardlink
#define sleep(x) Sleep(x * 1000)
-#define PATH_SEPARATOR '\\'
+#define PATH_SEPARATOR '\\'
#define RM_CMD "DEL /q"
#define RMDIR_CMD "RMDIR /s/q"
#define SCRIPT_EXT "bat"
#define EXE_EXT ".exe"
#define ECHO_QUOTE ""
-#define ECHO_BLANK "."
+#define ECHO_BLANK "."
#endif
#define CLUSTER_NAME(cluster) ((cluster) == &old_cluster ? "old" : \
typedef struct
{
/* Can't use NAMEDATALEN; not guaranteed to fit on client */
- char *nspname; /* namespace name */
- char *relname; /* relation name */
+ char *nspname; /* namespace name */
+ char *relname; /* relation name */
Oid reloid; /* relation oid */
Oid relfilenode; /* relation relfile node */
/* relation tablespace path, or "" for the cluster default */
Oid old_relfilenode;
Oid new_relfilenode;
/* the rest are used only for logging and error reporting */
- char *nspname; /* namespaces */
- char *relname;
+ char *nspname; /* namespaces */
+ char *relname;
} FileNameMap;
/*
typedef struct
{
Oid db_oid; /* oid of the database */
- char *db_name; /* database name */
+ char *db_name; /* database name */
char db_tblspace[MAXPGPATH]; /* database default tablespace path */
RelInfoArr rel_arr; /* array of all user relinfos */
} DbInfo;
char major_version_str[64]; /* string PG_VERSION of cluster */
uint32 bin_version; /* version returned from pg_ctl */
Oid pg_database_oid; /* OID of pg_database relation */
- Oid install_role_oid; /* OID of connected role */
- Oid role_count; /* number of roles defined in the cluster */
+ Oid install_role_oid; /* OID of connected role */
+ Oid role_count; /* number of roles defined in the cluster */
char *tablespace_suffix; /* directory specification */
} ClusterInfo;
/* check.c */
void output_check_banner(bool live_check);
-void check_and_dump_old_cluster(bool live_check,
- char **sequence_script_file_name);
+void check_and_dump_old_cluster(bool live_check,
+ char **sequence_script_file_name);
void check_new_cluster(void);
void report_clusters_compatible(void);
void issue_warnings(char *sequence_script_file_name);
-void output_completion_banner(char *analyze_script_file_name,
+void output_completion_banner(char *analyze_script_file_name,
char *deletion_script_file_name);
void check_cluster_versions(void);
void check_cluster_compatibility(bool live_check);
/* relfilenode.c */
void get_pg_database_relfilenode(ClusterInfo *cluster);
-void transfer_all_new_tablespaces(DbInfoArr *old_db_arr,
- DbInfoArr *new_db_arr, char *old_pgdata, char *new_pgdata);
-void transfer_all_new_dbs(DbInfoArr *old_db_arr,
+void transfer_all_new_tablespaces(DbInfoArr *old_db_arr,
+ DbInfoArr *new_db_arr, char *old_pgdata, char *new_pgdata);
+void transfer_all_new_dbs(DbInfoArr *old_db_arr,
DbInfoArr *new_db_arr, char *old_pgdata, char *new_pgdata,
- char *old_tablespace);
+ char *old_tablespace);
/* tablespace.c */
char *old_8_3_create_sequence_script(ClusterInfo *cluster);
/* parallel.c */
-void parallel_exec_prog(const char *log_file, const char *opt_log_file,
- const char *fmt,...)
+void
+parallel_exec_prog(const char *log_file, const char *opt_log_file,
+ const char *fmt,...)
__attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 4)));
-void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
- char *old_pgdata, char *new_pgdata,
- char *old_tablespace);
+void parallel_transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
+ char *old_pgdata, char *new_pgdata,
+ char *old_tablespace);
bool reap_child(bool wait_for_child);
-
static void transfer_single_new_db(pageCnvCtx *pageConverter,
FileNameMap *maps, int size, char *old_tablespace);
static void transfer_relfile(pageCnvCtx *pageConverter, FileNameMap *map,
- const char *suffix);
+ const char *suffix);
/*
*/
void
transfer_all_new_tablespaces(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
- char *old_pgdata, char *new_pgdata)
+ char *old_pgdata, char *new_pgdata)
{
pg_log(PG_REPORT, "%s user relation files\n",
user_opts.transfer_mode == TRANSFER_MODE_LINK ? "Linking" : "Copying");
/*
- * Transfering files by tablespace is tricky because a single database
- * can use multiple tablespaces. For non-parallel mode, we just pass a
- * NULL tablespace path, which matches all tablespaces. In parallel mode,
- * we pass the default tablespace and all user-created tablespaces
- * and let those operations happen in parallel.
+ * Transfering files by tablespace is tricky because a single database can
+ * use multiple tablespaces. For non-parallel mode, we just pass a NULL
+ * tablespace path, which matches all tablespaces. In parallel mode, we
+ * pass the default tablespace and all user-created tablespaces and let
+ * those operations happen in parallel.
*/
if (user_opts.jobs <= 1)
parallel_transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata,
new_pgdata, NULL);
else
{
- int tblnum;
+ int tblnum;
/* transfer default tablespace */
parallel_transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata,
- new_pgdata, old_pgdata);
+ new_pgdata, old_pgdata);
for (tblnum = 0; tblnum < os_info.num_old_tablespaces; tblnum++)
parallel_transfer_all_new_dbs(old_db_arr, new_db_arr, old_pgdata,
- new_pgdata, os_info.old_tablespaces[tblnum]);
+ new_pgdata, os_info.old_tablespaces[tblnum]);
/* reap all children */
while (reap_child(true) == true)
;
*/
void
transfer_all_new_dbs(DbInfoArr *old_db_arr, DbInfoArr *new_db_arr,
- char *old_pgdata, char *new_pgdata, char *old_tablespace)
+ char *old_pgdata, char *new_pgdata, char *old_tablespace)
{
int old_dbnum,
new_dbnum;
{
int mapnum;
bool vm_crashsafe_match = true;
-
+
/*
* Do the old and new cluster disagree on the crash-safetiness of the vm
- * files? If so, do not copy them.
- */
+ * files? If so, do not copy them.
+ */
if (old_cluster.controldata.cat_ver < VISIBILITY_MAP_CRASHSAFE_CAT_VER &&
new_cluster.controldata.cat_ver >= VISIBILITY_MAP_CRASHSAFE_CAT_VER)
vm_crashsafe_match = false;
{
/* transfer primary file */
transfer_relfile(pageConverter, &maps[mapnum], "");
-
+
/* fsm/vm files added in PG 8.4 */
if (GET_MAJOR_VERSION(old_cluster.major_version) >= 804)
{
int fd;
int segno;
char extent_suffix[65];
-
+
/*
- * Now copy/link any related segments as well. Remember, PG breaks
- * large files into 1GB segments, the first segment has no extension,
- * subsequent segments are named relfilenode.1, relfilenode.2,
- * relfilenode.3.
- * copied.
+ * Now copy/link any related segments as well. Remember, PG breaks large
+ * files into 1GB segments, the first segment has no extension, subsequent
+ * segments are named relfilenode.1, relfilenode.2, relfilenode.3. copied.
*/
for (segno = 0;; segno++)
{
snprintf(extent_suffix, sizeof(extent_suffix), ".%d", segno);
snprintf(old_file, sizeof(old_file), "%s%s/%u/%u%s%s", map->old_tablespace,
- map->old_tablespace_suffix, map->old_db_oid, map->old_relfilenode,
+ map->old_tablespace_suffix, map->old_db_oid, map->old_relfilenode,
type_suffix, extent_suffix);
snprintf(new_file, sizeof(new_file), "%s%s/%u/%u%s%s", map->new_tablespace,
- map->new_tablespace_suffix, map->new_db_oid, map->new_relfilenode,
+ map->new_tablespace_suffix, map->new_db_oid, map->new_relfilenode,
type_suffix, extent_suffix);
-
+
/* Is it an extent, fsm, or vm file? */
if (type_suffix[0] != '\0' || segno != 0)
{
}
unlink(new_file);
-
+
/* Copying files might take some time, so give feedback. */
pg_log(PG_STATUS, "%s", old_file);
-
+
if ((user_opts.transfer_mode == TRANSFER_MODE_LINK) && (pageConverter != NULL))
pg_log(PG_FATAL, "This upgrade requires page-by-page conversion, "
"you must use copy mode instead of link mode.\n");
-
+
if (user_opts.transfer_mode == TRANSFER_MODE_COPY)
{
pg_log(PG_VERBOSE, "copying \"%s\" to \"%s\"\n", old_file, new_file);
-
+
if ((msg = copyAndUpdateFile(pageConverter, old_file, new_file, true)) != NULL)
pg_log(PG_FATAL, "error while copying relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
map->nspname, map->relname, old_file, new_file, msg);
else
{
pg_log(PG_VERBOSE, "linking \"%s\" to \"%s\"\n", old_file, new_file);
-
+
if ((msg = linkAndUpdateFile(pageConverter, old_file, new_file)) != NULL)
pg_log(PG_FATAL,
"error while creating link for relation \"%s.%s\" (\"%s\" to \"%s\"): %s\n",
map->nspname, map->relname, old_file, new_file, msg);
}
- }
+ }
return;
}
-
char *
cluster_conn_opts(ClusterInfo *cluster)
{
- static char conn_opts[MAXPGPATH + NAMEDATALEN + 100];
+ static char conn_opts[MAXPGPATH + NAMEDATALEN + 100];
if (cluster->sockdir)
snprintf(conn_opts, sizeof(conn_opts),
strcat(socket_string,
" -c listen_addresses='' -c unix_socket_permissions=0700");
- /* Have a sockdir? Tell the postmaster. */
+ /* Have a sockdir? Tell the postmaster. */
if (cluster->sockdir)
snprintf(socket_string + strlen(socket_string),
sizeof(socket_string) - strlen(socket_string),
* win on ext4.
*/
snprintf(cmd, sizeof(cmd),
- "\"%s/pg_ctl\" -w -l \"%s\" -D \"%s\" -o \"-p %d%s%s %s%s\" start",
+ "\"%s/pg_ctl\" -w -l \"%s\" -D \"%s\" -o \"-p %d%s%s %s%s\" start",
cluster->bindir, SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
(cluster->controldata.cat_ver >=
BINARY_UPGRADE_SERVER_FLAG_CAT_VER) ? " -b" :
" -c autovacuum=off -c autovacuum_freeze_max_age=2000000000",
(cluster == &new_cluster) ?
- " -c synchronous_commit=off -c fsync=off -c full_page_writes=off" : "",
+ " -c synchronous_commit=off -c fsync=off -c full_page_writes=off" : "",
cluster->pgopts ? cluster->pgopts : "", socket_string);
/*
* it might supply a reason for the failure.
*/
pg_ctl_return = exec_prog(SERVER_START_LOG_FILE,
- /* pass both file names if they differ */
+ /* pass both file names if they differ */
(strcmp(SERVER_LOG_FILE,
SERVER_START_LOG_FILE) != 0) ?
SERVER_LOG_FILE : NULL,
if (!pg_ctl_return && !throw_error)
return false;
-
+
/* Check to see if we can connect to the server; if not, report it. */
if ((conn = get_db_conn(cluster, "template1")) == NULL ||
PQstatus(conn) != CONNECTION_OK)
if ((os_info.num_old_tablespaces = PQntuples(res)) != 0)
os_info.old_tablespaces = (char **) pg_malloc(
- os_info.num_old_tablespaces * sizeof(char *));
+ os_info.num_old_tablespaces * sizeof(char *));
else
os_info.old_tablespaces = NULL;
end_progress_output(void)
{
/*
- * In case nothing printed; pass a space so gcc doesn't complain about
- * empty format string.
+ * In case nothing printed; pass a space so gcc doesn't complain about
+ * empty format string.
*/
prep_status(" ");
}
/* for output to a display, do leading truncation and append \r */
if (isatty(fileno(stdout)))
/* -2 because we use a 2-space indent */
- printf(" %s%-*.*s\r",
- /* prefix with "..." if we do leading truncation */
- strlen(message) <= MESSAGE_WIDTH - 2 ? "" : "...",
- MESSAGE_WIDTH - 2, MESSAGE_WIDTH - 2,
- /* optional leading truncation */
- strlen(message) <= MESSAGE_WIDTH - 2 ? message :
- message + strlen(message) - MESSAGE_WIDTH + 3 + 2);
+ printf(" %s%-*.*s\r",
+ /* prefix with "..." if we do leading truncation */
+ strlen(message) <= MESSAGE_WIDTH - 2 ? "" : "...",
+ MESSAGE_WIDTH - 2, MESSAGE_WIDTH - 2,
+ /* optional leading truncation */
+ strlen(message) <= MESSAGE_WIDTH - 2 ? message :
+ message + strlen(message) - MESSAGE_WIDTH + 3 + 2);
else
printf(" %s\n", _(message));
break;
/*
* Stopgap implementation of timestamptz_to_str that doesn't depend on backend
- * infrastructure. This will work for timestamps that are within the range
+ * infrastructure. This will work for timestamps that are within the range
* of the platform time_t type. (pg_time_t is compatible except for possibly
* being wider.)
*
* be linked/called.
*/
void
-appendStringInfo(StringInfo str, const char *fmt, ...)
+appendStringInfo(StringInfo str, const char *fmt,...)
{
va_list args;
static void
print_rmgr_list(void)
{
- int i;
+ int i;
for (i = 0; i < RM_MAX_ID + 1; i++)
{
static bool
verify_directory(const char *directory)
{
- DIR *dir = opendir(directory);
+ DIR *dir = opendir(directory);
+
if (dir == NULL)
return false;
closedir(dir);
if (sep != NULL)
{
*dir = pg_strdup(path);
- (*dir)[(sep - path) + 1] = '\0'; /* no strndup */
+ (*dir)[(sep - path) + 1] = '\0'; /* no strndup */
*fname = pg_strdup(sep + 1);
}
/* local directory */
else if (!XLByteInSeg(private.startptr, segno))
{
fprintf(stderr,
- "%s: start log position %X/%X is not inside file \"%s\"\n",
+ "%s: start log position %X/%X is not inside file \"%s\"\n",
progname,
(uint32) (private.startptr >> 32),
(uint32) private.startptr,
(uint32) private.startptr);
/*
- * Display a message that we're skipping data if `from` wasn't a pointer to
- * the start of a record and also wasn't a pointer to the beginning of a
- * segment (e.g. we were used in file mode).
+ * Display a message that we're skipping data if `from` wasn't a pointer
+ * to the start of a record and also wasn't a pointer to the beginning of
+ * a segment (e.g. we were used in file mode).
*/
if (first_record != private.startptr && (private.startptr % XLogSegSize) != 0)
printf("first record is after %X/%X, at %X/%X, skipping over %u bytes\n",
const RmgrDescData RmgrDescTable[RM_MAX_ID + 1] = {
#include "access/rmgrlist.h"
};
-
typedef struct RmgrDescData
{
const char *rm_name;
- void (*rm_desc) (StringInfo buf, uint8 xl_info, char *rec);
+ void (*rm_desc) (StringInfo buf, uint8 xl_info, char *rec);
} RmgrDescData;
extern const RmgrDescData RmgrDescTable[];
-#endif /* RMGRDESC_H */
+#endif /* RMGRDESC_H */
bool use_log; /* log transaction latencies to a file */
bool use_quiet; /* quiet logging onto stderr */
-int agg_interval; /* log aggregates instead of individual transactions */
+int agg_interval; /* log aggregates instead of individual
+ * transactions */
bool is_connect; /* establish connection for each transaction */
bool is_latencies; /* report per-command latencies */
int main_pid; /* main process id used in log filename */
typedef struct
{
- long start_time; /* when does the interval start */
- int cnt; /* number of transactions */
- double min_duration; /* min/max durations */
- double max_duration;
- double sum; /* sum(duration), sum(duration^2) - for estimates */
- double sum2;
-
+ long start_time; /* when does the interval start */
+ int cnt; /* number of transactions */
+ double min_duration; /* min/max durations */
+ double max_duration;
+ double sum; /* sum(duration), sum(duration^2) - for
+ * estimates */
+ double sum2;
+
} AggVals;
static Command **sql_files[MAX_FILES]; /* SQL script files */
}
static
-void agg_vals_init(AggVals * aggs, instr_time start)
+void
+agg_vals_init(AggVals *aggs, instr_time start)
{
/* basic counters */
- aggs->cnt = 0; /* number of transactions */
- aggs->sum = 0; /* SUM(duration) */
- aggs->sum2 = 0; /* SUM(duration*duration) */
+ aggs->cnt = 0; /* number of transactions */
+ aggs->sum = 0; /* SUM(duration) */
+ aggs->sum2 = 0; /* SUM(duration*duration) */
/* min and max transaction duration */
aggs->min_duration = 0;
/* return false iff client should be disconnected */
static bool
-doCustom(TState *thread, CState *st, instr_time *conn_time, FILE *logfile, AggVals * agg)
+doCustom(TState *thread, CState *st, instr_time *conn_time, FILE *logfile, AggVals *agg)
{
PGresult *res;
Command **commands;
/* should we aggregate the results or not? */
if (agg_interval > 0)
{
- /* are we still in the same interval? if yes, accumulate the
- * values (print them otherwise) */
+ /*
+ * are we still in the same interval? if yes, accumulate
+ * the values (print them otherwise)
+ */
if (agg->start_time + agg_interval >= INSTR_TIME_GET_DOUBLE(now))
{
agg->cnt += 1;
- agg->sum += usec;
+ agg->sum += usec;
agg->sum2 += usec * usec;
/* first in this aggregation interval */
if ((agg->cnt == 1) || (usec < agg->min_duration))
- agg->min_duration = usec;
+ agg->min_duration = usec;
if ((agg->cnt == 1) || (usec > agg->max_duration))
agg->max_duration = usec;
}
else
{
- /* Loop until we reach the interval of the current transaction (and
- * print all the empty intervals in between). */
+ /*
+ * Loop until we reach the interval of the current
+ * transaction (and print all the empty intervals in
+ * between).
+ */
while (agg->start_time + agg_interval < INSTR_TIME_GET_DOUBLE(now))
{
- /* This is a non-Windows branch (thanks to the ifdef in usage), so
- * we don't need to handle this in a special way (see below). */
+ /*
+ * This is a non-Windows branch (thanks to the
+ * ifdef in usage), so we don't need to handle
+ * this in a special way (see below).
+ */
fprintf(logfile, "%ld %d %.0f %.0f %.0f %.0f\n",
- agg->start_time, agg->cnt, agg->sum, agg->sum2,
+ agg->start_time, agg->cnt, agg->sum, agg->sum2,
agg->min_duration, agg->max_duration);
/* move to the next inteval */
agg->sum2 = 0;
}
- /* and now update the reset values (include the current) */
+ /*
+ * and now update the reset values (include the
+ * current)
+ */
agg->cnt = 1;
agg->min_duration = usec;
agg->max_duration = usec;
{
/* no, print raw transactions */
#ifndef WIN32
- /* This is more than we really ought to know about instr_time */
+
+ /*
+ * This is more than we really ought to know about
+ * instr_time
+ */
fprintf(logfile, "%d %d %.0f %d %ld %ld\n",
st->id, st->cnt, usec, st->use_file,
(long) now.tv_sec, (long) now.tv_usec);
#else
- /* On Windows, instr_time doesn't provide a timestamp anyway */
+
+ /*
+ * On Windows, instr_time doesn't provide a timestamp
+ * anyway
+ */
fprintf(logfile, "%d %d %.0f %d 0 0\n",
st->id, st->cnt, usec, st->use_file);
#endif
}
/*
- * getrand() needs to be able to subtract max from min and add
- * one to the result without overflowing. Since we know max > min,
- * we can detect overflow just by checking for a negative result.
- * But we must check both that the subtraction doesn't overflow,
- * and that adding one to the result doesn't overflow either.
+ * getrand() needs to be able to subtract max from min and add one
+ * to the result without overflowing. Since we know max > min, we
+ * can detect overflow just by checking for a negative result. But
+ * we must check both that the subtraction doesn't overflow, and
+ * that adding one to the result doesn't overflow either.
*/
if (max - min < 0 || (max - min) + 1 < 0)
{
static void
init(bool is_no_vacuum)
{
-
/* The scale factor at/beyond which 32bit integers are incapable of storing
* 64bit values.
*
{
"pgbench_history",
scale >= SCALE_32BIT_THRESHOLD
- ? "tid int,bid int,aid bigint,delta int,mtime timestamp,filler char(22)"
- : "tid int,bid int,aid int,delta int,mtime timestamp,filler char(22)",
+ ? "tid int,bid int,aid bigint,delta int,mtime timestamp,filler char(22)"
+ : "tid int,bid int,aid int,delta int,mtime timestamp,filler char(22)",
0
},
{
{
"pgbench_accounts",
scale >= SCALE_32BIT_THRESHOLD
- ? "aid bigint not null,bid int,abalance int,filler char(84)"
- : "aid int not null,bid int,abalance int,filler char(84)",
+ ? "aid bigint not null,bid int,abalance int,filler char(84)"
+ : "aid int not null,bid int,abalance int,filler char(84)",
1
},
{
int64 k;
/* used to track elapsed time and estimate of the remaining time */
- instr_time start, diff;
- double elapsed_sec, remaining_sec;
+ instr_time start,
+ diff;
+ double elapsed_sec,
+ remaining_sec;
int log_interval = 1;
if ((con = doConnect()) == NULL)
exit(1);
}
- /* If we want to stick with the original logging, print a message each
- * 100k inserted rows. */
- if ((! use_quiet) && (j % 100000 == 0))
+ /*
+ * If we want to stick with the original logging, print a message each
+ * 100k inserted rows.
+ */
+ if ((!use_quiet) && (j % 100000 == 0))
{
INSTR_TIME_SET_CURRENT(diff);
INSTR_TIME_SUBTRACT(diff, start);
remaining_sec = (scale * naccounts - j) * elapsed_sec / j;
fprintf(stderr, INT64_FORMAT " of " INT64_FORMAT " tuples (%d%%) done (elapsed %.2f s, remaining %.2f s).\n",
- j, (int64)naccounts * scale,
- (int) (((int64) j * 100) / (naccounts * scale)),
- elapsed_sec, remaining_sec);
+ j, (int64) naccounts * scale,
+ (int) (((int64) j * 100) / (naccounts * scale)),
+ elapsed_sec, remaining_sec);
}
/* let's not call the timing for each row, but only each 100 rows */
else if (use_quiet && (j % 100 == 0))
remaining_sec = (scale * naccounts - j) * elapsed_sec / j;
/* have we reached the next interval (or end)? */
- if ((j == scale * naccounts) || (elapsed_sec >= log_interval * LOG_STEP_SECONDS)) {
+ if ((j == scale * naccounts) || (elapsed_sec >= log_interval * LOG_STEP_SECONDS))
+ {
fprintf(stderr, INT64_FORMAT " of " INT64_FORMAT " tuples (%d%%) done (elapsed %.2f s, remaining %.2f s).\n",
- j, (int64)naccounts * scale,
+ j, (int64) naccounts * scale,
(int) (((int64) j * 100) / (naccounts * scale)), elapsed_sec, remaining_sec);
/* skip to the next interval */
- log_interval = (int)ceil(elapsed_sec/LOG_STEP_SECONDS);
+ log_interval = (int) ceil(elapsed_sec / LOG_STEP_SECONDS);
}
}
exit(1);
}
- if (agg_interval > 0 && (! use_log)) {
+ if (agg_interval > 0 && (!use_log))
+ {
fprintf(stderr, "log aggregation is allowed only when actually logging transactions\n");
exit(1);
}
- if ((duration > 0) && (agg_interval > duration)) {
+ if ((duration > 0) && (agg_interval > duration))
+ {
fprintf(stderr, "number of seconds for aggregation (%d) must not be higher that test duration (%d)\n", agg_interval, duration);
exit(1);
}
- if ((duration > 0) && (agg_interval > 0) && (duration % agg_interval != 0)) {
+ if ((duration > 0) && (agg_interval > 0) && (duration % agg_interval != 0))
+ {
fprintf(stderr, "duration (%d) must be a multiple of aggregation interval (%d)\n", duration, agg_interval);
exit(1);
}
AggVals aggs;
result = pg_malloc(sizeof(TResult));
-
+
INSTR_TIME_SET_ZERO(result->conn_time);
/* open log file if requested */
INSTR_TIME_SUBTRACT(result->conn_time, thread->start_time);
agg_vals_init(&aggs, thread->start_time);
-
+
/* send start up queries in async manner */
for (i = 0; i < nstate; i++)
{
mp_result mp_int_mul_pow2(mp_int a, int p2, mp_int c);
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_result 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_result 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 */
+mp_result mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */
mp_int q, mp_int r); /* r = q % 2^p2 */
mp_result mp_int_mod(mp_int a, mp_int m, mp_int c); /* c = a % m */
/* Returns k >= 0 such that z = 2^k, if one exists; otherwise < 0 */
int mp_int_is_pow2(mp_int z);
-mp_result
-mp_int_exptmod(mp_int a, mp_int b, mp_int m,
+mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m,
mp_int c); /* c = a^b (mod m) */
-mp_result
-mp_int_exptmod_evalue(mp_int a, int value,
+mp_result mp_int_exptmod_evalue(mp_int a, int value,
mp_int m, mp_int c); /* c = a^v (mod m) */
-mp_result
-mp_int_exptmod_bvalue(int value, mp_int b,
+mp_result mp_int_exptmod_bvalue(int value, mp_int b,
mp_int m, mp_int c); /* c = v^b (mod m) */
-mp_result
-mp_int_exptmod_known(mp_int a, mp_int b,
+mp_result mp_int_exptmod_known(mp_int a, mp_int b,
mp_int m, mp_int mu,
mp_int c); /* c = a^b (mod m) */
mp_result mp_int_redux_const(mp_int m, mp_int c);
mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c); /* c = gcd(a, b) */
-mp_result
-mp_int_egcd(mp_int a, mp_int b, mp_int c, /* c = gcd(a, b) */
+mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, /* c = gcd(a, b) */
mp_int x, mp_int y); /* c = ax + by */
mp_result mp_int_sqrt(mp_int a, mp_int c); /* c = floor(sqrt(q)) */
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,
+int 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);
/* scan the relation */
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- HTSU_Result htsu;
+ HTSU_Result htsu;
TransactionId xmax;
uint16 infomask;
values = (char **) palloc(mydata->ncolumns * sizeof(char *));
values[Atnum_tid] = (char *) DirectFunctionCall1(tidout,
- PointerGetDatum(&tuple->t_self));
+ PointerGetDatum(&tuple->t_self));
values[Atnum_xmax] = palloc(NCHARS * sizeof(char));
snprintf(values[Atnum_xmax], NCHARS, "%d", xmax);
values[Atnum_ismulti] = pstrdup("true");
allow_old = !(infomask & HEAP_LOCK_MASK) &&
- (infomask & HEAP_XMAX_LOCK_ONLY);
+ (infomask & HEAP_XMAX_LOCK_ONLY);
nmembers = GetMultiXactIdMembers(xmax, &members, allow_old);
if (nmembers == -1)
{
result = HeapTupleGetDatum(tuple);
/*
- * no need to pfree what we allocated; it's on a short-lived memory
- * context anyway
+ * no need to pfree what we allocated; it's on a short-lived
+ * memory context anyway
*/
SRF_RETURN_NEXT(funcctx, result);
{
int32 version;
- BlockNumber pending_pages;
+ BlockNumber pending_pages;
int64 pending_tuples;
} GinIndexStat;
Relation rel;
Buffer buffer;
Page page;
- GinMetaPageData *metadata;
+ GinMetaPageData *metadata;
GinIndexStat stats;
HeapTuple tuple;
TupleDesc tupleDesc;
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot access temporary indexes of other sessions")));
+ errmsg("cannot access temporary indexes of other sessions")));
/*
* Read metapage
* anyway. However it makes the regression test outputs more predictable.
*
* We don't risk setting remote zone equal to ours, since the remote
- * server might use a different timezone database. Instead, use UTC
+ * server might use a different timezone database. Instead, use UTC
* (quoted, because very old servers are picky about case).
*/
do_sql_command(conn, "SET timezone = 'UTC'");
/* extracted fdw_private data */
char *query; /* text of SELECT command */
- List *retrieved_attrs; /* list of retrieved attribute numbers */
+ List *retrieved_attrs; /* list of retrieved attribute numbers */
/* for remote query execution */
PGconn *conn; /* connection for the scan */
char *query; /* text of INSERT/UPDATE/DELETE command */
List *target_attrs; /* list of target attribute numbers */
bool has_returning; /* is there a RETURNING clause? */
- List *retrieved_attrs; /* attr numbers retrieved by RETURNING */
+ List *retrieved_attrs; /* attr numbers retrieved by RETURNING */
/* info about parameters for prepared statement */
AttrNumber ctidAttno; /* attnum of input resjunk ctid column */
{
Relation rel; /* relcache entry for the foreign table */
AttInMetadata *attinmeta; /* attribute datatype conversion metadata */
- List *retrieved_attrs; /* attr numbers retrieved by query */
+ List *retrieved_attrs; /* attr numbers retrieved by query */
/* collected sample rows */
HeapTuple *rows; /* array of size targrows */
/*
* If the table or the server is configured to use remote estimates,
- * identify which user to do remote access as during planning. This
- * should match what ExecCheckRTEPerms() does. If we fail due to lack of
+ * identify which user to do remote access as during planning. This
+ * should match what ExecCheckRTEPerms() does. If we fail due to lack of
* permissions, the query would have failed at runtime anyway.
*/
if (fpinfo->use_remote_estimate)
/*
* Identify which attributes will need to be retrieved from the remote
- * server. These include all attrs needed for joins or final output, plus
+ * server. These include all attrs needed for joins or final output, plus
* all attrs used in the local_conds. (Note: if we end up using a
* parameterized scan, it's possible that some of the join clauses will be
* sent to the remote and thus we wouldn't really need to retrieve the
fsstate->query = strVal(list_nth(fsplan->fdw_private,
FdwScanPrivateSelectSql));
fsstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
- FdwScanPrivateRetrievedAttrs);
+ FdwScanPrivateRetrievedAttrs);
/* Create contexts for batches of tuples and per-tuple temp workspace. */
fsstate->batch_cxt = AllocSetContextCreate(estate->es_query_cxt,
fmstate->has_returning = intVal(list_nth(fdw_private,
FdwModifyPrivateHasReturning));
fmstate->retrieved_attrs = (List *) list_nth(fdw_private,
- FdwModifyPrivateRetrievedAttrs);
+ FdwModifyPrivateRetrievedAttrs);
/* Create context for per-tuple temp workspace. */
fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
* Notice that we pass NULL for paramTypes, thus forcing the remote server
* to infer types for all parameters. Since we explicitly cast every
* parameter (see deparse.c), the "inference" is trivial and will produce
- * the desired result. This allows us to avoid assuming that the remote
+ * the desired result. This allows us to avoid assuming that the remote
* server has the same OIDs we do for the parameters' types.
*
* We don't use a PG_TRY block here, so be careful not to throw error
astate->rows[pos] = make_tuple_from_result_row(res, row,
astate->rel,
astate->attinmeta,
- astate->retrieved_attrs,
+ astate->retrieved_attrs,
astate->temp_cxt);
MemoryContextSwitchTo(oldcontext);
List **retrieved_attrs);
extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
- List **retrieved_attrs);
+ List **retrieved_attrs);
#endif /* POSTGRES_FDW_H */
case OAT_POST_CREATE:
{
ObjectAccessPostCreate *pc_arg = arg;
- bool is_internal;
+ bool is_internal;
is_internal = pc_arg ? pc_arg->is_internal : false;
case DatabaseRelationId:
Assert(!is_internal);
sepgsql_database_post_create(objectId,
- sepgsql_context_info.createdb_dtemplate);
+ sepgsql_context_info.createdb_dtemplate);
break;
case NamespaceRelationId:
case OAT_POST_ALTER:
{
- ObjectAccessPostAlter *pa_arg = arg;
- bool is_internal = pa_arg->is_internal;
+ ObjectAccessPostAlter *pa_arg = arg;
+ bool is_internal = pa_arg->is_internal;
switch (classId)
{
case RelationRelationId:
if (subId == 0)
- {
+ {
/*
* A case when we don't want to apply permission
* check is that relation is internally altered
- * without user's intention. E.g, no need to
- * check on toast table/index to be renamed at
- * end of the table rewrites.
+ * without user's intention. E.g, no need to check
+ * on toast table/index to be renamed at end of
+ * the table rewrites.
*/
if (is_internal)
- break;
+ break;
sepgsql_relation_setattr(objectId);
- }
- else
- sepgsql_attribute_setattr(objectId, subId);
+ }
+ else
+ sepgsql_attribute_setattr(objectId, subId);
break;
case ProcedureRelationId:
case OAT_NAMESPACE_SEARCH:
{
- ObjectAccessNamespaceSearch *ns_arg = arg;
+ ObjectAccessNamespaceSearch *ns_arg = arg;
/*
- * If stacked extension already decided not to allow users
- * to search this schema, we just stick with that decision.
+ * If stacked extension already decided not to allow users to
+ * search this schema, we just stick with that decision.
*/
if (!ns_arg->result)
break;
*
* Also, db_procedure:entrypoint permission should be checked
* whether this procedure can perform as an entrypoint of the
- * trusted procedure, or not.
- * Note that db_procedure:execute permission shall be checked
- * individually.
+ * trusted procedure, or not. Note that db_procedure:execute
+ * permission shall be checked individually.
*/
if (stack->new_label)
{
void
sepgsql_proc_setattr(Oid functionId)
{
- Relation rel;
- ScanKeyData skey;
- SysScanDesc sscan;
- HeapTuple oldtup;
- HeapTuple newtup;
- Form_pg_proc oldform;
- Form_pg_proc newform;
- uint32 required;
- ObjectAddress object;
- char *audit_name;
+ Relation rel;
+ ScanKeyData skey;
+ SysScanDesc sscan;
+ HeapTuple oldtup;
+ HeapTuple newtup;
+ Form_pg_proc oldform;
+ Form_pg_proc newform;
+ uint32 required;
+ ObjectAddress object;
+ char *audit_name;
/*
* Fetch newer catalog
sepgsql_avc_check_perms(&object,
SEPG_CLASS_DB_PROCEDURE,
- required,
+ required,
audit_name,
true);
/* cleanups */
#include "sepgsql.h"
-static void sepgsql_index_modify(Oid indexOid);
+static void sepgsql_index_modify(Oid indexOid);
/*
* sepgsql_attribute_post_create
void
sepgsql_relation_setattr(Oid relOid)
{
- Relation rel;
- ScanKeyData skey;
- SysScanDesc sscan;
- HeapTuple oldtup;
- HeapTuple newtup;
- Form_pg_class oldform;
- Form_pg_class newform;
+ Relation rel;
+ ScanKeyData skey;
+ SysScanDesc sscan;
+ HeapTuple oldtup;
+ HeapTuple newtup;
+ Form_pg_class oldform;
+ Form_pg_class newform;
ObjectAddress object;
char *audit_name;
uint16_t tclass;
AttrNumber anum_relation_id,
AttrNumber anum_extra_id)
{
- ScanKeyData skey;
- SysScanDesc sscan;
+ ScanKeyData skey;
+ SysScanDesc sscan;
HeapTuple tuple;
Datum datum;
bool isnull;
/*
* sepgsql_index_modify
- * Handle index create, update, drop
+ * Handle index create, update, drop
*
* Unlike other relation kinds, indexes do not have their own security labels,
* so instead of doing checks directly, treat them as extra attributes of their
tcontext,
SEPG_CLASS_DB_SCHEMA,
nsp_name);
+
/*
* check db_schema:{create}
*/
static TrieChar *
placeChar(TrieChar *node, unsigned char *str, int lenstr, char *replaceTo, int replacelen)
{
- TrieChar *curnode;
+ TrieChar *curnode;
if (!node)
{
static TrieChar *
initTrie(char *filename)
{
- TrieChar *volatile rootTrie = NULL;
+ TrieChar *volatile rootTrie = NULL;
MemoryContext ccxt = CurrentMemoryContext;
tsearch_readline_state trst;
volatile bool skip;
if (state >= 3)
rootTrie = placeChar(rootTrie,
- (unsigned char *) src, srclen,
- trg, trglen);
+ (unsigned char *) src, srclen,
+ trg, trglen);
pfree(line);
}
*/
do
{
-#define PARAMS_ARRAY_SIZE 7
+#define PARAMS_ARRAY_SIZE 7
const char *keywords[PARAMS_ARRAY_SIZE];
const char *values[PARAMS_ARRAY_SIZE];
PG_MODULE_MAGIC;
-void _PG_init(void);
+void _PG_init(void);
/* flags set by signal handlers */
static volatile sig_atomic_t got_sighup = false;
static volatile sig_atomic_t got_sigterm = false;
/* GUC variables */
-static int worker_spi_naptime = 10;
-static int worker_spi_total_workers = 2;
+static int worker_spi_naptime = 10;
+static int worker_spi_total_workers = 2;
typedef struct worktable
{
- const char *schema;
- const char *name;
+ const char *schema;
+ const char *name;
} worktable;
/*
* Signal handler for SIGTERM
- * Set a flag to let the main loop to terminate, and set our latch to wake
- * it up.
+ * Set a flag to let the main loop to terminate, and set our latch to wake
+ * it up.
*/
static void
worker_spi_sigterm(SIGNAL_ARGS)
/*
* Signal handler for SIGHUP
- * Set a flag to let the main loop to reread the config file, and set
- * our latch to wake it up.
+ * Set a flag to let the main loop to reread the config file, and set
+ * our latch to wake it up.
*/
static void
worker_spi_sighup(SIGNAL_ARGS)
static void
initialize_worker_spi(worktable *table)
{
- int ret;
- int ntup;
- bool isnull;
- StringInfoData buf;
+ int ret;
+ int ntup;
+ bool isnull;
+ StringInfoData buf;
SetCurrentStatementStartTimestamp();
StartTransactionCommand();
appendStringInfo(&buf,
"CREATE SCHEMA \"%s\" "
"CREATE TABLE \"%s\" ("
- " type text CHECK (type IN ('total', 'delta')), "
+ " type text CHECK (type IN ('total', 'delta')), "
" value integer)"
- "CREATE UNIQUE INDEX \"%s_unique_total\" ON \"%s\" (type) "
+ "CREATE UNIQUE INDEX \"%s_unique_total\" ON \"%s\" (type) "
"WHERE type = 'total'",
- table->schema, table->name, table->name, table->name);
+ table->schema, table->name, table->name, table->name);
/* set statement start time */
SetCurrentStatementStartTimestamp();
static void
worker_spi_main(void *main_arg)
{
- worktable *table = (worktable *) main_arg;
- StringInfoData buf;
+ worktable *table = (worktable *) main_arg;
+ StringInfoData buf;
/* We're now ready to receive signals */
BackgroundWorkerUnblockSignals();
initialize_worker_spi(table);
/*
- * Quote identifiers passed to us. Note that this must be done after
+ * Quote identifiers passed to us. Note that this must be done after
* initialize_worker_spi, because that routine assumes the names are not
* quoted.
*
*/
while (!got_sigterm)
{
- int ret;
- int rc;
+ int ret;
+ int rc;
/*
* Background workers mustn't call usleep() or any direct equivalent:
/*
* In case of a SIGHUP, just reload the configuration.
*/
- if (got_sighup)
- {
- got_sighup = false;
- ProcessConfigFile(PGC_SIGHUP);
- }
+ if (got_sighup)
+ {
+ got_sighup = false;
+ ProcessConfigFile(PGC_SIGHUP);
+ }
/*
* Start a transaction on which we can run queries. Note that each
* StartTransactionCommand() call should be preceded by a
* SetCurrentStatementStartTimestamp() call, which sets both the time
* for the statement we're about the run, and also the transaction
- * start time. Also, each other query sent to SPI should probably be
+ * start time. Also, each other query sent to SPI should probably be
* preceded by SetCurrentStatementStartTimestamp(), so that statement
* start time is always up to date.
*
* The SPI_connect() call lets us run queries through the SPI manager,
- * and the PushActiveSnapshot() call creates an "active" snapshot which
- * is necessary for queries to have MVCC data to work on.
+ * and the PushActiveSnapshot() call creates an "active" snapshot
+ * which is necessary for queries to have MVCC data to work on.
*
- * The pgstat_report_activity() call makes our activity visible through
- * the pgstat views.
+ * The pgstat_report_activity() call makes our activity visible
+ * through the pgstat views.
*/
SetCurrentStatementStartTimestamp();
StartTransactionCommand();
if (SPI_processed > 0)
{
- bool isnull;
- int32 val;
+ bool isnull;
+ int32 val;
val = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[0],
- SPI_tuptable->tupdesc,
- 1, &isnull));
+ SPI_tuptable->tupdesc,
+ 1, &isnull));
if (!isnull)
elog(LOG, "%s: count in %s.%s is now %d",
MyBgworkerEntry->bgw_name,
void
_PG_init(void)
{
- BackgroundWorker worker;
- worktable *table;
- unsigned int i;
- char name[20];
+ BackgroundWorker worker;
+ worktable *table;
+ unsigned int i;
+ char name[20];
/* get the configuration */
DefineCustomIntVariable("worker_spi.naptime",
- "Duration between each check (in seconds).",
- NULL,
- &worker_spi_naptime,
- 10,
- 1,
- INT_MAX,
- PGC_SIGHUP,
- 0,
- NULL,
- NULL,
- NULL);
+ "Duration between each check (in seconds).",
+ NULL,
+ &worker_spi_naptime,
+ 10,
+ 1,
+ INT_MAX,
+ PGC_SIGHUP,
+ 0,
+ NULL,
+ NULL,
+ NULL);
DefineCustomIntVariable("worker_spi.total_workers",
- "Number of workers.",
- NULL,
- &worker_spi_total_workers,
- 2,
- 1,
- 100,
- PGC_POSTMASTER,
- 0,
- NULL,
- NULL,
- NULL);
+ "Number of workers.",
+ NULL,
+ &worker_spi_total_workers,
+ 2,
+ 1,
+ 100,
+ PGC_POSTMASTER,
+ 0,
+ NULL,
+ NULL,
+ NULL);
/* set up common data for all our workers */
worker.bgw_flags = BGWORKER_SHMEM_ACCESS |
ginFindParents(GinBtree btree, GinBtreeStack *stack,
BlockNumber rootBlkno)
{
-
Page page;
Buffer buffer;
BlockNumber blkno,
newtup = gistgetadjusted(indexrel, idxtuple, itup, giststate);
if (newtup)
{
- blkno = gistbufferinginserttuples(buildstate, buffer, level,
- &newtup, 1, childoffnum,
- InvalidBlockNumber, InvalidOffsetNumber);
+ blkno = gistbufferinginserttuples(buildstate, buffer, level,
+ &newtup, 1, childoffnum,
+ InvalidBlockNumber, InvalidOffsetNumber);
/* gistbufferinginserttuples() released the buffer */
}
else
GISTBuildBuffers *gfbb = buildstate->gfbb;
List *splitinfo;
bool is_split;
- BlockNumber placed_to_blk = InvalidBlockNumber;
+ BlockNumber placed_to_blk = InvalidBlockNumber;
is_split = gistplacetopage(buildstate->indexrel,
buildstate->freespace,
item->blkno = ItemPointerGetBlockNumber(&it->t_tid);
/*
- * LSN of current page is lsn of parent page for child. We only
- * have a shared lock, so we need to get the LSN atomically.
+ * LSN of current page is lsn of parent page for child. We
+ * only have a shared lock, so we need to get the LSN
+ * atomically.
*/
item->data.parentlsn = BufferGetLSNAtomic(buffer);
}
* some inserts to go to other equally-good subtrees.
*
* keep_current_best is -1 if we haven't yet had to make a random choice
- * whether to keep the current best tuple. If we have done so, and
+ * whether to keep the current best tuple. If we have done so, and
* decided to keep it, keep_current_best is 1; if we've decided to
* replace, keep_current_best is 0. (This state will be reset to -1 as
* soon as we've made the replacement, but sometimes we make the choice in
if (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
{
/*
- * Temporary relations are only accessible in our session, so a
- * simple backend-local counter will do.
+ * Temporary relations are only accessible in our session, so a simple
+ * backend-local counter will do.
*/
return counter++;
}
* follow-right flag, because that change is not included in the full-page
* image. To be sure that the intermediate state with the wrong flag value is
* not visible to concurrent Hot Standby queries, this function handles
- * restoring the full-page image as well as updating the flag. (Note that
+ * restoring the full-page image as well as updating the flag. (Note that
* we never need to do anything else to the child page in the current WAL
* action.)
*/
/*
* We need to acquire and hold lock on target page while updating the left
- * child page. If we have a full-page image of target page, getting the
+ * child page. If we have a full-page image of target page, getting the
* lock is a side-effect of restoring that image. Note that even if the
* target page no longer exists, we'll still attempt to replay the change
* on the child page.
/*
* If the previous iteration of this loop locked what is still the
- * correct target bucket, we are done. Otherwise, drop any old lock
+ * correct target bucket, we are done. Otherwise, drop any old lock
* and lock what now appears to be the correct bucket.
*/
if (retry)
/*
* If the previous iteration of this loop locked what is still the
- * correct target bucket, we are done. Otherwise, drop any old lock
+ * correct target bucket, we are done. Otherwise, drop any old lock
* and lock what now appears to be the correct bucket.
*/
if (retry)
static const struct
{
LOCKMODE hwlock;
- MultiXactStatus lockstatus;
- MultiXactStatus updstatus;
+ MultiXactStatus lockstatus;
+ MultiXactStatus updstatus;
}
-tupleLockExtraInfo[MaxLockTupleMode + 1] =
+
+ tupleLockExtraInfo[MaxLockTupleMode + 1] =
{
- { /* LockTupleKeyShare */
+ { /* LockTupleKeyShare */
AccessShareLock,
MultiXactStatusForKeyShare,
- -1 /* KeyShare does not allow updating tuples */
+ -1 /* KeyShare does not allow updating tuples */
},
- { /* LockTupleShare */
+ { /* LockTupleShare */
RowShareLock,
MultiXactStatusForShare,
- -1 /* Share does not allow updating tuples */
+ -1 /* Share does not allow updating tuples */
},
- { /* LockTupleNoKeyExclusive */
+ { /* LockTupleNoKeyExclusive */
ExclusiveLock,
MultiXactStatusForNoKeyUpdate,
MultiXactStatusNoKeyUpdate
},
- { /* LockTupleExclusive */
+ { /* LockTupleExclusive */
AccessExclusiveLock,
MultiXactStatusForUpdate,
MultiXactStatusUpdate
}
};
+
/* Get the LOCKMODE for a given MultiXactStatus */
#define LOCKMODE_from_mxstatus(status) \
(tupleLockExtraInfo[TUPLOCK_from_mxstatus((status))].hwlock)
*/
static const int MultiXactStatusLock[MaxMultiXactStatus + 1] =
{
- LockTupleKeyShare, /* ForKeyShare */
- LockTupleShare, /* ForShare */
- LockTupleNoKeyExclusive, /* ForNoKeyUpdate */
- LockTupleExclusive, /* ForUpdate */
- LockTupleNoKeyExclusive, /* NoKeyUpdate */
- LockTupleExclusive /* Update */
+ LockTupleKeyShare, /* ForKeyShare */
+ LockTupleShare, /* ForShare */
+ LockTupleNoKeyExclusive, /* ForNoKeyUpdate */
+ LockTupleExclusive, /* ForUpdate */
+ LockTupleNoKeyExclusive, /* NoKeyUpdate */
+ LockTupleExclusive /* Update */
};
/* Get the LockTupleMode for a given MultiXactStatus */
* page. That's how index-only scans work fine in hot standby. A crucial
* difference between index-only scans and heap scans is that the
* index-only scan completely relies on the visibility map where as heap
- * scan looks at the page-level PD_ALL_VISIBLE flag. We are not sure if the
- * page-level flag can be trusted in the same way, because it might get
- * propagated somehow without being explicitly WAL-logged, e.g. via a full
- * page write. Until we can prove that beyond doubt, let's check each
+ * scan looks at the page-level PD_ALL_VISIBLE flag. We are not sure if
+ * the page-level flag can be trusted in the same way, because it might
+ * get propagated somehow without being explicitly WAL-logged, e.g. via a
+ * full page write. Until we can prove that beyond doubt, let's check each
* tuple for visibility the hard way.
*/
all_visible = PageIsAllVisible(dp) && !snapshot->takenDuringRecovery;
* tuple. Check for XMIN match.
*/
if (TransactionIdIsValid(priorXmax) &&
- !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
+ !TransactionIdEquals(priorXmax, HeapTupleHeaderGetXmin(tp.t_data)))
{
UnlockReleaseBuffer(buffer);
break;
((infomask & HEAP_XMAX_IS_MULTI) != 0 ? XLHL_XMAX_IS_MULTI : 0) |
((infomask & HEAP_XMAX_LOCK_ONLY) != 0 ? XLHL_XMAX_LOCK_ONLY : 0) |
((infomask & HEAP_XMAX_EXCL_LOCK) != 0 ? XLHL_XMAX_EXCL_LOCK : 0) |
- /* note we ignore HEAP_XMAX_SHR_LOCK here */
+ /* note we ignore HEAP_XMAX_SHR_LOCK here */
((infomask & HEAP_XMAX_KEYSHR_LOCK) != 0 ? XLHL_XMAX_KEYSHR_LOCK : 0) |
((infomask2 & HEAP_KEYS_UPDATED) != 0 ?
XLHL_KEYS_UPDATED : 0);
}
/*
- * If this is the first possibly-multixact-able operation in the
- * current transaction, set my per-backend OldestMemberMXactId setting.
- * We can be certain that the transaction will never become a member of
- * any older MultiXactIds than that. (We have to do this even if we
- * end up just using our own TransactionId below, since some other
- * backend could incorporate our XID into a MultiXact immediately
- * afterwards.)
+ * If this is the first possibly-multixact-able operation in the current
+ * transaction, set my per-backend OldestMemberMXactId setting. We can be
+ * certain that the transaction will never become a member of any older
+ * MultiXactIds than that. (We have to do this even if we end up just
+ * using our own TransactionId below, since some other backend could
+ * incorporate our XID into a MultiXact immediately afterwards.)
*/
MultiXactIdSetOldestMember();
result = heap_delete(relation, tid,
GetCurrentCommandId(true), InvalidSnapshot,
- true /* wait for commit */,
+ true /* wait for commit */ ,
&hufd);
switch (result)
{
bool checked_lockers;
bool locker_remains;
TransactionId xmax_new_tuple,
- xmax_old_tuple;
+ xmax_old_tuple;
uint16 infomask_old_tuple,
infomask2_old_tuple,
infomask_new_tuple,
/*
* If we're not updating any "key" column, we can grab a weaker lock type.
- * This allows for more concurrency when we are running simultaneously with
- * foreign key checks.
+ * This allows for more concurrency when we are running simultaneously
+ * with foreign key checks.
*
- * Note that if a column gets detoasted while executing the update, but the
- * value ends up being the same, this test will fail and we will use the
- * stronger lock. This is acceptable; the important case to optimize is
- * updates that don't manipulate key columns, not those that
+ * Note that if a column gets detoasted while executing the update, but
+ * the value ends up being the same, this test will fail and we will use
+ * the stronger lock. This is acceptable; the important case to optimize
+ * is updates that don't manipulate key columns, not those that
* serendipitiously arrive at the same key values.
*/
HeapSatisfiesHOTandKeyUpdate(relation, hot_attrs, key_attrs,
/*
* If this is the first possibly-multixact-able operation in the
- * current transaction, set my per-backend OldestMemberMXactId setting.
- * We can be certain that the transaction will never become a member of
- * any older MultiXactIds than that. (We have to do this even if we
- * end up just using our own TransactionId below, since some other
- * backend could incorporate our XID into a MultiXact immediately
- * afterwards.)
+ * current transaction, set my per-backend OldestMemberMXactId
+ * setting. We can be certain that the transaction will never become a
+ * member of any older MultiXactIds than that. (We have to do this
+ * even if we end up just using our own TransactionId below, since
+ * some other backend could incorporate our XID into a MultiXact
+ * immediately afterwards.)
*/
MultiXactIdSetOldestMember();
}
}
else if (result == HeapTupleBeingUpdated && wait)
{
- TransactionId xwait;
+ TransactionId xwait;
uint16 infomask;
bool can_continue = false;
/*
* XXX note that we don't consider the "no wait" case here. This
* isn't a problem currently because no caller uses that case, but it
- * should be fixed if such a caller is introduced. It wasn't a problem
- * previously because this code would always wait, but now that some
- * tuple locks do not conflict with one of the lock modes we use, it is
- * possible that this case is interesting to handle specially.
+ * should be fixed if such a caller is introduced. It wasn't a
+ * problem previously because this code would always wait, but now
+ * that some tuple locks do not conflict with one of the lock modes we
+ * use, it is possible that this case is interesting to handle
+ * specially.
*
- * This may cause failures with third-party code that calls heap_update
- * directly.
+ * This may cause failures with third-party code that calls
+ * heap_update directly.
*/
/* must copy state data before unlocking buffer */
* gone (or even not sleep at all in some cases); we need to preserve
* it as locker, unless it is gone completely.
*
- * If it's not a multi, we need to check for sleeping conditions before
- * actually going to sleep. If the update doesn't conflict with the
- * locks, we just continue without sleeping (but making sure it is
- * preserved).
+ * If it's not a multi, we need to check for sleeping conditions
+ * before actually going to sleep. If the update doesn't conflict
+ * with the locks, we just continue without sleeping (but making sure
+ * it is preserved).
*/
if (infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId update_xact;
- int remain;
+ TransactionId update_xact;
+ int remain;
/* wait for multixact */
MultiXactIdWait((MultiXactId) xwait, mxact_status, &remain,
goto l2;
/*
- * Note that the multixact may not be done by now. It could have
+ * Note that the multixact may not be done by now. It could have
* surviving members; our own xact or other subxacts of this
* backend, and also any other concurrent transaction that locked
- * the tuple with KeyShare if we only got TupleLockUpdate. If this
- * is the case, we have to be careful to mark the updated tuple
- * with the surviving members in Xmax.
+ * the tuple with KeyShare if we only got TupleLockUpdate. If
+ * this is the case, we have to be careful to mark the updated
+ * tuple with the surviving members in Xmax.
*
- * Note that there could have been another update in the MultiXact.
- * In that case, we need to check whether it committed or aborted.
- * If it aborted we are safe to update it again; otherwise there is
- * an update conflict, and we have to return HeapTupleUpdated
- * below.
+ * Note that there could have been another update in the
+ * MultiXact. In that case, we need to check whether it committed
+ * or aborted. If it aborted we are safe to update it again;
+ * otherwise there is an update conflict, and we have to return
+ * HeapTupleUpdated below.
*
* In the LockTupleExclusive case, we still need to preserve the
* surviving members: those would include the tuple locks we had
else
{
/*
- * If it's just a key-share locker, and we're not changing the
- * key columns, we don't need to wait for it to end; but we
- * need to preserve it as locker.
+ * If it's just a key-share locker, and we're not changing the key
+ * columns, we don't need to wait for it to end; but we need to
+ * preserve it as locker.
*/
if (HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) && key_intact)
{
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
/*
- * recheck the locker; if someone else changed the tuple while we
- * weren't looking, start over.
+ * recheck the locker; if someone else changed the tuple while
+ * we weren't looking, start over.
*/
if ((oldtup.t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
- xwait))
+ !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
+ xwait))
goto l2;
can_continue = true;
LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
/*
- * xwait is done, but if xwait had just locked the tuple then some
- * other xact could update this tuple before we get to this point.
- * Check for xmax change, and start over if so.
+ * xwait is done, but if xwait had just locked the tuple then
+ * some other xact could update this tuple before we get to
+ * this point. Check for xmax change, and start over if so.
*/
if ((oldtup.t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
- xwait))
+ !TransactionIdEquals(HeapTupleHeaderGetRawXmax(oldtup.t_data),
+ xwait))
goto l2;
/* Otherwise check if it committed or aborted */
* visible while we were busy locking the buffer, or during some
* subsequent window during which we had it unlocked, we'll have to unlock
* and re-lock, to avoid holding the buffer lock across an I/O. That's a
- * bit unfortunate, especially since we'll now have to recheck whether
- * the tuple has been locked or updated under us, but hopefully it won't
+ * bit unfortunate, especially since we'll now have to recheck whether the
+ * tuple has been locked or updated under us, but hopefully it won't
* happen very often.
*/
if (vmbuffer == InvalidBuffer && PageIsAllVisible(page))
/*
* Extract the corresponding values. XXX this is pretty inefficient if
- * there are many indexed columns. Should HeapSatisfiesHOTandKeyUpdate do a
- * single heap_deform_tuple call on each tuple, instead? But that doesn't
- * work for system columns ...
+ * there are many indexed columns. Should HeapSatisfiesHOTandKeyUpdate do
+ * a single heap_deform_tuple call on each tuple, instead? But that
+ * doesn't work for system columns ...
*/
value1 = heap_getattr(tup1, attrnum, tupdesc, &isnull1);
value2 = heap_getattr(tup2, attrnum, tupdesc, &isnull2);
bool *satisfies_hot, bool *satisfies_key,
HeapTuple oldtup, HeapTuple newtup)
{
- int next_hot_attnum;
- int next_key_attnum;
- bool hot_result = true;
- bool key_result = true;
- bool key_done = false;
- bool hot_done = false;
+ int next_hot_attnum;
+ int next_key_attnum;
+ bool hot_result = true;
+ bool key_result = true;
+ bool key_done = false;
+ bool hot_done = false;
next_hot_attnum = bms_first_member(hot_attrs);
if (next_hot_attnum == -1)
for (;;)
{
- int check_now;
- bool changed;
+ int check_now;
+ bool changed;
/* both bitmapsets are now empty */
if (key_done && hot_done)
result = heap_update(relation, otid, tup,
GetCurrentCommandId(true), InvalidSnapshot,
- true /* wait for commit */,
+ true /* wait for commit */ ,
&hufd, &lockmode);
switch (result)
{
static MultiXactStatus
get_mxact_status_for_lock(LockTupleMode mode, bool is_update)
{
- MultiXactStatus retval;
+ MultiXactStatus retval;
if (is_update)
retval = tupleLockExtraInfo[mode].updstatus;
uint16 infomask;
uint16 infomask2;
bool require_sleep;
- ItemPointerData t_ctid;
+ ItemPointerData t_ctid;
/* must copy state data before unlocking buffer */
xwait = HeapTupleHeaderGetRawXmax(tuple->t_data);
LockBuffer(*buffer, BUFFER_LOCK_UNLOCK);
/*
- * If any subtransaction of the current top transaction already holds a
- * lock as strong or stronger than what we're requesting, we
+ * If any subtransaction of the current top transaction already holds
+ * a lock as strong or stronger than what we're requesting, we
* effectively hold the desired lock already. We *must* succeed
- * without trying to take the tuple lock, else we will deadlock against
- * anyone wanting to acquire a stronger lock.
+ * without trying to take the tuple lock, else we will deadlock
+ * against anyone wanting to acquire a stronger lock.
*/
if (infomask & HEAP_XMAX_IS_MULTI)
{
- int i;
- int nmembers;
+ int i;
+ int nmembers;
MultiXactMember *members;
/*
- * We don't need to allow old multixacts here; if that had been the
- * case, HeapTupleSatisfiesUpdate would have returned MayBeUpdated
- * and we wouldn't be here.
+ * We don't need to allow old multixacts here; if that had been
+ * the case, HeapTupleSatisfiesUpdate would have returned
+ * MayBeUpdated and we wouldn't be here.
*/
nmembers = GetMultiXactIdMembers(xwait, &members, false);
{
if (TransactionIdIsCurrentTransactionId(members[i].xid))
{
- LockTupleMode membermode;
+ LockTupleMode membermode;
membermode = TUPLOCK_from_mxstatus(members[i].status);
if (!ConditionalLockTupleTuplock(relation, tid, mode))
ereport(ERROR,
(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
- errmsg("could not obtain lock on row in relation \"%s\"",
- RelationGetRelationName(relation))));
+ errmsg("could not obtain lock on row in relation \"%s\"",
+ RelationGetRelationName(relation))));
}
else
LockTupleTuplock(relation, tid, mode);
* continue if the key hasn't been modified.
*
* However, if there are updates, we need to walk the update chain
- * to mark future versions of the row as locked, too. That way, if
- * somebody deletes that future version, we're protected against
- * the key going away. This locking of future versions could block
- * momentarily, if a concurrent transaction is deleting a key; or
- * it could return a value to the effect that the transaction
- * deleting the key has already committed. So we do this before
- * re-locking the buffer; otherwise this would be prone to
- * deadlocks.
+ * to mark future versions of the row as locked, too. That way,
+ * if somebody deletes that future version, we're protected
+ * against the key going away. This locking of future versions
+ * could block momentarily, if a concurrent transaction is
+ * deleting a key; or it could return a value to the effect that
+ * the transaction deleting the key has already committed. So we
+ * do this before re-locking the buffer; otherwise this would be
+ * prone to deadlocks.
*
* Note that the TID we're locking was grabbed before we unlocked
- * the buffer. For it to change while we're not looking, the other
- * properties we're testing for below after re-locking the buffer
- * would also change, in which case we would restart this loop
- * above.
+ * the buffer. For it to change while we're not looking, the
+ * other properties we're testing for below after re-locking the
+ * buffer would also change, in which case we would restart this
+ * loop above.
*/
if (!(infomask2 & HEAP_KEYS_UPDATED))
{
- bool updated;
+ bool updated;
updated = !HEAP_XMAX_IS_LOCKED_ONLY(infomask);
/*
- * If there are updates, follow the update chain; bail out
- * if that cannot be done.
+ * If there are updates, follow the update chain; bail out if
+ * that cannot be done.
*/
if (follow_updates && updated)
{
- HTSU_Result res;
+ HTSU_Result res;
res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
GetCurrentTransactionId(),
/*
* Make sure it's still an appropriate lock, else start over.
* Also, if it wasn't updated before we released the lock, but
- * is updated now, we start over too; the reason is that we now
- * need to follow the update chain to lock the new versions.
+ * is updated now, we start over too; the reason is that we
+ * now need to follow the update chain to lock the new
+ * versions.
*/
if (!HeapTupleHeaderIsOnlyLocked(tuple->t_data) &&
((tuple->t_data->t_infomask2 & HEAP_KEYS_UPDATED) ||
{
/*
* If we're requesting NoKeyExclusive, we might also be able to
- * avoid sleeping; just ensure that there's no other lock type than
- * KeyShare. Note that this is a bit more involved than just
+ * avoid sleeping; just ensure that there's no other lock type
+ * than KeyShare. Note that this is a bit more involved than just
* checking hint bits -- we need to expand the multixact to figure
* out lock modes for each one (unless there was only one such
* locker).
*/
if (infomask & HEAP_XMAX_IS_MULTI)
{
- int nmembers;
+ int nmembers;
MultiXactMember *members;
/*
- * We don't need to allow old multixacts here; if that had been
- * the case, HeapTupleSatisfiesUpdate would have returned
+ * We don't need to allow old multixacts here; if that had
+ * been the case, HeapTupleSatisfiesUpdate would have returned
* MayBeUpdated and we wouldn't be here.
*/
nmembers = GetMultiXactIdMembers(xwait, &members, false);
if (nmembers <= 0)
{
/*
- * No need to keep the previous xmax here. This is unlikely
- * to happen.
+ * No need to keep the previous xmax here. This is
+ * unlikely to happen.
*/
require_sleep = false;
}
else
{
- int i;
- bool allowed = true;
+ int i;
+ bool allowed = true;
for (i = 0; i < nmembers; i++)
{
/* if the xmax changed in the meantime, start over */
if ((tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
- xwait))
+ !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
+ xwait))
goto l3;
/* otherwise, we're good */
require_sleep = false;
if (follow_updates &&
!HEAP_XMAX_IS_LOCKED_ONLY(infomask))
{
- HTSU_Result res;
+ HTSU_Result res;
res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
GetCurrentTransactionId(),
* for xmax change, and start over if so.
*/
if (!(tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
- xwait))
+ !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
+ xwait))
goto l3;
/*
* Of course, the multixact might not be done here: if we're
* requesting a light lock mode, other transactions with light
* locks could still be alive, as well as locks owned by our
- * own xact or other subxacts of this backend. We need to
+ * own xact or other subxacts of this backend. We need to
* preserve the surviving MultiXact members. Note that it
* isn't absolutely necessary in the latter case, but doing so
* is simpler.
if (follow_updates &&
!HEAP_XMAX_IS_LOCKED_ONLY(infomask))
{
- HTSU_Result res;
+ HTSU_Result res;
res = heap_lock_updated_tuple(relation, tuple, &t_ctid,
GetCurrentTransactionId(),
/*
* xwait is done, but if xwait had just locked the tuple then
* some other xact could update this tuple before we get to
- * this point. Check for xmax change, and start over if so.
+ * this point. Check for xmax change, and start over if so.
*/
if ((tuple->t_data->t_infomask & HEAP_XMAX_IS_MULTI) ||
- !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
- xwait))
+ !TransactionIdEquals(HeapTupleHeaderGetRawXmax(tuple->t_data),
+ xwait))
goto l3;
/*
- * Otherwise check if it committed or aborted. Note we cannot
+ * Otherwise check if it committed or aborted. Note we cannot
* be here if the tuple was only locked by somebody who didn't
* conflict with us; that should have been handled above. So
* that transaction must necessarily be gone by now.
* for cases where it is a plain TransactionId.
*
* Note in particular that this covers the case where we already hold
- * exclusive lock on the tuple and the caller only wants key share or share
- * lock. It would certainly not do to give up the exclusive lock.
+ * exclusive lock on the tuple and the caller only wants key share or
+ * share lock. It would certainly not do to give up the exclusive lock.
*/
if (!(old_infomask & (HEAP_XMAX_INVALID |
HEAP_XMAX_COMMITTED |
}
/*
- * If this is the first possibly-multixact-able operation in the
- * current transaction, set my per-backend OldestMemberMXactId setting.
- * We can be certain that the transaction will never become a member of
- * any older MultiXactIds than that. (We have to do this even if we
- * end up just using our own TransactionId below, since some other
- * backend could incorporate our XID into a MultiXact immediately
- * afterwards.)
+ * If this is the first possibly-multixact-able operation in the current
+ * transaction, set my per-backend OldestMemberMXactId setting. We can be
+ * certain that the transaction will never become a member of any older
+ * MultiXactIds than that. (We have to do this even if we end up just
+ * using our own TransactionId below, since some other backend could
+ * incorporate our XID into a MultiXact immediately afterwards.)
*/
MultiXactIdSetOldestMember();
HeapTupleHeaderSetXmax(tuple->t_data, xid);
/*
- * Make sure there is no forward chain link in t_ctid. Note that in the
+ * Make sure there is no forward chain link in t_ctid. Note that in the
* cases where the tuple has been updated, we must not overwrite t_ctid,
* because it was set by the updater. Moreover, if the tuple has been
- * updated, we need to follow the update chain to lock the new versions
- * of the tuple as well.
+ * updated, we need to follow the update chain to lock the new versions of
+ * the tuple as well.
*/
if (HEAP_XMAX_IS_LOCKED_ONLY(new_infomask))
tuple->t_data->t_ctid = *tid;
TransactionId *result_xmax, uint16 *result_infomask,
uint16 *result_infomask2)
{
- TransactionId new_xmax;
- uint16 new_infomask,
- new_infomask2;
+ TransactionId new_xmax;
+ uint16 new_infomask,
+ new_infomask2;
l5:
new_infomask = 0;
}
else if (old_infomask & HEAP_XMAX_IS_MULTI)
{
- MultiXactStatus new_status;
+ MultiXactStatus new_status;
/*
- * Currently we don't allow XMAX_COMMITTED to be set for multis,
- * so cross-check.
+ * Currently we don't allow XMAX_COMMITTED to be set for multis, so
+ * cross-check.
*/
Assert(!(old_infomask & HEAP_XMAX_COMMITTED));
/*
* If the XMAX is already a MultiXactId, then we need to expand it to
- * include add_to_xmax; but if all the members were lockers and are all
- * gone, we can do away with the IS_MULTI bit and just set add_to_xmax
- * as the only locker/updater. If all lockers are gone and we have an
- * updater that aborted, we can also do without a multi.
+ * include add_to_xmax; but if all the members were lockers and are
+ * all gone, we can do away with the IS_MULTI bit and just set
+ * add_to_xmax as the only locker/updater. If all lockers are gone
+ * and we have an updater that aborted, we can also do without a
+ * multi.
*
* The cost of doing GetMultiXactIdMembers would be paid by
* MultiXactIdExpand if we weren't to do this, so this check is not
* It's a committed update, so we need to preserve him as updater of
* the tuple.
*/
- MultiXactStatus status;
- MultiXactStatus new_status;
+ MultiXactStatus status;
+ MultiXactStatus new_status;
if (old_infomask2 & HEAP_KEYS_UPDATED)
status = MultiXactStatusUpdate;
status = MultiXactStatusNoKeyUpdate;
new_status = get_mxact_status_for_lock(mode, is_update);
+
/*
* since it's not running, it's obviously impossible for the old
* updater to be identical to the current one, so we need not check
* create a new MultiXactId that includes both the old locker or
* updater and our own TransactionId.
*/
- MultiXactStatus status;
- MultiXactStatus new_status;
+ MultiXactStatus status;
+ MultiXactStatus new_status;
if (HEAP_XMAX_IS_LOCKED_ONLY(old_infomask))
{
{
/*
* LOCK_ONLY can be present alone only when a page has been
- * upgraded by pg_upgrade. But in that case,
- * TransactionIdIsInProgress() should have returned false. We
+ * upgraded by pg_upgrade. But in that case,
+ * TransactionIdIsInProgress() should have returned false. We
* assume it's no longer locked in this case.
*/
elog(WARNING, "LOCK_ONLY found for Xid in progress %u", xmax);
*/
if (xmax == add_to_xmax)
{
- LockTupleMode old_mode = TUPLOCK_from_mxstatus(status);
- bool old_isupd = ISUPDATE_from_mxstatus(status);
+ LockTupleMode old_mode = TUPLOCK_from_mxstatus(status);
+ bool old_isupd = ISUPDATE_from_mxstatus(status);
/*
* We can do this if the new LockTupleMode is higher or equal than
* It's a committed update, so we gotta preserve him as updater of the
* tuple.
*/
- MultiXactStatus status;
- MultiXactStatus new_status;
+ MultiXactStatus status;
+ MultiXactStatus new_status;
if (old_infomask2 & HEAP_KEYS_UPDATED)
status = MultiXactStatusUpdate;
status = MultiXactStatusNoKeyUpdate;
new_status = get_mxact_status_for_lock(mode, is_update);
+
/*
* since it's not running, it's obviously impossible for the old
* updater to be identical to the current one, so we need not check
heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid,
LockTupleMode mode)
{
- ItemPointerData tupid;
- HeapTupleData mytup;
- Buffer buf;
- uint16 new_infomask,
- new_infomask2,
- old_infomask;
- TransactionId xmax,
- new_xmax;
+ ItemPointerData tupid;
+ HeapTupleData mytup;
+ Buffer buf;
+ uint16 new_infomask,
+ new_infomask2,
+ old_infomask;
+ TransactionId xmax,
+ new_xmax;
ItemPointerCopy(tid, &tupid);
xmax = HeapTupleHeaderGetRawXmax(mytup.t_data);
/*
- * If this tuple is updated and the key has been modified (or deleted),
- * what we do depends on the status of the updating transaction: if
- * it's live, we sleep until it finishes; if it has committed, we have
- * to fail (i.e. return HeapTupleUpdated); if it aborted, we ignore it.
- * For updates that didn't touch the key, we can just plough ahead.
+ * If this tuple is updated and the key has been modified (or
+ * deleted), what we do depends on the status of the updating
+ * transaction: if it's live, we sleep until it finishes; if it has
+ * committed, we have to fail (i.e. return HeapTupleUpdated); if it
+ * aborted, we ignore it. For updates that didn't touch the key, we
+ * can just plough ahead.
*/
if (!(old_infomask & HEAP_XMAX_INVALID) &&
(mytup.t_data->t_infomask2 & HEAP_KEYS_UPDATED))
{
- TransactionId update_xid;
+ TransactionId update_xid;
/*
* Note: we *must* check TransactionIdIsInProgress before
goto l4;
}
else if (TransactionIdDidAbort(update_xid))
- ; /* okay to proceed */
+ ; /* okay to proceed */
else if (TransactionIdDidCommit(update_xid))
{
UnlockReleaseBuffer(buf);
{
xl_heap_lock_updated xlrec;
XLogRecPtr recptr;
- XLogRecData rdata[2];
+ XLogRecData rdata[2];
Page page = BufferGetPage(buf);
xlrec.target.node = rel->rd_node;
/* if we find the end of update chain, we're done. */
if (mytup.t_data->t_infomask & HEAP_XMAX_INVALID ||
- ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) ||
+ ItemPointerEquals(&mytup.t_self, &mytup.t_data->t_ctid) ||
HeapTupleHeaderIsOnlyLocked(mytup.t_data))
{
UnlockReleaseBuffer(buf);
/*
* heap_lock_updated_tuple
- * Follow update chain when locking an updated tuple, acquiring locks (row
- * marks) on the updated versions.
+ * Follow update chain when locking an updated tuple, acquiring locks (row
+ * marks) on the updated versions.
*
* The initial tuple is assumed to be already locked.
*
* This function doesn't check visibility, it just inconditionally marks the
- * tuple(s) as locked. If any tuple in the updated chain is being deleted
+ * tuple(s) as locked. If any tuple in the updated chain is being deleted
* concurrently (or updated with the key being modified), sleep until the
* transaction doing it is finished.
*
{
/*
* If this is the first possibly-multixact-able operation in the
- * current transaction, set my per-backend OldestMemberMXactId setting.
- * We can be certain that the transaction will never become a member of
- * any older MultiXactIds than that. (We have to do this even if we
- * end up just using our own TransactionId below, since some other
- * backend could incorporate our XID into a MultiXact immediately
- * afterwards.)
+ * current transaction, set my per-backend OldestMemberMXactId
+ * setting. We can be certain that the transaction will never become a
+ * member of any older MultiXactIds than that. (We have to do this
+ * even if we end up just using our own TransactionId below, since
+ * some other backend could incorporate our XID into a MultiXact
+ * immediately afterwards.)
*/
MultiXactIdSetOldestMember();
HeapTupleHeaderSetXmax(tuple, InvalidTransactionId);
/*
- * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED
- * + LOCKED. Normalize to INVALID just to be sure no one gets
- * confused. Also get rid of the HEAP_KEYS_UPDATED bit.
+ * The tuple might be marked either XMAX_INVALID or XMAX_COMMITTED +
+ * LOCKED. Normalize to INVALID just to be sure no one gets confused.
+ * Also get rid of the HEAP_KEYS_UPDATED bit.
*/
tuple->t_infomask &= ~HEAP_XMAX_BITS;
tuple->t_infomask |= HEAP_XMAX_INVALID;
GetMultiXactIdHintBits(MultiXactId multi, uint16 *new_infomask,
uint16 *new_infomask2)
{
- int nmembers;
- MultiXactMember *members;
- int i;
- uint16 bits = HEAP_XMAX_IS_MULTI;
- uint16 bits2 = 0;
- bool has_update = false;
- LockTupleMode strongest = LockTupleKeyShare;
+ int nmembers;
+ MultiXactMember *members;
+ int i;
+ uint16 bits = HEAP_XMAX_IS_MULTI;
+ uint16 bits2 = 0;
+ bool has_update = false;
+ LockTupleMode strongest = LockTupleKeyShare;
/*
* We only use this in multis we just created, so they cannot be values
for (i = 0; i < nmembers; i++)
{
- LockTupleMode mode;
+ LockTupleMode mode;
/*
* Remember the strongest lock mode held by any member of the
static TransactionId
MultiXactIdGetUpdateXid(TransactionId xmax, uint16 t_infomask)
{
- TransactionId update_xact = InvalidTransactionId;
- MultiXactMember *members;
- int nmembers;
+ TransactionId update_xact = InvalidTransactionId;
+ MultiXactMember *members;
+ int nmembers;
Assert(!(t_infomask & HEAP_XMAX_LOCK_ONLY));
Assert(t_infomask & HEAP_XMAX_IS_MULTI);
/*
- * Since we know the LOCK_ONLY bit is not set, this cannot be a
- * multi from pre-pg_upgrade.
+ * Since we know the LOCK_ONLY bit is not set, this cannot be a multi from
+ * pre-pg_upgrade.
*/
nmembers = GetMultiXactIdMembers(xmax, &members, false);
if (nmembers > 0)
{
- int i;
+ int i;
for (i = 0; i < nmembers; i++)
{
members[i].status == MultiXactStatusUpdate);
update_xact = members[i].xid;
#ifndef USE_ASSERT_CHECKING
+
/*
* in an assert-enabled build, walk the whole array to ensure
* there's no other updater.
/*
* HeapTupleGetUpdateXid
- * As above, but use a HeapTupleHeader
+ * As above, but use a HeapTupleHeader
*
* See also HeapTupleHeaderGetUpdateXid, which can be used without previously
* checking the hint bits.
/*
* Do_MultiXactIdWait
- * Actual implementation for the two functions below.
+ * Actual implementation for the two functions below.
*
* We do this by sleeping on each member using XactLockTableWait. Any
* members that belong to the current backend are *not* waited for, however;
* heap_tuple_needs_freeze
*
* Check to see whether any of the XID fields of a tuple (xmin, xmax, xvac)
- * are older than the specified cutoff XID or MultiXactId. If so, return TRUE.
+ * are older than the specified cutoff XID or MultiXactId. If so, return TRUE.
*
* It doesn't matter whether the tuple is alive or dead, we are checking
* to see if a tuple needs to be removed or frozen to avoid wraparound.
{
xl_heap_freeze *xlrec = (xl_heap_freeze *) XLogRecGetData(record);
TransactionId cutoff_xid = xlrec->cutoff_xid;
- MultiXactId cutoff_multi = xlrec->cutoff_multi;
+ MultiXactId cutoff_multi = xlrec->cutoff_multi;
Buffer buffer;
Page page;
return;
page = (Page) BufferGetPage(buffer);
- if (lsn <= PageGetLSN(page)) /* changes are applied */
+ if (lsn <= PageGetLSN(page)) /* changes are applied */
{
UnlockReleaseBuffer(buffer);
return;
goto newt;
page = (Page) BufferGetPage(obuffer);
- if (lsn <= PageGetLSN(page)) /* changes are applied */
+ if (lsn <= PageGetLSN(page)) /* changes are applied */
{
if (samepage)
{
return;
page = (Page) BufferGetPage(buffer);
- if (lsn <= PageGetLSN(page)) /* changes are applied */
+ if (lsn <= PageGetLSN(page)) /* changes are applied */
{
UnlockReleaseBuffer(buffer);
return;
heap_xlog_lock_updated(XLogRecPtr lsn, XLogRecord *record)
{
xl_heap_lock_updated *xlrec =
- (xl_heap_lock_updated *) XLogRecGetData(record);
+ (xl_heap_lock_updated *) XLogRecGetData(record);
Buffer buffer;
Page page;
OffsetNumber offnum;
return;
page = (Page) BufferGetPage(buffer);
- if (lsn <= PageGetLSN(page)) /* changes are applied */
+ if (lsn <= PageGetLSN(page)) /* changes are applied */
{
UnlockReleaseBuffer(buffer);
return;
return;
page = (Page) BufferGetPage(buffer);
- if (lsn <= PageGetLSN(page)) /* changes are applied */
+ if (lsn <= PageGetLSN(page)) /* changes are applied */
{
UnlockReleaseBuffer(buffer);
return;
* determine tuple visibility */
TransactionId rs_freeze_xid;/* Xid that will be used as freeze cutoff
* point */
- MultiXactId rs_freeze_multi;/* MultiXactId that will be used as freeze
+ MultiXactId rs_freeze_multi;/* MultiXactId that will be used as freeze
* cutoff point for multixacts */
MemoryContext rs_cxt; /* for hash tables and entries and tuples in
* them */
*/
if (DataChecksumsEnabled())
{
- Page heapPage = BufferGetPage(heapBuf);
+ Page heapPage = BufferGetPage(heapBuf);
/* caller is expected to set PD_ALL_VISIBLE first */
Assert(PageIsAllVisible(heapPage));
START_CRIT_SECTION();
/*
- * We don't do MarkBufferDirty here because we're about to initialise
- * the page, and nobody else can see it yet.
+ * We don't do MarkBufferDirty here because we're about to initialise the
+ * page, and nobody else can see it yet.
*/
/* XLOG stuff */
XLogInsert(RM_BTREE_ID, XLOG_BTREE_REUSE_PAGE, rdata);
/*
- * We don't do PageSetLSN here because we're about to initialise
- * the page, so no need.
+ * We don't do PageSetLSN here because we're about to initialise the
+ * page, so no need.
*/
}
* Note that this code ensures that the items remaining on the
* left page are in the correct item number order, but it does not
* reproduce the physical order they would have had. Is this
- * worth changing? See also _bt_restore_page().
+ * worth changing? See also _bt_restore_page().
*/
Page lpage = (Page) BufferGetPage(lbuf);
BTPageOpaque lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
/*
* In what follows, we have to examine the previous state of the index
- * page, as well as the heap page(s) it points to. This is only valid if
+ * page, as well as the heap page(s) it points to. This is only valid if
* WAL replay has reached a consistent database state; which means that
- * the preceding check is not just an optimization, but is *necessary*.
- * We won't have let in any user sessions before we reach consistency.
+ * the preceding check is not just an optimization, but is *necessary*. We
+ * won't have let in any user sessions before we reach consistency.
*/
if (!reachedConsistency)
elog(PANIC, "btree_xlog_delete_get_latestRemovedXid: cannot operate with inconsistent data");
/*
- * Get index page. If the DB is consistent, this should not fail, nor
+ * Get index page. If the DB is consistent, this should not fail, nor
* should any of the heap page fetches below. If one does, we return
- * InvalidTransactionId to cancel all HS transactions. That's probably
+ * InvalidTransactionId to cancel all HS transactions. That's probably
* overkill, but it's safe, and certainly better than panicking here.
*/
ibuffer = XLogReadBuffer(xlrec->node, xlrec->block, false);
/*
* XXX If all heap tuples were LP_DEAD then we will be returning
- * InvalidTransactionId here, causing conflict for all HS
- * transactions. That should happen very rarely (reasoning please?). Also
- * note that caller can't tell the difference between this case and the
- * fast path exit above. May need to change that in future.
+ * InvalidTransactionId here, causing conflict for all HS transactions.
+ * That should happen very rarely (reasoning please?). Also note that
+ * caller can't tell the difference between this case and the fast path
+ * exit above. May need to change that in future.
*/
return latestRemovedXid;
}
* If we have any conflict processing to do, it must happen before we
* update the page.
*
- * Btree delete records can conflict with standby queries. You might
+ * Btree delete records can conflict with standby queries. You might
* think that vacuum records would conflict as well, but we've handled
* that already. XLOG_HEAP2_CLEANUP_INFO records provide the highest xid
* cleaned by the vacuum of the heap and so we can resolve any conflicts
/*-------------------------------------------------------------------------
*
* clogdesc.c
- * rmgr descriptor routines for access/transam/clog.c
+ * rmgr descriptor routines for access/transam/clog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/clogdesc.c
+ * src/backend/access/rmgrdesc/clogdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* dbasedesc.c
- * rmgr descriptor routines for commands/dbcommands.c
+ * rmgr descriptor routines for commands/dbcommands.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/dbasedesc.c
+ * src/backend/access/rmgrdesc/dbasedesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* gindesc.c
- * rmgr descriptor routines for access/transam/gin/ginxlog.c
+ * rmgr descriptor routines for access/transam/gin/ginxlog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/gindesc.c
+ * src/backend/access/rmgrdesc/gindesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* gistdesc.c
- * rmgr descriptor routines for access/gist/gistxlog.c
+ * rmgr descriptor routines for access/gist/gistxlog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/gistdesc.c
+ * src/backend/access/rmgrdesc/gistdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* hashdesc.c
- * rmgr descriptor routines for access/hash/hash.c
+ * rmgr descriptor routines for access/hash/hash.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/hashdesc.c
+ * src/backend/access/rmgrdesc/hashdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* heapdesc.c
- * rmgr descriptor routines for access/heap/heapam.c
+ * rmgr descriptor routines for access/heap/heapam.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/heapdesc.c
+ * src/backend/access/rmgrdesc/heapdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* mxactdesc.c
- * rmgr descriptor routines for access/transam/multixact.c
+ * rmgr descriptor routines for access/transam/multixact.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/mxactdesc.c
+ * src/backend/access/rmgrdesc/mxactdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* nbtdesc.c
- * rmgr descriptor routines for access/nbtree/nbtxlog.c
+ * rmgr descriptor routines for access/nbtree/nbtxlog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/nbtdesc.c
+ * src/backend/access/rmgrdesc/nbtdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* relmapdesc.c
- * rmgr descriptor routines for utils/cache/relmapper.c
+ * rmgr descriptor routines for utils/cache/relmapper.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/relmapdesc.c
+ * src/backend/access/rmgrdesc/relmapdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* seqdesc.c
- * rmgr descriptor routines for commands/sequence.c
+ * rmgr descriptor routines for commands/sequence.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/seqdesc.c
+ * src/backend/access/rmgrdesc/seqdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* smgrdesc.c
- * rmgr descriptor routines for catalog/storage.c
+ * rmgr descriptor routines for catalog/storage.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/smgrdesc.c
+ * src/backend/access/rmgrdesc/smgrdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* spgdesc.c
- * rmgr descriptor routines for access/spgist/spgxlog.c
+ * rmgr descriptor routines for access/spgist/spgxlog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/spgdesc.c
+ * src/backend/access/rmgrdesc/spgdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* standbydesc.c
- * rmgr descriptor routines for storage/ipc/standby.c
+ * rmgr descriptor routines for storage/ipc/standby.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/standbydesc.c
+ * src/backend/access/rmgrdesc/standbydesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* tblspcdesc.c
- * rmgr descriptor routines for commands/tablespace.c
+ * rmgr descriptor routines for commands/tablespace.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/tblspcdesc.c
+ * src/backend/access/rmgrdesc/tblspcdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* xactdesc.c
- * rmgr descriptor routines for access/transam/xact.c
+ * rmgr descriptor routines for access/transam/xact.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/xactdesc.c
+ * src/backend/access/rmgrdesc/xactdesc.c
*
*-------------------------------------------------------------------------
*/
/*-------------------------------------------------------------------------
*
* xlogdesc.c
- * rmgr descriptor routines for access/transam/xlog.c
+ * rmgr descriptor routines for access/transam/xlog.c
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * src/backend/access/rmgrdesc/xlogdesc.c
+ * src/backend/access/rmgrdesc/xlogdesc.c
*
*-------------------------------------------------------------------------
*/
"tli %u; prev tli %u; fpw %s; xid %u/%u; oid %u; multi %u; offset %u; "
"oldest xid %u in DB %u; oldest multi %u in DB %u; "
"oldest running xid %u; %s",
- (uint32) (checkpoint->redo >> 32), (uint32) checkpoint->redo,
+ (uint32) (checkpoint->redo >> 32), (uint32) checkpoint->redo,
checkpoint->ThisTimeLineID,
checkpoint->PrevTimeLineID,
checkpoint->fullPageWrites ? "true" : "false",
}
else if (info == XLOG_HINT)
{
- BkpBlock *bkp = (BkpBlock *) rec;
+ BkpBlock *bkp = (BkpBlock *) rec;
+
appendStringInfo(buf, "page hint: %s block %u",
relpathperm(bkp->node, bkp->fork),
bkp->block);
* imposed by page headers, tuple headers, etc, we leave 100 bytes for that
* (the actual overhead should be no more than 56 bytes at this writing, so
* there is slop in this number). So we can safely create prefixes up to
- * BLCKSZ - 256 * 16 - 100 bytes long. Unfortunately, because 256 * 16 is
+ * BLCKSZ - 256 * 16 - 100 bytes long. Unfortunately, because 256 * 16 is
* already 4K, there is no safe prefix length when BLCKSZ is less than 8K;
* it is always possible to get "SPGiST inner tuple size exceeds maximum"
* if there are too many distinct next-byte values at a given place in the
*
* The pg_multixact manager is a pg_clog-like manager that stores an array of
* MultiXactMember for each MultiXactId. It is a fundamental part of the
- * shared-row-lock implementation. Each MultiXactMember is comprised of a
+ * shared-row-lock implementation. Each MultiXactMember is comprised of a
* TransactionId and a set of flag bits. The name is a bit historical:
* originally, a MultiXactId consisted of more than one TransactionId (except
* in rare corner cases), hence "multi". Nowadays, however, it's perfectly
* The minimum value in each database is stored in pg_database, and the
* global minimum is part of pg_control. Any vacuum that is able to
* advance its database's minimum value also computes a new global minimum,
- * and uses this value to truncate older segments. When new multixactid
+ * and uses this value to truncate older segments. When new multixactid
* values are to be created, care is taken that the counter does not
* fall within the wraparound horizon considering the global minimum value.
*
* additional flag bits for each TransactionId. To do this without getting
* into alignment issues, we store four bytes of flags, and then the
* corresponding 4 Xids. Each such 5-word (20-byte) set we call a "group", and
- * are stored as a whole in pages. Thus, with 8kB BLCKSZ, we keep 409 groups
+ * are stored as a whole in pages. Thus, with 8kB BLCKSZ, we keep 409 groups
* per page. This wastes 12 bytes per page, but that's OK -- simplicity (and
* performance) trumps space efficiency here.
*
MultiXactId lastTruncationPoint;
/*
- * oldest multixact that is still on disk. Anything older than this should
- * not be consulted.
+ * oldest multixact that is still on disk. Anything older than this
+ * should not be consulted.
*/
- MultiXactId oldestMultiXactId;
- Oid oldestMultiXactDB;
+ MultiXactId oldestMultiXactId;
+ Oid oldestMultiXactDB;
/* support for anti-wraparound measures */
- MultiXactId multiVacLimit;
- MultiXactId multiWarnLimit;
- MultiXactId multiStopLimit;
- MultiXactId multiWrapLimit;
+ MultiXactId multiVacLimit;
+ MultiXactId multiWarnLimit;
+ MultiXactId multiStopLimit;
+ MultiXactId multiWrapLimit;
/*
* Per-backend data starts here. We have two arrays stored in the area
* so they will be uninteresting by the time our next transaction starts.
* (XXX not clear that this is correct --- other members of the MultiXact
* could hang around longer than we did. However, it's not clear what a
- * better policy for flushing old cache entries would be.) FIXME actually
+ * better policy for flushing old cache entries would be.) FIXME actually
* this is plain wrong now that multixact's may contain update Xids.
*
* We allocate the cache entries in a memory context that is deleted at
static MultiXactId GetNewMultiXactId(int nmembers, MultiXactOffset *offset);
/* MultiXact cache management */
-static int mxactMemberComparator(const void *arg1, const void *arg2);
+static int mxactMemberComparator(const void *arg1, const void *arg2);
static MultiXactId mXactCacheGetBySet(int nmembers, MultiXactMember *members);
static int mXactCacheGetById(MultiXactId multi, MultiXactMember **members);
static void mXactCachePut(MultiXactId multi, int nmembers,
multi, xid, mxstatus_to_string(status));
/*
- * Note: we don't allow for old multis here. The reason is that the
- * only caller of this function does a check that the multixact is
- * no longer running.
+ * Note: we don't allow for old multis here. The reason is that the only
+ * caller of this function does a check that the multixact is no longer
+ * running.
*/
nmembers = GetMultiXactIdMembers(multi, &members, false);
if (nmembers < 0)
{
- MultiXactMember member;
+ MultiXactMember member;
/*
* The MultiXactId is obsolete. This can only happen if all the
}
/*
- * Determine which of the members of the MultiXactId are still of interest.
- * This is any running transaction, and also any transaction that grabbed
- * something stronger than just a lock and was committed. (An update that
- * aborted is of no interest here.)
+ * Determine which of the members of the MultiXactId are still of
+ * interest. This is any running transaction, and also any transaction
+ * that grabbed something stronger than just a lock and was committed.
+ * (An update that aborted is of no interest here.)
*
- * (Removing dead members is just an optimization, but a useful one.
- * Note we have the same race condition here as above: j could be 0 at the
- * end of the loop.)
+ * (Removing dead members is just an optimization, but a useful one. Note
+ * we have the same race condition here as above: j could be 0 at the end
+ * of the loop.)
*/
newMembers = (MultiXactMember *)
palloc(sizeof(MultiXactMember) * (nmembers + 1));
/*
* ReadNextMultiXactId
- * Return the next MultiXactId to be assigned, but don't allocate it
+ * Return the next MultiXactId to be assigned, but don't allocate it
*/
MultiXactId
ReadNextMultiXactId(void)
{
- MultiXactId mxid;
+ MultiXactId mxid;
/* XXX we could presumably do this without a lock. */
LWLockAcquire(MultiXactGenLock, LW_SHARED);
/*
* XXX Note: there's a lot of padding space in MultiXactMember. We could
- * find a more compact representation of this Xlog record -- perhaps all the
- * status flags in one XLogRecData, then all the xids in another one? Not
- * clear that it's worth the trouble though.
+ * find a more compact representation of this Xlog record -- perhaps all
+ * the status flags in one XLogRecData, then all the xids in another one?
+ * Not clear that it's worth the trouble though.
*/
rdata[0].data = (char *) (&xlrec);
rdata[0].len = SizeOfMultiXactCreate;
/*----------
* Check to see if it's safe to assign another MultiXactId. This protects
- * against catastrophic data loss due to multixact wraparound. The basic
+ * against catastrophic data loss due to multixact wraparound. The basic
* rules are:
*
* If we're past multiVacLimit, start trying to force autovacuum cycles.
{
/*
* For safety's sake, we release MultiXactGenLock while sending
- * signals, warnings, etc. This is not so much because we care about
+ * signals, warnings, etc. This is not so much because we care about
* preserving concurrency in this situation, as to avoid any
* possibility of deadlock while doing get_database_name(). First,
* copy all the shared values we'll need in this path.
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database \"%s\"",
oldest_datname),
- errhint("Execute a database-wide VACUUM in that database.\n"
- "You might also need to commit or roll back old prepared transactions.")));
+ errhint("Execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions.")));
else
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
errmsg("database is not accepting commands that generate new MultiXactIds to avoid wraparound data loss in database with OID %u",
oldest_datoid),
- errhint("Execute a database-wide VACUUM in that database.\n"
- "You might also need to commit or roll back old prepared transactions.")));
+ errhint("Execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions.")));
}
else if (!MultiXactIdPrecedes(result, multiWarnLimit))
{
(errmsg("database \"%s\" must be vacuumed before %u more MultiXactIds are used",
oldest_datname,
multiWrapLimit - result),
- errhint("Execute a database-wide VACUUM in that database.\n"
- "You might also need to commit or roll back old prepared transactions.")));
+ errhint("Execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions.")));
else
ereport(WARNING,
(errmsg("database with OID %u must be vacuumed before %u more MultiXactIds are used",
oldest_datoid,
multiWrapLimit - result),
- errhint("Execute a database-wide VACUUM in that database.\n"
- "You might also need to commit or roll back old prepared transactions.")));
+ errhint("Execute a database-wide VACUUM in that database.\n"
+ "You might also need to commit or roll back old prepared transactions.")));
}
/* Re-acquire lock and start over */
*
* We don't care about MultiXactId wraparound here; it will be handled by
* the next iteration. But note that nextMXact may be InvalidMultiXactId
- * or the first value on a segment-beginning page after this routine exits,
- * so anyone else looking at the variable must be prepared to deal with
- * either case. Similarly, nextOffset may be zero, but we won't use that
- * as the actual start offset of the next multixact.
+ * or the first value on a segment-beginning page after this routine
+ * exits, so anyone else looking at the variable must be prepared to deal
+ * with either case. Similarly, nextOffset may be zero, but we won't use
+ * that as the actual start offset of the next multixact.
*/
(MultiXactState->nextMXact)++;
*
* An ID older than MultiXactState->oldestMultiXactId cannot possibly be
* useful; it should have already been frozen by vacuum. We've truncated
- * the on-disk structures anyway. Returning the wrong values could lead to
- * an incorrect visibility result. However, to support pg_upgrade we need
- * to allow an empty set to be returned regardless, if the caller is
+ * the on-disk structures anyway. Returning the wrong values could lead
+ * to an incorrect visibility result. However, to support pg_upgrade we
+ * need to allow an empty set to be returned regardless, if the caller is
* willing to accept it; the caller is expected to check that it's an
* allowed condition (such as ensuring that the infomask bits set on the
- * tuple are consistent with the pg_upgrade scenario). If the caller is
+ * tuple are consistent with the pg_upgrade scenario). If the caller is
* expecting this to be called only on recently created multis, then we
* raise an error.
*
* Conversely, an ID >= nextMXact shouldn't ever be seen here; if it is
- * seen, it implies undetected ID wraparound has occurred. This raises
- * a hard error.
+ * seen, it implies undetected ID wraparound has occurred. This raises a
+ * hard error.
*
* Shared lock is enough here since we aren't modifying any global state.
* Acquire it just long enough to grab the current counter values. We may
{
ereport(allow_old ? DEBUG1 : ERROR,
(errcode(ERRCODE_INTERNAL_ERROR),
- errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
- multi)));
+ errmsg("MultiXactId %u does no longer exist -- apparent wraparound",
+ multi)));
return -1;
}
memcpy(ptr, entry->members, size);
debug_elog3(DEBUG2, "CacheGet: found %s",
- mxid_to_string(multi, entry->nmembers, entry->members));
+ mxid_to_string(multi, entry->nmembers, entry->members));
return entry->nmembers;
}
}
char *
mxid_to_string(MultiXactId multi, int nmembers, MultiXactMember *members)
{
- static char *str = NULL;
- StringInfoData buf;
+ static char *str = NULL;
+ StringInfoData buf;
int i;
if (str != NULL)
*
* StartupXLOG has already established nextMXact/nextOffset by calling
* MultiXactSetNextMXact and/or MultiXactAdvanceNextMXact, and the oldestMulti
- * info from pg_control and/or MultiXactAdvanceOldest. Note that we may
+ * info from pg_control and/or MultiXactAdvanceOldest. Note that we may
* already have replayed WAL data into the SLRU files.
*
* We don't need any locks here, really; the SLRU locks are taken
void
SetMultiXactIdLimit(MultiXactId oldest_datminmxid, Oid oldest_datoid)
{
- MultiXactId multiVacLimit;
- MultiXactId multiWarnLimit;
- MultiXactId multiStopLimit;
- MultiXactId multiWrapLimit;
- MultiXactId curMulti;
+ MultiXactId multiVacLimit;
+ MultiXactId multiWarnLimit;
+ MultiXactId multiStopLimit;
+ MultiXactId multiWrapLimit;
+ MultiXactId curMulti;
Assert(MultiXactIdIsValid(oldest_datminmxid));
/*
* The place where we actually get into deep trouble is halfway around
- * from the oldest potentially-existing XID/multi. (This calculation is
+ * from the oldest potentially-existing XID/multi. (This calculation is
* probably off by one or two counts for Xids, because the special XIDs
* reduce the size of the loop a little bit. But we throw in plenty of
* slop below, so it doesn't matter.)
multiStopLimit -= FirstMultiXactId;
/*
- * We'll start complaining loudly when we get within 10M multis of the stop
- * point. This is kind of arbitrary, but if you let your gas gauge get
- * down to 1% of full, would you be looking for the next gas station? We
- * need to be fairly liberal about this number because there are lots of
- * scenarios where most transactions are done by automatic clients that
+ * We'll start complaining loudly when we get within 10M multis of the
+ * stop point. This is kind of arbitrary, but if you let your gas gauge
+ * get down to 1% of full, would you be looking for the next gas station?
+ * We need to be fairly liberal about this number because there are lots
+ * of scenarios where most transactions are done by automatic clients that
* won't pay attention to warnings. (No, we're not gonna make this
* configurable. If you know enough to configure it, you know enough to
* not get in this kind of trouble in the first place.)
multiWarnLimit -= FirstMultiXactId;
/*
- * We'll start trying to force autovacuums when oldest_datminmxid gets
- * to be more than 200 million transactions old.
+ * We'll start trying to force autovacuums when oldest_datminmxid gets to
+ * be more than 200 million transactions old.
*/
multiVacLimit = oldest_datminmxid + 200000000;
if (multiVacLimit < FirstMultiXactId)
/* Log the info */
ereport(DEBUG1,
- (errmsg("MultiXactId wrap limit is %u, limited by database with OID %u",
- multiWrapLimit, oldest_datoid)));
+ (errmsg("MultiXactId wrap limit is %u, limited by database with OID %u",
+ multiWrapLimit, oldest_datoid)));
/*
* If past the autovacuum force point, immediately signal an autovac
MultiXactId
GetOldestMultiXactId(void)
{
- MultiXactId oldestMXact;
- MultiXactId nextMXact;
- int i;
+ MultiXactId oldestMXact;
+ MultiXactId nextMXact;
+ int i;
/*
* This is the oldest valid value among all the OldestMemberMXactId[] and
typedef struct mxtruncinfo
{
- int earliestExistingPage;
+ int earliestExistingPage;
} mxtruncinfo;
/*
* SlruScanDirectory callback
- * This callback determines the earliest existing page number.
+ * This callback determines the earliest existing page number.
*/
static bool
SlruScanDirCbFindEarliest(SlruCtl ctl, char *filename, int segpage, void *data)
{
- mxtruncinfo *trunc = (mxtruncinfo *) data;
+ mxtruncinfo *trunc = (mxtruncinfo *) data;
if (trunc->earliestExistingPage == -1 ||
ctl->PagePrecedes(segpage, trunc->earliestExistingPage))
trunc->earliestExistingPage = segpage;
}
- return false; /* keep going */
+ return false; /* keep going */
}
/*
void
TruncateMultiXact(MultiXactId oldestMXact)
{
- MultiXactOffset oldestOffset;
- mxtruncinfo trunc;
- MultiXactId earliest;
+ MultiXactOffset oldestOffset;
+ mxtruncinfo trunc;
+ MultiXactId earliest;
/*
* Note we can't just plow ahead with the truncation; it's possible that
* there are no segments to truncate, which is a problem because we are
- * going to attempt to read the offsets page to determine where to truncate
- * the members SLRU. So we first scan the directory to determine the
- * earliest offsets page number that we can read without error.
+ * going to attempt to read the offsets page to determine where to
+ * truncate the members SLRU. So we first scan the directory to determine
+ * the earliest offsets page number that we can read without error.
*/
trunc.earliestExistingPage = -1;
SlruScanDirectory(MultiXactOffsetCtl, SlruScanDirCbFindEarliest, &trunc);
return;
/*
- * First, compute the safe truncation point for MultiXactMember.
- * This is the starting offset of the multixact we were passed
- * as MultiXactOffset cutoff.
+ * First, compute the safe truncation point for MultiXactMember. This is
+ * the starting offset of the multixact we were passed as MultiXactOffset
+ * cutoff.
*/
{
int pageno;
else if (info == XLOG_MULTIXACT_CREATE_ID)
{
xl_multixact_create *xlrec =
- (xl_multixact_create *) XLogRecGetData(record);
+ (xl_multixact_create *) XLogRecGetData(record);
TransactionId max_xid;
int i;
{
typedef struct
{
- MultiXactMember *members;
- int nmembers;
- int iter;
+ MultiXactMember *members;
+ int nmembers;
+ int iter;
} mxact;
- MultiXactId mxid = PG_GETARG_UINT32(0);
- mxact *multi;
+ MultiXactId mxid = PG_GETARG_UINT32(0);
+ mxact *multi;
FuncCallContext *funccxt;
if (mxid < FirstMultiXactId)
*
* parentTLI ID of the parent timeline
- * switchpoint XLogRecPtr of the WAL position where the switch happened
+ * switchpoint XLogRecPtr of the WAL position where the switch happened
* reason human-readable explanation of why the timeline was changed
*
* The fields are separated by tabs. Lines beginning with # are comments, and
{
char path[MAXPGPATH];
char histfname[MAXFNAMELEN];
- TimeLineID tli;
+ TimeLineID tli;
for (tli = begin; tli < end; tli++)
{
errhint("Timeline IDs must be less than child timeline's ID.")));
/*
- * Create one more entry for the "tip" of the timeline, which has no
- * entry in the history file.
+ * Create one more entry for the "tip" of the timeline, which has no entry
+ * in the history file.
*/
entry = (TimeLineHistoryEntry *) palloc(sizeof(TimeLineHistoryEntry));
entry->tli = targetTLI;
/*
* Prefer link() to rename() here just to be really sure that we don't
- * overwrite an existing file. However, there shouldn't be one, so
+ * overwrite an existing file. However, there shouldn't be one, so
* rename() is an acceptable substitute except for the truly paranoid.
*/
#if HAVE_WORKING_LINK
bool
tliInHistory(TimeLineID tli, List *expectedTLEs)
{
- ListCell *cell;
+ ListCell *cell;
foreach(cell, expectedTLEs)
{
TimeLineID
tliOfPointInHistory(XLogRecPtr ptr, List *history)
{
- ListCell *cell;
+ ListCell *cell;
foreach(cell, history)
{
TimeLineHistoryEntry *tle = (TimeLineHistoryEntry *) lfirst(cell);
+
if ((XLogRecPtrIsInvalid(tle->begin) || tle->begin <= ptr) &&
(XLogRecPtrIsInvalid(tle->end) || ptr < tle->end))
{
/* shouldn't happen. */
elog(ERROR, "timeline history was not contiguous");
- return 0; /* keep compiler quiet */
+ return 0; /* keep compiler quiet */
}
/*
if (nextTLI)
*nextTLI = 0;
- foreach (cell, history)
+ foreach(cell, history)
{
TimeLineHistoryEntry *tle = (TimeLineHistoryEntry *) lfirst(cell);
ereport(ERROR,
(errmsg("requested timeline %u is not in this server's history",
tli)));
- return InvalidXLogRecPtr; /* keep compiler quiet */
+ return InvalidXLogRecPtr; /* keep compiler quiet */
}
*
* It's safe to change the delayChkpt flag of our own backend without
* holding the ProcArrayLock, since we're the only one modifying it.
- * This makes checkpoint's determination of which xacts are delayChkpt a
- * bit fuzzy, but it doesn't matter.
+ * This makes checkpoint's determination of which xacts are delayChkpt
+ * a bit fuzzy, but it doesn't matter.
*/
START_CRIT_SECTION();
MyPgXact->delayChkpt = true;
* from the template database, and then commit the transaction. If we
* crash after all the files have been copied but before the commit, you
* have files in the data directory without an entry in pg_database. To
- * minimize the window
- * for that, we use ForceSyncCommit() to rush the commit record to disk as
- * quick as possible. We have the same window during recovery, and forcing
- * an XLogFlush() (which updates minRecoveryPoint during recovery) helps
- * to reduce that problem window, for any user that requested
- * ForceSyncCommit().
+ * minimize the window for that, we use ForceSyncCommit() to rush the
+ * commit record to disk as quick as possible. We have the same window
+ * during recovery, and forcing an XLogFlush() (which updates
+ * minRecoveryPoint during recovery) helps to reduce that problem window,
+ * for any user that requested ForceSyncCommit().
*/
if (XactCompletionForceSyncCommit(xinfo))
XLogFlush(lsn);
* will switch to using offline XLOG archives as soon as we reach the end of
* WAL in pg_xlog.
*/
-bool ArchiveRecoveryRequested = false;
-bool InArchiveRecovery = false;
+bool ArchiveRecoveryRequested = false;
+bool InArchiveRecovery = false;
/* Was the last xlog file restored from archive, or local? */
static bool restoredFromArchive = false;
/* options taken from recovery.conf for archive recovery */
-char *recoveryRestoreCommand = NULL;
+char *recoveryRestoreCommand = NULL;
static char *recoveryEndCommand = NULL;
static char *archiveCleanupCommand = NULL;
static RecoveryTargetType recoveryTarget = RECOVERY_TARGET_UNSET;
static char *TriggerFile = NULL;
/* are we currently in standby mode? */
-bool StandbyMode = false;
+bool StandbyMode = false;
/* whether request for fast promotion has been made yet */
static bool fast_promote = false;
uint32 ckptXidEpoch; /* nextXID & epoch of latest checkpoint */
TransactionId ckptXid;
XLogRecPtr asyncXactLSN; /* LSN of newest async commit/abort */
- XLogSegNo lastRemovedSegNo; /* latest removed/recycled XLOG segment */
+ XLogSegNo lastRemovedSegNo; /* latest removed/recycled XLOG
+ * segment */
/* Fake LSN counter, for unlogged relations. Protected by ulsn_lck */
- XLogRecPtr unloggedLSN;
+ XLogRecPtr unloggedLSN;
slock_t ulsn_lck;
/* Protected by WALWriteLock: */
*/
typedef enum
{
- XLOG_FROM_ANY = 0, /* request to read WAL from any source */
- XLOG_FROM_ARCHIVE, /* restored using restore_command */
- XLOG_FROM_PG_XLOG, /* existing file in pg_xlog */
- XLOG_FROM_STREAM, /* streamed from master */
+ XLOG_FROM_ANY = 0, /* request to read WAL from any source */
+ XLOG_FROM_ARCHIVE, /* restored using restore_command */
+ XLOG_FROM_PG_XLOG, /* existing file in pg_xlog */
+ XLOG_FROM_STREAM, /* streamed from master */
} XLogSource;
/* human-readable names for XLogSources, for debugging output */
-static const char *xlogSourceNames[] = { "any", "archive", "pg_xlog", "stream" };
+static const char *xlogSourceNames[] = {"any", "archive", "pg_xlog", "stream"};
/*
* openLogFile is -1 or a kernel FD for an open log file segment.
* next.
*/
static XLogSource currentSource = 0; /* XLOG_FROM_* code */
-static bool lastSourceFailed = false;
+static bool lastSourceFailed = false;
typedef struct XLogPageReadPrivate
{
* XLogReceiptSource tracks where we last successfully read some WAL.)
*/
static TimestampTz XLogReceiptTime = 0;
-static XLogSource XLogReceiptSource = 0; /* XLOG_FROM_* code */
+static XLogSource XLogReceiptSource = 0; /* XLOG_FROM_* code */
/* State information for XLOG reading */
static XLogRecPtr ReadRecPtr; /* start of last record read */
static bool XLogCheckBuffer(XLogRecData *rdata, bool holdsExclusiveLock,
XLogRecPtr *lsn, BkpBlock *bkpb);
static Buffer RestoreBackupBlockContents(XLogRecPtr lsn, BkpBlock bkpb,
- char *blk, bool get_cleanup_lock, bool keep_buffer);
+ char *blk, bool get_cleanup_lock, bool keep_buffer);
static bool AdvanceXLInsertBuffer(bool new_segment);
static bool XLogCheckpointNeeded(XLogSegNo new_segno);
static void XLogWrite(XLogwrtRqst WriteRqst, bool flexible, bool xlog_switch);
bool use_lock);
static int XLogFileRead(XLogSegNo segno, int emode, TimeLineID tli,
int source, bool notexistOk);
-static int XLogFileReadAnyTLI(XLogSegNo segno, int emode, int source);
+static int XLogFileReadAnyTLI(XLogSegNo segno, int emode, int source);
static int XLogPageRead(XLogReaderState *xlogreader, XLogRecPtr targetPagePtr,
int reqLen, XLogRecPtr targetRecPtr, char *readBuf,
TimeLineID *readTLI);
/* OK, put it in this slot */
dtbuf[i] = rdt->buffer;
if (doPageWrites && XLogCheckBuffer(rdt, true,
- &(dtbuf_lsn[i]), &(dtbuf_xlg[i])))
+ &(dtbuf_lsn[i]), &(dtbuf_xlg[i])))
{
dtbuf_bkp[i] = true;
rdt->data = NULL;
page = BufferGetPage(rdata->buffer);
/*
- * We assume page LSN is first data on *every* page that can be passed
- * to XLogInsert, whether it has the standard page layout or not. We
- * don't need to take the buffer header lock for PageGetLSN if we hold
- * an exclusive lock on the page and/or the relation.
+ * We assume page LSN is first data on *every* page that can be passed to
+ * XLogInsert, whether it has the standard page layout or not. We don't
+ * need to take the buffer header lock for PageGetLSN if we hold an
+ * exclusive lock on the page and/or the relation.
*/
if (holdsExclusiveLock)
*lsn = PageGetLSN(page);
*/
if (LogwrtResult.Write >= XLogCtl->xlblocks[curridx])
elog(PANIC, "xlog write request %X/%X is past end of log %X/%X",
- (uint32) (LogwrtResult.Write >> 32), (uint32) LogwrtResult.Write,
+ (uint32) (LogwrtResult.Write >> 32), (uint32) LogwrtResult.Write,
(uint32) (XLogCtl->xlblocks[curridx] >> 32),
(uint32) XLogCtl->xlblocks[curridx]);
if (lseek(openLogFile, (off_t) startoffset, SEEK_SET) < 0)
ereport(PANIC,
(errcode_for_file_access(),
- errmsg("could not seek in log file %s to offset %u: %m",
- XLogFileNameP(ThisTimeLineID, openLogSegNo),
- startoffset)));
+ errmsg("could not seek in log file %s to offset %u: %m",
+ XLogFileNameP(ThisTimeLineID, openLogSegNo),
+ startoffset)));
openLogOff = startoffset;
}
if (!force && newMinRecoveryPoint < lsn)
elog(WARNING,
"xlog min recovery request %X/%X is past current point %X/%X",
- (uint32) (lsn >> 32) , (uint32) lsn,
+ (uint32) (lsn >> 32), (uint32) lsn,
(uint32) (newMinRecoveryPoint >> 32),
(uint32) newMinRecoveryPoint);
minRecoveryPointTLI = newMinRecoveryPointTLI;
ereport(DEBUG2,
- (errmsg("updated min recovery point to %X/%X on timeline %u",
- (uint32) (minRecoveryPoint >> 32),
- (uint32) minRecoveryPoint,
- newMinRecoveryPointTLI)));
+ (errmsg("updated min recovery point to %X/%X on timeline %u",
+ (uint32) (minRecoveryPoint >> 32),
+ (uint32) minRecoveryPoint,
+ newMinRecoveryPointTLI)));
}
}
LWLockRelease(ControlFileLock);
elog(LOG, "xlog flush request %X/%X; write %X/%X; flush %X/%X",
(uint32) (record >> 32), (uint32) record,
(uint32) (LogwrtResult.Write >> 32), (uint32) LogwrtResult.Write,
- (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
+ (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
#endif
START_CRIT_SECTION();
/*
* Sleep before flush! By adding a delay here, we may give further
* backends the opportunity to join the backlog of group commit
- * followers; this can significantly improve transaction throughput, at
- * the risk of increasing transaction latency.
+ * followers; this can significantly improve transaction throughput,
+ * at the risk of increasing transaction latency.
*
* We do not sleep if enableFsync is not turned on, nor if there are
* fewer than CommitSiblings other backends with active transactions.
XLogCtlInsert *Insert = &XLogCtl->Insert;
uint32 freespace = INSERT_FREESPACE(Insert);
- if (freespace == 0) /* buffer is full */
+ if (freespace == 0) /* buffer is full */
WriteRqstPtr = XLogCtl->xlblocks[Insert->curridx];
else
{
elog(ERROR,
"xlog flush request %X/%X is not satisfied --- flushed only to %X/%X",
(uint32) (record >> 32), (uint32) record,
- (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
+ (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
}
/*
elog(LOG, "xlog bg flush request %X/%X; write %X/%X; flush %X/%X",
(uint32) (WriteRqstPtr >> 32), (uint32) WriteRqstPtr,
(uint32) (LogwrtResult.Write >> 32), (uint32) LogwrtResult.Write,
- (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
+ (uint32) (LogwrtResult.Flush >> 32), (uint32) LogwrtResult.Flush);
#endif
START_CRIT_SECTION();
if (fd < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not open file \"%s\": %m", path)));
+ errmsg("could not open file \"%s\": %m", path)));
elog(DEBUG2, "done creating and filling new WAL file");
* want to read.
*
* If we haven't read the timeline history file yet, read it now, so that
- * we know which TLIs to scan. We don't save the list in expectedTLEs,
+ * we know which TLIs to scan. We don't save the list in expectedTLEs,
* however, unless we actually find a valid segment. That way if there is
* neither a timeline history file nor a WAL segment in the archive, and
* streaming replication is set up, we'll read the timeline history file
}
/*
- * The checksum value on this page is currently invalid. We don't
- * need to reset it here since it will be set before being written.
+ * The checksum value on this page is currently invalid. We don't need to
+ * reset it here since it will be set before being written.
*/
PageSetLSN(page, lsn);
for (;;)
{
- char *errormsg;
+ char *errormsg;
record = XLogReadRecord(xlogreader, RecPtr, &errormsg);
ReadRecPtr = xlogreader->ReadRecPtr;
}
/*
- * We only end up here without a message when XLogPageRead() failed
- * - in that case we already logged something.
- * In StandbyMode that only happens if we have been triggered, so
- * we shouldn't loop anymore in that case.
+ * We only end up here without a message when XLogPageRead()
+ * failed - in that case we already logged something. In
+ * StandbyMode that only happens if we have been triggered, so we
+ * shouldn't loop anymore in that case.
*/
if (errormsg)
ereport(emode_for_corrupt_record(emode,
RecPtr ? RecPtr : EndRecPtr),
- (errmsg_internal("%s", errormsg) /* already translated */));
+ (errmsg_internal("%s", errormsg) /* already translated */ ));
}
+
/*
* Check page TLI is one of the expected values.
*/
else if (!tliInHistory(xlogreader->latestPageTLI, expectedTLEs))
{
char fname[MAXFNAMELEN];
- XLogSegNo segno;
- int32 offset;
+ XLogSegNo segno;
+ int32 offset;
XLByteToSeg(xlogreader->latestPagePtr, segno);
offset = xlogreader->latestPagePtr % XLogSegSize;
XLogFileName(fname, xlogreader->readPageTLI, segno);
ereport(emode_for_corrupt_record(emode,
RecPtr ? RecPtr : EndRecPtr),
- (errmsg("unexpected timeline ID %u in log segment %s, offset %u",
- xlogreader->latestPageTLI,
- fname,
- offset)));
+ (errmsg("unexpected timeline ID %u in log segment %s, offset %u",
+ xlogreader->latestPageTLI,
+ fname,
+ offset)));
record = NULL;
}
lastSourceFailed = true;
/*
- * If archive recovery was requested, but we were still doing crash
- * recovery, switch to archive recovery and retry using the offline
- * archive. We have now replayed all the valid WAL in pg_xlog, so
- * we are presumably now consistent.
+ * If archive recovery was requested, but we were still doing
+ * crash recovery, switch to archive recovery and retry using the
+ * offline archive. We have now replayed all the valid WAL in
+ * pg_xlog, so we are presumably now consistent.
*
* We require that there's at least some valid WAL present in
* pg_xlog, however (!fetch_ckpt). We could recover using the WAL
newExpectedTLEs = readTimeLineHistory(newtarget);
/*
- * If the current timeline is not part of the history of the new
- * timeline, we cannot proceed to it.
+ * If the current timeline is not part of the history of the new timeline,
+ * we cannot proceed to it.
*/
found = false;
- foreach (cell, newExpectedTLEs)
+ foreach(cell, newExpectedTLEs)
{
currentTle = (TimeLineHistoryEntry *) lfirst(cell);
XLogRecPtr
GetFakeLSNForUnloggedRel(void)
{
- XLogRecPtr nextUnloggedLSN;
+ XLogRecPtr nextUnloggedLSN;
/* use volatile pointer to prevent code rearrangement */
volatile XLogCtlData *xlogctl = XLogCtl;
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg("out of memory"),
- errdetail("Failed while allocating an XLog reading processor")));
+ errdetail("Failed while allocating an XLog reading processor")));
xlogreader->system_identifier = ControlFile->system_identifier;
if (read_backup_label(&checkPointLoc, &backupEndRequired,
&backupFromStandby))
{
/*
- * Archive recovery was requested, and thanks to the backup label file,
- * we know how far we need to replay to reach consistency. Enter
+ * Archive recovery was requested, and thanks to the backup label
+ * file, we know how far we need to replay to reach consistency. Enter
* archive recovery directly.
*/
InArchiveRecovery = true;
wasShutdown = (record->xl_info == XLOG_CHECKPOINT_SHUTDOWN);
ereport(DEBUG1,
(errmsg("checkpoint record is at %X/%X",
- (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
+ (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
InRecovery = true; /* force recovery even if SHUTDOWNED */
/*
/*
* It's possible that archive recovery was requested, but we don't
* know how far we need to replay the WAL before we reach consistency.
- * This can happen for example if a base backup is taken from a running
- * server using an atomic filesystem snapshot, without calling
+ * This can happen for example if a base backup is taken from a
+ * running server using an atomic filesystem snapshot, without calling
* pg_start/stop_backup. Or if you just kill a running master server
* and put it into archive recovery by creating a recovery.conf file.
*
* replaying all the WAL present in pg_xlog, and only enter archive
* recovery after that.
*
- * But usually we already know how far we need to replay the WAL (up to
- * minRecoveryPoint, up to backupEndPoint, or until we see an
+ * But usually we already know how far we need to replay the WAL (up
+ * to minRecoveryPoint, up to backupEndPoint, or until we see an
* end-of-backup record), and we can enter archive recovery directly.
*/
if (ArchiveRecoveryRequested &&
{
ereport(DEBUG1,
(errmsg("checkpoint record is at %X/%X",
- (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
+ (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
}
else if (StandbyMode)
{
{
ereport(LOG,
(errmsg("using previous checkpoint record at %X/%X",
- (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
+ (uint32) (checkPointLoc >> 32), (uint32) checkPointLoc)));
InRecovery = true; /* force recovery even if SHUTDOWNED */
}
else
* timeline in the history of the requested timeline, we cannot proceed:
* the backup is not part of the history of the requested timeline.
*/
- Assert(expectedTLEs); /* was initialized by reading checkpoint record */
+ Assert(expectedTLEs); /* was initialized by reading checkpoint
+ * record */
if (tliOfPointInHistory(checkPointLoc, expectedTLEs) !=
- checkPoint.ThisTimeLineID)
+ checkPoint.ThisTimeLineID)
{
- XLogRecPtr switchpoint;
+ XLogRecPtr switchpoint;
/*
- * tliSwitchPoint will throw an error if the checkpoint's timeline
- * is not in expectedTLEs at all.
+ * tliSwitchPoint will throw an error if the checkpoint's timeline is
+ * not in expectedTLEs at all.
*/
switchpoint = tliSwitchPoint(ControlFile->checkPointCopy.ThisTimeLineID, expectedTLEs, NULL);
ereport(FATAL,
* history, too.
*/
if (!XLogRecPtrIsInvalid(ControlFile->minRecoveryPoint) &&
- tliOfPointInHistory(ControlFile->minRecoveryPoint - 1, expectedTLEs) !=
- ControlFile->minRecoveryPointTLI)
+ tliOfPointInHistory(ControlFile->minRecoveryPoint - 1, expectedTLEs) !=
+ ControlFile->minRecoveryPointTLI)
ereport(FATAL,
(errmsg("requested timeline %u does not contain minimum recovery point %X/%X on timeline %u",
recoveryTargetTLI,
ereport(DEBUG1,
(errmsg("redo record is at %X/%X; shutdown %s",
- (uint32) (checkPoint.redo >> 32), (uint32) checkPoint.redo,
+ (uint32) (checkPoint.redo >> 32), (uint32) checkPoint.redo,
wasShutdown ? "TRUE" : "FALSE")));
ereport(DEBUG1,
(errmsg("next transaction ID: %u/%u; next OID: %u",
ThisTimeLineID = checkPoint.ThisTimeLineID;
/*
- * Copy any missing timeline history files between 'now' and the
- * recovery target timeline from archive to pg_xlog. While we don't need
- * those files ourselves - the history file of the recovery target
- * timeline covers all the previous timelines in the history too - a
- * cascading standby server might be interested in them. Or, if you
- * archive the WAL from this server to a different archive than the
- * master, it'd be good for all the history files to get archived there
- * after failover, so that you can use one of the old timelines as a
- * PITR target. Timeline history files are small, so it's better to copy
- * them unnecessarily than not copy them and regret later.
+ * Copy any missing timeline history files between 'now' and the recovery
+ * target timeline from archive to pg_xlog. While we don't need those
+ * files ourselves - the history file of the recovery target timeline
+ * covers all the previous timelines in the history too - a cascading
+ * standby server might be interested in them. Or, if you archive the WAL
+ * from this server to a different archive than the master, it'd be good
+ * for all the history files to get archived there after failover, so that
+ * you can use one of the old timelines as a PITR target. Timeline history
+ * files are small, so it's better to copy them unnecessarily than not
+ * copy them and regret later.
*/
restoreTimeLineHistoryFiles(ThisTimeLineID, recoveryTargetTLI);
"automatic recovery in progress")));
if (recoveryTargetTLI > ControlFile->checkPointCopy.ThisTimeLineID)
ereport(LOG,
- (errmsg("crash recovery starts in timeline %u "
- "and has target timeline %u",
- ControlFile->checkPointCopy.ThisTimeLineID,
- recoveryTargetTLI)));
+ (errmsg("crash recovery starts in timeline %u "
+ "and has target timeline %u",
+ ControlFile->checkPointCopy.ThisTimeLineID,
+ recoveryTargetTLI)));
ControlFile->state = DB_IN_CRASH_RECOVERY;
}
ControlFile->prevCheckPoint = ControlFile->checkPoint;
ereport(LOG,
(errmsg("redo starts at %X/%X",
- (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr)));
+ (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr)));
/*
* main redo apply loop
*/
do
{
- bool switchedTLI = false;
+ bool switchedTLI = false;
+
#ifdef WAL_DEBUG
if (XLOG_DEBUG ||
(rmid == RM_XACT_ID && trace_recovery_messages <= DEBUG2) ||
initStringInfo(&buf);
appendStringInfo(&buf, "REDO @ %X/%X; LSN %X/%X: ",
- (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr,
- (uint32) (EndRecPtr >> 32), (uint32) EndRecPtr);
+ (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr,
+ (uint32) (EndRecPtr >> 32), (uint32) EndRecPtr);
xlog_outrec(&buf, record);
appendStringInfo(&buf, " - ");
RmgrTable[record->xl_rmid].rm_desc(&buf,
}
/*
- * Before replaying this record, check if this record
- * causes the current timeline to change. The record is
- * already considered to be part of the new timeline,
- * so we update ThisTimeLineID before replaying it.
- * That's important so that replayEndTLI, which is
- * recorded as the minimum recovery point's TLI if
- * recovery stops after this record, is set correctly.
+ * Before replaying this record, check if this record causes
+ * the current timeline to change. The record is already
+ * considered to be part of the new timeline, so we update
+ * ThisTimeLineID before replaying it. That's important so
+ * that replayEndTLI, which is recorded as the minimum
+ * recovery point's TLI if recovery stops after this record,
+ * is set correctly.
*/
if (record->xl_rmid == RM_XLOG_ID)
{
}
else if (info == XLOG_END_OF_RECOVERY)
{
- xl_end_of_recovery xlrec;
+ xl_end_of_recovery xlrec;
memcpy(&xlrec, XLogRecGetData(record), sizeof(xl_end_of_recovery));
newTLI = xlrec.ThisTimeLineID;
ereport(LOG,
(errmsg("redo done at %X/%X",
- (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr)));
+ (uint32) (ReadRecPtr >> 32), (uint32) ReadRecPtr)));
xtime = GetLatestXTime();
if (xtime)
ereport(LOG,
PrevTimeLineID = ThisTimeLineID;
if (ArchiveRecoveryRequested)
{
- char reason[200];
+ char reason[200];
Assert(InArchiveRecovery);
* allows some extra error checking in xlog_redo.
*
* In fast promotion, only create a lightweight end-of-recovery record
- * instead of a full checkpoint. A checkpoint is requested later, after
- * we're fully out of recovery mode and already accepting queries.
+ * instead of a full checkpoint. A checkpoint is requested later,
+ * after we're fully out of recovery mode and already accepting
+ * queries.
*/
if (bgwriterLaunched)
{
fast_promoted = true;
/*
- * Insert a special WAL record to mark the end of recovery,
- * since we aren't doing a checkpoint. That means that the
- * checkpointer process may likely be in the middle of a
- * time-smoothed restartpoint and could continue to be for
- * minutes after this. That sounds strange, but the effect
- * is roughly the same and it would be stranger to try to
- * come out of the restartpoint and then checkpoint.
- * We request a checkpoint later anyway, just for safety.
+ * Insert a special WAL record to mark the end of
+ * recovery, since we aren't doing a checkpoint. That
+ * means that the checkpointer process may likely be in
+ * the middle of a time-smoothed restartpoint and could
+ * continue to be for minutes after this. That sounds
+ * strange, but the effect is roughly the same and it
+ * would be stranger to try to come out of the
+ * restartpoint and then checkpoint. We request a
+ * checkpoint later anyway, just for safety.
*/
CreateEndOfRecoveryRecord();
}
if (!fast_promoted)
RequestCheckpoint(CHECKPOINT_END_OF_RECOVERY |
- CHECKPOINT_IMMEDIATE |
- CHECKPOINT_WAIT);
+ CHECKPOINT_IMMEDIATE |
+ CHECKPOINT_WAIT);
}
else
CreateCheckPoint(CHECKPOINT_END_OF_RECOVERY | CHECKPOINT_IMMEDIATE);
}
/*
- * If there were cascading standby servers connected to us, nudge any
- * wal sender processes to notice that we've been promoted.
+ * If there were cascading standby servers connected to us, nudge any wal
+ * sender processes to notice that we've been promoted.
*/
WalSndWakeup();
}
/*
- * Have we passed our safe starting point? Note that minRecoveryPoint
- * is known to be incorrectly set if ControlFile->backupEndRequired,
- * until the XLOG_BACKUP_RECORD arrives to advise us of the correct
+ * Have we passed our safe starting point? Note that minRecoveryPoint is
+ * known to be incorrectly set if ControlFile->backupEndRequired, until
+ * the XLOG_BACKUP_RECORD arrives to advise us of the correct
* minRecoveryPoint. All we know prior to that is that we're not
* consistent yet.
*/
uint32 freespace;
XLogSegNo _logSegNo;
VirtualTransactionId *vxids;
- int nvxids;
+ int nvxids;
/*
* An end-of-recovery checkpoint is really a shutdown checkpoint, just
TRACE_POSTGRESQL_CHECKPOINT_START(flags);
/*
- * In some cases there are groups of actions that must all occur on
- * one side or the other of a checkpoint record. Before flushing the
+ * In some cases there are groups of actions that must all occur on one
+ * side or the other of a checkpoint record. Before flushing the
* checkpoint record we must explicitly wait for any backend currently
* performing those groups of actions.
*
* One example is end of transaction, so we must wait for any transactions
- * that are currently in commit critical sections. If an xact inserted
+ * that are currently in commit critical sections. If an xact inserted
* its commit record into XLOG just before the REDO point, then a crash
* restart from the REDO point would not replay that record, which means
* that our flushing had better include the xact's update of pg_clog. So
vxids = GetVirtualXIDsDelayingChkpt(&nvxids);
if (nvxids > 0)
{
- uint32 nwaits = 0;
+ uint32 nwaits = 0;
do
{
void
CreateEndOfRecoveryRecord(void)
{
- xl_end_of_recovery xlrec;
- XLogRecData rdata;
- XLogRecPtr recptr;
+ xl_end_of_recovery xlrec;
+ XLogRecData rdata;
+ XLogRecPtr recptr;
/* sanity check */
if (!RecoveryInProgress())
XLogFlush(recptr);
/*
- * Update the control file so that crash recovery can follow
- * the timeline changes to this point.
+ * Update the control file so that crash recovery can follow the timeline
+ * changes to this point.
*/
LWLockAcquire(ControlFileLock, LW_EXCLUSIVE);
ControlFile->time = (pg_time_t) xlrec.end_time;
END_CRIT_SECTION();
- LocalXLogInsertAllowed = -1; /* return to "check" state */
+ LocalXLogInsertAllowed = -1; /* return to "check" state */
}
/*
{
ereport(DEBUG2,
(errmsg("skipping restartpoint, already performed at %X/%X",
- (uint32) (lastCheckPoint.redo >> 32), (uint32) lastCheckPoint.redo)));
+ (uint32) (lastCheckPoint.redo >> 32), (uint32) lastCheckPoint.redo)));
UpdateMinRecoveryPoint(InvalidXLogRecPtr, true);
if (flags & CHECKPOINT_IS_SHUTDOWN)
XLogRecPtr endptr;
/*
- * Get the current end of xlog replayed or received, whichever is later.
+ * Get the current end of xlog replayed or received, whichever is
+ * later.
*/
receivePtr = GetWalRcvWriteRecPtr(NULL, NULL);
replayPtr = GetXLogReplayRecPtr(NULL);
_logSegNo--;
/*
- * Update ThisTimeLineID to the timeline we're currently replaying,
- * so that we install any recycled segments on that timeline.
+ * Update ThisTimeLineID to the timeline we're currently replaying, so
+ * that we install any recycled segments on that timeline.
*
* There is no guarantee that the WAL segments will be useful on the
* current timeline; if recovery proceeds to a new timeline right
* It's possible or perhaps even likely that we finish recovery while
* a restartpoint is in progress. That means we may get to this point
* some minutes afterwards. Setting ThisTimeLineID at that time would
- * actually set it backwards, so we don't want that to persist; if
- * we do reset it here, make sure to reset it back afterwards. This
+ * actually set it backwards, so we don't want that to persist; if we
+ * do reset it here, make sure to reset it back afterwards. This
* doesn't look very clean or principled, but its the best of about
* five different ways of handling this edge case.
*/
if (RecoveryInProgress())
- (void) GetXLogReplayRecPtr(&ThisTimeLineID);
+ (void) GetXLogReplayRecPtr(&ThisTimeLineID);
RemoveOldXlogFiles(_logSegNo, endptr);
xtime = GetLatestXTime();
ereport((log_checkpoints ? LOG : DEBUG2),
(errmsg("recovery restart point at %X/%X",
- (uint32) (lastCheckPoint.redo >> 32), (uint32) lastCheckPoint.redo),
+ (uint32) (lastCheckPoint.redo >> 32), (uint32) lastCheckPoint.redo),
xtime ? errdetail("last completed transaction was at log time %s",
timestamptz_to_str(xtime)) : 0));
XLogRecPtr
XLogSaveBufferForHint(Buffer buffer)
{
- XLogRecPtr recptr = InvalidXLogRecPtr;
- XLogRecPtr lsn;
+ XLogRecPtr recptr = InvalidXLogRecPtr;
+ XLogRecPtr lsn;
XLogRecData rdata[2];
- BkpBlock bkpb;
+ BkpBlock bkpb;
/*
* Ensure no checkpoint can change our view of RedoRecPtr.
GetRedoRecPtr();
/*
- * Setup phony rdata element for use within XLogCheckBuffer only.
- * We reuse and reset rdata for any actual WAL record insert.
+ * Setup phony rdata element for use within XLogCheckBuffer only. We reuse
+ * and reset rdata for any actual WAL record insert.
*/
rdata[0].buffer = buffer;
rdata[0].buffer_std = true;
*/
if (XLogCheckBuffer(rdata, false, &lsn, &bkpb))
{
- char copied_buffer[BLCKSZ];
- char *origdata = (char *) BufferGetBlock(buffer);
+ char copied_buffer[BLCKSZ];
+ char *origdata = (char *) BufferGetBlock(buffer);
/*
* Copy buffer so we don't have to worry about concurrent hint bit or
*/
memcpy(copied_buffer, origdata, bkpb.hole_offset);
memcpy(copied_buffer + bkpb.hole_offset,
- origdata + bkpb.hole_offset + bkpb.hole_length,
- BLCKSZ - bkpb.hole_offset - bkpb.hole_length);
+ origdata + bkpb.hole_offset + bkpb.hole_length,
+ BLCKSZ - bkpb.hole_offset - bkpb.hole_length);
/*
* Header for backup block.
ereport(PANIC,
(errmsg("unexpected prev timeline ID %u (current timeline ID %u) in checkpoint record",
prevTLI, ThisTimeLineID)));
+
/*
- * The new timeline better be in the list of timelines we expect
- * to see, according to the timeline history. It should also not
- * decrease.
+ * The new timeline better be in the list of timelines we expect to see,
+ * according to the timeline history. It should also not decrease.
*/
if (newTLI < ThisTimeLineID || !tliInHistory(newTLI, expectedTLEs))
ereport(PANIC,
- (errmsg("unexpected timeline ID %u (after %u) in checkpoint record",
- newTLI, ThisTimeLineID)));
+ (errmsg("unexpected timeline ID %u (after %u) in checkpoint record",
+ newTLI, ThisTimeLineID)));
/*
- * If we have not yet reached min recovery point, and we're about
- * to switch to a timeline greater than the timeline of the min
- * recovery point: trouble. After switching to the new timeline,
- * we could not possibly visit the min recovery point on the
- * correct timeline anymore. This can happen if there is a newer
- * timeline in the archive that branched before the timeline the
- * min recovery point is on, and you attempt to do PITR to the
- * new timeline.
+ * If we have not yet reached min recovery point, and we're about to
+ * switch to a timeline greater than the timeline of the min recovery
+ * point: trouble. After switching to the new timeline, we could not
+ * possibly visit the min recovery point on the correct timeline anymore.
+ * This can happen if there is a newer timeline in the archive that
+ * branched before the timeline the min recovery point is on, and you
+ * attempt to do PITR to the new timeline.
*/
if (!XLogRecPtrIsInvalid(minRecoveryPoint) &&
lsn < minRecoveryPoint &&
}
else if (info == XLOG_HINT)
{
- char *data;
- BkpBlock bkpb;
+ char *data;
+ BkpBlock bkpb;
/*
- * Hint bit records contain a backup block stored "inline" in the normal
- * data since the locking when writing hint records isn't sufficient to
- * use the normal backup block mechanism, which assumes exclusive lock
- * on the buffer supplied.
+ * Hint bit records contain a backup block stored "inline" in the
+ * normal data since the locking when writing hint records isn't
+ * sufficient to use the normal backup block mechanism, which assumes
+ * exclusive lock on the buffer supplied.
*
- * Since the only change in these backup block are hint bits, there are
- * no recovery conflicts generated.
+ * Since the only change in these backup block are hint bits, there
+ * are no recovery conflicts generated.
*
- * This also means there is no corresponding API call for this,
- * so an smgr implementation has no need to implement anything.
- * Which means nothing is needed in md.c etc
+ * This also means there is no corresponding API call for this, so an
+ * smgr implementation has no need to implement anything. Which means
+ * nothing is needed in md.c etc
*/
data = XLogRecGetData(record);
memcpy(&bkpb, data, sizeof(BkpBlock));
ereport(PANIC,
(errcode_for_file_access(),
errmsg("could not fsync log segment %s: %m",
- XLogFileNameP(ThisTimeLineID, openLogSegNo))));
+ XLogFileNameP(ThisTimeLineID, openLogSegNo))));
if (get_sync_bit(sync_method) != get_sync_bit(new_sync_method))
XLogFileClose();
}
if (pg_fsync_writethrough(fd) != 0)
ereport(PANIC,
(errcode_for_file_access(),
- errmsg("could not fsync write-through log file %s: %m",
- XLogFileNameP(ThisTimeLineID, segno))));
+ errmsg("could not fsync write-through log file %s: %m",
+ XLogFileNameP(ThisTimeLineID, segno))));
break;
#endif
#ifdef HAVE_FDATASYNC
XLogFileNameP(TimeLineID tli, XLogSegNo segno)
{
char *result = palloc(MAXFNAMELEN);
+
XLogFileName(result, tli, segno);
return result;
}
"%Y-%m-%d %H:%M:%S %Z",
pg_localtime(&stamp_time, log_timezone));
appendStringInfo(&labelfbuf, "START WAL LOCATION: %X/%X (file %s)\n",
- (uint32) (startpoint >> 32), (uint32) startpoint, xlogfilename);
+ (uint32) (startpoint >> 32), (uint32) startpoint, xlogfilename);
appendStringInfo(&labelfbuf, "CHECKPOINT LOCATION: %X/%X\n",
- (uint32) (checkpointloc >> 32), (uint32) checkpointloc);
+ (uint32) (checkpointloc >> 32), (uint32) checkpointloc);
appendStringInfo(&labelfbuf, "BACKUP METHOD: %s\n",
exclusive ? "pg_start_backup" : "streamed");
appendStringInfo(&labelfbuf, "BACKUP FROM: %s\n",
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("WAL generated with full_page_writes=off was replayed "
"during online backup"),
- errhint("This means that the backup being taken on the standby "
- "is corrupt and should not be used. "
+ errhint("This means that the backup being taken on the standby "
+ "is corrupt and should not be used. "
"Enable full_page_writes and run CHECKPOINT on the master, "
- "and then try an online backup again.")));
+ "and then try an online backup again.")));
LWLockAcquire(ControlFileLock, LW_SHARED);
errmsg("could not create file \"%s\": %m",
histfilepath)));
fprintf(fp, "START WAL LOCATION: %X/%X (file %s)\n",
- (uint32) (startpoint >> 32), (uint32) startpoint, startxlogfilename);
+ (uint32) (startpoint >> 32), (uint32) startpoint, startxlogfilename);
fprintf(fp, "STOP WAL LOCATION: %X/%X (file %s)\n",
(uint32) (stoppoint >> 32), (uint32) stoppoint, stopxlogfilename);
/* transfer remaining lines from label to history file */
XLogRecPtr targetRecPtr, char *readBuf, TimeLineID *readTLI)
{
XLogPageReadPrivate *private =
- (XLogPageReadPrivate *) xlogreader->private_data;
+ (XLogPageReadPrivate *) xlogreader->private_data;
int emode = private->emode;
uint32 targetPageOff;
- XLogSegNo targetSegNo PG_USED_FOR_ASSERTS_ONLY;
+ XLogSegNo targetSegNo PG_USED_FOR_ASSERTS_ONLY;
XLByteToSeg(targetPagePtr, targetSegNo);
targetPageOff = targetPagePtr % XLogSegSize;
readOff = targetPageOff;
if (lseek(readFile, (off_t) readOff, SEEK_SET) < 0)
{
- char fname[MAXFNAMELEN];
+ char fname[MAXFNAMELEN];
XLogFileName(fname, curFileTLI, readSegNo);
ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
(errcode_for_file_access(),
- errmsg("could not seek in log segment %s to offset %u: %m",
+ errmsg("could not seek in log segment %s to offset %u: %m",
fname, readOff)));
goto next_record_is_invalid;
}
if (read(readFile, readBuf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
{
- char fname[MAXFNAMELEN];
+ char fname[MAXFNAMELEN];
XLogFileName(fname, curFileTLI, readSegNo);
ereport(emode_for_corrupt_record(emode, targetPagePtr + reqLen),
(errcode_for_file_access(),
- errmsg("could not read from log segment %s, offset %u: %m",
+ errmsg("could not read from log segment %s, offset %u: %m",
fname, readOff)));
goto next_record_is_invalid;
}
bool fetching_ckpt, XLogRecPtr tliRecPtr)
{
static pg_time_t last_fail_time = 0;
- pg_time_t now;
+ pg_time_t now;
/*-------
* Standby mode is implemented by a state machine:
*
- * 1. Read from archive (XLOG_FROM_ARCHIVE)
+ * 1. Read from archive (XLOG_FROM_ARCHIVE)
* 2. Read from pg_xlog (XLOG_FROM_PG_XLOG)
* 3. Check trigger file
* 4. Read from primary server via walreceiver (XLOG_FROM_STREAM)
for (;;)
{
- int oldSource = currentSource;
+ int oldSource = currentSource;
/*
* First check if we failed to read from the current source, and
break;
case XLOG_FROM_PG_XLOG:
+
/*
- * Check to see if the trigger file exists. Note that we do
- * this only after failure, so when you create the trigger
- * file, we still finish replaying as much as we can from
- * archive and pg_xlog before failover.
+ * Check to see if the trigger file exists. Note that we
+ * do this only after failure, so when you create the
+ * trigger file, we still finish replaying as much as we
+ * can from archive and pg_xlog before failover.
*/
if (StandbyMode && CheckForStandbyTrigger())
{
}
/*
- * Not in standby mode, and we've now tried the archive and
- * pg_xlog.
+ * Not in standby mode, and we've now tried the archive
+ * and pg_xlog.
*/
if (!StandbyMode)
return false;
/*
- * If primary_conninfo is set, launch walreceiver to try to
- * stream the missing WAL.
+ * If primary_conninfo is set, launch walreceiver to try
+ * to stream the missing WAL.
*
* If fetching_ckpt is TRUE, RecPtr points to the initial
* checkpoint location. In that case, we use RedoStartLSN
*/
if (PrimaryConnInfo)
{
- XLogRecPtr ptr;
- TimeLineID tli;
+ XLogRecPtr ptr;
+ TimeLineID tli;
if (fetching_ckpt)
{
RequestXLogStreaming(tli, ptr, PrimaryConnInfo);
receivedUpto = 0;
}
+
/*
- * Move to XLOG_FROM_STREAM state in either case. We'll get
- * immediate failure if we didn't launch walreceiver, and
- * move on to the next state.
+ * Move to XLOG_FROM_STREAM state in either case. We'll
+ * get immediate failure if we didn't launch walreceiver,
+ * and move on to the next state.
*/
currentSource = XLOG_FROM_STREAM;
break;
case XLOG_FROM_STREAM:
+
/*
- * Failure while streaming. Most likely, we got here because
- * streaming replication was terminated, or promotion was
- * triggered. But we also get here if we find an invalid
- * record in the WAL streamed from master, in which case
- * something is seriously wrong. There's little chance that
- * the problem will just go away, but PANIC is not good for
- * availability either, especially in hot standby mode. So,
- * we treat that the same as disconnection, and retry from
- * archive/pg_xlog again. The WAL in the archive should be
- * identical to what was streamed, so it's unlikely that it
- * helps, but one can hope...
+ * Failure while streaming. Most likely, we got here
+ * because streaming replication was terminated, or
+ * promotion was triggered. But we also get here if we
+ * find an invalid record in the WAL streamed from master,
+ * in which case something is seriously wrong. There's
+ * little chance that the problem will just go away, but
+ * PANIC is not good for availability either, especially
+ * in hot standby mode. So, we treat that the same as
+ * disconnection, and retry from archive/pg_xlog again.
+ * The WAL in the archive should be identical to what was
+ * streamed, so it's unlikely that it helps, but one can
+ * hope...
*/
+
/*
* Before we leave XLOG_FROM_STREAM state, make sure that
* walreceiver is not active, so that it won't overwrite
}
/*
- * XLOG_FROM_STREAM is the last state in our state machine,
- * so we've exhausted all the options for obtaining the
- * requested WAL. We're going to loop back and retry from
- * the archive, but if it hasn't been long since last
- * attempt, sleep 5 seconds to avoid busy-waiting.
+ * XLOG_FROM_STREAM is the last state in our state
+ * machine, so we've exhausted all the options for
+ * obtaining the requested WAL. We're going to loop back
+ * and retry from the archive, but if it hasn't been long
+ * since last attempt, sleep 5 seconds to avoid
+ * busy-waiting.
*/
now = (pg_time_t) time(NULL);
if ((now - last_fail_time) < 5)
else if (currentSource == XLOG_FROM_PG_XLOG)
{
/*
- * We just successfully read a file in pg_xlog. We prefer files
- * in the archive over ones in pg_xlog, so try the next file
- * again from the archive first.
+ * We just successfully read a file in pg_xlog. We prefer files in
+ * the archive over ones in pg_xlog, so try the next file again
+ * from the archive first.
*/
if (InArchiveRecovery)
currentSource = XLOG_FROM_ARCHIVE;
break;
case XLOG_FROM_STREAM:
- {
- bool havedata;
-
- /*
- * Check if WAL receiver is still active.
- */
- if (!WalRcvStreaming())
- {
- lastSourceFailed = true;
- break;
- }
-
- /*
- * Walreceiver is active, so see if new data has arrived.
- *
- * We only advance XLogReceiptTime when we obtain fresh WAL
- * from walreceiver and observe that we had already processed
- * everything before the most recent "chunk" that it flushed to
- * disk. In steady state where we are keeping up with the
- * incoming data, XLogReceiptTime will be updated on each cycle.
- * When we are behind, XLogReceiptTime will not advance, so the
- * grace time allotted to conflicting queries will decrease.
- */
- if (RecPtr < receivedUpto)
- havedata = true;
- else
{
- XLogRecPtr latestChunkStart;
+ bool havedata;
- receivedUpto = GetWalRcvWriteRecPtr(&latestChunkStart, &receiveTLI);
- if (RecPtr < receivedUpto && receiveTLI == curFileTLI)
+ /*
+ * Check if WAL receiver is still active.
+ */
+ if (!WalRcvStreaming())
{
+ lastSourceFailed = true;
+ break;
+ }
+
+ /*
+ * Walreceiver is active, so see if new data has arrived.
+ *
+ * We only advance XLogReceiptTime when we obtain fresh
+ * WAL from walreceiver and observe that we had already
+ * processed everything before the most recent "chunk"
+ * that it flushed to disk. In steady state where we are
+ * keeping up with the incoming data, XLogReceiptTime will
+ * be updated on each cycle. When we are behind,
+ * XLogReceiptTime will not advance, so the grace time
+ * allotted to conflicting queries will decrease.
+ */
+ if (RecPtr < receivedUpto)
havedata = true;
- if (latestChunkStart <= RecPtr)
+ else
+ {
+ XLogRecPtr latestChunkStart;
+
+ receivedUpto = GetWalRcvWriteRecPtr(&latestChunkStart, &receiveTLI);
+ if (RecPtr < receivedUpto && receiveTLI == curFileTLI)
{
- XLogReceiptTime = GetCurrentTimestamp();
- SetCurrentChunkStartTime(XLogReceiptTime);
+ havedata = true;
+ if (latestChunkStart <= RecPtr)
+ {
+ XLogReceiptTime = GetCurrentTimestamp();
+ SetCurrentChunkStartTime(XLogReceiptTime);
+ }
}
+ else
+ havedata = false;
}
- else
- havedata = false;
- }
- if (havedata)
- {
- /*
- * Great, streamed far enough. Open the file if it's not
- * open already. Also read the timeline history file if
- * we haven't initialized timeline history yet; it should
- * be streamed over and present in pg_xlog by now. Use
- * XLOG_FROM_STREAM so that source info is set correctly
- * and XLogReceiptTime isn't changed.
- */
- if (readFile < 0)
+ if (havedata)
{
- if (!expectedTLEs)
- expectedTLEs = readTimeLineHistory(receiveTLI);
- readFile = XLogFileRead(readSegNo, PANIC,
- receiveTLI,
- XLOG_FROM_STREAM, false);
- Assert(readFile >= 0);
+ /*
+ * Great, streamed far enough. Open the file if it's
+ * not open already. Also read the timeline history
+ * file if we haven't initialized timeline history
+ * yet; it should be streamed over and present in
+ * pg_xlog by now. Use XLOG_FROM_STREAM so that
+ * source info is set correctly and XLogReceiptTime
+ * isn't changed.
+ */
+ if (readFile < 0)
+ {
+ if (!expectedTLEs)
+ expectedTLEs = readTimeLineHistory(receiveTLI);
+ readFile = XLogFileRead(readSegNo, PANIC,
+ receiveTLI,
+ XLOG_FROM_STREAM, false);
+ Assert(readFile >= 0);
+ }
+ else
+ {
+ /* just make sure source info is correct... */
+ readSource = XLOG_FROM_STREAM;
+ XLogReceiptSource = XLOG_FROM_STREAM;
+ return true;
+ }
+ break;
}
- else
+
+ /*
+ * Data not here yet. Check for trigger, then wait for
+ * walreceiver to wake us up when new WAL arrives.
+ */
+ if (CheckForStandbyTrigger())
{
- /* just make sure source info is correct... */
- readSource = XLOG_FROM_STREAM;
- XLogReceiptSource = XLOG_FROM_STREAM;
- return true;
+ /*
+ * Note that we don't "return false" immediately here.
+ * After being triggered, we still want to replay all
+ * the WAL that was already streamed. It's in pg_xlog
+ * now, so we just treat this as a failure, and the
+ * state machine will move on to replay the streamed
+ * WAL from pg_xlog, and then recheck the trigger and
+ * exit replay.
+ */
+ lastSourceFailed = true;
+ break;
}
- break;
- }
- /*
- * Data not here yet. Check for trigger, then wait for
- * walreceiver to wake us up when new WAL arrives.
- */
- if (CheckForStandbyTrigger())
- {
/*
- * Note that we don't "return false" immediately here.
- * After being triggered, we still want to replay all the
- * WAL that was already streamed. It's in pg_xlog now, so
- * we just treat this as a failure, and the state machine
- * will move on to replay the streamed WAL from pg_xlog,
- * and then recheck the trigger and exit replay.
+ * Wait for more WAL to arrive. Time out after 5 seconds,
+ * like when polling the archive, to react to a trigger
+ * file promptly.
*/
- lastSourceFailed = true;
+ WaitLatch(&XLogCtl->recoveryWakeupLatch,
+ WL_LATCH_SET | WL_TIMEOUT,
+ 5000L);
+ ResetLatch(&XLogCtl->recoveryWakeupLatch);
break;
}
- /*
- * Wait for more WAL to arrive. Time out after 5 seconds, like
- * when polling the archive, to react to a trigger file
- * promptly.
- */
- WaitLatch(&XLogCtl->recoveryWakeupLatch,
- WL_LATCH_SET | WL_TIMEOUT,
- 5000L);
- ResetLatch(&XLogCtl->recoveryWakeupLatch);
- break;
- }
-
default:
elog(ERROR, "unexpected WAL source %d", currentSource);
}
if (IsPromoteTriggered())
{
/*
- * In 9.1 and 9.2 the postmaster unlinked the promote file
- * inside the signal handler. We now leave the file in place
- * and let the Startup process do the unlink. This allows
- * Startup to know whether we're doing fast or normal
- * promotion. Fast promotion takes precedence.
+ * In 9.1 and 9.2 the postmaster unlinked the promote file inside the
+ * signal handler. We now leave the file in place and let the Startup
+ * process do the unlink. This allows Startup to know whether we're
+ * doing fast or normal promotion. Fast promotion takes precedence.
*/
if (stat(FAST_PROMOTE_SIGNAL_FILE, &stat_buf) == 0)
{
* of log segments that weren't yet transferred to the archive.
*
* Notice that we don't actually overwrite any files when we copy back
- * from archive because the restore_command may inadvertently
- * restore inappropriate xlogs, or they may be corrupt, so we may wish to
- * fallback to the segments remaining in current XLOGDIR later. The
+ * from archive because the restore_command may inadvertently restore
+ * inappropriate xlogs, or they may be corrupt, so we may wish to fallback
+ * to the segments remaining in current XLOGDIR later. The
* copy-from-archive filename is always the same, ensuring that we don't
* run out of disk space on long recoveries.
*/
if (stat(xlogfpath, &statbuf) == 0)
{
- char oldpath[MAXPGPATH];
+ char oldpath[MAXPGPATH];
+
#ifdef WIN32
static unsigned int deletedcounter = 1;
+
/*
- * On Windows, if another process (e.g a walsender process) holds
- * the file open in FILE_SHARE_DELETE mode, unlink will succeed,
- * but the file will still show up in directory listing until the
- * last handle is closed, and we cannot rename the new file in its
- * place until that. To avoid that problem, rename the old file to
- * a temporary name first. Use a counter to create a unique
- * filename, because the same file might be restored from the
- * archive multiple times, and a walsender could still be holding
- * onto an old deleted version of it.
+ * On Windows, if another process (e.g a walsender process) holds the
+ * file open in FILE_SHARE_DELETE mode, unlink will succeed, but the
+ * file will still show up in directory listing until the last handle
+ * is closed, and we cannot rename the new file in its place until
+ * that. To avoid that problem, rename the old file to a temporary
+ * name first. Use a counter to create a unique filename, because the
+ * same file might be restored from the archive multiple times, and a
+ * walsender could still be holding onto an old deleted version of it.
*/
snprintf(oldpath, MAXPGPATH, "%s.deleted%u",
xlogfpath, deletedcounter++);
path, xlogfpath)));
/*
- * Create .done file forcibly to prevent the restored segment from
- * being archived again later.
+ * Create .done file forcibly to prevent the restored segment from being
+ * archived again later.
*/
XLogArchiveForceDone(xlogfname);
/*
- * If the existing file was replaced, since walsenders might have it
- * open, request them to reload a currently-open segment. This is only
- * required for WAL segments, walsenders don't hold other files open, but
- * there's no harm in doing this too often, and we don't know what kind
- * of a file we're dealing with here.
+ * If the existing file was replaced, since walsenders might have it open,
+ * request them to reload a currently-open segment. This is only required
+ * for WAL segments, walsenders don't hold other files open, but there's
+ * no harm in doing this too often, and we don't know what kind of a file
+ * we're dealing with here.
*/
if (reload)
WalSndRqstFileReload();
* XXX: this won't handle values higher than 2^63 correctly.
*/
result = DatumGetNumeric(DirectFunctionCall2(numeric_sub,
- DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes1)),
- DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes2))));
+ DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes1)),
+ DirectFunctionCall1(int8_numeric, Int64GetDatum((int64) bytes2))));
PG_RETURN_NUMERIC(result);
}
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not read file \"%s\": %m",
- BACKUP_LABEL_FILE)));
+ BACKUP_LABEL_FILE)));
PG_RETURN_NULL();
}
if (ferror(lfp))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read file \"%s\": %m", BACKUP_LABEL_FILE)));
+ errmsg("could not read file \"%s\": %m", BACKUP_LABEL_FILE)));
/* Close the backup label file. */
if (FreeFile(lfp))
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not close file \"%s\": %m", BACKUP_LABEL_FILE)));
+ errmsg("could not close file \"%s\": %m", BACKUP_LABEL_FILE)));
if (strlen(backup_start_time) == 0)
ereport(ERROR,
targetRecOff = RecPtr % XLOG_BLCKSZ;
/*
- * Read the page containing the record into state->readBuf. Request
- * enough byte to cover the whole record header, or at least the part of
- * it that fits on the same page.
+ * Read the page containing the record into state->readBuf. Request enough
+ * byte to cover the whole record header, or at least the part of it that
+ * fits on the same page.
*/
readOff = ReadPageInternal(state,
targetPagePtr,
extern int optind;
extern char *optarg;
-uint32 bootstrap_data_checksum_version = 0; /* No checksum */
+uint32 bootstrap_data_checksum_version = 0; /* No checksum */
#define ALLOC(t, c) ((t *) calloc((unsigned)(c), sizeof(t)))
* ----------------
*/
-AuxProcType MyAuxProcType = NotAnAuxProcess; /* declared in miscadmin.h */
+AuxProcType MyAuxProcType = NotAnAuxProcess; /* declared in miscadmin.h */
Relation boot_reldesc; /* current relation descriptor */
/*
* Assign the ProcSignalSlot for an auxiliary process. Since it
* doesn't have a BackendId, the slot is statically allocated based on
- * the auxiliary process type (MyAuxProcType). Backends use slots
+ * the auxiliary process type (MyAuxProcType). Backends use slots
* indexed in the range from 1 to MaxBackends (inclusive), so we use
* MaxBackends + AuxProcType + 1 as the index of the slot for an
* auxiliary process.
void
aclcheck_error_type(AclResult aclerr, Oid typeOid)
{
- Oid element_type = get_element_type(typeOid);
+ Oid element_type = get_element_type(typeOid);
aclcheck_error(aclerr, ACL_KIND_TYPE, format_type_be(element_type ? element_type : typeOid));
}
* This is exported separately because there are cases where we want to use
* an index that will not be recognized by RelationGetOidIndex: TOAST tables
* have indexes that are usable, but have multiple columns and are on
- * ordinary columns rather than a true OID column. This code will work
+ * ordinary columns rather than a true OID column. This code will work
* anyway, so long as the OID is the index's first column. The caller must
* pass in the actual heap attnum of the OID column, however.
*
deleteObjectsInList(ObjectAddresses *targetObjects, Relation *depRel,
int flags)
{
- int i;
+ int i;
/*
* Keep track of objects for event triggers, if necessary.
bool is_validated, bool is_local, int inhcount,
bool is_no_inherit, bool is_internal);
static void StoreConstraints(Relation rel, List *cooked_constraints,
- bool is_internal);
+ bool is_internal);
static bool MergeWithExistingConstraint(Relation rel, char *ccname, Node *expr,
bool allow_merge, bool is_local,
bool is_no_inherit);
* that will do.
*/
new_rel_reltup->relfrozenxid = RecentXmin;
+
/*
* Similarly, initialize the minimum Multixact to the first value that
* could possibly be stored in tuples in the table. Running
/*
* Post creation hook for attribute defaults.
*
- * XXX. ALTER TABLE ALTER COLUMN SET/DROP DEFAULT is implemented
- * with a couple of deletion/creation of the attribute's default entry,
- * so the callee should check existence of an older version of this
- * entry if it needs to distinguish.
+ * XXX. ALTER TABLE ALTER COLUMN SET/DROP DEFAULT is implemented with a
+ * couple of deletion/creation of the attribute's default entry, so the
+ * callee should check existence of an older version of this entry if it
+ * needs to distinguish.
*/
InvokeObjectPostCreateHookArg(AttrDefaultRelationId,
RelationGetRelid(rel), attnum, is_internal);
is_local, /* conislocal */
inhcount, /* coninhcount */
is_no_inherit, /* connoinherit */
- is_internal); /* internally constructed? */
+ is_internal); /* internally constructed? */
pfree(ccbin);
pfree(ccsrc);
Oid namespaceId;
namespaceId = LookupExplicitNamespace(relation->schemaname, missing_ok);
+
/*
- * For missing_ok, allow a non-existant schema name to
- * return InvalidOid.
+ * For missing_ok, allow a non-existant schema name to
+ * return InvalidOid.
*/
if (namespaceId != myTempNamespace)
ereport(ERROR,
namespaceId = get_namespace_oid(nspname, missing_ok);
if (missing_ok && !OidIsValid(namespaceId))
return InvalidOid;
-
+
aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
RunObjectPostCreateHook(Oid classId, Oid objectId, int subId,
bool is_internal)
{
- ObjectAccessPostCreate pc_arg;
+ ObjectAccessPostCreate pc_arg;
/* caller should check, but just in case... */
Assert(object_access_hook != NULL);
memset(&pc_arg, 0, sizeof(ObjectAccessPostCreate));
pc_arg.is_internal = is_internal;
- (*object_access_hook)(OAT_POST_CREATE,
- classId, objectId, subId,
- (void *) &pc_arg);
+ (*object_access_hook) (OAT_POST_CREATE,
+ classId, objectId, subId,
+ (void *) &pc_arg);
}
/*
RunObjectDropHook(Oid classId, Oid objectId, int subId,
int dropflags)
{
- ObjectAccessDrop drop_arg;
+ ObjectAccessDrop drop_arg;
/* caller should check, but just in case... */
Assert(object_access_hook != NULL);
memset(&drop_arg, 0, sizeof(ObjectAccessDrop));
drop_arg.dropflags = dropflags;
- (*object_access_hook)(OAT_DROP,
- classId, objectId, subId,
- (void *) &drop_arg);
+ (*object_access_hook) (OAT_DROP,
+ classId, objectId, subId,
+ (void *) &drop_arg);
}
/*
RunObjectPostAlterHook(Oid classId, Oid objectId, int subId,
Oid auxiliaryId, bool is_internal)
{
- ObjectAccessPostAlter pa_arg;
+ ObjectAccessPostAlter pa_arg;
/* caller should check, but just in case... */
Assert(object_access_hook != NULL);
pa_arg.auxiliary_id = auxiliaryId;
pa_arg.is_internal = is_internal;
- (*object_access_hook)(OAT_POST_ALTER,
- classId, objectId, subId,
- (void *) &pa_arg);
+ (*object_access_hook) (OAT_POST_ALTER,
+ classId, objectId, subId,
+ (void *) &pa_arg);
}
/*
bool
RunNamespaceSearchHook(Oid objectId, bool ereport_on_violation)
{
- ObjectAccessNamespaceSearch ns_arg;
+ ObjectAccessNamespaceSearch ns_arg;
/* caller should check, but just in case... */
Assert(object_access_hook != NULL);
ns_arg.ereport_on_violation = ereport_on_violation;
ns_arg.result = true;
- (*object_access_hook)(OAT_NAMESPACE_SEARCH,
- NamespaceRelationId, objectId, 0,
- (void *) &ns_arg);
+ (*object_access_hook) (OAT_NAMESPACE_SEARCH,
+ NamespaceRelationId, objectId, 0,
+ (void *) &ns_arg);
return ns_arg.result;
}
/* caller should check, but just in case... */
Assert(object_access_hook != NULL);
- (*object_access_hook)(OAT_FUNCTION_EXECUTE,
- ProcedureRelationId, objectId, 0,
- NULL);
+ (*object_access_hook) (OAT_FUNCTION_EXECUTE,
+ ProcedureRelationId, objectId, 0,
+ NULL);
}
AttrNumber attnum_owner; /* attnum of owner field */
AttrNumber attnum_acl; /* attnum of acl field */
AclObjectKind acl_kind; /* ACL_KIND_* of this object type */
- bool is_nsp_name_unique; /* can the nsp/name combination (or name
- * alone, if there's no namespace) be
- * considered an unique identifier for an
- * object of this class? */
+ bool is_nsp_name_unique; /* can the nsp/name combination (or
+ * name alone, if there's no
+ * namespace) be considered an unique
+ * identifier for an object of this
+ * class? */
} ObjectPropertyType;
static ObjectPropertyType ObjectProperty[] =
ereport(ERROR,
(errmsg_internal("unrecognized class id: %u", class_id)));
- return NULL; /* keep MSC compiler happy */
+ return NULL; /* keep MSC compiler happy */
}
/*
if (oidCacheId > 0)
{
tuple = SearchSysCacheCopy1(oidCacheId, ObjectIdGetDatum(objectId));
- if (!HeapTupleIsValid(tuple)) /* should not happen */
+ if (!HeapTupleIsValid(tuple)) /* should not happen */
return NULL;
}
else
{
Oid oidIndexId = get_object_oid_index(classId);
- SysScanDesc scan;
- ScanKeyData skey;
+ SysScanDesc scan;
+ ScanKeyData skey;
Assert(OidIsValid(oidIndexId));
break;
}
- case OCLASS_EVENT_TRIGGER:
+ case OCLASS_EVENT_TRIGGER:
{
HeapTuple tup;
elog(ERROR, "cache lookup failed for event trigger %u",
object->objectId);
appendStringInfo(&buffer, _("event trigger %s"),
- NameStr(((Form_pg_event_trigger) GETSTRUCT(tup))->evtname));
+ NameStr(((Form_pg_event_trigger) GETSTRUCT(tup))->evtname));
ReleaseSysCache(tup);
break;
}
RelationGetDescr(catalog), &isnull);
if (isnull)
elog(ERROR, "invalid null namespace in object %u/%u/%d",
- address.classId, address.objectId, address.objectSubId);
+ address.classId, address.objectId, address.objectSubId);
}
/*
- * We only return the object name if it can be used (together
- * with the schema name, if any) as an unique identifier.
+ * We only return the object name if it can be used (together with
+ * the schema name, if any) as an unique identifier.
*/
if (get_object_namensp_unique(address.classId))
{
nameAttnum = get_object_attnum_name(address.classId);
if (nameAttnum != InvalidAttrNumber)
{
- Datum nameDatum;
+ Datum nameDatum;
nameDatum = heap_getattr(objtup, nameAttnum,
- RelationGetDescr(catalog), &isnull);
+ RelationGetDescr(catalog), &isnull);
if (isnull)
elog(ERROR, "invalid null name in object %u/%u/%d",
address.classId, address.objectId, address.objectSubId);
/* schema name */
if (OidIsValid(schema_oid))
{
- const char *schema = quote_identifier(get_namespace_name(schema_oid));
+ const char *schema = quote_identifier(get_namespace_name(schema_oid));
values[1] = CStringGetTextDatum(schema);
nulls[1] = false;
{
Relation constrRel;
HeapTuple constrTup;
- Form_pg_constraint constrForm;
+ Form_pg_constraint constrForm;
constrRel = heap_open(ConstraintRelationId, AccessShareLock);
constrTup = get_catalog_object_by_oid(constrRel, constroid);
Form_pg_proc procForm;
procTup = SearchSysCache1(PROCOID,
- ObjectIdGetDatum(procid));
+ ObjectIdGetDatum(procid));
if (!HeapTupleIsValid(procTup))
elog(ERROR, "cache lookup failed for procedure %u", procid);
procForm = (Form_pg_proc) GETSTRUCT(procTup);
getRelationIdentity(&buffer, object->objectId);
if (object->objectSubId != 0)
{
- char *attr;
+ char *attr;
attr = get_relid_attribute_name(object->objectId,
object->objectSubId);
castForm = (Form_pg_cast) GETSTRUCT(tup);
appendStringInfo(&buffer, "(%s AS %s)",
- format_type_be_qualified(castForm->castsource),
- format_type_be_qualified(castForm->casttarget));
+ format_type_be_qualified(castForm->castsource),
+ format_type_be_qualified(castForm->casttarget));
heap_close(castRel, AccessShareLock);
break;
{
HeapTuple collTup;
Form_pg_collation coll;
- char *schema;
+ char *schema;
collTup = SearchSysCache1(COLLOID,
ObjectIdGetDatum(object->objectId));
schema = get_namespace_name(coll->collnamespace);
appendStringInfoString(&buffer,
quote_qualified_identifier(schema,
- NameStr(coll->collname)));
+ NameStr(coll->collname)));
ReleaseSysCache(collTup);
break;
}
}
else
{
- ObjectAddress domain;
+ ObjectAddress domain;
domain.classId = TypeRelationId;
domain.objectId = con->contypid;
object->objectId);
langForm = (Form_pg_language) GETSTRUCT(langTup);
appendStringInfo(&buffer, "%s",
- quote_identifier(NameStr(langForm->lanname)));
+ quote_identifier(NameStr(langForm->lanname)));
ReleaseSysCache(langTup);
break;
}
appendStringInfo(&buffer,
"%s",
quote_qualified_identifier(schema,
- NameStr(opcForm->opcname)));
+ NameStr(opcForm->opcname)));
appendStringInfo(&buffer, " for %s",
quote_identifier(NameStr(amForm->amname)));
appendStringInfo(&buffer, "operator %d (%s, %s) of %s",
amopForm->amopstrategy,
- format_type_be_qualified(amopForm->amoplefttype),
- format_type_be_qualified(amopForm->amoprighttype),
+ format_type_be_qualified(amopForm->amoplefttype),
+ format_type_be_qualified(amopForm->amoprighttype),
opfam.data);
pfree(opfam.data);
appendStringInfo(&buffer, "function %d (%s, %s) of %s",
amprocForm->amprocnum,
- format_type_be_qualified(amprocForm->amproclefttype),
- format_type_be_qualified(amprocForm->amprocrighttype),
+ format_type_be_qualified(amprocForm->amproclefttype),
+ format_type_be_qualified(amprocForm->amprocrighttype),
opfam.data);
pfree(opfam.data);
case OCLASS_TSPARSER:
{
HeapTuple tup;
- Form_pg_ts_parser formParser;
+ Form_pg_ts_parser formParser;
tup = SearchSysCache1(TSPARSEROID,
ObjectIdGetDatum(object->objectId));
object->objectId);
formParser = (Form_pg_ts_parser) GETSTRUCT(tup);
appendStringInfo(&buffer, "%s",
- quote_identifier(NameStr(formParser->prsname)));
+ quote_identifier(NameStr(formParser->prsname)));
ReleaseSysCache(tup);
break;
}
case OCLASS_TSDICT:
{
HeapTuple tup;
- Form_pg_ts_dict formDict;
+ Form_pg_ts_dict formDict;
tup = SearchSysCache1(TSDICTOID,
ObjectIdGetDatum(object->objectId));
object->objectId);
formDict = (Form_pg_ts_dict) GETSTRUCT(tup);
appendStringInfo(&buffer, "%s",
- quote_identifier(NameStr(formDict->dictname)));
+ quote_identifier(NameStr(formDict->dictname)));
ReleaseSysCache(tup);
break;
}
object->objectId);
formTmpl = (Form_pg_ts_template) GETSTRUCT(tup);
appendStringInfo(&buffer, "%s",
- quote_identifier(NameStr(formTmpl->tmplname)));
+ quote_identifier(NameStr(formTmpl->tmplname)));
ReleaseSysCache(tup);
break;
}
case OCLASS_ROLE:
{
- char *username;
+ char *username;
username = GetUserNameFromId(object->objectId);
appendStringInfo(&buffer, "%s",
appendStringInfo(&buffer,
"for role %s",
- quote_identifier(GetUserNameFromId(defacl->defaclrole)));
+ quote_identifier(GetUserNameFromId(defacl->defaclrole)));
if (OidIsValid(defacl->defaclnamespace))
{
- char *schema;
+ char *schema;
schema = get_namespace_name(defacl->defaclnamespace);
appendStringInfo(&buffer,
object->objectId);
trigForm = (Form_pg_event_trigger) GETSTRUCT(tup);
appendStringInfo(&buffer, "%s",
- quote_identifier(NameStr(trigForm->evtname)));
+ quote_identifier(NameStr(trigForm->evtname)));
ReleaseSysCache(tup);
break;
}
*/
void
AlterConstraintNamespaces(Oid ownerId, Oid oldNspId,
- Oid newNspId, bool isType, ObjectAddresses *objsMoved)
+ Oid newNspId, bool isType, ObjectAddresses *objsMoved)
{
Relation conRel;
ScanKeyData key[1];
while (HeapTupleIsValid((tup = systable_getnext(scan))))
{
Form_pg_constraint conform = (Form_pg_constraint) GETSTRUCT(tup);
- ObjectAddress thisobj;
+ ObjectAddress thisobj;
thisobj.classId = ConstraintRelationId;
thisobj.objectId = HeapTupleGetOid(tup);
const char *newVal,
const char *neighbor,
bool newValIsAfter,
- bool skipIfExists)
+ bool skipIfExists)
{
Relation pg_enum;
Oid newOid;
return false;
/*
- * For SQL standard compatibility, '+' and '-' cannot be the last char of a
- * multi-char operator unless the operator contains chars that are not in
- * SQL operators. The idea is to lex '=-' as two operators, but not to
- * forbid operator names like '?-' that could not be sequences of standard SQL
- * operators.
+ * For SQL standard compatibility, '+' and '-' cannot be the last char of
+ * a multi-char operator unless the operator contains chars that are not
+ * in SQL operators. The idea is to lex '=-' as two operators, but not to
+ * forbid operator names like '?-' that could not be sequences of standard
+ * SQL operators.
*/
if (len > 1 &&
(name[len - 1] == '+' ||
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot change return type of existing function"),
errhint("Use DROP FUNCTION %s first.",
- format_procedure(HeapTupleGetOid(oldtup)))));
+ format_procedure(HeapTupleGetOid(oldtup)))));
/*
* If it returns RECORD, check for possible change of record type
errmsg("cannot change return type of existing function"),
errdetail("Row type defined by OUT parameters is different."),
errhint("Use DROP FUNCTION %s first.",
- format_procedure(HeapTupleGetOid(oldtup)))));
+ format_procedure(HeapTupleGetOid(oldtup)))));
}
/*
errmsg("cannot change name of input parameter \"%s\"",
old_arg_names[j]),
errhint("Use DROP FUNCTION %s first.",
- format_procedure(HeapTupleGetOid(oldtup)))));
+ format_procedure(HeapTupleGetOid(oldtup)))));
}
}
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot remove parameter defaults from existing function"),
errhint("Use DROP FUNCTION %s first.",
- format_procedure(HeapTupleGetOid(oldtup)))));
+ format_procedure(HeapTupleGetOid(oldtup)))));
proargdefaults = SysCacheGetAttr(PROCNAMEARGSNSP, oldtup,
Anum_pg_proc_proargdefaults,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot change data type of existing parameter default value"),
errhint("Use DROP FUNCTION %s first.",
- format_procedure(HeapTupleGetOid(oldtup)))));
+ format_procedure(HeapTupleGetOid(oldtup)))));
newlc = lnext(newlc);
}
}
AlterEventTriggerOwner_oid(sdepForm->objid, newrole);
break;
- /* Generic alter owner cases */
+ /* Generic alter owner cases */
case CollationRelationId:
case ConversionRelationId:
case OperatorRelationId:
smgrcreate(reln, MAIN_FORKNUM, true);
/*
- * Before we perform the truncation, update minimum recovery point
- * to cover this WAL record. Once the relation is truncated, there's
- * no going back. The buffer manager enforces the WAL-first rule
- * for normal updates to relation files, so that the minimum recovery
- * point is always updated before the corresponding change in the
- * data file is flushed to disk. We have to do the same manually
- * here.
+ * Before we perform the truncation, update minimum recovery point to
+ * cover this WAL record. Once the relation is truncated, there's no
+ * going back. The buffer manager enforces the WAL-first rule for
+ * normal updates to relation files, so that the minimum recovery
+ * point is always updated before the corresponding change in the data
+ * file is flushed to disk. We have to do the same manually here.
*
* Doing this before the truncation means that if the truncation fails
* for some reason, you cannot start up the system even after restart,
/*
* Most of the argument-checking is done inside of AggregateCreate
*/
- return AggregateCreate(aggName, /* aggregate name */
+ return AggregateCreate(aggName, /* aggregate name */
aggNamespace, /* namespace */
- aggArgTypes, /* input data type(s) */
+ aggArgTypes, /* input data type(s) */
numArgs,
transfuncName, /* step function name */
finalfuncName, /* final function name */
sortoperatorName, /* sort operator name */
- transTypeId, /* transition data type */
+ transTypeId, /* transition data type */
initval); /* initial condition */
}
#include "utils/tqual.h"
-static Oid AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid);
+static Oid AlterObjectNamespace_internal(Relation rel, Oid objid, Oid nspOid);
/*
* Raise an error to the effect that an object of the given name is already
static void
report_name_conflict(Oid classId, const char *name)
{
- char *msgfmt;
+ char *msgfmt;
switch (classId)
{
static void
report_namespace_conflict(Oid classId, const char *name, Oid nspOid)
{
- char *msgfmt;
+ char *msgfmt;
Assert(OidIsValid(nspOid));
}
/*
- * Check for duplicate name (more friendly than unique-index failure).
- * Since this is just a friendliness check, we can just skip it in cases
- * where there isn't suitable support.
- */
+ * Check for duplicate name (more friendly than unique-index failure).
+ * Since this is just a friendliness check, we can just skip it in cases
+ * where there isn't suitable support.
+ */
if (classId == ProcedureRelationId)
{
Form_pg_proc proc = (Form_pg_proc) GETSTRUCT(oldtup);
case OBJECT_TSPARSER:
case OBJECT_TSTEMPLATE:
{
- ObjectAddress address;
- Relation catalog;
- Relation relation;
+ ObjectAddress address;
+ Relation catalog;
+ Relation relation;
address = get_object_address(stmt->renameType,
stmt->object, stmt->objarg,
default:
elog(ERROR, "unrecognized rename stmt type: %d",
(int) stmt->renameType);
- return InvalidOid; /* keep compiler happy */
+ return InvalidOid; /* keep compiler happy */
}
}
return AlterEventTriggerOwner(strVal(linitial(stmt->object)),
newowner);
- /* Generic cases */
+ /* Generic cases */
case OBJECT_AGGREGATE:
case OBJECT_COLLATION:
case OBJECT_CONVERSION:
Relation catalog;
Relation relation;
Oid classId;
- ObjectAddress address;
+ ObjectAddress address;
address = get_object_address(stmt->objectType,
stmt->object,
/* Superusers can bypass permission checks */
if (!superuser())
{
- AclObjectKind aclkind = get_object_aclkind(classId);
+ AclObjectKind aclkind = get_object_aclkind(classId);
/* must be owner */
if (!has_privs_of_role(GetUserId(), old_ownerId))
{
- char *objname;
- char namebuf[NAMEDATALEN];
+ char *objname;
+ char namebuf[NAMEDATALEN];
if (Anum_name != InvalidAttrNumber)
{
/* New owner must have CREATE privilege on namespace */
if (OidIsValid(namespaceId))
{
- AclResult aclresult;
+ AclResult aclresult;
aclresult = pg_namespace_aclcheck(namespaceId, new_ownerId,
ACL_CREATE);
Anum_acl, RelationGetDescr(rel), &isnull);
if (!isnull)
{
- Acl *newAcl;
+ Acl *newAcl;
newAcl = aclnewowner(DatumGetAclP(datum),
old_ownerId, new_ownerId);
Assert(listenChannels == NIL); /* else caller error */
- if (!amRegisteredListener) /* nothing to do */
+ if (!amRegisteredListener) /* nothing to do */
return;
LWLockAcquire(AsyncQueueLock, LW_SHARED);
/*
* If we LISTEN but then roll back the transaction after PreCommit_Notify,
* we have registered as a listener but have not made any entry in
- * listenChannels. In that case, deregister again.
+ * listenChannels. In that case, deregister again.
*/
if (amRegisteredListener && listenChannels == NIL)
asyncQueueUnregister();
bool is_system_catalog;
bool swap_toast_by_content;
TransactionId frozenXid;
- MultiXactId frozenMulti;
+ MultiXactId frozenMulti;
/* Mark the correct index as clustered */
if (OidIsValid(indexOid))
bool is_system_catalog;
TransactionId OldestXmin;
TransactionId FreezeXid;
- MultiXactId MultiXactFrzLimit;
+ MultiXactId MultiXactFrzLimit;
RewriteState rwstate;
bool use_sort;
Tuplesortstate *tuplesort;
List *force_notnull; /* list of column names */
bool *force_notnull_flags; /* per-column CSV FNN flags */
bool convert_selectively; /* do selective binary conversion? */
- List *convert_select; /* list of column names (can be NIL) */
+ List *convert_select; /* list of column names (can be NIL) */
bool *convert_select_flags; /* per-column CSV/TEXT CS flags */
/* these are just for error messages, see CopyFromErrorCallback */
*/
StringInfoData line_buf;
bool line_buf_converted; /* converted to server encoding? */
- bool line_buf_valid; /* contains the row being processed? */
+ bool line_buf_valid; /* contains the row being processed? */
/*
* Finally, raw_buf holds raw data read from the data source (file or
ClosePipeToProgram(cstate);
/*
- * If ClosePipeToProgram() didn't throw an error,
- * the program terminated normally, but closed the
- * pipe first. Restore errno, and throw an error.
+ * If ClosePipeToProgram() didn't throw an error, the
+ * program terminated normally, but closed the pipe
+ * first. Restore errno, and throw an error.
*/
errno = EPIPE;
}
bool is_from = stmt->is_from;
bool pipe = (stmt->filename == NULL);
Relation rel;
- Oid relid;
+ Oid relid;
/* Disallow COPY to/from file or program except to superusers. */
if (!pipe && !superuser())
if (stmt->is_program)
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("must be superuser to COPY to or from an external program"),
+ errmsg("must be superuser to COPY to or from an external program"),
errhint("Anyone can COPY to stdout or from stdin. "
- "psql's \\copy command also works for anyone.")));
+ "psql's \\copy command also works for anyone.")));
else
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be superuser to COPY to or from a file"),
errhint("Anyone can COPY to stdout or from stdin. "
- "psql's \\copy command also works for anyone.")));
+ "psql's \\copy command also works for anyone.")));
}
if (stmt->relation)
else if (strcmp(defel->defname, "convert_selectively") == 0)
{
/*
- * Undocumented, not-accessible-from-SQL option: convert only
- * the named columns to binary form, storing the rest as NULLs.
- * It's allowed for the column list to be NIL.
+ * Undocumented, not-accessible-from-SQL option: convert only the
+ * named columns to binary form, storing the rest as NULLs. It's
+ * allowed for the column list to be NIL.
*/
if (cstate->convert_selectively)
ereport(ERROR,
ereport(ERROR,
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg_internal("selected column \"%s\" not referenced by COPY",
- NameStr(tupDesc->attrs[attnum - 1]->attname))));
+ NameStr(tupDesc->attrs[attnum - 1]->attname))));
cstate->convert_select_flags[attnum - 1] = true;
}
}
static void
ClosePipeToProgram(CopyState cstate)
{
- int pclose_rc;
+ int pclose_rc;
Assert(cstate->is_program);
Node *query,
const char *queryString,
const char *filename,
- bool is_program,
+ bool is_program,
List *attnamelist,
List *options)
{
}
else
{
- mode_t oumask; /* Pre-existing umask value */
+ mode_t oumask; /* Pre-existing umask value */
struct stat st;
/*
if (!is_absolute_path(filename))
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME),
- errmsg("relative path not allowed for COPY to file")));
+ errmsg("relative path not allowed for COPY to file")));
oumask = umask(S_IWGRP | S_IWOTH);
cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
* Error is relevant to a particular line.
*
* If line_buf still contains the correct line, and it's already
- * transcoded, print it. If it's still in a foreign encoding,
- * it's quite likely that the error is precisely a failure to do
+ * transcoded, print it. If it's still in a foreign encoding, it's
+ * quite likely that the error is precisely a failure to do
* encoding conversion (ie, bad data). We dare not try to convert
* it, and at present there's no way to regurgitate it without
* conversion. So we have to punt and just report the line number.
}
/*
- * Optimize if new relfilenode was created in this subxact or
- * one of its committed children and we won't see those rows later
- * as part of an earlier scan or command. This ensures that if this
- * subtransaction aborts then the frozen rows won't be visible
- * after xact cleanup. Note that the stronger test of exactly
- * which subtransaction created it is crucial for correctness
- * of this optimisation.
+ * Optimize if new relfilenode was created in this subxact or one of its
+ * committed children and we won't see those rows later as part of an
+ * earlier scan or command. This ensures that if this subtransaction
+ * aborts then the frozen rows won't be visible after xact cleanup. Note
+ * that the stronger test of exactly which subtransaction created it is
+ * crucial for correctness of this optimisation.
*/
if (cstate->freeze)
{
if (!ThereAreNoPriorRegisteredSnapshots() || !ThereAreNoReadyPortals())
ereport(ERROR,
(ERRCODE_INVALID_TRANSACTION_STATE,
- errmsg("cannot perform FREEZE because of prior transaction activity")));
+ errmsg("cannot perform FREEZE because of prior transaction activity")));
if (cstate->rel->rd_createSubid != GetCurrentSubTransactionId() &&
- cstate->rel->rd_newRelfilenodeSubid != GetCurrentSubTransactionId())
+ cstate->rel->rd_newRelfilenodeSubid != GetCurrentSubTransactionId())
ereport(ERROR,
(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE,
errmsg("cannot perform FREEZE because the table was not created or truncated in the current subtransaction")));
CopyState
BeginCopyFrom(Relation rel,
const char *filename,
- bool is_program,
+ bool is_program,
List *attnamelist,
List *options)
{
int
GetIntoRelEFlags(IntoClause *intoClause)
{
- int flags;
+ int flags;
/*
* We need to tell the executor whether it has to produce OIDs or not,
if (is_matview)
{
/* StoreViewQuery scribbles on tree, so make a copy */
- Query *query = (Query *) copyObject(into->viewQuery);
+ Query *query = (Query *) copyObject(into->viewQuery);
StoreViewQuery(intoRelationId, query, false);
CommandCounterIncrement();
pgdbrel = heap_open(DatabaseRelationId, RowExclusiveLock);
if (!get_db_info(dbname, AccessExclusiveLock, &db_id, NULL, NULL,
- &db_istemplate, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
+ &db_istemplate, NULL, NULL, NULL, NULL, NULL, NULL, NULL))
{
if (!missing_ok)
{
pgdbrel = heap_open(DatabaseRelationId, RowExclusiveLock);
if (!get_db_info(dbname, AccessExclusiveLock, &db_id, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, &src_tblspcoid, NULL, NULL))
+ NULL, NULL, NULL, NULL, NULL, &src_tblspcoid, NULL, NULL))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exist", dbname)));
AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel)
{
Relation rel;
- Oid dboid;
+ Oid dboid;
HeapTuple tuple,
newtuple;
ScanKeyData scankey;
errdetail_busy_db(int notherbackends, int npreparedxacts)
{
if (notherbackends > 0 && npreparedxacts > 0)
- /* We don't deal with singular versus plural here, since gettext
- * doesn't support multiple plurals in one string. */
+
+ /*
+ * We don't deal with singular versus plural here, since gettext
+ * doesn't support multiple plurals in one string.
+ */
errdetail("There are %d other session(s) and %d prepared transaction(s) using the database.",
notherbackends, npreparedxacts);
else if (notherbackends > 0)
notherbackends);
else
errdetail_plural("There is %d prepared transaction using the database.",
- "There are %d prepared transactions using the database.",
+ "There are %d prepared transactions using the database.",
npreparedxacts,
npreparedxacts);
return 0; /* just to keep ereport macro happy */
{
slist_head SQLDropList;
bool in_sql_drop;
- MemoryContext cxt;
+ MemoryContext cxt;
struct EventTriggerQueryState *previous;
} EventTriggerQueryState;
-EventTriggerQueryState *currentEventTriggerState = NULL;
+EventTriggerQueryState *currentEventTriggerState = NULL;
typedef struct
{
- const char *obtypename;
- bool supported;
+ const char *obtypename;
+ bool supported;
} event_trigger_support_data;
typedef enum
} event_trigger_command_tag_check_result;
static event_trigger_support_data event_trigger_support[] = {
- { "AGGREGATE", true },
- { "CAST", true },
- { "CONSTRAINT", true },
- { "COLLATION", true },
- { "CONVERSION", true },
- { "DATABASE", false },
- { "DOMAIN", true },
- { "EXTENSION", true },
- { "EVENT TRIGGER", false },
- { "FOREIGN DATA WRAPPER", true },
- { "FOREIGN TABLE", true },
- { "FUNCTION", true },
- { "INDEX", true },
- { "LANGUAGE", true },
- { "MATERIALIZED VIEW", true },
- { "OPERATOR", true },
- { "OPERATOR CLASS", true },
- { "OPERATOR FAMILY", true },
- { "ROLE", false },
- { "RULE", true },
- { "SCHEMA", true },
- { "SEQUENCE", true },
- { "SERVER", true },
- { "TABLE", true },
- { "TABLESPACE", false},
- { "TRIGGER", true },
- { "TEXT SEARCH CONFIGURATION", true },
- { "TEXT SEARCH DICTIONARY", true },
- { "TEXT SEARCH PARSER", true },
- { "TEXT SEARCH TEMPLATE", true },
- { "TYPE", true },
- { "USER MAPPING", true },
- { "VIEW", true },
- { NULL, false }
+ {"AGGREGATE", true},
+ {"CAST", true},
+ {"CONSTRAINT", true},
+ {"COLLATION", true},
+ {"CONVERSION", true},
+ {"DATABASE", false},
+ {"DOMAIN", true},
+ {"EXTENSION", true},
+ {"EVENT TRIGGER", false},
+ {"FOREIGN DATA WRAPPER", true},
+ {"FOREIGN TABLE", true},
+ {"FUNCTION", true},
+ {"INDEX", true},
+ {"LANGUAGE", true},
+ {"MATERIALIZED VIEW", true},
+ {"OPERATOR", true},
+ {"OPERATOR CLASS", true},
+ {"OPERATOR FAMILY", true},
+ {"ROLE", false},
+ {"RULE", true},
+ {"SCHEMA", true},
+ {"SEQUENCE", true},
+ {"SERVER", true},
+ {"TABLE", true},
+ {"TABLESPACE", false},
+ {"TRIGGER", true},
+ {"TEXT SEARCH CONFIGURATION", true},
+ {"TEXT SEARCH DICTIONARY", true},
+ {"TEXT SEARCH PARSER", true},
+ {"TEXT SEARCH TEMPLATE", true},
+ {"TYPE", true},
+ {"USER MAPPING", true},
+ {"VIEW", true},
+ {NULL, false}
};
/* Support for dropped objects */
typedef struct SQLDropObject
{
- ObjectAddress address;
- const char *schemaname;
- const char *objname;
- const char *objidentity;
- const char *objecttype;
- slist_node next;
+ ObjectAddress address;
+ const char *schemaname;
+ const char *objname;
+ const char *objidentity;
+ const char *objecttype;
+ slist_node next;
} SQLDropObject;
static void AlterEventTriggerOwner_internal(Relation rel,
- HeapTuple tup,
- Oid newOwnerId);
+ HeapTuple tup,
+ Oid newOwnerId);
static event_trigger_command_tag_check_result check_ddl_tag(const char *tag);
static void error_duplicate_filter_variable(const char *defname);
static Datum filter_list_to_array(List *filterlist);
static Oid insert_event_trigger_tuple(char *trigname, char *eventname,
- Oid evtOwner, Oid funcoid, List *tags);
+ Oid evtOwner, Oid funcoid, List *tags);
static void validate_ddl_tags(const char *filtervar, List *taglist);
static void EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata);
*/
if (!superuser())
ereport(ERROR,
- (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("permission denied to create event trigger \"%s\"",
- stmt->trigname),
- errhint("Must be superuser to create an event trigger.")));
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to create event trigger \"%s\"",
+ stmt->trigname),
+ errhint("Must be superuser to create an event trigger.")));
/* Validate event name. */
if (strcmp(stmt->eventname, "ddl_command_start") != 0 &&
strcmp(stmt->eventname, "ddl_command_end") != 0 &&
strcmp(stmt->eventname, "sql_drop") != 0)
ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("unrecognized event name \"%s\"",
- stmt->eventname)));
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("unrecognized event name \"%s\"",
+ stmt->eventname)));
/* Validate filter conditions. */
- foreach (lc, stmt->whenclause)
+ foreach(lc, stmt->whenclause)
{
- DefElem *def = (DefElem *) lfirst(lc);
+ DefElem *def = (DefElem *) lfirst(lc);
if (strcmp(def->defname, "tag") == 0)
{
}
else
ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("unrecognized filter variable \"%s\"", def->defname)));
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("unrecognized filter variable \"%s\"", def->defname)));
}
/* Validate tag list, if any. */
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("event trigger \"%s\" already exists",
- stmt->trigname)));
+ stmt->trigname)));
/* Find and validate the trigger function. */
funcoid = LookupFuncName(stmt->funcname, 0, NULL, false);
{
ListCell *lc;
- foreach (lc, taglist)
+ foreach(lc, taglist)
{
const char *tag = strVal(lfirst(lc));
event_trigger_command_tag_check_result result;
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("filter value \"%s\" not recognized for filter variable \"%s\"",
- tag, filtervar)));
+ tag, filtervar)));
if (result == EVENT_TRIGGER_COMMAND_TAG_NOT_SUPPORTED)
ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* translator: %s represents an SQL statement name */
- errmsg("event triggers are not supported for %s",
- tag)));
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ /* translator: %s represents an SQL statement name */
+ errmsg("event triggers are not supported for %s",
+ tag)));
}
}
check_ddl_tag(const char *tag)
{
const char *obtypename;
- event_trigger_support_data *etsd;
+ event_trigger_support_data *etsd;
/*
* Handle some idiosyncratic special cases.
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("filter variable \"%s\" specified more than once",
- defname)));
+ defname)));
}
/*
insert_event_trigger_tuple(char *trigname, char *eventname, Oid evtOwner,
Oid funcoid, List *taglist)
{
- Relation tgrel;
- Oid trigoid;
+ Relation tgrel;
+ Oid trigoid;
HeapTuple tuple;
Datum values[Natts_pg_trigger];
bool nulls[Natts_pg_trigger];
- ObjectAddress myself, referenced;
+ ObjectAddress myself,
+ referenced;
/* Open pg_event_trigger. */
tgrel = heap_open(EventTriggerRelationId, RowExclusiveLock);
{
Relation tgrel;
HeapTuple tup;
- Oid trigoid;
+ Oid trigoid;
Form_pg_event_trigger evtForm;
- char tgenabled = stmt->tgenabled;
+ char tgenabled = stmt->tgenabled;
tgrel = heap_open(EventTriggerRelationId, RowExclusiveLock);
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("event trigger \"%s\" does not exist",
- stmt->trigname)));
+ stmt->trigname)));
trigoid = HeapTupleGetOid(tup);
if (!HeapTupleIsValid(tup))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("event trigger with OID %u does not exist", trigOid)));
+ errmsg("event trigger with OID %u does not exist", trigOid)));
AlterEventTriggerOwner_internal(rel, tup, newOwnerId);
if (!superuser_arg(newOwnerId))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("permission denied to change owner of event trigger \"%s\"",
- NameStr(form->evtname)),
- errhint("The owner of an event trigger must be a superuser.")));
+ errmsg("permission denied to change owner of event trigger \"%s\"",
+ NameStr(form->evtname)),
+ errhint("The owner of an event trigger must be a superuser.")));
form->evtowner = newOwnerId;
simple_heap_update(rel, &tup->t_self, tup);
* tags matching.
*/
static bool
-filter_event_trigger(const char **tag, EventTriggerCacheItem *item)
+filter_event_trigger(const char **tag, EventTriggerCacheItem *item)
{
/*
* Filter by session replication role, knowing that we never see disabled
}
/*
- * Setup for running triggers for the given event. Return value is an OID list
+ * Setup for running triggers for the given event. Return value is an OID list
* of functions to run; if there are any, trigdata is filled with an
* appropriate EventTriggerData for them to receive.
*/
* invoked to match up exactly with the list that CREATE EVENT TRIGGER
* accepts. This debugging cross-check will throw an error if this
* function is invoked for a command tag that CREATE EVENT TRIGGER won't
- * accept. (Unfortunately, there doesn't seem to be any simple, automated
+ * accept. (Unfortunately, there doesn't seem to be any simple, automated
* way to verify that CREATE EVENT TRIGGER doesn't accept extra stuff that
* never reaches this control point.)
*
tag = CreateCommandTag(parsetree);
/*
- * Filter list of event triggers by command tag, and copy them into
- * our memory context. Once we start running the command trigers, or
- * indeed once we do anything at all that touches the catalogs, an
- * invalidation might leave cachelist pointing at garbage, so we must
- * do this before we can do much else.
+ * Filter list of event triggers by command tag, and copy them into our
+ * memory context. Once we start running the command trigers, or indeed
+ * once we do anything at all that touches the catalogs, an invalidation
+ * might leave cachelist pointing at garbage, so we must do this before we
+ * can do much else.
*/
- foreach (lc, cachelist)
+ foreach(lc, cachelist)
{
- EventTriggerCacheItem *item = lfirst(lc);
+ EventTriggerCacheItem *item = lfirst(lc);
if (filter_event_trigger(&tag, item))
{
EventTriggerDDLCommandStart(Node *parsetree)
{
List *runlist;
- EventTriggerData trigdata;
+ EventTriggerData trigdata;
/*
* Event Triggers are completely disabled in standalone mode. There are
return;
runlist = EventTriggerCommonSetup(parsetree,
- EVT_DDLCommandStart, "ddl_command_start",
+ EVT_DDLCommandStart, "ddl_command_start",
&trigdata);
if (runlist == NIL)
return;
list_free(runlist);
/*
- * Make sure anything the event triggers did will be visible to
- * the main command.
+ * Make sure anything the event triggers did will be visible to the main
+ * command.
*/
CommandCounterIncrement();
}
EventTriggerDDLCommandEnd(Node *parsetree)
{
List *runlist;
- EventTriggerData trigdata;
+ EventTriggerData trigdata;
/*
* See EventTriggerDDLCommandStart for a discussion about why event
return;
/*
- * Make sure anything the main command did will be visible to the
- * event triggers.
+ * Make sure anything the main command did will be visible to the event
+ * triggers.
*/
CommandCounterIncrement();
EventTriggerSQLDrop(Node *parsetree)
{
List *runlist;
- EventTriggerData trigdata;
+ EventTriggerData trigdata;
/*
* See EventTriggerDDLCommandStart for a discussion about why event
return;
/*
- * Use current state to determine whether this event fires at all. If there
- * are no triggers for the sql_drop event, then we don't have anything to do
- * here. Note that dropped object collection is disabled if this is the case,
- * so even if we were to try to run, the list would be empty.
+ * Use current state to determine whether this event fires at all. If
+ * there are no triggers for the sql_drop event, then we don't have
+ * anything to do here. Note that dropped object collection is disabled
+ * if this is the case, so even if we were to try to run, the list would
+ * be empty.
*/
if (!currentEventTriggerState ||
slist_is_empty(¤tEventTriggerState->SQLDropList))
runlist = EventTriggerCommonSetup(parsetree,
EVT_SQLDrop, "sql_drop",
&trigdata);
+
/*
- * Nothing to do if run list is empty. Note this shouldn't happen, because
- * if there are no sql_drop events, then objects-to-drop wouldn't have been
- * collected in the first place and we would have quitted above.
+ * Nothing to do if run list is empty. Note this shouldn't happen,
+ * because if there are no sql_drop events, then objects-to-drop wouldn't
+ * have been collected in the first place and we would have quitted above.
*/
if (runlist == NIL)
return;
/*
- * Make sure anything the main command did will be visible to the
- * event triggers.
+ * Make sure anything the main command did will be visible to the event
+ * triggers.
*/
CommandCounterIncrement();
/*
- * Make sure pg_event_trigger_dropped_objects only works when running these
- * triggers. Use PG_TRY to ensure in_sql_drop is reset even when one
- * trigger fails. (This is perhaps not necessary, as the currentState
+ * Make sure pg_event_trigger_dropped_objects only works when running
+ * these triggers. Use PG_TRY to ensure in_sql_drop is reset even when
+ * one trigger fails. (This is perhaps not necessary, as the currentState
* variable will be removed shortly by our caller, but it seems better to
* play safe.)
*/
static void
EventTriggerInvoke(List *fn_oid_list, EventTriggerData *trigdata)
{
- MemoryContext context;
- MemoryContext oldcontext;
- ListCell *lc;
- bool first = true;
+ MemoryContext context;
+ MemoryContext oldcontext;
+ ListCell *lc;
+ bool first = true;
/* Guard against stack overflow due to recursive event trigger */
check_stack_depth();
/*
- * Let's evaluate event triggers in their own memory context, so
- * that any leaks get cleaned up promptly.
+ * Let's evaluate event triggers in their own memory context, so that any
+ * leaks get cleaned up promptly.
*/
context = AllocSetContextCreate(CurrentMemoryContext,
"event trigger context",
oldcontext = MemoryContextSwitchTo(context);
/* Call each event trigger. */
- foreach (lc, fn_oid_list)
+ foreach(lc, fn_oid_list)
{
- Oid fnoid = lfirst_oid(lc);
- FmgrInfo flinfo;
+ Oid fnoid = lfirst_oid(lc);
+ FmgrInfo flinfo;
FunctionCallInfoData fcinfo;
PgStat_FunctionCallUsage fcusage;
/*
- * We want each event trigger to be able to see the results of
- * the previous event trigger's action. Caller is responsible
- * for any command-counter increment that is needed between the
- * event trigger and anything else in the transaction.
+ * We want each event trigger to be able to see the results of the
+ * previous event trigger's action. Caller is responsible for any
+ * command-counter increment that is needed between the event trigger
+ * and anything else in the transaction.
*/
if (first)
first = false;
return true;
case MAX_OCLASS:
+
/*
* This shouldn't ever happen, but we keep the case to avoid a
* compiler warning without a "default" clause in the switch.
EventTriggerBeginCompleteQuery(void)
{
EventTriggerQueryState *state;
- MemoryContext cxt;
+ MemoryContext cxt;
/*
* Currently, sql_drop events are the only reason to have event trigger
* returned false previously.
*
* Note: this might be called in the PG_CATCH block of a failing transaction,
- * so be wary of running anything unnecessary. (In particular, it's probably
+ * so be wary of running anything unnecessary. (In particular, it's probably
* unwise to try to allocate memory.)
*/
void
void
EventTriggerSQLDropAddObject(ObjectAddress *object)
{
- SQLDropObject *obj;
- MemoryContext oldcxt;
+ SQLDropObject *obj;
+ MemoryContext oldcxt;
if (!currentEventTriggerState)
return;
/*
* Obtain schema names from the object's catalog tuple, if one exists;
- * this lets us skip objects in temp schemas. We trust that ObjectProperty
- * contains all object classes that can be schema-qualified.
+ * this lets us skip objects in temp schemas. We trust that
+ * ObjectProperty contains all object classes that can be
+ * schema-qualified.
*/
if (is_objectclass_supported(object->classId))
{
RelationGetDescr(catalog), &isnull);
if (!isnull)
{
- Oid namespaceId;
+ Oid namespaceId;
namespaceId = DatumGetObjectId(datum);
/* Don't report objects in temp namespaces */
Datum
pg_event_trigger_dropped_objects(PG_FUNCTION_ARGS)
{
- ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
- TupleDesc tupdesc;
- Tuplestorestate *tupstore;
- MemoryContext per_query_ctx;
- MemoryContext oldcontext;
- slist_iter iter;
+ ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ TupleDesc tupdesc;
+ Tuplestorestate *tupstore;
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+ slist_iter iter;
/*
* Protect this function from being called out of context
!currentEventTriggerState->in_sql_drop)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("%s can only be called in a sql_drop event trigger function",
- "pg_event_trigger_dropped_objects()")));
+ errmsg("%s can only be called in a sql_drop event trigger function",
+ "pg_event_trigger_dropped_objects()")));
/* check to see if caller supports us returning a tuplestore */
if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
instrument_option |= INSTRUMENT_BUFFERS;
/*
- * We always collect timing for the entire statement, even when
- * node-level timing is off, so we don't look at es->timing here.
+ * We always collect timing for the entire statement, even when node-level
+ * timing is off, so we don't look at es->timing here.
*/
INSTR_TIME_SET_CURRENT(starttime);
GetUserId(),
languageOid,
languageValidator,
- prosrc_str, /* converted to text later */
- probin_str, /* converted to text later */
+ prosrc_str, /* converted to text later */
+ probin_str, /* converted to text later */
false, /* not an aggregate */
isWindowFunc,
security,
* (but not VACUUM).
*/
rel = heap_openrv(stmt->relation,
- (stmt->concurrent ? ShareUpdateExclusiveLock : ShareLock));
+ (stmt->concurrent ? ShareUpdateExclusiveLock : ShareLock));
relationId = RelationGetRelid(rel);
namespaceId = RelationGetNamespace(rel);
* Drop the reference snapshot. We must do this before waiting out other
* snapshot holders, else we will deadlock against other processes also
* doing CREATE INDEX CONCURRENTLY, which would see our snapshot as one
- * they must wait for. But first, save the snapshot's xmin to use as
+ * they must wait for. But first, save the snapshot's xmin to use as
* limitXmin for GetCurrentVirtualXIDs().
*/
limitXmin = snapshot->xmin;
static void transientrel_shutdown(DestReceiver *self);
static void transientrel_destroy(DestReceiver *self);
static void refresh_matview_datafill(DestReceiver *dest, Query *query,
- const char *queryString);
+ const char *queryString);
/*
* SetMatViewPopulatedState
*/
void
ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
- ParamListInfo params, char *completionTag)
+ ParamListInfo params, char *completionTag)
{
Oid matviewOid;
Relation matviewRel;
* Get a lock until end of transaction.
*/
matviewOid = RangeVarGetRelidExtended(stmt->relation,
- AccessExclusiveLock, false, false,
- RangeVarCallbackOwnsTable, NULL);
+ AccessExclusiveLock, false, false,
+ RangeVarCallbackOwnsTable, NULL);
matviewRel = heap_open(matviewOid, NoLock);
/* Make sure it is a materialized view. */
refresh_matview_datafill(DestReceiver *dest, Query *query,
const char *queryString)
{
- List *rewritten;
+ List *rewritten;
PlannedStmt *plan;
QueryDesc *queryDesc;
transientrel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
{
DR_transientrel *myState = (DR_transientrel *) self;
- Relation transientrel;
+ Relation transientrel;
transientrel = heap_open(myState->transientoid, NoLock);
* Subroutine for ALTER OPERATOR CLASS SET SCHEMA/RENAME
*
* Is there an operator class with the given name and signature already
- * in the given namespace? If so, raise an appropriate error message.
+ * in the given namespace? If so, raise an appropriate error message.
*/
void
IsThereOpClassInNamespace(const char *opcname, Oid opcmethod,
* Subroutine for ALTER OPERATOR FAMILY SET SCHEMA/RENAME
*
* Is there an operator family with the given name and signature already
- * in the given namespace? If so, raise an appropriate error message.
+ * in the given namespace? If so, raise an appropriate error message.
*/
void
IsThereOpFamilyInNamespace(const char *opfname, Oid opfmethod,
* now have OperatorCreate do all the work..
*/
return
- OperatorCreate(oprName, /* operator name */
+ OperatorCreate(oprName, /* operator name */
oprNamespace, /* namespace */
- typeId1, /* left type id */
- typeId2, /* right type id */
- functionOid, /* function for operator */
- commutatorName, /* optional commutator operator name */
- negatorName, /* optional negator operator name */
- restrictionOid, /* optional restrict. sel. procedure */
- joinOid, /* optional join sel. procedure name */
+ typeId1, /* left type id */
+ typeId2, /* right type id */
+ functionOid, /* function for operator */
+ commutatorName, /* optional commutator operator name */
+ negatorName, /* optional negator operator name */
+ restrictionOid, /* optional restrict. sel. procedure */
+ joinOid, /* optional join sel. procedure name */
canMerge, /* operator merges */
canHash); /* operator hashes */
}
} PLTemplate;
static Oid create_proc_lang(const char *languageName, bool replace,
- Oid languageOwner, Oid handlerOid, Oid inlineOid,
- Oid valOid, bool trusted);
+ Oid languageOwner, Oid handlerOid, Oid inlineOid,
+ Oid valOid, bool trusted);
static PLTemplate *find_language_template(const char *languageName);
/* ---------------------------------------------------------------------
/*
* We must mark the buffer dirty before doing XLogInsert(); see notes in
* SyncOneBuffer(). However, we don't apply the desired changes just yet.
- * This looks like a violation of the buffer update protocol, but it is
- * in fact safe because we hold exclusive lock on the buffer. Any other
+ * This looks like a violation of the buffer update protocol, but it is in
+ * fact safe because we hold exclusive lock on the buffer. Any other
* process, including a checkpoint, that tries to examine the buffer
* contents will block until we release the lock, and then will see the
* final state that we install below.
}
/*
- * We must reset log_cnt when isInit or when changing any parameters
- * that would affect future nextval allocations.
+ * We must reset log_cnt when isInit or when changing any parameters that
+ * would affect future nextval allocations.
*/
if (isInit)
new->log_cnt = 0;
int16 seqNumber, Relation inhRelation);
static int findAttrByName(const char *attributeName, List *schema);
static void AlterIndexNamespaces(Relation classRel, Relation rel,
- Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved);
+ Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved);
static void AlterSeqNamespaces(Relation classRel, Relation rel,
Oid oldNspOid, Oid newNspOid, ObjectAddresses *objsMoved,
LOCKMODE lockmode);
{
Oid heap_relid;
Oid toast_relid;
- MultiXactId minmulti;
+ MultiXactId minmulti;
/*
* This effectively deletes all rows in the table, and may be done
&found_whole_row);
/*
- * For the moment we have to reject whole-row variables.
- * We could convert them, if we knew the new table's rowtype
- * OID, but that hasn't been assigned yet.
+ * For the moment we have to reject whole-row variables. We
+ * could convert them, if we knew the new table's rowtype OID,
+ * but that hasn't been assigned yet.
*/
if (found_whole_row)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot convert whole-row table reference"),
+ errmsg("cannot convert whole-row table reference"),
errdetail("Constraint \"%s\" contains a whole-row reference to table \"%s\".",
name,
RelationGetRelationName(relation))));
Relation targetrelation;
Relation attrelation;
HeapTuple atttup;
- Form_pg_attribute attform;
+ Form_pg_attribute attform;
int attnum;
/*
rename_constraint_internal(relid, typid,
stmt->subname,
stmt->newname,
- stmt->relation ? interpretInhOption(stmt->relation->inhOpt) : false, /* recursive? */
- false, /* recursing? */
+ stmt->relation ? interpretInhOption(stmt->relation->inhOpt) : false, /* recursive? */
+ false, /* recursing? */
0 /* expected inhcount */ );
}
case AT_ColumnDefault:
case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
true, false, lockmode);
break;
- case AT_ReAddConstraint: /* Re-add pre-existing check constraint */
+ case AT_ReAddConstraint: /* Re-add pre-existing check
+ * constraint */
ATExecAddConstraint(wqueue, tab, rel, (Constraint *) cmd->def,
false, true, lockmode);
break;
ereport(ERROR,
(errcode(ERRCODE_NOT_NULL_VIOLATION),
errmsg("column \"%s\" contains null values",
- NameStr(newTupDesc->attrs[attn]->attname)),
+ NameStr(newTupDesc->attrs[attn]->attname)),
errtablecol(oldrel, attn + 1)));
}
stmt->deferrable,
stmt->initdeferred,
stmt->primary,
- true, /* update pg_index */
- true, /* remove old dependencies */
+ true, /* update pg_index */
+ true, /* remove old dependencies */
allowSystemTableMods,
- false); /* is_internal */
+ false); /* is_internal */
index_close(indexRel, NoLock);
}
!parent_rel->rd_islocaltemp)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot inherit from temporary relation of another session")));
+ errmsg("cannot inherit from temporary relation of another session")));
/* Ditto for the child */
if (child_rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
!child_rel->rd_islocaltemp)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot inherit to temporary relation of another session")));
+ errmsg("cannot inherit to temporary relation of another session")));
/*
* Check for duplicates in the list of parents, and determine the highest
RelationGetRelid(parent_rel));
/*
- * Post alter hook of this inherits. Since object_access_hook doesn't
- * take multiple object identifiers, we relay oid of parent relation
- * using auxiliary_id argument.
+ * Post alter hook of this inherits. Since object_access_hook doesn't take
+ * multiple object identifiers, we relay oid of parent relation using
+ * auxiliary_id argument.
*/
InvokeObjectPostAlterHookArg(InheritsRelationId,
RelationGetRelid(rel), 0,
void
AlterRelationNamespaceInternal(Relation classRel, Oid relOid,
Oid oldNspOid, Oid newNspOid,
- bool hasDependEntry, ObjectAddresses *objsMoved)
+ bool hasDependEntry, ObjectAddresses *objsMoved)
{
HeapTuple classTup;
Form_pg_class classForm;
- ObjectAddress thisobj;
+ ObjectAddress thisobj;
classTup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relOid));
if (!HeapTupleIsValid(classTup))
/* Update dependency on schema if caller said so */
if (hasDependEntry &&
changeDependencyFor(RelationRelationId, relOid,
- NamespaceRelationId, oldNspOid, newNspOid) != 1)
+ NamespaceRelationId, oldNspOid, newNspOid) != 1)
elog(ERROR, "failed to change schema dependency for relation \"%s\"",
NameStr(classForm->relname));
/* Do nothing (there shouldn't be such entries, actually) */
break;
case ONCOMMIT_DELETE_ROWS:
+
/*
* If this transaction hasn't accessed any temporary
* relations, we can skip truncating ON COMMIT DELETE ROWS
* This is intended as a callback for RangeVarGetRelidExtended(). It allows
* the relation to be locked only if (1) it's a plain table, materialized
* view, or TOAST table and (2) the current user is the owner (or the
- * superuser). This meets the permission-checking needs of CLUSTER, REINDEX
+ * superuser). This meets the permission-checking needs of CLUSTER, REINDEX
* TABLE, and REFRESH MATERIALIZED VIEW; we expose it here so that it can be
* used by all.
*/
true, /* islocal */
0, /* inhcount */
true, /* isnoinherit */
- isInternal); /* is_internal */
+ isInternal); /* is_internal */
}
/*
if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
{
tgoid = HeapTupleGetOid(tuple);
+
/*
* Update pg_trigger tuple with new tgname.
*/
if (trigdesc && trigdesc->trig_delete_after_row)
{
HeapTuple trigtuple = GetTupleForTrigger(estate, NULL, relinfo,
- tupleid, LockTupleExclusive,
+ tupleid, LockTupleExclusive,
NULL);
AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_DELETE,
if (trigdesc && trigdesc->trig_update_after_row)
{
HeapTuple trigtuple = GetTupleForTrigger(estate, NULL, relinfo,
- tupleid, LockTupleExclusive,
+ tupleid, LockTupleExclusive,
NULL);
AfterTriggerSaveEvent(estate, relinfo, TRIGGER_EVENT_UPDATE,
tuple.t_self = *tid;
test = heap_lock_tuple(relation, &tuple,
estate->es_output_cid,
- lockmode, false /* wait */,
+ lockmode, false /* wait */ ,
false, &buffer, &hufd);
switch (test)
{
case HeapTupleSelfUpdated:
+
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
array_type, /* type name */
typeNamespace, /* namespace */
InvalidOid, /* relation oid (n/a here) */
- 0, /* relation kind (ditto) */
- GetUserId(), /* owner's ID */
- -1, /* internal size (always varlena) */
+ 0, /* relation kind (ditto) */
+ GetUserId(), /* owner's ID */
+ -1, /* internal size (always varlena) */
TYPTYPE_BASE, /* type-type (base type) */
TYPCATEGORY_ARRAY, /* type-category (array) */
- false, /* array types are never preferred */
+ false, /* array types are never preferred */
delimiter, /* array element delimiter */
F_ARRAY_IN, /* input procedure */
- F_ARRAY_OUT, /* output procedure */
+ F_ARRAY_OUT, /* output procedure */
F_ARRAY_RECV, /* receive procedure */
F_ARRAY_SEND, /* send procedure */
- typmodinOid, /* typmodin procedure */
+ typmodinOid, /* typmodin procedure */
typmodoutOid, /* typmodout procedure */
F_ARRAY_TYPANALYZE, /* analyze procedure */
- typoid, /* element type ID */
- true, /* yes this is an array type */
+ typoid, /* element type ID */
+ true, /* yes this is an array type */
InvalidOid, /* no further array type */
InvalidOid, /* base type ID */
- NULL, /* never a default type value */
- NULL, /* binary default isn't sent either */
- false, /* never passed by value */
+ NULL, /* never a default type value */
+ NULL, /* binary default isn't sent either */
+ false, /* never passed by value */
alignment, /* see above */
- 'x', /* ARRAY is always toastable */
- -1, /* typMod (Domains only) */
- 0, /* Array dimensions of typbasetype */
- false, /* Type NOT NULL */
+ 'x', /* ARRAY is always toastable */
+ -1, /* typMod (Domains only) */
+ 0, /* Array dimensions of typbasetype */
+ false, /* Type NOT NULL */
collation); /* type's collation */
pfree(array_type);
/*
* Check constraints are handled after domain creation, as
* they require the Oid of the domain; at this point we can
- * only check that they're not marked NO INHERIT, because
- * that would be bogus.
+ * only check that they're not marked NO INHERIT, because that
+ * would be bogus.
*/
if (constr->is_no_inherit)
ereport(ERROR,
/*
* Ordinarily we disallow adding values within transaction blocks, because
* we can't cope with enum OID values getting into indexes and then having
- * their defining pg_enum entries go away. However, it's okay if the enum
- * type was created in the current transaction, since then there can be
- * no such indexes that wouldn't themselves go away on rollback. (We
- * support this case because pg_dump --binary-upgrade needs it.) We test
- * this by seeing if the pg_type row has xmin == current XID and is not
- * HEAP_UPDATED. If it is HEAP_UPDATED, we can't be sure whether the
- * type was created or only modified in this xact. So we are disallowing
- * some cases that could theoretically be safe; but fortunately pg_dump
- * only needs the simplest case.
+ * their defining pg_enum entries go away. However, it's okay if the enum
+ * type was created in the current transaction, since then there can be no
+ * such indexes that wouldn't themselves go away on rollback. (We support
+ * this case because pg_dump --binary-upgrade needs it.) We test this by
+ * seeing if the pg_type row has xmin == current XID and is not
+ * HEAP_UPDATED. If it is HEAP_UPDATED, we can't be sure whether the type
+ * was created or only modified in this xact. So we are disallowing some
+ * cases that could theoretically be safe; but fortunately pg_dump only
+ * needs the simplest case.
*/
if (HeapTupleHeaderGetXmin(tup->t_data) == GetCurrentTransactionId() &&
!(tup->t_data->t_infomask & HEAP_UPDATED))
- /* safe to do inside transaction block */ ;
+ /* safe to do inside transaction block */ ;
else
PreventTransactionChain(isTopLevel, "ALTER TYPE ... ADD");
/*
* In principle the auxiliary information for this
* error should be errdatatype(), but errtablecol()
- * seems considerably more useful in practice. Since
+ * seems considerably more useful in practice. Since
* this code only executes in an ALTER DOMAIN command,
* the client should already know which domain is in
* question.
/*
* In principle the auxiliary information for this error
* should be errdomainconstraint(), but errtablecol()
- * seems considerably more useful in practice. Since this
+ * seems considerably more useful in practice. Since this
* code only executes in an ALTER DOMAIN command, the
* client should already know which domain is in question,
* and which constraint too.
true, /* is local */
0, /* inhcount */
false, /* connoinherit */
- false); /* is_internal */
+ false); /* is_internal */
/*
* Return the compiled constraint expression so the calling routine can
* hasDependEntry should be TRUE if type is expected to have a pg_shdepend
* entry (ie, it's not a table rowtype nor an array type).
* is_primary_ops should be TRUE if this function is invoked with user's
- * direct operation (e.g, shdepReassignOwned). Elsewhere,
+ * direct operation (e.g, shdepReassignOwned). Elsewhere,
*/
void
AlterTypeOwnerInternal(Oid typeOid, Oid newOwnerId,
TypeName *typename;
Oid typeOid;
Oid nspOid;
- ObjectAddresses *objsMoved;
+ ObjectAddresses *objsMoved;
/* Make a TypeName so we can use standard type lookup machinery */
typename = makeTypeNameFromNameList(names);
{
HeapTuple roletuple;
Oid databaseid = InvalidOid;
- Oid roleid = InvalidOid;
+ Oid roleid = InvalidOid;
if (stmt->role)
{
* Since we don't take a lock here, the relation might be gone, or the
* RangeVar might no longer refer to the OID we look up here. In the
* former case, VACUUM will do nothing; in the latter case, it will
- * process the OID we looked up here, rather than the new one.
- * Neither is ideal, but there's little practical alternative, since
- * we're going to commit this transaction and begin a new one between
- * now and then.
+ * process the OID we looked up here, rather than the new one. Neither
+ * is ideal, but there's little practical alternative, since we're
+ * going to commit this transaction and begin a new one between now
+ * and then.
*/
relid = RangeVarGetRelid(vacrel, NoLock, false);
if (multiXactFrzLimit != NULL)
{
- MultiXactId mxLimit;
+ MultiXactId mxLimit;
/*
* simplistic multixactid freezing: use the same freezing policy as
SysScanDesc scan;
HeapTuple classTup;
TransactionId newFrozenXid;
- MultiXactId newFrozenMulti;
+ MultiXactId newFrozenMulti;
bool dirty = false;
/*
newFrozenXid = GetOldestXmin(true, true);
/*
- * Similarly, initialize the MultiXact "min" with the value that would
- * be used on pg_class for new tables. See AddNewRelationTuple().
+ * Similarly, initialize the MultiXact "min" with the value that would be
+ * used on pg_class for new tables. See AddNewRelationTuple().
*/
newFrozenMulti = GetOldestMultiXactId();
/*
* Update the wrap limit for GetNewTransactionId and creation of new
- * MultiXactIds. Note: these functions will also signal the postmaster for
- * an(other) autovac cycle if needed. XXX should we avoid possibly
+ * MultiXactIds. Note: these functions will also signal the postmaster
+ * for an(other) autovac cycle if needed. XXX should we avoid possibly
* signalling twice?
*/
SetTransactionIdLimit(frozenXID, oldestxid_datoid);
* that the potential for improvement was great enough to merit the cost of
* supporting them.
*/
-#define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL 20 /* ms */
-#define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL 50 /* ms */
-#define VACUUM_TRUNCATE_LOCK_TIMEOUT 5000 /* ms */
+#define VACUUM_TRUNCATE_LOCK_CHECK_INTERVAL 20 /* ms */
+#define VACUUM_TRUNCATE_LOCK_WAIT_INTERVAL 50 /* ms */
+#define VACUUM_TRUNCATE_LOCK_TIMEOUT 5000 /* ms */
/*
* Guesstimation of number of dead tuples per page. This is used to
double new_rel_tuples;
BlockNumber new_rel_allvisible;
TransactionId new_frozen_xid;
- MultiXactId new_min_multi;
+ MultiXactId new_min_multi;
/* measure elapsed time iff autovacuum logging requires it */
if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0)
/* report results to the stats collector, too */
pgstat_report_vacuum(RelationGetRelid(onerel),
- onerel->rd_rel->relisshared,
- new_rel_tuples);
+ onerel->rd_rel->relisshared,
+ new_rel_tuples);
/* and log the action if appropriate */
if (IsAutoVacuumWorkerProcess() && Log_autovacuum_min_duration >= 0)
"pages: %d removed, %d remain\n"
"tuples: %.0f removed, %.0f remain\n"
"buffer usage: %d hits, %d misses, %d dirtied\n"
- "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"
+ "avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"
"system usage: %s",
get_database_name(MyDatabaseId),
get_namespace_name(RelationGetNamespace(onerel)),
/*
* It should never be the case that the visibility map page is set
* while the page-level bit is clear, but the reverse is allowed
- * (if checksums are not enabled). Regardless, set the both bits
+ * (if checksums are not enabled). Regardless, set the both bits
* so that we get back in sync.
*
* NB: If the heap page is all-visible but the VM bit is not set,
- * we don't need to dirty the heap page. However, if checksums are
- * enabled, we do need to make sure that the heap page is dirtied
- * before passing it to visibilitymap_set(), because it may be
- * logged. Given that this situation should only happen in rare
- * cases after a crash, it is not worth optimizing.
+ * we don't need to dirty the heap page. However, if checksums
+ * are enabled, we do need to make sure that the heap page is
+ * dirtied before passing it to visibilitymap_set(), because it
+ * may be logged. Given that this situation should only happen in
+ * rare cases after a crash, it is not worth optimizing.
*/
PageSetAllVisible(page);
MarkBufferDirty(buf);
Page page = BufferGetPage(buffer);
OffsetNumber unused[MaxOffsetNumber];
int uncnt = 0;
- TransactionId visibility_cutoff_xid;
+ TransactionId visibility_cutoff_xid;
START_CRIT_SECTION();
MarkBufferDirty(buffer);
/*
- * Now that we have removed the dead tuples from the page, once again check
- * if the page has become all-visible.
+ * Now that we have removed the dead tuples from the page, once again
+ * check if the page has become all-visible.
*/
if (!visibilitymap_test(onerel, blkno, vmbuffer) &&
heap_page_is_all_visible(buffer, &visibility_cutoff_xid))
Assert(BufferIsValid(*vmbuffer));
PageSetAllVisible(page);
visibilitymap_set(onerel, blkno, buffer, InvalidXLogRecPtr, *vmbuffer,
- visibility_cutoff_xid);
+ visibility_cutoff_xid);
}
/* XLOG stuff */
static bool
heap_page_is_all_visible(Buffer buf, TransactionId *visibility_cutoff_xid)
{
- Page page = BufferGetPage(buf);
+ Page page = BufferGetPage(buf);
OffsetNumber offnum,
- maxoff;
- bool all_visible = true;
+ maxoff;
+ bool all_visible = true;
*visibility_cutoff_xid = InvalidTransactionId;
/*
* This is a stripped down version of the line pointer scan in
- * lazy_scan_heap(). So if you change anything here, also check that
- * code.
+ * lazy_scan_heap(). So if you change anything here, also check that code.
*/
maxoff = PageGetMaxOffsetNumber(page);
for (offnum = FirstOffsetNumber;
- offnum <= maxoff && all_visible;
- offnum = OffsetNumberNext(offnum))
+ offnum <= maxoff && all_visible;
+ offnum = OffsetNumberNext(offnum))
{
- ItemId itemid;
- HeapTupleData tuple;
+ ItemId itemid;
+ HeapTupleData tuple;
itemid = PageGetItemId(page, offnum);
ItemPointerSet(&(tuple.t_self), BufferGetBlockNumber(buf), offnum);
/*
- * Dead line pointers can have index pointers pointing to them. So they
- * can't be treated as visible
+ * Dead line pointers can have index pointers pointing to them. So
+ * they can't be treated as visible
*/
if (ItemIdIsDead(itemid))
{
}
/*
- * 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))
elog(ERROR, "unexpected HeapTupleSatisfiesVacuum result");
break;
}
- } /* scan along page */
+ } /* scan along page */
return all_visible;
}
RelationGetRelationName(resultRel))));
break;
case RELKIND_VIEW:
+
/*
* Okay only if there's a suitable INSTEAD OF trigger. Messages
* here should match rewriteHandler.c's rewriteTargetView, except
* that we omit errdetail because we haven't got the information
- * handy (and given that we really shouldn't get here anyway,
- * it's not worth great exertion to get).
+ * handy (and given that we really shouldn't get here anyway, it's
+ * not worth great exertion to get).
*/
switch (operation)
{
if (fdwroutine->ExecForeignInsert == NULL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot insert into foreign table \"%s\"",
- RelationGetRelationName(resultRel))));
+ errmsg("cannot insert into foreign table \"%s\"",
+ RelationGetRelationName(resultRel))));
break;
case CMD_UPDATE:
if (fdwroutine->ExecForeignUpdate == NULL)
if (fdwroutine->ExecForeignDelete == NULL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot delete from foreign table \"%s\"",
- RelationGetRelationName(resultRel))));
+ errmsg("cannot delete from foreign table \"%s\"",
+ RelationGetRelationName(resultRel))));
break;
default:
elog(ERROR, "unrecognized CmdType: %d", (int) operation);
}
/*
- * close any relations selected FOR [KEY] UPDATE/SHARE, again keeping locks
+ * close any relations selected FOR [KEY] UPDATE/SHARE, again keeping
+ * locks
*/
foreach(l, estate->es_rowMarks)
{
qual = resultRelInfo->ri_ConstraintExprs[i];
/*
- * NOTE: SQL specifies that a NULL result from a constraint
- * expression is not to be treated as a failure. Therefore, tell
- * ExecQual to return TRUE for NULL.
+ * NOTE: SQL specifies that a NULL result from a constraint expression
+ * is not to be treated as a failure. Therefore, tell ExecQual to
+ * return TRUE for NULL.
*/
if (!ExecQual(qual, econtext, true))
return check[i].ccname;
/*
* If tuple was inserted by our own transaction, we have to check
* cmin against es_output_cid: cmin >= current CID means our
- * command cannot see the tuple, so we should ignore it.
- * Otherwise heap_lock_tuple() will throw an error, and so would
- * any later attempt to update or delete the tuple. (We need not
- * check cmax because HeapTupleSatisfiesDirty will consider a
- * tuple deleted by our transaction dead, regardless of cmax.)
- * Wee just checked that priorXmax == xmin, so we can test that
- * variable instead of doing HeapTupleHeaderGetXmin again.
+ * command cannot see the tuple, so we should ignore it. Otherwise
+ * heap_lock_tuple() will throw an error, and so would any later
+ * attempt to update or delete the tuple. (We need not check cmax
+ * because HeapTupleSatisfiesDirty will consider a tuple deleted
+ * by our transaction dead, regardless of cmax.) Wee just checked
+ * that priorXmax == xmin, so we can test that variable instead of
+ * doing HeapTupleHeaderGetXmin again.
*/
if (TransactionIdIsCurrentTransactionId(priorXmax) &&
HeapTupleHeaderGetCmin(tuple.t_data) >= estate->es_output_cid)
*/
test = heap_lock_tuple(relation, &tuple,
estate->es_output_cid,
- lockmode, false /* wait */,
+ lockmode, false /* wait */ ,
false, &buffer, &hufd);
/* We now have two pins on the buffer, get rid of one */
ReleaseBuffer(buffer);
switch (test)
{
case HeapTupleSelfUpdated:
+
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
{
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("WHERE CURRENT OF is not supported for this table type")));
+ errmsg("WHERE CURRENT OF is not supported for this table type")));
return 0; /* keep compiler quiet */
}
rettype,
-1,
get_typcollation(rettype),
- COERCE_IMPLICIT_CAST);
+ COERCE_IMPLICIT_CAST);
/* Relabel is dangerous if sort/group or setop column */
if (tle->ressortgroupref != 0 || parse->setOperations)
*modifyTargetList = true;
atttype,
-1,
get_typcollation(atttype),
- COERCE_IMPLICIT_CAST);
+ COERCE_IMPLICIT_CAST);
/* Relabel is dangerous if sort/group or setop column */
if (tle->ressortgroupref != 0 || parse->setOperations)
*modifyTargetList = true;
break;
default:
elog(ERROR, "unsupported rowmark type");
- lockmode = LockTupleNoKeyExclusive; /* keep compiler quiet */
+ lockmode = LockTupleNoKeyExclusive; /* keep compiler quiet */
break;
}
switch (test)
{
case HeapTupleSelfUpdated:
+
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
result = heap_delete(resultRelationDesc, tupleid,
estate->es_output_cid,
estate->es_crosscheck_snapshot,
- true /* wait for commit */,
+ true /* wait for commit */ ,
&hufd);
switch (result)
{
case HeapTupleSelfUpdated:
+
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
* transaction. The former case is possible in a join DELETE
- * where multiple tuples join to the same target tuple.
- * This is somewhat questionable, but Postgres has always
- * allowed it: we just ignore additional deletion attempts.
+ * where multiple tuples join to the same target tuple. This
+ * is somewhat questionable, but Postgres has always allowed
+ * it: we just ignore additional deletion attempts.
*
* The latter case arises if the tuple is modified by a
* command in a BEFORE trigger, or perhaps by a command in a
* proceed. We don't want to discard the original DELETE
* while keeping the triggered actions based on its deletion;
* and it would be no better to allow the original DELETE
- * while discarding updates that it triggered. The row update
+ * while discarding updates that it triggered. The row update
* carries some information that might be important according
* to business rules; so throwing an error is the only safe
* course.
*
- * If a trigger actually intends this type of interaction,
- * it can re-execute the DELETE and then return NULL to
- * cancel the outer delete.
+ * If a trigger actually intends this type of interaction, it
+ * can re-execute the DELETE and then return NULL to cancel
+ * the outer delete.
*/
if (hufd.cmax != estate->es_output_cid)
ereport(ERROR,
}
else
{
- LockTupleMode lockmode;
+ LockTupleMode lockmode;
/*
* Check the constraints of the tuple
result = heap_update(resultRelationDesc, tupleid, tuple,
estate->es_output_cid,
estate->es_crosscheck_snapshot,
- true /* wait for commit */,
+ true /* wait for commit */ ,
&hufd, &lockmode);
switch (result)
{
case HeapTupleSelfUpdated:
+
/*
* The target tuple was already updated or deleted by the
* current command, or by a later command in the current
* transaction. The former case is possible in a join UPDATE
- * where multiple tuples join to the same target tuple.
- * This is pretty questionable, but Postgres has always
- * allowed it: we just execute the first update action and
- * ignore additional update attempts.
+ * where multiple tuples join to the same target tuple. This
+ * is pretty questionable, but Postgres has always allowed it:
+ * we just execute the first update action and ignore
+ * additional update attempts.
*
* The latter case arises if the tuple is modified by a
* command in a BEFORE trigger, or perhaps by a command in a
* previous ones. So throwing an error is the only safe
* course.
*
- * If a trigger actually intends this type of interaction,
- * it can re-execute the UPDATE (assuming it can figure out
- * how) and then return NULL to cancel the outer update.
+ * If a trigger actually intends this type of interaction, it
+ * can re-execute the UPDATE (assuming it can figure out how)
+ * and then return NULL to cancel the outer update.
*/
if (hufd.cmax != estate->es_output_cid)
ereport(ERROR,
* open that relation and acquire appropriate lock on it.
*/
currentRelation = ExecOpenScanRelation(estate,
- ((SeqScan *) node->ps.plan)->scanrelid,
+ ((SeqScan *) node->ps.plan)->scanrelid,
eflags);
/* initialize a heapscan */
* CachedPlanSources.
*
* This is exported so that pl/pgsql can use it (this beats letting pl/pgsql
- * look directly into the SPIPlan for itself). It's not documented in
+ * look directly into the SPIPlan for itself). It's not documented in
* spi.sgml because we'd just as soon not have too many places using this.
*/
List *
* return NULL. Caller is responsible for doing ReleaseCachedPlan().
*
* This is exported so that pl/pgsql can use it (this beats letting pl/pgsql
- * look directly into the SPIPlan for itself). It's not documented in
+ * look directly into the SPIPlan for itself). It's not documented in
* spi.sgml because we'd just as soon not have too many places using this.
*/
CachedPlan *
stmt_list = pg_analyze_and_rewrite_params(parsetree,
src,
plan->parserSetup,
- plan->parserSetupArg);
+ plan->parserSetupArg);
}
else
{
plan->parserSetup,
plan->parserSetupArg,
plan->cursor_options,
- false); /* not fixed result */
+ false); /* not fixed result */
}
/*
int sz;
binaryheap *heap;
- sz = offsetof(binaryheap, bh_nodes) + sizeof(Datum) * capacity;
+ sz = offsetof(binaryheap, bh_nodes) +sizeof(Datum) * capacity;
heap = palloc(sz);
heap->bh_size = 0;
heap->bh_space = capacity;
static inline void
swap_nodes(binaryheap *heap, int a, int b)
{
- Datum swap;
+ Datum swap;
swap = heap->bh_nodes[a];
heap->bh_nodes[a] = heap->bh_nodes[b];
return ret;
retval = krb5_recvauth(pg_krb5_context, &auth_context,
- (krb5_pointer) &port->sock, pg_krb_srvnam,
+ (krb5_pointer) & port->sock, pg_krb_srvnam,
pg_krb5_server, 0, pg_krb5_keytab, &ticket);
if (retval)
{
{
ldap_unbind(*ldap);
ereport(LOG,
- (errmsg("could not set LDAP protocol version: %s", ldap_err2string(r))));
+ (errmsg("could not set LDAP protocol version: %s", ldap_err2string(r))));
return STATUS_ERROR;
}
{
ldap_unbind(*ldap);
ereport(LOG,
- (errmsg("could not start LDAP TLS session: %s", ldap_err2string(r))));
+ (errmsg("could not start LDAP TLS session: %s", ldap_err2string(r))));
return STATUS_ERROR;
}
}
{
ereport(LOG,
(errmsg("could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": %s",
- port->hba->ldapbinddn, port->hba->ldapserver, ldap_err2string(r))));
+ port->hba->ldapbinddn, port->hba->ldapserver, ldap_err2string(r))));
return STATUS_ERROR;
}
{
ereport(LOG,
(errmsg("could not search LDAP for filter \"%s\" on server \"%s\": %s",
- filter, port->hba->ldapserver, ldap_err2string(r))));
+ filter, port->hba->ldapserver, ldap_err2string(r))));
pfree(filter);
return STATUS_ERROR;
}
{
if (count == 0)
ereport(LOG,
- (errmsg("LDAP user \"%s\" does not exist", port->user_name),
- errdetail("LDAP search for filter \"%s\" on server \"%s\" returned no entries.",
- filter, port->hba->ldapserver)));
+ (errmsg("LDAP user \"%s\" does not exist", port->user_name),
+ errdetail("LDAP search for filter \"%s\" on server \"%s\" returned no entries.",
+ filter, port->hba->ldapserver)));
else
ereport(LOG,
- (errmsg("LDAP user \"%s\" is not unique", port->user_name),
- errdetail_plural("LDAP search for filter \"%s\" on server \"%s\" returned %d entry.",
- "LDAP search for filter \"%s\" on server \"%s\" returned %d entries.",
- count,
- filter, port->hba->ldapserver, count)));
+ (errmsg("LDAP user \"%s\" is not unique", port->user_name),
+ errdetail_plural("LDAP search for filter \"%s\" on server \"%s\" returned %d entry.",
+ "LDAP search for filter \"%s\" on server \"%s\" returned %d entries.",
+ count,
+ filter, port->hba->ldapserver, count)));
pfree(filter);
ldap_msgfree(search_message);
if (r != LDAP_SUCCESS)
{
ereport(LOG,
- (errmsg("LDAP login failed for user \"%s\" on server \"%s\": %s",
- fulluser, port->hba->ldapserver, ldap_err2string(r))));
+ (errmsg("LDAP login failed for user \"%s\" on server \"%s\": %s",
+ fulluser, port->hba->ldapserver, ldap_err2string(r))));
pfree(fulluser);
return STATUS_ERROR;
}
while (!feof(file) && !ferror(file))
{
- char rawline[MAX_LINE];
- char *lineptr;
+ char rawline[MAX_LINE];
+ char *lineptr;
if (!fgets(rawline, sizeof(rawline), file))
break;
- if (strlen(rawline) == MAX_LINE-1)
+ if (strlen(rawline) == MAX_LINE - 1)
/* Line too long! */
ereport(ERROR,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
line_number, filename)));
/* Strip trailing linebreak from rawline */
- while (rawline[strlen(rawline)-1] == '\n' ||
- rawline[strlen(rawline)-1] == '\r')
- rawline[strlen(rawline)-1] = '\0';
+ while (rawline[strlen(rawline) - 1] == '\n' ||
+ rawline[strlen(rawline) - 1] == '\r')
+ rawline[strlen(rawline) - 1] = '\0';
lineptr = rawline;
while (strlen(lineptr) > 0)
{
#ifdef LDAP_API_FEATURE_X_OPENLDAP
LDAPURLDesc *urldata;
- int rc;
+ int rc;
#endif
REQUIRE_AUTH_OPTION(uaLDAP, "ldapurl", "ldap");
if (rc != LDAP_SUCCESS)
{
ereport(LOG,
- (errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("could not parse LDAP URL \"%s\": %s", val, ldap_err2string(rc))));
+ (errcode(ERRCODE_CONFIG_FILE_ERROR),
+ errmsg("could not parse LDAP URL \"%s\": %s", val, ldap_err2string(rc))));
return false;
}
{
ereport(LOG,
(errcode(ERRCODE_CONFIG_FILE_ERROR),
- errmsg("unsupported LDAP URL scheme: %s", urldata->lud_scheme)));
+ errmsg("unsupported LDAP URL scheme: %s", urldata->lud_scheme)));
ldap_free_urldesc(urldata);
return false;
}
hbaline->ldapbasedn = pstrdup(urldata->lud_dn);
if (urldata->lud_attrs)
- hbaline->ldapsearchattribute = pstrdup(urldata->lud_attrs[0]); /* only use first one */
+ hbaline->ldapsearchattribute = pstrdup(urldata->lud_attrs[0]); /* only use first one */
hbaline->ldapscope = urldata->lud_scope;
if (urldata->lud_filter)
{
return false;
}
ldap_free_urldesc(urldata);
-#else /* not OpenLDAP */
+#else /* not OpenLDAP */
ereport(LOG,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("LDAP URLs not supported on this platform")));
-#endif /* not OpenLDAP */
+#endif /* not OpenLDAP */
}
else if (strcmp(name, "ldaptls") == 0)
{
ereport(LOG,
(errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
errmsg("regular expression \"%s\" has no subexpressions as requested by backreference in \"%s\"",
- identLine->ident_user + 1, identLine->pg_role)));
+ identLine->ident_user + 1, identLine->pg_role)));
*error_p = true;
return;
}
MemoryContext linecxt;
MemoryContext oldcxt;
MemoryContext ident_context;
- IdentLine *newline;
+ IdentLine *newline;
file = AllocateFile(IdentFileName, "r");
if (file == NULL)
/* Now parse all the lines */
ident_context = AllocSetContextCreate(TopMemoryContext,
- "ident parser context",
- ALLOCSET_DEFAULT_MINSIZE,
- ALLOCSET_DEFAULT_MINSIZE,
- ALLOCSET_DEFAULT_MAXSIZE);
+ "ident parser context",
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_MINSIZE,
+ ALLOCSET_DEFAULT_MAXSIZE);
oldcxt = MemoryContextSwitchTo(ident_context);
forboth(line_cell, ident_lines, num_cell, ident_line_nums)
{
{
if (!pg_set_noblock(MyProcPort->sock))
ereport(COMMERROR,
- (errmsg("could not set socket to nonblocking mode: %m")));
+ (errmsg("could not set socket to nonblocking mode: %m")));
}
else
{
#ifdef EXEC_BACKEND
if (argc > 1 && strncmp(argv[1], "--fork", 6) == 0)
- SubPostmasterMain(argc, argv); /* does not return */
+ SubPostmasterMain(argc, argv); /* does not return */
#endif
#ifdef WIN32
else if (argc > 1 && strcmp(argv[1], "--single") == 0)
PostgresMain(argc, argv,
NULL, /* no dbname */
- get_current_username(progname)); /* does not return */
+ get_current_username(progname)); /* does not return */
else
- PostmasterMain(argc, argv); /* does not return */
- abort(); /* should not get here */
+ PostmasterMain(argc, argv); /* does not return */
+ abort(); /* should not get here */
}
cx(PlannerInfo *root, Gene *tour1, Gene *tour2, Gene *offspring,
int num_gene, City *city_table)
{
-
int i,
start_pos,
curr_pos;
px(PlannerInfo *root, Gene *tour1, Gene *tour2, Gene *offspring, int num_gene,
City *city_table)
{
-
int num_positions;
int i,
pos,
*/
if (childrel->cheapest_total_path->param_info == NULL)
subpaths = accumulate_append_subpath(subpaths,
- childrel->cheapest_total_path);
+ childrel->cheapest_total_path);
else
subpaths_valid = false;
#include "postgres.h"
#ifdef _MSC_VER
-#include /* for _isnan */
+#include /* for _isnan */
#endif
#include
* The subquery could be an expansion of a view that's had columns
* added to it since the current query was parsed, so that there are
* non-junk tlist columns in it that don't correspond to any column
- * visible at our query level. Ignore such columns.
+ * visible at our query level. Ignore such columns.
*/
if (te->resno < rel->min_attr || te->resno > rel->max_attr)
continue;
/*
* We add ec2's items to ec1, then set ec2's ec_merged link to point
- * to ec1 and remove ec2 from the eq_classes list. We cannot simply
+ * to ec1 and remove ec2 from the eq_classes list. We cannot simply
* delete ec2 because that could leave dangling pointers in existing
* PathKeys. We leave it behind with a link so that the merged EC can
* be found.
continue;
/*
- * Scan members, looking for a match to the target column. Note
- * that child EC members are considered, but only when they belong to
- * the target relation. (Unlike regular members, the same expression
+ * Scan members, looking for a match to the target column. Note that
+ * child EC members are considered, but only when they belong to the
+ * target relation. (Unlike regular members, the same expression
* could be a child member of more than one EC. Therefore, it's
* potentially order-dependent which EC a child relation's target
* column gets matched to. This is annoying but it only happens in
* If there are any rels that have LATERAL references to this one, we
* cannot use join quals referencing them as index quals for this one,
* since such rels would have to be on the inside not the outside of a
- * nestloop join relative to this one. Create a Relids set listing all
+ * nestloop join relative to this one. Create a Relids set listing all
* such rels, for use in checks of potential join clauses.
*/
lateral_referencers = NULL;
*
* For simplicity in selecting relevant clauses, we represent each set of
* outer rels as a maximum set of clause_relids --- that is, the indexed
- * relation itself is also included in the relids set. considered_relids
+ * relation itself is also included in the relids set. considered_relids
* lists all relids sets we've already tried.
*/
for (indexcol = 0; indexcol < index->ncolumns; indexcol++)
*/
foreach(lc2, *considered_relids)
{
- Relids oldrelids = (Relids) lfirst(lc2);
+ Relids oldrelids = (Relids) lfirst(lc2);
/*
* If either is a subset of the other, no new set is possible.
/*
* If this clause was derived from an equivalence class, the
* clause list may contain other clauses derived from the same
- * eclass. We should not consider that combining this clause with
+ * eclass. We should not consider that combining this clause with
* one of those clauses generates a usefully different
* parameterization; so skip if any clause derived from the same
* eclass would already have been included when using oldrelids.
}
/*
- * Add applicable eclass join clauses. The clauses generated for each
+ * Add applicable eclass join clauses. The clauses generated for each
* column are redundant (cf generate_implied_equalities_for_column),
- * so we need at most one. This is the only exception to the general
+ * so we need at most one. This is the only exception to the general
* rule of using all available index clauses.
*/
foreach(lc, eclauseset->indexclauses[indexcol])
return;
/*
- * Construct a list of clauses that we can assume true for the purpose
- * of proving the index(es) usable. Restriction clauses for the rel are
+ * Construct a list of clauses that we can assume true for the purpose of
+ * proving the index(es) usable. Restriction clauses for the rel are
* always usable, and so are any join clauses that are "movable to" this
* rel. Also, we can consider any EC-derivable join clauses (which must
* be "movable to" this rel, by definition).
/*
* Add on any equivalence-derivable join clauses. Computing the correct
* relid sets for generate_join_implied_equalities is slightly tricky
- * because the rel could be a child rel rather than a true baserel, and
- * in that case we must remove its parent's relid from all_baserels.
+ * because the rel could be a child rel rather than a true baserel, and in
+ * that case we must remove its parent's relid from all_baserels.
*/
if (rel->reloptkind == RELOPT_OTHER_MEMBER_REL)
{
clauselist =
list_concat(clauselist,
generate_join_implied_equalities(root,
- bms_union(rel->relids,
- otherrels),
+ bms_union(rel->relids,
+ otherrels),
otherrels,
rel));
* However, when a LATERAL subquery is involved, we have to be a bit
* laxer, because there will simply not be any paths for the joinrel that
* aren't parameterized by whatever the subquery is parameterized by,
- * unless its parameterization is resolved within the joinrel. Hence, add
+ * unless its parameterization is resolved within the joinrel. Hence, add
* to param_source_rels anything that is laterally referenced in either
* input and is not in the join already.
*/
* sort.
*
* This function intentionally does not consider parameterized input
- * paths, except when the cheapest-total is parameterized. If we did so,
+ * paths, except when the cheapest-total is parameterized. If we did so,
* we'd have a combinatorial explosion of mergejoin paths of dubious
* value. This interacts with decisions elsewhere that also discriminate
* against mergejoins with parameterized inputs; see comments in
* Likewise remove references from LateralJoinInfo data structures.
*
* If we are deleting a LATERAL subquery, we can forget its
- * LateralJoinInfo altogether. Otherwise, make sure the target is not
+ * LateralJoinInfo altogether. Otherwise, make sure the target is not
* included in any lateral_lhs set. (It probably can't be, since that
* should have precluded deciding to remove it; but let's cope anyway.)
*/
newvars = NIL;
foreach(lc, vars)
{
- Node *node = (Node *) lfirst(lc);
+ Node *node = (Node *) lfirst(lc);
node = copyObject(node);
if (IsA(node, Var))
{
- Var *var = (Var *) node;
+ Var *var = (Var *) node;
/* Adjustment is easy since it's just one node */
var->varlevelsup = 0;
else if (IsA(node, PlaceHolderVar))
{
PlaceHolderVar *phv = (PlaceHolderVar *) node;
- int levelsup = phv->phlevelsup;
+ int levelsup = phv->phlevelsup;
/* Have to work harder to adjust the contained expression too */
if (levelsup != 0)
{
RelOptInfo *brel = root->simple_rel_array[rti];
Relids lateral_relids;
- ListCell *lc;
+ ListCell *lc;
/* there may be empty slots corresponding to non-baserel RTEs */
if (brel == NULL)
/* consider each laterally-referenced Var or PHV */
foreach(lc, brel->lateral_vars)
{
- Node *node = (Node *) lfirst(lc);
+ Node *node = (Node *) lfirst(lc);
if (IsA(node, Var))
{
- Var *var = (Var *) node;
+ Var *var = (Var *) node;
add_lateral_info(root, rti, bms_make_singleton(var->varno));
lateral_relids = bms_add_member(lateral_relids,
* If it's an appendrel parent, copy its lateral_relids to each child
* rel. We intentionally give each child rel the same minimum
* parameterization, even though it's quite possible that some don't
- * reference all the lateral rels. This is because any append path
+ * reference all the lateral rels. This is because any append path
* for the parent will have to have the same parameterization for
* every child anyway, and there's no value in forcing extra
* reparameterize_path() calls.
* add_lateral_info
* Add a LateralJoinInfo to root->lateral_info_list, if needed
*
- * We suppress redundant list entries. The passed lhs set must be freshly
+ * We suppress redundant list entries. The passed lhs set must be freshly
* made; we free it if not used in a new list entry.
*/
static void
Assert(jointype != JOIN_RIGHT);
/*
- * Presently the executor cannot support FOR [KEY] UPDATE/SHARE marking of rels
- * appearing on the nullable side of an outer join. (It's somewhat unclear
- * what that would mean, anyway: what should we mark when a result row is
- * generated from no element of the nullable relation?) So, complain if
- * any nullable rel is FOR [KEY] UPDATE/SHARE.
+ * Presently the executor cannot support FOR [KEY] UPDATE/SHARE marking of
+ * rels appearing on the nullable side of an outer join. (It's somewhat
+ * unclear what that would mean, anyway: what should we mark when a result
+ * row is generated from no element of the nullable relation?) So,
+ * complain if any nullable rel is FOR [KEY] UPDATE/SHARE.
*
* You might be wondering why this test isn't made far upstream in the
* parser. It's because the parser hasn't got enough info --- consider
* that provides all its variables.
*
* "nullable_relids" is the set of relids used in the expressions that are
- * potentially nullable below the expressions. (This has to be supplied by
+ * potentially nullable below the expressions. (This has to be supplied by
* caller because this function is used after deconstruct_jointree, so we
* don't have knowledge of where the clause items came from.)
*
* We have to replace Aggrefs with Params in equivalence classes too, else
* ORDER BY or DISTINCT on an optimized aggregate will fail. We don't
* need to process child eclass members though, since they aren't of
- * interest anymore --- and replace_aggs_with_params_mutator isn't able
- * to handle Aggrefs containing translated child Vars, anyway.
+ * interest anymore --- and replace_aggs_with_params_mutator isn't able to
+ * handle Aggrefs containing translated child Vars, anyway.
*
* Note: at some point it might become necessary to mutate other data
* structures too, such as the query's sortClause or distinctClause. Right
#define EXPRKIND_QUAL 0
#define EXPRKIND_TARGET 1
#define EXPRKIND_RTFUNC 2
-#define EXPRKIND_RTFUNC_LATERAL 3
+#define EXPRKIND_RTFUNC_LATERAL 3
#define EXPRKIND_VALUES 4
-#define EXPRKIND_VALUES_LATERAL 5
+#define EXPRKIND_VALUES_LATERAL 5
#define EXPRKIND_LIMIT 6
#define EXPRKIND_APPINFO 7
#define EXPRKIND_PHV 8
returningLists = NIL;
/*
- * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
- * have dealt with fetching non-locked marked rows, else we need
- * to have ModifyTable do that.
+ * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node
+ * will have dealt with fetching non-locked marked rows, else we
+ * need to have ModifyTable do that.
*/
if (parse->rowMarks)
rowMarks = NIL;
root->simple_rel_array = save_rel_array;
/*
- * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will have
- * dealt with fetching non-locked marked rows, else we need to have
+ * If there was a FOR [KEY] UPDATE/SHARE clause, the LockRows node will
+ * have dealt with fetching non-locked marked rows, else we need to have
* ModifyTable do that.
*/
if (parse->rowMarks)
*/
current_pathkeys = make_pathkeys_for_sortclauses(root,
set_sortclauses,
- result_plan->targetlist);
+ result_plan->targetlist);
/*
* We should not need to call preprocess_targetlist, since we must be
tlist);
/*
- * Can't handle FOR [KEY] UPDATE/SHARE here (parser should have checked
- * already, but let's make sure).
+ * Can't handle FOR [KEY] UPDATE/SHARE here (parser should have
+ * checked already, but let's make sure).
*/
if (parse->rowMarks)
ereport(ERROR,
* it's not worth trying to avoid it. In particular, think not to
* skip adding the Result if the initial window_tlist matches the
* top-level plan node's output, because we might change the tlist
- * inside the following loop.) Note that on second and subsequent
+ * inside the following loop.) 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.
/*
* The "base" targetlist for all steps of the windowing process is
- * a flat tlist of all Vars and Aggs needed in the result. (In
+ * 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 add window partitioning and sorting
* expressions to the base tlist, to ensure they're computed only
* once at the bottom of the stack (that's critical for volatile
- * functions). As we climb up the stack, we'll add outputs for
+ * functions). As we climb up the stack, we'll add outputs for
* the WindowFuncs computed at each level.
*/
window_tlist = make_windowInputTargetList(root,
/*
* The copyObject steps here are needed to ensure that each plan
- * node has a separately modifiable tlist. (XXX wouldn't a
+ * node has a separately modifiable tlist. (XXX wouldn't a
* shallow list copy do for that?)
*/
result_plan->targetlist = (List *) copyObject(window_tlist);
* plan's tlist for any partitioning or ordering columns that
* aren't plain Vars. (In theory, make_windowInputTargetList
* should have provided all such columns, but let's not assume
- * that here.) Furthermore, this way we can use existing
+ * that here.) Furthermore, this way we can use existing
* infrastructure to identify which input columns are the
* interesting ones.
*/
}
/*
- * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node. (Note: we
- * intentionally test parse->rowMarks not root->rowMarks here. If there
- * are only non-locking rowmarks, they should be handled by the
+ * If there is a FOR [KEY] UPDATE/SHARE clause, add the LockRows node.
+ * (Note: we intentionally test parse->rowMarks not root->rowMarks here.
+ * If there are only non-locking rowmarks, they should be handled by the
* ModifyTable node instead.)
*/
if (parse->rowMarks)
if (parse->rowMarks)
{
/*
- * We've got trouble if FOR [KEY] UPDATE/SHARE appears inside grouping,
- * since grouping renders a reference to individual tuple CTIDs
- * invalid. This is also checked at parse time, but that's
+ * We've got trouble if FOR [KEY] UPDATE/SHARE appears inside
+ * grouping, since grouping renders a reference to individual tuple
+ * CTIDs invalid. This is also checked at parse time, but that's
* insufficient because of rule substitution, query pullup, etc.
*/
CheckSelectLocking(parse);
else
{
/*
- * We only need rowmarks for UPDATE, DELETE, or FOR [KEY] UPDATE/SHARE.
+ * We only need rowmarks for UPDATE, DELETE, or FOR [KEY]
+ * UPDATE/SHARE.
*/
if (parse->commandType != CMD_UPDATE &&
parse->commandType != CMD_DELETE)
*
* If we have constant-zero OFFSET and constant-null LIMIT, we can skip adding
* a Limit node. This is worth checking for because "OFFSET 0" is a common
- * locution for an optimization fence. (Because other places in the planner
+ * locution for an optimization fence. (Because other places in the planner
* merely check whether parse->limitOffset isn't NULL, it will still work as
* an optimization fence --- we're just suppressing unnecessary run-time
* overhead.)
/* Treat NULL as no offset; the executor would too */
if (!((Const *) node)->constisnull)
{
- int64 offset = DatumGetInt64(((Const *) node)->constvalue);
+ int64 offset = DatumGetInt64(((Const *) node)->constvalue);
/* Executor would treat less-than-zero same as zero */
if (offset > 0)
*
* When grouping_planner inserts one or more WindowAgg nodes into the plan,
* this function computes the initial target list to be computed by the node
- * just below the first WindowAgg. This list must contain all values needed
+ * just below the first WindowAgg. This list must contain all values needed
* to evaluate the window functions, compute the final target list, and
* perform any required final sort step. If multiple WindowAggs are needed,
* each intermediate one adds its window function results onto this tlist;
*
* This function is much like make_subplanTargetList, though not quite enough
* like it to share code. As in that function, we flatten most expressions
- * into their component variables. But we do not want to flatten window
+ * into their component variables. But we do not want to flatten window
* PARTITION BY/ORDER BY clauses, since that might result in multiple
* evaluations of them, which would be bad (possibly even resulting in
* inconsistent answers, if they contain volatile functions). Also, we must
rte = makeNode(RangeTblEntry);
rte->rtekind = RTE_RELATION;
rte->relid = tableOid;
- rte->relkind = RELKIND_RELATION; /* Don't be too picky. */
+ rte->relkind = RELKIND_RELATION; /* Don't be too picky. */
rte->lateral = false;
rte->inh = false;
rte->inFromCl = true;
*
* If this jointree node is within either side of an outer join, then
* lowest_outer_join references the lowest such JoinExpr node; otherwise
- * it is NULL. We use this to constrain the effects of LATERAL subqueries.
+ * it is NULL. We use this to constrain the effects of LATERAL subqueries.
*
* If this jointree node is within the nullable side of an outer join, then
* lowest_nulling_outer_join references the lowest such JoinExpr node;
case JOIN_INNER:
j->larg = pull_up_subqueries_recurse(root, j->larg,
lowest_outer_join,
- lowest_nulling_outer_join,
+ lowest_nulling_outer_join,
NULL);
j->rarg = pull_up_subqueries_recurse(root, j->rarg,
lowest_outer_join,
- lowest_nulling_outer_join,
+ lowest_nulling_outer_join,
NULL);
break;
case JOIN_LEFT:
case JOIN_ANTI:
j->larg = pull_up_subqueries_recurse(root, j->larg,
j,
- lowest_nulling_outer_join,
+ lowest_nulling_outer_join,
NULL);
j->rarg = pull_up_subqueries_recurse(root, j->rarg,
j,
NULL);
j->rarg = pull_up_subqueries_recurse(root, j->rarg,
j,
- lowest_nulling_outer_join,
+ lowest_nulling_outer_join,
NULL);
break;
default:
/*
* Make a modifiable copy of the subquery's rtable, so we can adjust
- * upper-level Vars in it. There are no such Vars in the setOperations
+ * upper-level Vars in it. There are no such Vars in the setOperations
* tree proper, so fixing the rtable should be sufficient.
*/
rtable = copyObject(subquery->rtable);
return false;
/*
- * Don't pull up if the RTE represents a security-barrier view; we couldn't
- * prevent information leakage once the RTE's Vars are scattered about in
- * the upper query.
+ * Don't pull up if the RTE represents a security-barrier view; we
+ * couldn't prevent information leakage once the RTE's Vars are scattered
+ * about in the upper query.
*/
if (rte->security_barrier)
return false;
*/
if (rte->lateral && lowest_outer_join != NULL)
{
- Relids lvarnos = pull_varnos_of_level((Node *) subquery, 1);
- Relids jvarnos = get_relids_in_jointree((Node *) lowest_outer_join,
- true);
+ Relids lvarnos = pull_varnos_of_level((Node *) subquery, 1);
+ Relids jvarnos = get_relids_in_jointree((Node *) lowest_outer_join,
+ true);
if (!bms_is_subset(lvarnos, jvarnos))
return false;
/*
* If the RangeTblRef refers to a LATERAL subquery (that isn't the
* same subquery we're pulling up), it might contain references to the
- * target subquery, which we must replace. We drive this from the
+ * target subquery, which we must replace. We drive this from the
* jointree scan, rather than a scan of the rtable, for a couple of
* reasons: we can avoid processing no-longer-referenced RTEs, and we
* can use the appropriate setting of need_phvs depending on whether
newexpr->funcresulttype = result_type;
newexpr->funcretset = false;
newexpr->funcvariadic = funcvariadic;
- newexpr->funcformat = COERCE_EXPLICIT_CALL; /* doesn't matter */
+ newexpr->funcformat = COERCE_EXPLICIT_CALL; /* doesn't matter */
newexpr->funccollid = result_collid; /* doesn't matter */
newexpr->inputcollid = input_collid;
newexpr->args = args;
*
* cheapest_total_path is normally the cheapest-total-cost unparameterized
* path; but if there are no unparameterized paths, we assign it to be the
- * best (cheapest least-parameterized) parameterized path. However, only
+ * best (cheapest least-parameterized) parameterized path. However, only
* unparameterized paths are considered candidates for cheapest_startup_path,
* so that will be NULL if there are no unparameterized paths.
*
* The cheapest_parameterized_paths list collects all parameterized paths
- * that have survived the add_path() tournament for this relation. (Since
+ * that have survived the add_path() tournament for this relation. (Since
* add_path ignores pathkeys and startup cost for a parameterized path,
* these will be paths that have best total cost or best row count for their
* parameterization.) cheapest_parameterized_paths always includes the
/* old path is less-parameterized, keep it */
break;
case BMS_DIFFERENT:
+
/*
* This means that neither path has the least possible
* parameterization for the rel. We'll sit on the old
parameterized_paths = lcons(cheapest_total_path, parameterized_paths);
/*
- * If there is no unparameterized path, use the best parameterized path
- * as cheapest_total_path (but not as cheapest_startup_path).
+ * If there is no unparameterized path, use the best parameterized path as
+ * cheapest_total_path (but not as cheapest_startup_path).
*/
if (cheapest_total_path == NULL)
cheapest_total_path = best_param_path;
accept_new = false; /* old dominates new */
else if (compare_path_costs_fuzzily(new_path,
old_path,
- 1.0000000001,
+ 1.0000000001,
parent_rel->consider_startup) == COSTS_BETTER1)
remove_old = true; /* new dominates old */
else
pathnode->path.pathtype = T_Result;
pathnode->path.parent = NULL;
- pathnode->path.param_info = NULL; /* there are no other rels... */
+ pathnode->path.param_info = NULL; /* there are no other rels... */
pathnode->path.pathkeys = NIL;
pathnode->quals = quals;
else
{
/*
- * Process INSERT ... VALUES with a single VALUES sublist. We treat
+ * Process INSERT ... VALUES with a single VALUES sublist. We treat
* this case separately for efficiency. The sublist is just computed
* directly as the Query's targetlist, with no VALUES RTE. So it
* works just like a SELECT without any FROM.
/*
* Ordinarily there can't be any current-level Vars in the expression
* lists, because the namespace was empty ... but if we're inside CREATE
- * RULE, then NEW/OLD references might appear. In that case we have to
+ * RULE, then NEW/OLD references might appear. In that case we have to
* mark the VALUES RTE as LATERAL.
*/
if (pstate->p_rtable != NIL &&
/*
* A materialized view would either need to save parameters for use in
- * maintaining/loading the data or prohibit them entirely. The latter
+ * maintaining/loading the data or prohibit them entirely. The latter
* seems safer and more sane.
*/
if (query_contains_extern_params(query))
errmsg("materialized views may not be defined using bound parameters")));
/*
- * For now, we disallow unlogged materialized views, because it
- * seems like a bad idea for them to just go to empty after a crash.
- * (If we could mark them as unpopulated, that would be better, but
- * that requires catalog changes which crash recovery can't presently
+ * For now, we disallow unlogged materialized views, because it seems
+ * like a bad idea for them to just go to empty after a crash. (If we
+ * could mark them as unpopulated, that would be better, but that
+ * requires catalog changes which crash recovery can't presently
* handle.)
*/
if (stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED)
if (qry->distinctClause != NIL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row-level locks are not allowed with DISTINCT clause")));
+ errmsg("row-level locks are not allowed with DISTINCT clause")));
if (qry->groupClause != NIL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row-level locks are not allowed with GROUP BY clause")));
+ errmsg("row-level locks are not allowed with GROUP BY clause")));
if (qry->havingQual != NULL)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row-level locks are not allowed with HAVING clause")));
+ errmsg("row-level locks are not allowed with HAVING clause")));
if (qry->hasAggs)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row-level locks are not allowed with aggregate functions")));
+ errmsg("row-level locks are not allowed with aggregate functions")));
if (qry->hasWindowFuncs)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("row-level locks are not allowed with window functions")));
+ errmsg("row-level locks are not allowed with window functions")));
if (expression_returns_set((Node *) qry->targetList))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
{
/*
* If the same RTE is specified for more than one locking strength,
- * treat is as the strongest. (Reasonable, since you can't take both a
- * shared and exclusive lock at the same time; it'll end up being
+ * treat is as the strongest. (Reasonable, since you can't take both
+ * a shared and exclusive lock at the same time; it'll end up being
* exclusive anyway.)
*
* We also consider that NOWAIT wins if it's specified both ways. This
use warnings;
use strict;
-my $gram_filename = $ARGV[0];
+my $gram_filename = $ARGV[0];
my $kwlist_filename = $ARGV[1];
my $errors = 0;
if (!($kcat))
{
+
# Is this the beginning of a keyword list?
foreach $k (keys %keyword_categories)
{
}
elsif ($arr[$fieldIndexer] eq '/*')
{
+
# start of a multiline comment
$comment = 1;
next;
if ($arr[$fieldIndexer] eq ';')
{
+
# end of keyword list
$kcat = '';
next;
foreach $kword (@{ $keywords{$kcat} })
{
+
# Some keyword have a _P suffix. Remove it for the comparison.
$bare_kword = $kword;
$bare_kword =~ s/_P$//;
}
else
{
+
# Remove it from the hash, so that we can
# complain at the end if there's keywords left
# that were not found in kwlist.h
if (errkind)
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
- /* translator: %s is name of a SQL construct, eg GROUP BY */
+ /* translator: %s is name of a SQL construct, eg GROUP BY */
errmsg("aggregate functions are not allowed in %s",
ParseExprKindName(pstate->p_expr_kind)),
parser_errposition(pstate, agg->location)));
if (errkind)
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- /* translator: %s is name of a SQL construct, eg GROUP BY */
+ /* translator: %s is name of a SQL construct, eg GROUP BY */
errmsg("window functions are not allowed in %s",
ParseExprKindName(pstate->p_expr_kind)),
parser_errposition(pstate, wfunc->location)));
* *top_rti: receives the rangetable index of top_rte. (Ditto.)
*
* *namespace: receives a List of ParseNamespaceItems for the RTEs exposed
- * as table/column names by this item. (The lateral_only flags in these items
+ * as table/column names by this item. (The lateral_only flags in these items
* are indeterminate and should be explicitly set by the caller before use.)
*/
static Node *
/*
* Make the left-side RTEs available for LATERAL access within the
* right side, by temporarily adding them to the pstate's namespace
- * list. Per SQL:2008, if the join type is not INNER or LEFT then
- * the left-side names must still be exposed, but it's an error to
+ * list. Per SQL:2008, if the join type is not INNER or LEFT then the
+ * left-side names must still be exposed, but it's an error to
* reference them. (Stupid design, but that's what it says.) Hence,
* we always push them into the namespace, but mark them as not
* lateral_ok if the jointype is wrong.
*
* Note: if there are nested alias-less JOINs, the lower-level ones
* will remain in the list although they have neither p_rel_visible
- * nor p_cols_visible set. We could delete such list items, but it's
+ * nor p_cols_visible set. We could delete such list items, but it's
* unclear that it's worth expending cycles to do so.
*/
if (j->alias != NULL)
contain_aggs_of_level((Node *) tle->expr, 0))
ereport(ERROR,
(errcode(ERRCODE_GROUPING_ERROR),
- /* translator: %s is name of a SQL construct, eg GROUP BY */
+ /* translator: %s is name of a SQL construct, eg GROUP BY */
errmsg("aggregate functions are not allowed in %s",
ParseExprKindName(exprKind)),
parser_errposition(pstate,
- locate_agg_of_level((Node *) tle->expr, 0))));
+ locate_agg_of_level((Node *) tle->expr, 0))));
if (pstate->p_hasWindowFuncs &&
contain_windowfuncs((Node *) tle->expr))
ereport(ERROR,
(errcode(ERRCODE_WINDOWING_ERROR),
- /* translator: %s is name of a SQL construct, eg GROUP BY */
+ /* translator: %s is name of a SQL construct, eg GROUP BY */
errmsg("window functions are not allowed in %s",
ParseExprKindName(exprKind)),
parser_errposition(pstate,
- locate_windowfunc((Node *) tle->expr))));
+ locate_windowfunc((Node *) tle->expr))));
break;
case EXPR_KIND_ORDER_BY:
/* no extra checks needed */
*
* node the ORDER BY, GROUP BY, or DISTINCT ON expression to be matched
* tlist the target list (passed by reference so we can append to it)
- * exprKind identifies clause type being processed
+ * exprKind identifies clause type being processed
*/
static TargetEntry *
findTargetlistEntrySQL92(ParseState *pstate, Node *node, List **tlist,
*
* node the ORDER BY, GROUP BY, etc expression to be matched
* tlist the target list (passed by reference so we can append to it)
- * exprKind identifies clause type being processed
+ * exprKind identifies clause type being processed
*/
static TargetEntry *
findTargetlistEntrySQL99(ParseState *pstate, Node *node, List **tlist,
break;
default:
elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
- result = NULL; /* keep compiler quiet */
+ result = NULL; /* keep compiler quiet */
break;
}
break;
return result;
/*
- * Check to see if the sublink is in an invalid place within the query.
- * We allow sublinks everywhere in SELECT/INSERT/UPDATE/DELETE, but
- * generally not in utility statements.
+ * Check to see if the sublink is in an invalid place within the query. We
+ * allow sublinks everywhere in SELECT/INSERT/UPDATE/DELETE, but generally
+ * not in utility statements.
*/
err = NULL;
switch (pstate->p_expr_kind)
xexpr = makeNode(XmlExpr);
xexpr->op = IS_XMLSERIALIZE;
xexpr->args = list_make1(coerce_to_specific_type(pstate,
- transformExprRecurse(pstate, xs->expr),
+ transformExprRecurse(pstate, xs->expr),
XMLOID,
"XMLSERIALIZE"));
*
* This is different from refnameRangeTblEntry in that it considers every
* entry in the ParseState's rangetable(s), not only those that are currently
- * visible in the p_namespace list(s). This behavior is invalid per the SQL
+ * visible in the p_namespace list(s). This behavior is invalid per the SQL
* spec, and it may give ambiguous results (there might be multiple equally
* valid matches, but only one will be returned). This must be used ONLY
* as a heuristic in giving suitable error messages. See errorMissingRTE.
*
* This is different from colNameToVar in that it considers every entry in
* the ParseState's rangetable(s), not only those that are currently visible
- * in the p_namespace list(s). This behavior is invalid per the SQL spec,
+ * in the p_namespace list(s). This behavior is invalid per the SQL spec,
* and it may give ambiguous results (there might be multiple equally valid
* matches, but only one will be returned). This must be used ONLY as a
* heuristic in giving suitable error messages. See errorMissingColumn.
*
* node the (untransformed) parse tree for the value expression.
* expr the transformed expression, or NULL if caller didn't do it yet.
- * exprKind expression kind (EXPR_KIND_SELECT_TARGET, etc)
+ * exprKind expression kind (EXPR_KIND_SELECT_TARGET, etc)
* colname the column name to be assigned, or NULL if none yet set.
* resjunk true if the target should be marked resjunk, ie, it is not
* wanted in the final projected tuple.
* Transforms '*' (in the target list) into a list of targetlist entries.
*
* tlist entries are generated for each relation visible for unqualified
- * column name access. We do not consider qualified-name-only entries because
+ * column name access. We do not consider qualified-name-only entries because
* that would include input tables of aliasless JOINs, NEW/OLD pseudo-entries,
* etc.
*
if (cxt->isforeign)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("constraints are not supported on foreign tables"),
+ errmsg("constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
cxt->ckconstraints = lappend(cxt->ckconstraints, constraint);
if (cxt->isforeign)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("constraints are not supported on foreign tables"),
+ errmsg("constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
if (constraint->keys == NIL)
if (cxt->isforeign)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("constraints are not supported on foreign tables"),
+ errmsg("constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
+
/*
* Fill in the current attribute's name and throw it into the
* list of FK constraints to be processed later.
constr = tupleDesc->constr;
/*
- * Initialize column number map for map_variable_attnos(). We need this
+ * Initialize column number map for map_variable_attnos(). We need this
* since dropped columns in the source table aren't copied, so the new
* table can have different column numbers.
*/
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot convert whole-row table reference"),
- errdetail("Index \"%s\" contains a whole-row table reference.",
- RelationGetRelationName(source_idx))));
+ errdetail("Index \"%s\" contains a whole-row table reference.",
+ RelationGetRelationName(source_idx))));
index->whereClause = pred_tree;
}
/*
* Scan the index list and remove any redundant index specifications. This
* can happen if, for instance, the user writes UNIQUE PRIMARY KEY. A
- * strict reading of SQL would suggest raising an error instead, but
- * that strikes me as too anal-retentive. - tgl 2001-02-14
+ * strict reading of SQL would suggest raising an error instead, but that
+ * strikes me as too anal-retentive. - tgl 2001-02-14
*
* XXX in ALTER TABLE case, it'd be nice to look for duplicate
* pre-existing indexes, too.
#define MAP_HASSEMAPHORE 0
#endif
-#define PG_MMAP_FLAGS (MAP_SHARED|MAP_ANONYMOUS|MAP_HASSEMAPHORE)
+#define PG_MMAP_FLAGS (MAP_SHARED|MAP_ANONYMOUS|MAP_HASSEMAPHORE)
/* Some really old systems don't define MAP_FAILED. */
#ifndef MAP_FAILED
IPC_CREAT | IPC_EXCL | IPCProtection),
(errno == EINVAL) ?
errhint("This error usually means that PostgreSQL's request for a shared memory "
- "segment exceeded your kernel's SHMMAX parameter, or possibly that "
+ "segment exceeded your kernel's SHMMAX parameter, or possibly that "
"it is less than "
"your kernel's SHMMIN parameter.\n"
"The PostgreSQL documentation contains more information about shared "
"memory configuration.") : 0,
(errno == ENOMEM) ?
errhint("This error usually means that PostgreSQL's request for a shared "
- "memory segment exceeded your kernel's SHMALL parameter. You may need "
+ "memory segment exceeded your kernel's SHMALL parameter. You may need "
"to reconfigure the kernel with larger SHMALL.\n"
"The PostgreSQL documentation contains more information about shared "
"memory configuration.") : 0,
"It occurs either if all available shared memory IDs have been taken, "
"in which case you need to raise the SHMMNI parameter in your kernel, "
"or because the system's overall limit for shared memory has been "
- "reached.\n"
+ "reached.\n"
"The PostgreSQL documentation contains more information about shared "
"memory configuration.") : 0));
}
* settings.
*
* However, we disable this logic in the EXEC_BACKEND case, and fall back
- * to the old method of allocating the entire segment using System V shared
- * memory, because there's no way to attach an mmap'd segment to a process
- * after exec(). Since EXEC_BACKEND is intended only for developer use,
- * this shouldn't be a big problem.
+ * to the old method of allocating the entire segment using System V
+ * shared memory, because there's no way to attach an mmap'd segment to a
+ * process after exec(). Since EXEC_BACKEND is intended only for
+ * developer use, this shouldn't be a big problem.
*/
#ifndef EXEC_BACKEND
{
- long pagesize = sysconf(_SC_PAGE_SIZE);
+ long pagesize = sysconf(_SC_PAGE_SIZE);
/*
* Ensure request size is a multiple of pagesize.
/*
* We assume that no one will attempt to run PostgreSQL 9.3 or later
* on systems that are ancient enough that anonymous shared memory is
- * not supported, such as pre-2.4 versions of Linux. If that turns out
- * to be false, we might need to add a run-time test here and do this
- * only if the running kernel supports it.
+ * not supported, such as pre-2.4 versions of Linux. If that turns
+ * out to be false, we might need to add a run-time test here and do
+ * this only if the running kernel supports it.
*/
- AnonymousShmem = mmap(NULL, size, PROT_READ|PROT_WRITE, PG_MMAP_FLAGS,
+ AnonymousShmem = mmap(NULL, size, PROT_READ | PROT_WRITE, PG_MMAP_FLAGS,
-1, 0);
if (AnonymousShmem == MAP_FAILED)
ereport(FATAL,
- (errmsg("could not map anonymous shared memory: %m"),
- (errno == ENOMEM) ?
- errhint("This error usually means that PostgreSQL's request "
- "for a shared memory segment exceeded available memory "
- "or swap space. To reduce the request size (currently "
- "%lu bytes), reduce PostgreSQL's shared memory usage, "
- "perhaps by reducing shared_buffers or "
- "max_connections.",
- (unsigned long) size) : 0));
+ (errmsg("could not map anonymous shared memory: %m"),
+ (errno == ENOMEM) ?
+ errhint("This error usually means that PostgreSQL's request "
+ "for a shared memory segment exceeded available memory "
+ "or swap space. To reduce the request size (currently "
+ "%lu bytes), reduce PostgreSQL's shared memory usage, "
+ "perhaps by reducing shared_buffers or "
+ "max_connections.",
+ (unsigned long) size) : 0));
AnonymousShmemSize = size;
/* Now we need only allocate a minimal-sized SysV shmem block. */
/*
* If AnonymousShmem is NULL here, then we're not using anonymous shared
- * memory, and should return a pointer to the System V shared memory block.
- * Otherwise, the System V shared memory block is only a shim, and we must
- * return a pointer to the real block.
+ * memory, and should return a pointer to the System V shared memory
+ * block. Otherwise, the System V shared memory block is only a shim, and
+ * we must return a pointer to the real block.
*/
if (AnonymousShmem == NULL)
return hdr;
Oid adw_datid;
char *adw_name;
TransactionId adw_frozenxid;
- MultiXactId adw_frozenmulti;
+ MultiXactId adw_frozenmulti;
PgStat_StatDBEntry *adw_entry;
} avw_dbase;
int wi_cost_delay;
int wi_cost_limit;
int wi_cost_limit_base;
-} WorkerInfoData;
+} WorkerInfoData;
typedef struct WorkerInfoData *WorkerInfo;
int score;
int nelems;
HTAB *dbhash;
- dlist_iter iter;
+ dlist_iter iter;
/* use fresh stats */
autovac_refresh_stats();
PgStat_StatDBEntry *entry;
/*
- * skip databases with no stat entries -- in particular, this gets
- * rid of dropped databases
+ * skip databases with no stat entries -- in particular, this gets rid
+ * of dropped databases
*/
entry = pgstat_fetch_stat_dbentry(avdb->adl_datid);
if (entry == NULL)
foreach(cell, dblist)
{
avw_dbase *tmp = lfirst(cell);
- dlist_iter iter;
+ dlist_iter iter;
/* Check to see if this one is at risk of wraparound */
if (TransactionIdPrecedes(tmp->adw_frozenxid, xidForceLimit))
launch_worker(TimestampTz now)
{
Oid dbid;
- dlist_iter iter;
+ dlist_iter iter;
dbid = do_start_worker();
if (OidIsValid(dbid))
{
- bool found = false;
+ bool found = false;
/*
* Walk the database list and update the corresponding entry. If the
cost_total = 0.0;
dlist_foreach(iter, &AutoVacuumShmem->av_runningWorkers)
{
- WorkerInfo worker = dlist_container(WorkerInfoData, wi_links, iter.cur);
+ WorkerInfo worker = dlist_container(WorkerInfoData, wi_links, iter.cur);
if (worker->wi_proc != NULL &&
worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
cost_avail = (double) vac_cost_limit / vac_cost_delay;
dlist_foreach(iter, &AutoVacuumShmem->av_runningWorkers)
{
- WorkerInfo worker = dlist_container(WorkerInfoData, wi_links, iter.cur);
+ WorkerInfo worker = dlist_container(WorkerInfoData, wi_links, iter.cur);
if (worker->wi_proc != NULL &&
worker->wi_cost_limit_base > 0 && worker->wi_cost_delay > 0)
/* freeze parameters */
int freeze_max_age;
TransactionId xidForceLimit;
- MultiXactId multiForceLimit;
+ MultiXactId multiForceLimit;
AssertArg(classForm != NULL);
AssertArg(OidIsValid(relid));
*/
typedef struct
{
- RelFileNode rnode;
+ RelFileNode rnode;
ForkNumber forknum;
BlockNumber segno; /* see md.c for special values */
/* might add a real request-type field later; not needed yet */
{
/*
* First time through, so initialize. Note that we zero the whole
- * requests array; this is so that CompactCheckpointerRequestQueue
- * can assume that any pad bytes in the request structs are zeroes.
+ * requests array; this is so that CompactCheckpointerRequestQueue can
+ * assume that any pad bytes in the request structs are zeroes.
*/
MemSet(CheckpointerShmem, 0, size);
SpinLockInit(&CheckpointerShmem->ckpt_lck);
#endif /* LINUX_OOM_SCORE_ADJ */
/*
- * Older Linux kernels have oom_adj not oom_score_adj. This works
- * similarly except with a different scale of adjustment values.
- * If it's necessary to build Postgres to work with either API,
- * you can define both LINUX_OOM_SCORE_ADJ and LINUX_OOM_ADJ.
+ * Older Linux kernels have oom_adj not oom_score_adj. This works
+ * similarly except with a different scale of adjustment values. If
+ * it's necessary to build Postgres to work with either API, you can
+ * define both LINUX_OOM_SCORE_ADJ and LINUX_OOM_ADJ.
*/
#ifdef LINUX_OOM_ADJ
{
elog(FATAL, "setsid() failed: %m");
#endif
- InitializeLatchSupport(); /* needed for latch waits */
+ InitializeLatchSupport(); /* needed for latch waits */
InitLatch(&mainloop_latch); /* initialize latch used in main loop */
{
/*
* track_activities is disabled, but we last reported a
- * non-disabled state. As our final update, change the state and
+ * non-disabled state. As our final update, change the state and
* clear fields we will not be updating anymore.
*/
beentry->st_changecount++;
* request's cutoff time, update it; otherwise there's nothing to do.
*
* Note that if a request is found, we return early and skip the below
- * check for clock skew. This is okay, since the only way for a DB request
- * to be present in the list is that we have been here since the last write
- * round.
+ * check for clock skew. This is okay, since the only way for a DB
+ * request to be present in the list is that we have been here since the
+ * last write round.
*/
slist_foreach(iter, &last_statrequests)
{
* List of background workers.
*
* A worker that requests a database connection during registration will have
- * rw_backend set, and will be present in BackendList. Note: do not rely on
+ * rw_backend set, and will be present in BackendList. Note: do not rely on
* rw_backend being non-NULL for shmem-connected workers!
*/
typedef struct RegisteredBgWorker
int rw_cookie;
#endif
slist_node rw_lnode; /* list link */
-} RegisteredBgWorker;
+} RegisteredBgWorker;
static slist_head BackgroundWorkerList = SLIST_STATIC_INIT(BackgroundWorkerList);
/* The socket number we are listening for connections on */
int PostPortNumber;
+
/* The directory names for Unix socket(s) */
char *Unix_socket_directories;
+
/* The TCP listen address(es) */
char *ListenAddresses;
HANDLE procHandle;
DWORD procId;
} win32_deadchild_waitinfo;
-#endif /* WIN32 */
+#endif /* WIN32 */
static pid_t backend_forkexec(Port *port);
static pid_t internal_forkexec(int argc, char *argv[], Port *port);
/* syntax error in list */
ereport(FATAL,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("invalid list syntax for \"unix_socket_directories\"")));
+ errmsg("invalid list syntax for \"unix_socket_directories\"")));
}
foreach(l, elemlist)
/*
* We can start up without the IDENT file, although it means that you
* cannot log in using any of the authentication methods that need a
- * user name mapping. load_ident() already logged the details of
- * error to the log.
+ * user name mapping. load_ident() already logged the details of error
+ * to the log.
*/
}
* we don't actually sleep so that they are quickly serviced.
*/
static void
-DetermineSleepTime(struct timeval *timeout)
+DetermineSleepTime(struct timeval * timeout)
{
TimestampTz next_wakeup = 0;
rw = slist_container(RegisteredBgWorker, rw_lnode, siter.cur);
if (rw->rw_pid == 0)
- continue; /* not running */
+ continue; /* not running */
if (rw->rw_pid == pid)
{
/*
remote_host[0] = '\0';
remote_port[0] = '\0';
if ((ret = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
- remote_host, sizeof(remote_host),
- remote_port, sizeof(remote_port),
- (log_hostname ? 0 : NI_NUMERICHOST) | NI_NUMERICSERV)) != 0)
+ remote_host, sizeof(remote_host),
+ remote_port, sizeof(remote_port),
+ (log_hostname ? 0 : NI_NUMERICHOST) | NI_NUMERICSERV)) != 0)
ereport(WARNING,
(errmsg_internal("pg_getnameinfo_all() failed: %s",
gai_strerror(ret))));
/* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0);
- AuxiliaryProcessMain(argc - 2, argv + 2); /* does not return */
+ AuxiliaryProcessMain(argc - 2, argv + 2); /* does not return */
}
if (strcmp(argv[1], "--forkavlauncher") == 0)
{
/* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0);
- AutoVacLauncherMain(argc - 2, argv + 2); /* does not return */
+ AutoVacLauncherMain(argc - 2, argv + 2); /* does not return */
}
if (strcmp(argv[1], "--forkavworker") == 0)
{
/* Attach process to shared data structures */
CreateSharedMemoryAndSemaphores(false, 0);
- AutoVacWorkerMain(argc - 2, argv + 2); /* does not return */
+ AutoVacWorkerMain(argc - 2, argv + 2); /* does not return */
}
if (strncmp(argv[1], "--forkbgworker=", 15) == 0)
{
/* Do not want to attach to shared memory */
- PgArchiverMain(argc, argv); /* does not return */
+ PgArchiverMain(argc, argv); /* does not return */
}
if (strcmp(argv[1], "--forkcol") == 0)
{
/* Do not want to attach to shared memory */
- PgstatCollectorMain(argc, argv); /* does not return */
+ PgstatCollectorMain(argc, argv); /* does not return */
}
if (strcmp(argv[1], "--forklog") == 0)
{
/* Do not want to attach to shared memory */
- SysLoggerMain(argc, argv); /* does not return */
+ SysLoggerMain(argc, argv); /* does not return */
}
abort(); /* shouldn't get here */
}
/*
- * Enforce maximum number of workers. Note this is overly restrictive:
- * we could allow more non-shmem-connected workers, because these don't
- * count towards the MAX_BACKENDS limit elsewhere. This doesn't really
- * matter for practical purposes; several million processes would need to
- * run on a single server.
+ * Enforce maximum number of workers. Note this is overly restrictive: we
+ * could allow more non-shmem-connected workers, because these don't count
+ * towards the MAX_BACKENDS limit elsewhere. This doesn't really matter
+ * for practical purposes; several million processes would need to run on
+ * a single server.
*/
if (++numworkers > maxworkers)
{
#ifdef WIN32
/*
- * Subset implementation of waitpid() for Windows. We assume pid is -1
+ * Subset implementation of waitpid() for Windows. We assume pid is -1
* (that is, check all child processes) and options is WNOHANG (don't wait).
*/
static pid_t
elog(FATAL, "setsid() failed: %m");
#endif
- InitializeLatchSupport(); /* needed for latch waits */
+ InitializeLatchSupport(); /* needed for latch waits */
/* Initialize private latch for use by signal handlers */
InitLatch(&sysLoggerLatch);
/*
* The initial logfile is created right in the postmaster, to verify that
- * the Log_directory is writable. We save the reference time so that
- * the syslogger child process can recompute this file name.
+ * the Log_directory is writable. We save the reference time so that the
+ * syslogger child process can recompute this file name.
*
* It might look a bit strange to re-do this during a syslogger restart,
* but we must do so since the postmaster closed syslogFile after the
for (s = nfa->states; s != NULL; s = s->next)
{
nstates++;
- narcs += s->nouts + 1; /* need one extra for endmarker */
+ narcs += s->nouts + 1; /* need one extra for endmarker */
}
cnfa->stflags = (char *) MALLOC(nstates * sizeof(char));
struct cnfa * cnfa,
FILE *f)
{
- struct carc * ca;
+ struct carc *ca;
int pos;
fprintf(f, "%d%s", st, (cnfa->stflags[st] & CNFA_NOPROGRESS) ? ":" : ".");
* forward declarations
*/
static int findprefix(struct cnfa * cnfa, struct colormap * cm,
- chr *string, size_t *slength);
+ chr *string, size_t *slength);
/*
*
* This function does not analyze all complex cases (such as lookahead
* constraints) exactly. Therefore it is possible that some strings matching
- * the reported prefix or exact-match string do not satisfy the regex. But
+ * the reported prefix or exact-match string do not satisfy the regex. But
* it should never be the case that a string satisfying the regex does not
* match the reported prefix or exact-match string.
*/
/*
* Since a correct NFA should never contain any exit-free loops, it should
- * not be possible for our traversal to return to a previously visited
- * NFA state. Hence we need at most nstates chrs in the output string.
+ * not be possible for our traversal to return to a previously visited NFA
+ * state. Hence we need at most nstates chrs in the output string.
*/
*string = (chr *) MALLOC(cnfa->nstates * sizeof(chr));
if (*string == NULL)
/*
* The "pre" state must have only BOS/BOL outarcs, else pattern isn't
- * anchored left. If we have both BOS and BOL, they must go to the
- * same next state.
+ * anchored left. If we have both BOS and BOL, they must go to the same
+ * next state.
*/
st = cnfa->pre;
nextst = -1;
* We could find a state with multiple out-arcs that are all labeled with
* the same singleton color; this comes from patterns like "^ab(cde|cxy)".
* In that case we add the chr "c" to the output string but then exit the
- * loop with nextst == -1. This leaves a little bit on the table: if the
+ * loop with nextst == -1. This leaves a little bit on the table: if the
* pattern is like "^ab(cde|cdy)", we won't notice that "d" could be added
* to the prefix. But chasing multiple parallel state chains doesn't seem
* worth the trouble.
/*
* Identify the color's sole member chr and add it to the prefix
- * string. In general the colormap data structure doesn't provide a
+ * string. In general the colormap data structure doesn't provide a
* way to find color member chrs, except by trying GETCOLOR() on each
* possible chr value, which won't do at all. However, for the cases
* we care about it should be sufficient to test the "firstchr" value,
* that is the first chr ever added to the color. There are cases
* where this might no longer be a member of the color (so we do need
* to test), but none of them are likely to arise for a character that
- * is a member of a common prefix. If we do hit such a corner case,
+ * is a member of a common prefix. If we do hit such a corner case,
* we just fall out without adding anything to the prefix string.
*/
c = cm->cd[thiscolor].firstchr;
static void perform_base_backup(basebackup_options *opt, DIR *tblspcdir);
static void parse_basebackup_options(List *options, basebackup_options *opt);
static void SendXlogRecPtrResult(XLogRecPtr ptr, TimeLineID tli);
-static int compareWalFileNames(const void *a, const void *b);
+static int compareWalFileNames(const void *a, const void *b);
/* Was the backup currently in-progress initiated in recovery mode? */
static bool backup_started_in_recovery = false;
* I'd rather not worry about timelines here, so scan pg_xlog and
* include all WAL files in the range between 'startptr' and 'endptr',
* regardless of the timeline the file is stamped with. If there are
- * some spurious WAL files belonging to timelines that don't belong
- * in this server's history, they will be included too. Normally there
+ * some spurious WAL files belonging to timelines that don't belong in
+ * this server's history, they will be included too. Normally there
* shouldn't be such files, but if there are, there's little harm in
* including them.
*/
dir = AllocateDir("pg_xlog");
if (!dir)
ereport(ERROR,
- (errmsg("could not open directory \"%s\": %m", "pg_xlog")));
+ (errmsg("could not open directory \"%s\": %m", "pg_xlog")));
while ((de = ReadDir(dir, "pg_xlog")) != NULL)
{
/* Does it look like a WAL segment, and is it in the range? */
CheckXLogRemoved(startsegno, ThisTimeLineID);
/*
- * Put the WAL filenames into an array, and sort. We send the files
- * in order from oldest to newest, to reduce the chance that a file
- * is recycled before we get a chance to send it over.
+ * Put the WAL filenames into an array, and sort. We send the files in
+ * order from oldest to newest, to reduce the chance that a file is
+ * recycled before we get a chance to send it over.
*/
nWalFiles = list_length(walFileList);
walFiles = palloc(nWalFiles * sizeof(char *));
XLogFromFileName(walFiles[0], &tli, &segno);
if (segno != startsegno)
{
- char startfname[MAXFNAMELEN];
+ char startfname[MAXFNAMELEN];
+
XLogFileName(startfname, ThisTimeLineID, startsegno);
ereport(ERROR,
(errmsg("could not find WAL file \"%s\"", startfname)));
}
for (i = 0; i < nWalFiles; i++)
{
- XLogSegNo currsegno = segno;
- XLogSegNo nextsegno = segno + 1;
+ XLogSegNo currsegno = segno;
+ XLogSegNo nextsegno = segno + 1;
XLogFromFileName(walFiles[i], &tli, &segno);
if (!(nextsegno == segno || currsegno == segno))
{
- char nextfname[MAXFNAMELEN];
+ char nextfname[MAXFNAMELEN];
+
XLogFileName(nextfname, ThisTimeLineID, nextsegno);
ereport(ERROR,
- (errmsg("could not find WAL file \"%s\"", nextfname)));
+ (errmsg("could not find WAL file \"%s\"", nextfname)));
}
}
if (segno != endsegno)
{
- char endfname[MAXFNAMELEN];
+ char endfname[MAXFNAMELEN];
+
XLogFileName(endfname, ThisTimeLineID, endsegno);
ereport(ERROR,
(errmsg("could not find WAL file \"%s\"", endfname)));
CheckXLogRemoved(segno, tli);
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("unexpected WAL file size \"%s\"", walFiles[i])));
+ errmsg("unexpected WAL file size \"%s\"", walFiles[i])));
}
_tarWriteHeader(pathbuf, NULL, &statbuf);
CheckXLogRemoved(segno, tli);
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("unexpected WAL file size \"%s\"", walFiles[i])));
+ errmsg("unexpected WAL file size \"%s\"", walFiles[i])));
}
/* XLogSegSize is a multiple of 512, so no need for padding */
* file is required for recovery, and even that only if there happens
* to be a timeline switch in the first WAL segment that contains the
* checkpoint record, or if we're taking a base backup from a standby
- * server and the target timeline changes while the backup is taken.
+ * server and the target timeline changes while the backup is taken.
* But they are small and highly useful for debugging purposes, so
* better include them all, always.
*/
foreach(lc, historyFileList)
{
- char *fname = lfirst(lc);
+ char *fname = lfirst(lc);
+
snprintf(pathbuf, MAXPGPATH, XLOGDIR "/%s", fname);
if (lstat(pathbuf, &statbuf) != 0)
static int
compareWalFileNames(const void *a, const void *b)
{
- char *fna = *((char **) a);
- char *fnb = *((char **) b);
+ char *fna = *((char **) a);
+ char *fnb = *((char **) b);
return strcmp(fna + 8, fnb + 8);
}
pq_sendstring(&buf, "tli");
pq_sendint(&buf, 0, 4); /* table oid */
pq_sendint(&buf, 0, 2); /* attnum */
+
/*
* int8 may seem like a surprising data type for this, but in thory int4
* would not be wide enough for this, as TimeLineID is unsigned.
*/
- pq_sendint(&buf, INT8OID, 4); /* type oid */
+ pq_sendint(&buf, INT8OID, 4); /* type oid */
pq_sendint(&buf, -1, 2);
pq_sendint(&buf, 0, 4);
pq_sendint(&buf, 0, 2);
/*
* Include the tablespace directory pointed to by 'path' in the output tar
- * stream. If 'sizeonly' is true, we just calculate a total length and return
+ * stream. If 'sizeonly' is true, we just calculate a total length and return
* it, without actually sending anything.
*/
static int64
TABLESPACE_VERSION_DIRECTORY);
/*
- * Store a directory entry in the tar file so we get the permissions right.
+ * Store a directory entry in the tar file so we get the permissions
+ * right.
*/
if (lstat(pathbuf, &statbuf) != 0)
{
}
if (!sizeonly)
_tarWriteHeader(TABLESPACE_VERSION_DIRECTORY, NULL, &statbuf);
- size = 512; /* Size of the header just added */
+ size = 512; /* Size of the header just added */
/* Send all the files in the tablespace version directory */
size += sendDir(pathbuf, strlen(path), sizeonly);
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("the standby was promoted during online backup"),
- errhint("This means that the backup being taken is corrupt "
- "and should not be used. "
- "Try taking another online backup.")));
+ errhint("This means that the backup being taken is corrupt "
+ "and should not be used. "
+ "Try taking another online backup.")));
snprintf(pathbuf, MAXPGPATH, "%s/%s", path, de->d_name);
}
else if (S_ISREG(statbuf.st_mode))
{
- bool sent = false;
+ bool sent = false;
if (!sizeonly)
sent = sendFile(pathbuf, pathbuf + basepathlen + 1, &statbuf,
{
/* Add size, rounded up to 512byte block */
size += ((statbuf.st_size + 511) & ~511);
- size += 512; /* Size of the header of the file */
+ size += 512; /* Size of the header of the file */
}
}
else
* and the file did not exist.
*/
static bool
-sendFile(char *readfilename, char *tarfilename, struct stat *statbuf,
+sendFile(char *readfilename, char *tarfilename, struct stat * statbuf,
bool missing_ok)
{
FILE *fp;
static void libpqrcv_readtimelinehistoryfile(TimeLineID tli, char **filename, char **content, int *len);
static bool libpqrcv_startstreaming(TimeLineID tli, XLogRecPtr startpoint);
static void libpqrcv_endstreaming(TimeLineID *next_tli);
-static int libpqrcv_receive(int timeout, char **buffer);
+static int libpqrcv_receive(int timeout, char **buffer);
static void libpqrcv_send(const char *buffer, int nbytes);
static void libpqrcv_disconnect(void);
if (PQputCopyEnd(streamConn, NULL) <= 0 || PQflush(streamConn))
ereport(ERROR,
- (errmsg("could not send end-of-streaming message to primary: %s",
- PQerrorMessage(streamConn))));
+ (errmsg("could not send end-of-streaming message to primary: %s",
+ PQerrorMessage(streamConn))));
/*
* After COPY is finished, we should receive a result set indicating the
- * next timeline's ID, or just CommandComplete if the server was shut down.
+ * next timeline's ID, or just CommandComplete if the server was shut
+ * down.
*
* If we had not yet received CopyDone from the backend, PGRES_COPY_IN
* would also be possible. However, at the moment this function is only
* 0 if no data was available within timeout, or wait was interrupted
* by signal.
*
- * -1 if the server ended the COPY.
+ * -1 if the server ended the COPY.
*
* ereports on error.
*/
elog(DEBUG3, "released %d procs up to write %X/%X, %d procs up to flush %X/%X",
numwrite, (uint32) (MyWalSnd->write >> 32), (uint32) MyWalSnd->write,
- numflush, (uint32) (MyWalSnd->flush >> 32), (uint32) MyWalSnd->flush);
+ numflush, (uint32) (MyWalSnd->flush >> 32), (uint32) MyWalSnd->flush);
/*
* If we are managing the highest priority standby, though we weren't
* corresponding the filename of recvFile.
*/
static int recvFile = -1;
-static TimeLineID recvFileTLI = 0;
+static TimeLineID recvFileTLI = 0;
static XLogSegNo recvSegNo = 0;
static uint32 recvOff = 0;
XLogRecPtr Flush; /* last byte + 1 flushed in the standby */
} LogstreamResult;
-static StringInfoData reply_message;
-static StringInfoData incoming_message;
+static StringInfoData reply_message;
+static StringInfoData incoming_message;
/*
* About SIGTERM handling:
/*
* Get any missing history files. We do this always, even when we're
- * not interested in that timeline, so that if we're promoted to become
- * the master later on, we don't select the same timeline that was
- * already used in the current master. This isn't bullet-proof - you'll
- * need some external software to manage your cluster if you need to
- * ensure that a unique timeline id is chosen in every case, but let's
- * avoid the confusion of timeline id collisions where we can.
+ * not interested in that timeline, so that if we're promoted to
+ * become the master later on, we don't select the same timeline that
+ * was already used in the current master. This isn't bullet-proof -
+ * you'll need some external software to manage your cluster if you
+ * need to ensure that a unique timeline id is chosen in every case,
+ * but let's avoid the confusion of timeline id collisions where we
+ * can.
*/
WalRcvFetchTimeLineHistoryFiles(startpointTLI, primaryTLI);
ThisTimeLineID = startpointTLI;
if (walrcv_startstreaming(startpointTLI, startpoint))
{
- bool endofwal = false;
+ bool endofwal = false;
if (first_stream)
ereport(LOG,
(errmsg("started streaming WAL from primary at %X/%X on timeline %u",
- (uint32) (startpoint >> 32), (uint32) startpoint,
+ (uint32) (startpoint >> 32), (uint32) startpoint,
startpointTLI)));
else
ereport(LOG,
- (errmsg("restarted WAL streaming at %X/%X on timeline %u",
- (uint32) (startpoint >> 32), (uint32) startpoint,
- startpointTLI)));
+ (errmsg("restarted WAL streaming at %X/%X on timeline %u",
+ (uint32) (startpoint >> 32), (uint32) startpoint,
+ startpointTLI)));
first_stream = false;
/* Initialize LogstreamResult and buffers for processing messages */
/*
* Emergency bailout if postmaster has died. This is to avoid
- * the necessity for manual cleanup of all postmaster children.
+ * the necessity for manual cleanup of all postmaster
+ * children.
*/
if (!PostmasterIsAlive())
exit(1);
{
if (len > 0)
{
- /* Something was received from master, so reset timeout */
+ /*
+ * Something was received from master, so reset
+ * timeout
+ */
last_recv_timestamp = GetCurrentTimestamp();
ping_sent = false;
XLogWalRcvProcessMsg(buf[0], &buf[1], len - 1);
/*
* We didn't receive anything new. If we haven't heard
* anything from the server for more than
- * wal_receiver_timeout / 2, ping the server. Also, if it's
- * been longer than wal_receiver_status_interval since the
- * last update we sent, send a status update to the master
- * anyway, to report any progress in applying WAL.
+ * wal_receiver_timeout / 2, ping the server. Also, if
+ * it's been longer than wal_receiver_status_interval
+ * since the last update we sent, send a status update to
+ * the master anyway, to report any progress in applying
+ * WAL.
*/
- bool requestReply = false;
+ bool requestReply = false;
/*
* Check if time since last receive from standby has
(errmsg("terminating walreceiver due to timeout")));
/*
- * We didn't receive anything new, for half of receiver
- * replication timeout. Ping the server.
+ * We didn't receive anything new, for half of
+ * receiver replication timeout. Ping the server.
*/
if (!ping_sent)
{
timeout = TimestampTzPlusMilliseconds(last_recv_timestamp,
- (wal_receiver_timeout/2));
+ (wal_receiver_timeout / 2));
if (now >= timeout)
{
requestReply = true;
DisableWalRcvImmediateExit();
/*
- * If the server had switched to a new timeline that we didn't know
- * about when we began streaming, fetch its timeline history file
- * now.
+ * If the server had switched to a new timeline that we didn't
+ * know about when we began streaming, fetch its timeline history
+ * file now.
*/
WalRcvFetchTimeLineHistoryFiles(startpointTLI, primaryTLI);
}
if (walrcv->walRcvState == WALRCV_STOPPING)
{
/*
- * We should've received SIGTERM if the startup process wants
- * us to die, but might as well check it here too.
+ * We should've received SIGTERM if the startup process wants us
+ * to die, but might as well check it here too.
*/
SpinLockRelease(&walrcv->mutex);
exit(1);
static void
WalRcvFetchTimeLineHistoryFiles(TimeLineID first, TimeLineID last)
{
- TimeLineID tli;
+ TimeLineID tli;
for (tli = first; tli <= last; tli++)
{
DisableWalRcvImmediateExit();
/*
- * Check that the filename on the master matches what we calculated
- * ourselves. This is just a sanity check, it should always match.
+ * Check that the filename on the master matches what we
+ * calculated ourselves. This is just a sanity check, it should
+ * always match.
*/
TLHistoryFileName(expectedfname, tli);
if (strcmp(fname, expectedfname) != 0)
int hdrlen;
XLogRecPtr dataStart;
XLogRecPtr walEnd;
- TimestampTz sendTime;
+ TimestampTz sendTime;
bool replyRequested;
resetStringInfo(&incoming_message);
dataStart = pq_getmsgint64(&incoming_message);
walEnd = pq_getmsgint64(&incoming_message);
sendTime = IntegerTimestampToTimestampTz(
- pq_getmsgint64(&incoming_message));
+ pq_getmsgint64(&incoming_message));
ProcessWalSndrMessage(walEnd, sendTime);
buf += hdrlen;
/* read the fields */
walEnd = pq_getmsgint64(&incoming_message);
sendTime = IntegerTimestampToTimestampTz(
- pq_getmsgint64(&incoming_message));
+ pq_getmsgint64(&incoming_message));
replyRequested = pq_getmsgbyte(&incoming_message);
ProcessWalSndrMessage(walEnd, sendTime);
XLogFileNameP(recvFileTLI, recvSegNo))));
/*
- * Create .done file forcibly to prevent the streamed segment from
- * being archived later.
+ * Create .done file forcibly to prevent the streamed segment
+ * from being archived later.
*/
XLogFileName(xlogfname, recvFileTLI, recvSegNo);
XLogArchiveForceDone(xlogfname);
if (lseek(recvFile, (off_t) startoff, SEEK_SET) < 0)
ereport(PANIC,
(errcode_for_file_access(),
- errmsg("could not seek in log segment %s, to offset %u: %m",
- XLogFileNameP(recvFileTLI, recvSegNo),
- startoff)));
+ errmsg("could not seek in log segment %s, to offset %u: %m",
+ XLogFileNameP(recvFileTLI, recvSegNo),
+ startoff)));
recvOff = startoff;
}
* Send feedback at most once per wal_receiver_status_interval.
*/
if (!TimestampDifferenceExceeds(sendTime, now,
- wal_receiver_status_interval * 1000))
+ wal_receiver_status_interval * 1000))
return;
sendTime = now;
}
/* User-settable parameters for walsender */
int max_wal_senders = 0; /* the maximum number of concurrent walsenders */
-int wal_sender_timeout = 60 * 1000; /* maximum time to send one
+int wal_sender_timeout = 60 * 1000; /* maximum time to send one
* WAL data message */
+
/*
* State for WalSndWakeupRequest
*/
-bool wake_wal_senders = false;
+bool wake_wal_senders = false;
/*
* These variables are used similarly to openLogFile/Id/Seg/Off,
static uint32 sendOff = 0;
/* Timeline ID of the currently open file */
-static TimeLineID curFileTimeLine = 0;
+static TimeLineID curFileTimeLine = 0;
/*
* These variables keep track of the state of the timeline we're currently
* the timeline is not the latest timeline on this server, and the server's
* history forked off from that timeline at sendTimeLineValidUpto.
*/
-static TimeLineID sendTimeLine = 0;
-static TimeLineID sendTimeLineNextTLI = 0;
-static bool sendTimeLineIsHistoric = false;
-static XLogRecPtr sendTimeLineValidUpto = InvalidXLogRecPtr;
+static TimeLineID sendTimeLine = 0;
+static TimeLineID sendTimeLineNextTLI = 0;
+static bool sendTimeLineIsHistoric = false;
+static XLogRecPtr sendTimeLineValidUpto = InvalidXLogRecPtr;
/*
* How far have we sent WAL already? This is also advertised in
* Timestamp of the last receipt of the reply from the standby.
*/
static TimestampTz last_reply_timestamp;
+
/* Have we sent a heartbeat message asking for reply, since last reply? */
-static bool ping_sent = false;
+static bool ping_sent = false;
/*
* While streaming WAL in Copy mode, streamingDoneSending is set to true
* after that. streamingDoneReceiving is set to true when we receive CopyDone
* from the other end. When both become true, it's time to exit Copy mode.
*/
-static bool streamingDoneSending;
-static bool streamingDoneReceiving;
+static bool streamingDoneSending;
+static bool streamingDoneReceiving;
/* Flags set by signal handlers for later service in main loop */
static volatile sig_atomic_t got_SIGHUP = false;
off_t bytesleft;
/*
- * Reply with a result set with one row, and two columns. The first col
- * is the name of the history file, 2nd is the contents.
+ * Reply with a result set with one row, and two columns. The first col is
+ * the name of the history file, 2nd is the contents.
*/
TLHistoryFileName(histfname, cmd->timeline);
pq_sendint(&buf, 0, 2); /* format code */
/* second field */
- pq_sendstring(&buf, "content"); /* col name */
+ pq_sendstring(&buf, "content"); /* col name */
pq_sendint(&buf, 0, 4); /* table oid */
pq_sendint(&buf, 0, 2); /* attnum */
pq_sendint(&buf, BYTEAOID, 4); /* type oid */
/* Send a DataRow message */
pq_beginmessage(&buf, 'D');
pq_sendint(&buf, 2, 2); /* # of columns */
- pq_sendint(&buf, strlen(histfname), 4); /* col1 len */
+ pq_sendint(&buf, strlen(histfname), 4); /* col1 len */
pq_sendbytes(&buf, histfname, strlen(histfname));
fd = OpenTransientFile(path, O_RDONLY | PG_BINARY, 0666);
if (lseek(fd, 0, SEEK_SET) != 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek to beginning of file \"%s\": %m", path)));
+ errmsg("could not seek to beginning of file \"%s\": %m", path)));
pq_sendint(&buf, histfilelen, 4); /* col2 len */
bytesleft = histfilelen;
while (bytesleft > 0)
{
- char rbuf[BLCKSZ];
- int nread;
+ char rbuf[BLCKSZ];
+ int nread;
nread = read(fd, rbuf, sizeof(rbuf));
if (nread <= 0)
StartReplication(StartReplicationCmd *cmd)
{
StringInfoData buf;
- XLogRecPtr FlushPtr;
+ XLogRecPtr FlushPtr;
/*
* We assume here that we're logging enough information in the WAL for
/*
* Select the timeline. If it was given explicitly by the client, use
- * that. Otherwise use the timeline of the last replayed record, which
- * is kept in ThisTimeLineID.
+ * that. Otherwise use the timeline of the last replayed record, which is
+ * kept in ThisTimeLineID.
*/
if (am_cascading_walsender)
{
sendTimeLineIsHistoric = true;
/*
- * Check that the timeline the client requested for exists, and the
- * requested start location is on that timeline.
+ * Check that the timeline the client requested for exists, and
+ * the requested start location is on that timeline.
*/
timeLineHistory = readTimeLineHistory(ThisTimeLineID);
switchpoint = tliSwitchPoint(cmd->timeline, timeLineHistory,
* requested startpoint is on that timeline in our history.
*
* This is quite loose on purpose. We only check that we didn't
- * fork off the requested timeline before the switchpoint. We don't
- * check that we switched *to* it before the requested starting
- * point. This is because the client can legitimately request to
- * start replication from the beginning of the WAL segment that
- * contains switchpoint, but on the new timeline, so that it
- * doesn't end up with a partial segment. If you ask for a too old
- * starting point, you'll get an error later when we fail to find
- * the requested WAL segment in pg_xlog.
+ * fork off the requested timeline before the switchpoint. We
+ * don't check that we switched *to* it before the requested
+ * starting point. This is because the client can legitimately
+ * request to start replication from the beginning of the WAL
+ * segment that contains switchpoint, but on the new timeline, so
+ * that it doesn't end up with a partial segment. If you ask for a
+ * too old starting point, you'll get an error later when we fail
+ * to find the requested WAL segment in pg_xlog.
*
* XXX: we could be more strict here and only allow a startpoint
* that's older than the switchpoint, if it it's still in the same
if (!sendTimeLineIsHistoric || cmd->startpoint < sendTimeLineValidUpto)
{
/*
- * When we first start replication the standby will be behind the primary.
- * For some applications, for example, synchronous replication, it is
- * important to have a clear state for this initial catchup mode, so we
- * can trigger actions when we change streaming state later. We may stay
- * in this state for a long time, which is exactly why we want to be able
- * to monitor whether or not we are still here.
+ * When we first start replication the standby will be behind the
+ * primary. For some applications, for example, synchronous
+ * replication, it is important to have a clear state for this initial
+ * catchup mode, so we can trigger actions when we change streaming
+ * state later. We may stay in this state for a long time, which is
+ * exactly why we want to be able to monitor whether or not we are
+ * still here.
*/
WalSndSetState(WALSNDSTATE_CATCHUP);
if (sendTimeLineIsHistoric)
{
char tli_str[11];
- char startpos_str[8+1+8+1];
+ char startpos_str[8 + 1 + 8 + 1];
snprintf(tli_str, sizeof(tli_str), "%u", sendTimeLineNextTLI);
snprintf(startpos_str, sizeof(startpos_str), "%X/%X",
(uint32) (sendTimeLineValidUpto >> 32),
(uint32) sendTimeLineValidUpto);
- pq_beginmessage(&buf, 'T'); /* RowDescription */
- pq_sendint(&buf, 2, 2); /* 2 fields */
+ pq_beginmessage(&buf, 'T'); /* RowDescription */
+ pq_sendint(&buf, 2, 2); /* 2 fields */
/* Field header */
pq_sendstring(&buf, "next_tli");
- pq_sendint(&buf, 0, 4); /* table oid */
- pq_sendint(&buf, 0, 2); /* attnum */
+ pq_sendint(&buf, 0, 4); /* table oid */
+ pq_sendint(&buf, 0, 2); /* attnum */
+
/*
* int8 may seem like a surprising data type for this, but in theory
* int4 would not be wide enough for this, as TimeLineID is unsigned.
pq_sendint(&buf, 0, 2);
pq_sendstring(&buf, "next_tli_startpos");
- pq_sendint(&buf, 0, 4); /* table oid */
- pq_sendint(&buf, 0, 2); /* attnum */
+ pq_sendint(&buf, 0, 4); /* table oid */
+ pq_sendint(&buf, 0, 2); /* attnum */
pq_sendint(&buf, TEXTOID, 4); /* type oid */
pq_sendint(&buf, -1, 2);
pq_sendint(&buf, 0, 4);
/* Data row */
pq_beginmessage(&buf, 'D');
- pq_sendint(&buf, 2, 2); /* number of columns */
+ pq_sendint(&buf, 2, 2); /* number of columns */
pq_sendint(&buf, strlen(tli_str), 4); /* length */
pq_sendbytes(&buf, tli_str, strlen(tli_str));
- pq_sendint(&buf, strlen(startpos_str), 4); /* length */
+ pq_sendint(&buf, strlen(startpos_str), 4); /* length */
pq_sendbytes(&buf, startpos_str, strlen(startpos_str));
pq_endmessage(&buf);
writePtr = pq_getmsgint64(&reply_message);
flushPtr = pq_getmsgint64(&reply_message);
applyPtr = pq_getmsgint64(&reply_message);
- (void) pq_getmsgint64(&reply_message); /* sendTime; not used ATM */
+ (void) pq_getmsgint64(&reply_message); /* sendTime; not used ATM */
replyRequested = pq_getmsgbyte(&reply_message);
elog(DEBUG2, "write %X/%X flush %X/%X apply %X/%X%s",
* Decipher the reply message. The caller already consumed the msgtype
* byte.
*/
- (void) pq_getmsgint64(&reply_message); /* sendTime; not used ATM */
+ (void) pq_getmsgint64(&reply_message); /* sendTime; not used ATM */
feedbackXmin = pq_getmsgint(&reply_message, 4);
feedbackEpoch = pq_getmsgint(&reply_message, 4);
* cleanup conflicts on the standby server.
*
* There is a small window for a race condition here: although we just
- * checked that feedbackXmin precedes nextXid, the nextXid could have gotten
- * advanced between our fetching it and applying the xmin below, perhaps
- * far enough to make feedbackXmin wrap around. In that case the xmin we
- * set here would be "in the future" and have no effect. No point in
- * worrying about this since it's too late to save the desired data
+ * checked that feedbackXmin precedes nextXid, the nextXid could have
+ * gotten advanced between our fetching it and applying the xmin below,
+ * perhaps far enough to make feedbackXmin wrap around. In that case the
+ * xmin we set here would be "in the future" and have no effect. No point
+ * in worrying about this since it's too late to save the desired data
* anyway. Assuming that the standby sends us an increasing sequence of
* xmins, this could only happen during the first reply cycle, else our
* own xmin would prevent nextXid from advancing so far.
ping_sent = false;
/*
- * Loop until we reach the end of this timeline or the client requests
- * to stop streaming.
+ * Loop until we reach the end of this timeline or the client requests to
+ * stop streaming.
*/
for (;;)
{
{
/*
* If half of wal_sender_timeout has lapsed without receiving
- * any reply from standby, send a keep-alive message to standby
- * requesting an immediate reply.
+ * any reply from standby, send a keep-alive message to
+ * standby requesting an immediate reply.
*/
timeout = TimestampTzPlusMilliseconds(last_reply_timestamp,
wal_sender_timeout / 2);
return;
send_failure:
+
/*
* Get here on send failure. Clean up and exit.
*
curFileTimeLine = sendTimeLine;
if (sendTimeLineIsHistoric)
{
- XLogSegNo endSegNo;
+ XLogSegNo endSegNo;
XLByteToSeg(sendTimeLineValidUpto, endSegNo);
if (sendSegNo == endSegNo)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("requested WAL segment %s has already been removed",
- XLogFileNameP(curFileTimeLine, sendSegNo))));
+ XLogFileNameP(curFileTimeLine, sendSegNo))));
else
ereport(ERROR,
(errcode_for_file_access(),
if (lseek(sendFile, (off_t) startoff, SEEK_SET) < 0)
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not seek in log segment %s to offset %u: %m",
- XLogFileNameP(curFileTimeLine, sendSegNo),
- startoff)));
+ errmsg("could not seek in log segment %s to offset %u: %m",
+ XLogFileNameP(curFileTimeLine, sendSegNo),
+ startoff)));
sendOff = startoff;
}
{
ereport(ERROR,
(errcode_for_file_access(),
- errmsg("could not read from log segment %s, offset %u, length %lu: %m",
- XLogFileNameP(curFileTimeLine, sendSegNo),
- sendOff, (unsigned long) segbytes)));
+ errmsg("could not read from log segment %s, offset %u, length %lu: %m",
+ XLogFileNameP(curFileTimeLine, sendSegNo),
+ sendOff, (unsigned long) segbytes)));
}
/* Update state for read */
/*
* Streaming the latest timeline on a standby.
*
- * Attempt to send all WAL that has already been replayed, so that
- * we know it's valid. If we're receiving WAL through streaming
+ * Attempt to send all WAL that has already been replayed, so that we
+ * know it's valid. If we're receiving WAL through streaming
* replication, it's also OK to send any WAL that has been received
* but not replayed.
*
* The timeline we're recovering from can change, or we can be
- * promoted. In either case, the current timeline becomes historic.
- * We need to detect that so that we don't try to stream past the
- * point where we switched to another timeline. We check for promotion
- * or timeline switch after calculating FlushPtr, to avoid a race
+ * promoted. In either case, the current timeline becomes historic. We
+ * need to detect that so that we don't try to stream past the point
+ * where we switched to another timeline. We check for promotion or
+ * timeline switch after calculating FlushPtr, to avoid a race
* condition: if the timeline becomes historic just after we checked
* that it was still current, it's still be OK to stream it up to the
* FlushPtr that was calculated before it became historic.
*
* Attempt to send all data that's already been written out and
* fsync'd to disk. We cannot go further than what's been written out
- * given the current implementation of XLogRead(). And in any case
+ * given the current implementation of XLogRead(). And in any case
* it's unsafe to send WAL that is not securely down to disk on the
* master: if the master subsequently crashes and restarts, slaves
* must not have applied any WAL that gets lost on the master.
* forked to the next timeline, stop streaming.
*
* Note: We might already have sent WAL > sendTimeLineValidUpto. The
- * startup process will normally replay all WAL that has been received from
- * the master, before promoting, but if the WAL streaming is terminated at
- * a WAL page boundary, the valid portion of the timeline might end in the
- * middle of a WAL record. We might've already sent the first half of that
- * partial WAL record to the cascading standby, so that sentPtr >
- * sendTimeLineValidUpto. That's OK; the cascading standby can't replay the
- * partial WAL record either, so it can still follow our timeline switch.
+ * startup process will normally replay all WAL that has been received
+ * from the master, before promoting, but if the WAL streaming is
+ * terminated at a WAL page boundary, the valid portion of the timeline
+ * might end in the middle of a WAL record. We might've already sent the
+ * first half of that partial WAL record to the cascading standby, so that
+ * sentPtr > sendTimeLineValidUpto. That's OK; the cascading standby can't
+ * replay the partial WAL record either, so it can still follow our
+ * timeline switch.
*/
if (sendTimeLineIsHistoric && sendTimeLineValidUpto <= sentPtr)
{
pq_sendbyte(&output_message, 'w');
pq_sendint64(&output_message, startptr); /* dataStart */
- pq_sendint64(&output_message, SendRqstPtr); /* walEnd */
- pq_sendint64(&output_message, 0); /* sendtime, filled in last */
+ pq_sendint64(&output_message, SendRqstPtr); /* walEnd */
+ pq_sendint64(&output_message, 0); /* sendtime, filled in last */
/*
* Read the log directly into the output buffer to avoid extra memcpy
static XLogRecPtr
GetStandbyFlushRecPtr(void)
{
- XLogRecPtr replayPtr;
- TimeLineID replayTLI;
- XLogRecPtr receivePtr;
- TimeLineID receiveTLI;
+ XLogRecPtr replayPtr;
+ TimeLineID replayTLI;
+ XLogRecPtr receivePtr;
+ TimeLineID receiveTLI;
XLogRecPtr result;
/*
* We can safely send what's already been replayed. Also, if walreceiver
- * is streaming WAL from the same timeline, we can send anything that
- * it has streamed, but hasn't been replayed yet.
+ * is streaming WAL from the same timeline, we can send anything that it
+ * has streamed, but hasn't been replayed yet.
*/
receivePtr = GetWalRcvWriteRecPtr(NULL, &receiveTLI);
pqsignal(SIGHUP, WalSndSigHupHandler); /* set flag to read config
* file */
pqsignal(SIGINT, SIG_IGN); /* not used */
- pqsignal(SIGTERM, die); /* request shutdown */
- pqsignal(SIGQUIT, quickdie); /* hard crash time */
+ pqsignal(SIGTERM, die); /* request shutdown */
+ pqsignal(SIGQUIT, quickdie); /* hard crash time */
InitializeTimeouts(); /* establishes SIGALRM handler */
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, WalSndXLogSendHandler); /* request WAL sending */
ListCell *l;
Query *query;
bool RelisBecomingView = false;
- Oid ruleId = InvalidOid;
+ Oid ruleId = InvalidOid;
/*
* If we are installing an ON SELECT rule, we had better grab
* If the relation is becoming a view:
* - delete the associated storage files
* - get rid of any system attributes in pg_attribute; a view shouldn't
- * have any of those
+ * have any of those
* - remove the toast table; there is no need for it anymore, and its
- * presence would make vacuum slightly more complicated
+ * presence would make vacuum slightly more complicated
* - set relkind to RELKIND_VIEW, and adjust other pg_class fields
- * to be appropriate for a view
+ * to be appropriate for a view
*
* NB: we had better have AccessExclusiveLock to do this ...
* ---------------------------------------------------------------------
DeleteSystemAttributeTuples(event_relid);
/*
- * Drop the toast table if any. (This won't take care of updating
- * the toast fields in the relation's own pg_class entry; we handle
- * that below.)
+ * Drop the toast table if any. (This won't take care of updating the
+ * toast fields in the relation's own pg_class entry; we handle that
+ * below.)
*/
if (OidIsValid(toastrelid))
{
static void rewriteTargetListUD(Query *parsetree, RangeTblEntry *target_rte,
Relation target_relation);
static void markQueryForLocking(Query *qry, Node *jtnode,
- LockClauseStrength strength, bool noWait, bool pushedDown);
+ LockClauseStrength strength, bool noWait, bool pushedDown);
static List *matchLocks(CmdType event, RuleLock *rulelocks,
int varno, Query *parsetree);
static Query *fireRIRrules(Query *parsetree, List *activeRIRs,
*
* If the relation is the query's result relation, then we
* need RowExclusiveLock. Otherwise, check to see if the
- * relation is accessed FOR [KEY] UPDATE/SHARE or not. We can't
- * just grab AccessShareLock because then the executor would
- * be trying to upgrade the lock, leading to possible
+ * relation is accessed FOR [KEY] UPDATE/SHARE or not. We
+ * can't just grab AccessShareLock because then the executor
+ * would be trying to upgrade the lock, leading to possible
* deadlocks.
*/
if (rt_index == parsetree->resultRelation)
}
/*
- * If FOR [KEY] UPDATE/SHARE of view, be sure we get right initial lock on the
- * relations it references.
+ * If FOR [KEY] UPDATE/SHARE of view, be sure we get right initial lock on
+ * the relations it references.
*/
rc = get_parse_rowmark(parsetree, rt_index);
forUpdatePushedDown |= (rc != NULL);
rte->modifiedCols = NULL;
/*
- * If FOR [KEY] UPDATE/SHARE of view, mark all the contained tables as implicit
- * FOR [KEY] UPDATE/SHARE, the same as the parser would have done if the view's
- * subquery had been written out explicitly.
+ * If FOR [KEY] UPDATE/SHARE of view, mark all the contained tables as
+ * implicit FOR [KEY] UPDATE/SHARE, the same as the parser would have done
+ * if the view's subquery had been written out explicitly.
*
* Note: we don't consider forUpdatePushedDown here; such marks will be
* made by recursing from the upper level in markQueryForLocking.
/*
* If the relation doesn't exist, say "false" rather than throwing an
- * error. This is helpful since scanning an information_schema view
- * under MVCC rules can result in referencing rels that were just
- * deleted according to a SnapshotNow probe.
+ * error. This is helpful since scanning an information_schema view under
+ * MVCC rules can result in referencing rels that were just deleted
+ * according to a SnapshotNow probe.
*/
if (rel == NULL)
return false;
* that does not correspond to what happens in ordinary SELECT usage of a
* view: all referenced columns must have read permission, even if
* optimization finds that some of them can be discarded during query
- * transformation. The flattening we're doing here is an optional
+ * transformation. The flattening we're doing here is an optional
* optimization, too. (If you are unpersuaded and want to change this,
* note that applying adjust_view_column_set to view_rte->selectedCols is
* clearly *not* the right answer, since that neglects base-rel columns
parsetree = rewriteTargetView(parsetree, rt_entry_relation);
/*
- * At this point product_queries contains any DO ALSO rule actions.
- * Add the rewritten query before or after those. This must match
- * the handling the original query would have gotten below, if
- * we allowed it to be included again.
+ * At this point product_queries contains any DO ALSO rule
+ * actions. Add the rewritten query before or after those. This
+ * must match the handling the original query would have gotten
+ * below, if we allowed it to be included again.
*/
if (parsetree->commandType == CMD_INSERT)
product_queries = lcons(parsetree, product_queries);
returning = true;
}
- /*
- * If we got any product queries, recursively rewrite them --- but
- * first check for recursion!
- */
- if (product_queries != NIL)
- {
- ListCell *n;
- rewrite_event *rev;
+ /*
+ * If we got any product queries, recursively rewrite them --- but
+ * first check for recursion!
+ */
+ if (product_queries != NIL)
+ {
+ ListCell *n;
+ rewrite_event *rev;
- foreach(n, rewrite_events)
- {
- rev = (rewrite_event *) lfirst(n);
- if (rev->relation == RelationGetRelid(rt_entry_relation) &&
- rev->event == event)
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
- errmsg("infinite recursion detected in rules for relation \"%s\"",
+ foreach(n, rewrite_events)
+ {
+ rev = (rewrite_event *) lfirst(n);
+ if (rev->relation == RelationGetRelid(rt_entry_relation) &&
+ rev->event == event)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
+ errmsg("infinite recursion detected in rules for relation \"%s\"",
RelationGetRelationName(rt_entry_relation))));
- }
-
- rev = (rewrite_event *) palloc(sizeof(rewrite_event));
- rev->relation = RelationGetRelid(rt_entry_relation);
- rev->event = event;
- rewrite_events = lcons(rev, rewrite_events);
+ }
- foreach(n, product_queries)
- {
- Query *pt = (Query *) lfirst(n);
- List *newstuff;
+ rev = (rewrite_event *) palloc(sizeof(rewrite_event));
+ rev->relation = RelationGetRelid(rt_entry_relation);
+ rev->event = event;
+ rewrite_events = lcons(rev, rewrite_events);
- newstuff = RewriteQuery(pt, rewrite_events);
- rewritten = list_concat(rewritten, newstuff);
- }
+ foreach(n, product_queries)
+ {
+ Query *pt = (Query *) lfirst(n);
+ List *newstuff;
- rewrite_events = list_delete_first(rewrite_events);
+ newstuff = RewriteQuery(pt, rewrite_events);
+ rewritten = list_concat(rewritten, newstuff);
}
+ rewrite_events = list_delete_first(rewrite_events);
+ }
+
/*
* If there is an INSTEAD, and the original query has a RETURNING, we
* have to have found a RETURNING in the rule(s), else fail. (Because
* If the expression tree contains a whole-row Var for the target RTE,
* the Var is not changed but *found_whole_row is returned as TRUE.
* For most callers this is an error condition, but we leave it to the caller
- * to report the error so that useful context can be provided. (In some
+ * to report the error so that useful context can be provided. (In some
* usages it would be appropriate to modify the Var's vartype and insert a
* ConvertRowtypeExpr node to map back to the original vartype. We might
* someday extend this function's API to support that. For now, the only
typedef struct
{
- int target_varno; /* RTE index to search for */
- int sublevels_up; /* (current) nesting depth */
+ int target_varno; /* RTE index to search for */
+ int sublevels_up; /* (current) nesting depth */
const AttrNumber *attno_map; /* map array for user attnos */
- int map_length; /* number of entries in attno_map[] */
+ int map_length; /* number of entries in attno_map[] */
bool *found_whole_row; /* output flag */
} map_variable_attnos_context;
var->varlevelsup == context->sublevels_up)
{
/* Found a matching variable, make the substitution */
- Var *newvar = (Var *) palloc(sizeof(Var));
- int attno = var->varattno;
+ Var *newvar = (Var *) palloc(sizeof(Var));
+ int attno = var->varattno;
*newvar = *var;
if (attno > 0)
return (Node *) var;
case REPLACEVARS_SUBSTITUTE_NULL:
+
/*
* If Var is of domain type, we should add a CoerceToDomain
* node, in case there is a NOT NULL domain constraint.
*/
return coerce_to_domain((Node *) makeNullConst(var->vartype,
var->vartypmod,
- var->varcollid),
+ var->varcollid),
InvalidOid, -1,
var->vartype,
COERCE_IMPLICIT_CAST,
bool *foundPtr);
static void FlushBuffer(volatile BufferDesc *buf, SMgrRelation reln);
static void AtProcExit_Buffers(int code, Datum arg);
-static int rnode_comparator(const void *p1, const void *p2);
+static int rnode_comparator(const void *p1, const void *p2);
/*
else
ereport(ERROR,
(errcode(ERRCODE_DATA_CORRUPTED),
- errmsg("invalid page in block %u of relation %s",
- blockNum,
- relpath(smgr->smgr_rnode, forkNum))));
+ errmsg("invalid page in block %u of relation %s",
+ blockNum,
+ relpath(smgr->smgr_rnode, forkNum))));
}
}
}
/*
* Unless this is a shutdown checkpoint, we write only permanent, dirty
- * buffers. But at shutdown or end of recovery, we write all dirty buffers.
+ * buffers. But at shutdown or end of recovery, we write all dirty
+ * buffers.
*/
if (!((flags & CHECKPOINT_IS_SHUTDOWN) || (flags & CHECKPOINT_END_OF_RECOVERY)))
mask |= BM_PERMANENT;
instr_time io_start,
io_time;
Block bufBlock;
- char *bufToWrite;
+ char *bufToWrite;
/*
* Acquire the buffer's io_in_progress lock. If StartBufferIO returns
* However, this rule does not apply to unlogged relations, which will be
* lost after a crash anyway. Most unlogged relation pages do not bear
* LSNs since we never emit WAL records for them, and therefore flushing
- * up through the buffer LSN would be useless, but harmless. However, GiST
- * indexes use LSNs internally to track page-splits, and therefore unlogged
- * GiST pages bear "fake" LSNs generated by GetFakeLSNForUnloggedRel. It
- * is unlikely but possible that the fake LSN counter could advance past
- * the WAL insertion point; and if it did happen, attempting to flush WAL
- * through that location would fail, with disastrous system-wide
- * consequences. To make sure that can't happen, skip the flush if the
- * buffer isn't permanent.
+ * up through the buffer LSN would be useless, but harmless. However,
+ * GiST indexes use LSNs internally to track page-splits, and therefore
+ * unlogged GiST pages bear "fake" LSNs generated by
+ * GetFakeLSNForUnloggedRel. It is unlikely but possible that the fake
+ * LSN counter could advance past the WAL insertion point; and if it did
+ * happen, attempting to flush WAL through that location would fail, with
+ * disastrous system-wide consequences. To make sure that can't happen,
+ * skip the flush if the buffer isn't permanent.
*/
if (buf->flags & BM_PERMANENT)
XLogFlush(recptr);
BufferGetLSNAtomic(Buffer buffer)
{
volatile BufferDesc *bufHdr = &BufferDescriptors[buffer - 1];
- char *page = BufferGetPage(buffer);
- XLogRecPtr lsn;
+ char *page = BufferGetPage(buffer);
+ XLogRecPtr lsn;
/*
* If we don't need locking for correctness, fastpath out.
void
DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
{
- int i,
+ int i,
n = 0;
RelFileNode *nodes;
bool use_bsearch;
if (nnodes == 0)
return;
- nodes = palloc(sizeof(RelFileNode) * nnodes); /* non-local relations */
+ nodes = palloc(sizeof(RelFileNode) * nnodes); /* non-local relations */
/* If it's a local relation, it's localbuf.c's problem. */
for (i = 0; i < nnodes; i++)
}
/*
- * If there are no non-local relations, then we're done. Release the memory
- * and return.
+ * If there are no non-local relations, then we're done. Release the
+ * memory and return.
*/
if (n == 0)
{
/*
* For low number of relations to drop just use a simple walk through, to
- * save the bsearch overhead. The threshold to use is rather a guess than a
- * exactly determined value, as it depends on many factors (CPU and RAM
+ * save the bsearch overhead. The threshold to use is rather a guess than
+ * a exactly determined value, as it depends on many factors (CPU and RAM
* speeds, amount of shared buffers etc.).
*/
use_bsearch = n > DROP_RELS_BSEARCH_THRESHOLD;
if (!use_bsearch)
{
- int j;
+ int j;
for (j = 0; j < n; j++)
{
if (RelFileNodeEquals(bufHdr->tag.rnode, rel->rd_node) &&
(bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_DIRTY))
{
- ErrorContextCallback errcallback;
- Page localpage;
+ ErrorContextCallback errcallback;
+ Page localpage;
localpage = (char *) LocalBufHdrGetBlock(bufHdr);
* This is essentially the same as MarkBufferDirty, except:
*
* 1. The caller does not write WAL; so if checksums are enabled, we may need
- * to write an XLOG_HINT WAL record to protect against torn pages.
+ * to write an XLOG_HINT WAL record to protect against torn pages.
* 2. The caller might have only share-lock instead of exclusive-lock on the
- * buffer's content lock.
+ * buffer's content lock.
* 3. This function does not guarantee that the buffer is always marked dirty
- * (due to a race condition), so it cannot be used for important changes.
+ * (due to a race condition), so it cannot be used for important changes.
*/
void
MarkBufferDirtyHint(Buffer buffer)
{
volatile BufferDesc *bufHdr;
- Page page = BufferGetPage(buffer);
+ Page page = BufferGetPage(buffer);
if (!BufferIsValid(buffer))
elog(ERROR, "bad buffer ID: %d", buffer);
/*
* This routine might get called many times on the same page, if we are
* making the first scan after commit of an xact that added/deleted many
- * tuples. So, be as quick as we can if the buffer is already dirty. We do
- * this by not acquiring spinlock if it looks like the status bits are
+ * tuples. So, be as quick as we can if the buffer is already dirty. We
+ * do this by not acquiring spinlock if it looks like the status bits are
* already set. Since we make this test unlocked, there's a chance we
* might fail to notice that the flags have just been cleared, and failed
* to reset them, due to memory-ordering issues. But since this function
- * is only intended to be used in cases where failing to write out the data
- * would be harmless anyway, it doesn't really matter.
+ * is only intended to be used in cases where failing to write out the
+ * data would be harmless anyway, it doesn't really matter.
*/
if ((bufHdr->flags & (BM_DIRTY | BM_JUST_DIRTIED)) !=
(BM_DIRTY | BM_JUST_DIRTIED))
/*
* If checksums are enabled, and the buffer is permanent, then a full
- * page image may be required even for some hint bit updates to protect
- * against torn pages. This full page image is only necessary if the
- * hint bit update is the first change to the page since the last
- * checkpoint.
+ * page image may be required even for some hint bit updates to
+ * protect against torn pages. This full page image is only necessary
+ * if the hint bit update is the first change to the page since the
+ * last checkpoint.
*
- * We don't check full_page_writes here because that logic is
- * included when we call XLogInsert() since the value changes
- * dynamically.
+ * We don't check full_page_writes here because that logic is included
+ * when we call XLogInsert() since the value changes dynamically.
*/
if (DataChecksumsEnabled() && (bufHdr->flags & BM_PERMANENT))
{
/*
* If we're in recovery we cannot dirty a page because of a hint.
- * We can set the hint, just not dirty the page as a result so
- * the hint is lost when we evict the page or shutdown.
+ * We can set the hint, just not dirty the page as a result so the
+ * hint is lost when we evict the page or shutdown.
*
* See src/backend/storage/page/README for longer discussion.
*/
/*
* If the block is already dirty because we either made a change
* or set a hint already, then we don't need to write a full page
- * image. Note that aggressive cleaning of blocks
- * dirtied by hint bit setting would increase the call rate.
- * Bulk setting of hint bits would reduce the call rate...
+ * image. Note that aggressive cleaning of blocks dirtied by hint
+ * bit setting would increase the call rate. Bulk setting of hint
+ * bits would reduce the call rate...
*
* We must issue the WAL record before we mark the buffer dirty.
- * Otherwise we might write the page before we write the WAL.
- * That causes a race condition, since a checkpoint might occur
- * between writing the WAL record and marking the buffer dirty.
- * We solve that with a kluge, but one that is already in use
- * during transaction commit to prevent race conditions.
- * Basically, we simply prevent the checkpoint WAL record from
- * being written until we have marked the buffer dirty. We don't
- * start the checkpoint flush until we have marked dirty, so our
- * checkpoint must flush the change to disk successfully or the
- * checkpoint never gets written, so crash recovery will fix.
+ * Otherwise we might write the page before we write the WAL. That
+ * causes a race condition, since a checkpoint might occur between
+ * writing the WAL record and marking the buffer dirty. We solve
+ * that with a kluge, but one that is already in use during
+ * transaction commit to prevent race conditions. Basically, we
+ * simply prevent the checkpoint WAL record from being written
+ * until we have marked the buffer dirty. We don't start the
+ * checkpoint flush until we have marked dirty, so our checkpoint
+ * must flush the change to disk successfully or the checkpoint
+ * never gets written, so crash recovery will fix.
*
* It's possible we may enter here without an xid, so it is
* essential that CreateCheckpoint waits for virtual transactions
dirtied = true; /* Means "will be dirtied by this action" */
/*
- * Set the page LSN if we wrote a backup block. We aren't
- * supposed to set this when only holding a share lock but
- * as long as we serialise it somehow we're OK. We choose to
- * set LSN while holding the buffer header lock, which causes
- * any reader of an LSN who holds only a share lock to also
- * obtain a buffer header lock before using PageGetLSN(),
- * which is enforced in BufferGetLSNAtomic().
+ * Set the page LSN if we wrote a backup block. We aren't supposed
+ * to set this when only holding a share lock but as long as we
+ * serialise it somehow we're OK. We choose to set LSN while
+ * holding the buffer header lock, which causes any reader of an
+ * LSN who holds only a share lock to also obtain a buffer header
+ * lock before using PageGetLSN(), which is enforced in
+ * BufferGetLSNAtomic().
*
* If checksums are enabled, you might think we should reset the
* checksum here. That will happen when the page is written
*/
if (bufHdr->flags & BM_DIRTY)
{
- SMgrRelation oreln;
- Page localpage = (char *) LocalBufHdrGetBlock(bufHdr);
+ SMgrRelation oreln;
+ Page localpage = (char *) LocalBufHdrGetBlock(bufHdr);
/* Find smgr relation for buffer */
oreln = smgropen(bufHdr->tag.rnode, MyBackendId);
{
if (LocalRefCount[i] != 0)
{
- Buffer b = -i - 1;
+ Buffer b = -i - 1;
PrintBufferLeakWarning(b);
RefCountErrors++;
{
if (LocalRefCount[i] != 0)
{
- Buffer b = -i - 1;
+ Buffer b = -i - 1;
PrintBufferLeakWarning(b);
RefCountErrors++;
pgxact->xmin = InvalidTransactionId;
/* must be cleared with xid/xmin: */
pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
- pgxact->delayChkpt = false; /* be sure this is cleared in abort */
+ pgxact->delayChkpt = false; /* be sure this is cleared in abort */
proc->recoveryConflictPending = false;
/* Clear the subtransaction-XID cache too while holding the lock */
pgxact->xmin = InvalidTransactionId;
/* must be cleared with xid/xmin: */
pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK;
- pgxact->delayChkpt = false; /* be sure this is cleared in abort */
+ pgxact->delayChkpt = false; /* be sure this is cleared in abort */
proc->recoveryConflictPending = false;
Assert(pgxact->nxids == 0);
* depending upon when the snapshot was taken, or change normal
* snapshot processing so it matches.
*
- * Note: It is possible for recovery to end before we finish taking the
- * snapshot, and for newly assigned transaction ids to be added to the
- * ProcArray. xmax cannot change while we hold ProcArrayLock, so those
- * newly added transaction ids would be filtered away, so we need not
- * be concerned about them.
+ * Note: It is possible for recovery to end before we finish taking
+ * the snapshot, and for newly assigned transaction ids to be added to
+ * the ProcArray. xmax cannot change while we hold ProcArrayLock, so
+ * those newly added transaction ids would be filtered away, so we
+ * need not be concerned about them.
*/
subcount = KnownAssignedXidsGetAndSetXmin(snapshot->subxip, &xmin,
xmax);
/*
* Top-level XID of a transaction is always less than any of
- * its subxids, so we don't need to check if any of the subxids
- * are smaller than oldestRunningXid
+ * its subxids, so we don't need to check if any of the
+ * subxids are smaller than oldestRunningXid
*/
}
}
for (index = 0; index < arrayP->numProcs; index++)
{
- int pgprocno = arrayP->pgprocnos[index];
- volatile PGPROC *proc = &allProcs[pgprocno];
- volatile PGXACT *pgxact = &allPgXact[pgprocno];
+ int pgprocno = arrayP->pgprocnos[index];
+ volatile PGPROC *proc = &allProcs[pgprocno];
+ volatile PGXACT *pgxact = &allPgXact[pgprocno];
if (pgxact->delayChkpt)
{
{
for (index = 0; index < arrayP->numProcs; index++)
{
- int pgprocno = arrayP->pgprocnos[index];
- volatile PGPROC *proc = &allProcs[pgprocno];
- volatile PGXACT *pgxact = &allPgXact[pgprocno];
+ int pgprocno = arrayP->pgprocnos[index];
+ volatile PGPROC *proc = &allProcs[pgprocno];
+ volatile PGXACT *pgxact = &allPgXact[pgprocno];
VirtualTransactionId vxid;
GET_VXID_FROM_PGPROC(vxid, *proc);
ProcWaitForSignal();
/*
- * Clear any timeout requests established above. We assume here that
- * the Startup process doesn't have any other timeouts than what this
- * function uses. If that stops being true, we could cancel the
- * timeouts individually, but that'd be slower.
+ * Clear any timeout requests established above. We assume here that the
+ * Startup process doesn't have any other timeouts than what this function
+ * uses. If that stops being true, we could cancel the timeouts
+ * individually, but that'd be slower.
*/
disable_all_timeouts(false);
}
static void
RemoveLocalLock(LOCALLOCK *locallock)
{
- int i;
+ int i;
for (i = locallock->numLockOwners - 1; i >= 0; i--)
{
LOCALLOCKOWNER *lockOwners = locallock->lockOwners;
/* If session lock is above array position 0, move it down to 0 */
- for (i = 0; i < locallock->numLockOwners ; i++)
+ for (i = 0; i < locallock->numLockOwners; i++)
{
if (lockOwners[i].owner == NULL)
lockOwners[0] = lockOwners[i];
}
else
{
- int i;
+ int i;
for (i = nlocks - 1; i >= 0; i--)
ReleaseLockIfHeld(locallocks[i], false);
}
else
{
- int i;
+ int i;
for (i = nlocks - 1; i >= 0; i--)
LockReassignOwner(locallocks[i], parent);
int ip = -1;
/*
- * Scan to see if there are any locks belonging to current owner or
- * its parent
+ * Scan to see if there are any locks belonging to current owner or its
+ * parent
*/
lockOwners = locallock->lockOwners;
for (i = locallock->numLockOwners - 1; i >= 0; i--)
}
if (ic < 0)
- return; /* no current locks */
+ return; /* no current locks */
if (ip < 0)
{
LWLockAcquire(proc->backendLock, LW_SHARED);
/*
- * If the target backend isn't referencing the same database as the
- * lock, then we needn't examine the individual relation IDs at
- * all; none of them can be relevant.
+ * If the target backend isn't referencing the same database as
+ * the lock, then we needn't examine the individual relation IDs
+ * at all; none of them can be relevant.
*
* See FastPathTransferLocks() for discussion of why we do this
* test after acquiring the lock.
/*
* We cannot simply modify proclock->tag.myProc to reassign
* ownership of the lock, because that's part of the hash key and
- * the proclock would then be in the wrong hash chain. Instead
+ * the proclock would then be in the wrong hash chain. Instead
* use hash_update_hash_key. (We used to create a new hash entry,
* but that risks out-of-memory failure if other processes are
- * busy making proclocks too.) We must unlink the proclock from
+ * busy making proclocks too.) We must unlink the proclock from
* our procLink chain and put it into the new proc's chain, too.
*
* Note: the updated proclock hash key will still belong to the
- * same hash partition, cf proclock_hash(). So the partition
- * lock we already hold is sufficient for this.
+ * same hash partition, cf proclock_hash(). So the partition lock
+ * we already hold is sufficient for this.
*/
SHMQueueDelete(&proclock->procLink);
proclocktag.myProc = newproc;
/*
- * Update the proclock. We should not find any existing entry
- * for the same hash key, since there can be only one entry for
- * any given lock with my own proc.
+ * Update the proclock. We should not find any existing entry for
+ * the same hash key, since there can be only one entry for any
+ * given lock with my own proc.
*/
if (!hash_update_hash_key(LockMethodProcLockHash,
(void *) proclock,
/*
* Can't use serializable mode while recovery is still active, as it is,
- * for example, on a hot standby. We could get here despite the check
- * in check_XactIsoLevel() if default_transaction_isolation is set to
+ * for example, on a hot standby. We could get here despite the check in
+ * check_XactIsoLevel() if default_transaction_isolation is set to
* serializable, so phrase the hint accordingly.
*/
if (RecoveryInProgress())
* five separate consumers: (1) normal backends, (2) autovacuum workers
* and the autovacuum launcher, (3) background workers, (4) auxiliary
* processes, and (5) prepared transactions. Each PGPROC structure is
- * dedicated to exactly one of these purposes, and they do not move between
- * groups.
+ * dedicated to exactly one of these purposes, and they do not move
+ * between groups.
*/
procs = (PGPROC *) ShmemAlloc(TotalProcs * sizeof(PGPROC));
ProcGlobal->allProcs = procs;
elog(ERROR, "you already exist");
/*
- * Initialize process-local latch support. This could fail if the kernel
+ * Initialize process-local latch support. This could fail if the kernel
* is low on resources, and if so we want to exit cleanly before acquiring
* any shared-memory resources.
*/
elog(ERROR, "you already exist");
/*
- * Initialize process-local latch support. This could fail if the kernel
+ * Initialize process-local latch support. This could fail if the kernel
* is low on resources, and if so we want to exit cleanly before acquiring
* any shared-memory resources.
*/
{
int pid = autovac->pid;
StringInfoData locktagbuf;
- StringInfoData logbuf; /* errdetail for server log */
+ StringInfoData logbuf; /* errdetail for server log */
initStringInfo(&locktagbuf);
initStringInfo(&logbuf);
DescribeLockTag(&locktagbuf, &lock->tag);
appendStringInfo(&logbuf,
- _("Process %d waits for %s on %s."),
- MyProcPid,
- GetLockmodeName(lock->tag.locktag_lockmethodid,
- lockmode),
- locktagbuf.data);
+ _("Process %d waits for %s on %s."),
+ MyProcPid,
+ GetLockmodeName(lock->tag.locktag_lockmethodid,
+ lockmode),
+ locktagbuf.data);
/* release lock as quickly as possible */
LWLockRelease(ProcArrayLock);
ereport(LOG,
- (errmsg("sending cancel to blocking autovacuum PID %d",
- pid),
- errdetail_log("%s", logbuf.data)));
+ (errmsg("sending cancel to blocking autovacuum PID %d",
+ pid),
+ errdetail_log("%s", logbuf.data)));
pfree(logbuf.data);
pfree(locktagbuf.data);
int
SpinlockSemas(void)
{
- int nsemas;
+ int nsemas;
/*
* It would be cleaner to distribute this logic into the affected modules,
#include "access/xlog.h"
#include "storage/checksum.h"
-bool ignore_checksum_failure = false;
+bool ignore_checksum_failure = false;
-static char pageCopyData[BLCKSZ]; /* for checksum calculation */
+static char pageCopyData[BLCKSZ]; /* for checksum calculation */
static Page pageCopy = pageCopyData;
static uint16 PageCalcChecksum16(Page page, BlockNumber blkno);
}
/*
- * The following checks don't prove the header is correct,
- * only that it looks sane enough to allow into the buffer pool.
- * Later usage of the block can still reveal problems,
- * which is why we offer the checksum option.
+ * The following checks don't prove the header is correct, only that
+ * it looks sane enough to allow into the buffer pool. Later usage of
+ * the block can still reveal problems, which is why we offer the
+ * checksum option.
*/
if ((p->pd_flags & ~PD_VALID_FLAG_BITS) == 0 &&
- p->pd_lower <= p->pd_upper &&
- p->pd_upper <= p->pd_special &&
- p->pd_special <= BLCKSZ &&
- p->pd_special == MAXALIGN(p->pd_special))
+ p->pd_lower <= p->pd_upper &&
+ p->pd_upper <= p->pd_special &&
+ p->pd_special <= BLCKSZ &&
+ p->pd_special == MAXALIGN(p->pd_special))
header_sane = true;
if (header_sane && !checksum_failure)
/*
* We make a copy iff we need to calculate a checksum because other
- * backends may set hint bits on this page while we write, which
- * would mean the checksum differs from the page contents. It doesn't
- * matter if we include or exclude hints during the copy, as long
- * as we write a valid page and associated checksum.
+ * backends may set hint bits on this page while we write, which would
+ * mean the checksum differs from the page contents. It doesn't matter if
+ * we include or exclude hints during the copy, as long as we write a
+ * valid page and associated checksum.
*/
memcpy((char *) pageCopy, (char *) page, BLCKSZ);
PageSetChecksumInplace(pageCopy, blkno);
if (DataChecksumsEnabled())
{
PageHeader p = (PageHeader) page;
+
p->pd_checksum = PageCalcChecksum16(page, blkno);
}
static uint16
PageCalcChecksum16(Page page, BlockNumber blkno)
{
- PageHeader phdr = (PageHeader) page;
+ PageHeader phdr = (PageHeader) page;
uint16 save_checksum;
uint32 checksum;
/*
* Save pd_checksum and set it to zero, so that the checksum calculation
- * isn't affected by the checksum stored on the page. We do this to
- * allow optimization of the checksum calculation on the whole block
- * in one go.
+ * isn't affected by the checksum stored on the page. We do this to allow
+ * optimization of the checksum calculation on the whole block in one go.
*/
save_checksum = phdr->pd_checksum;
phdr->pd_checksum = 0;
* for Fowler/Noll/Vo) The primitive of a plain FNV-1a hash folds in data 1
* byte at a time according to the formula:
*
- * hash = (hash ^ value) * FNV_PRIME
+ * hash = (hash ^ value) * FNV_PRIME
*
* FNV-1a algorithm is described at http://www.isthe.com/chongo/tech/comp/fnv/
*
* avalanche into lower positions. For performance reasons we choose to combine
* 4 bytes at a time. The actual hash formula used as the basis is:
*
- * hash = (hash ^ value) * FNV_PRIME ^ ((hash ^ value) >> 17)
+ * hash = (hash ^ value) * FNV_PRIME ^ ((hash ^ value) >> 17)
*
* The main bottleneck in this calculation is the multiplication latency. To
* hide the latency and to make use of SIMD parallelism multiple hash values
uint32
checksum_block(char *data, uint32 size)
{
- uint32 sums[N_SUMS];
- uint32 (*dataArr)[N_SUMS] = (uint32 (*)[N_SUMS]) data;
- uint32 result = 0;
- int i, j;
+ uint32 sums[N_SUMS];
+ uint32 (*dataArr)[N_SUMS] = (uint32 (*)[N_SUMS]) data;
+ uint32 result = 0;
+ int i,
+ j;
/* ensure that the size is compatible with the algorithm */
- Assert((size % (sizeof(uint32)*N_SUMS)) == 0);
+ Assert((size % (sizeof(uint32) * N_SUMS)) == 0);
/* initialize partial checksums to their corresponding offsets */
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets));
/* main checksum calculation */
- for (i = 0; i < size/sizeof(uint32)/N_SUMS; i++)
+ for (i = 0; i < size / sizeof(uint32) / N_SUMS; i++)
for (j = 0; j < N_SUMS; j++)
CHECKSUM_COMP(sums[j], dataArr[i][j]);
void
smgrdounlinkall(SMgrRelation *rels, int nrels, bool isRedo)
{
- int i = 0;
+ int i = 0;
RelFileNodeBackend *rnodes;
- ForkNumber forknum;
+ ForkNumber forknum;
if (nrels == 0)
return;
/*
- * create an array which contains all relations to be dropped, and
- * close each relation's forks at the smgr level while at it
+ * create an array which contains all relations to be dropped, and close
+ * each relation's forks at the smgr level while at it
*/
rnodes = palloc(sizeof(RelFileNodeBackend) * nrels);
for (i = 0; i < nrels; i++)
}
/*
- * Get rid of any remaining buffers for the relations. bufmgr will just
+ * Get rid of any remaining buffers for the relations. bufmgr will just
* drop them without bothering to write the contents.
*/
DropRelFileNodesAllBuffers(rnodes, nrels);
/*
- * It'd be nice to tell the stats collector to forget them immediately, too.
- * But we can't because we don't know the OIDs.
+ * It'd be nice to tell the stats collector to forget them immediately,
+ * too. But we can't because we don't know the OIDs.
*/
/*
* dangling smgr references they may have for these rels. We should do
* this before starting the actual unlinking, in case we fail partway
* through that step. Note that the sinval messages will eventually come
- * back to this backend, too, and thereby provide a backstop that we closed
- * our own smgr rel.
+ * back to this backend, too, and thereby provide a backstop that we
+ * closed our own smgr rel.
*/
for (i = 0; i < nrels; i++)
CacheInvalidateSmgr(rnodes[i]);
for (i = 0; i < nrels; i++)
{
- int which = rels[i]->smgr_which;
+ int which = rels[i]->smgr_which;
+
for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
(*(smgrsw[which].smgr_unlink)) (rnodes[i], forknum, isRedo);
}
pqsignal(SIGQUIT, quickdie); /* hard crash time */
else
pqsignal(SIGQUIT, die); /* cancel current query and exit */
- InitializeTimeouts(); /* establishes SIGALRM handler */
+ InitializeTimeouts(); /* establishes SIGALRM handler */
/*
* Ignore failure to write to frontend. Note: if frontend closes
ProcessUtility(utilityStmt,
portal->sourceText,
- isTopLevel ? PROCESS_UTILITY_TOPLEVEL : PROCESS_UTILITY_QUERY,
+ isTopLevel ? PROCESS_UTILITY_TOPLEVEL : PROCESS_UTILITY_QUERY,
portal->portalParams,
dest,
completionTag);
* exclusive. We treat occurrences as independent events.
*
* This is only a good plan if we have a pretty fair number of
- * MCELEMs available; we set the threshold at 100. If no stats or
+ * MCELEMs available; we set the threshold at 100. If no stats or
* insufficient stats, arbitrarily use DEFAULT_TS_MATCH_SEL*4.
*/
if (lookup == NULL || length < 100)
/*
* If element type is pass-by-reference, we must copy it into
- * palloc'd space, so that we can release the array below.
- * (We do this so that the space needed for element values is
+ * palloc'd space, so that we can release the array below. (We
+ * do this so that the space needed for element values is
* limited by the size of the hashtable; if we kept all the
* array values around, it could be much more.)
*/
*
* Find all array entries matching (not distinct from) search/search_isnull,
* and delete them if remove is true, else replace them with
- * replace/replace_isnull. Comparisons are done using the specified
+ * replace/replace_isnull. Comparisons are done using the specified
* collation. fcinfo is passed only for caching purposes.
*/
static ArrayType *
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(element_type))));
+ errmsg("could not identify an equality operator for type %s",
+ format_type_be(element_type))));
fcinfo->flinfo->fn_extra = (void *) typentry;
}
typlen = typentry->typlen;
typalign = typentry->typalign;
/*
- * Detoast values if they are toasted. The replacement value must be
+ * Detoast values if they are toasted. The replacement value must be
* detoasted for insertion into the result array, while detoasting the
* search value only once saves cycles.
*/
if (!AllocSizeIsValid(nbytes))
ereport(ERROR,
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
- errmsg("array size exceeds the maximum allowed (%d)",
- (int) MaxAllocSize)));
+ errmsg("array size exceeds the maximum allowed (%d)",
+ (int) MaxAllocSize)));
}
nresult++;
}
if (zone->month != 0 || zone->day != 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("interval time zone \"%s\" must not include months or days",
- DatumGetCString(DirectFunctionCall1(interval_out,
+ errmsg("interval time zone \"%s\" must not include months or days",
+ DatumGetCString(DirectFunctionCall1(interval_out,
PointerGetDatum(zone))))));
#ifdef HAVE_INT64_TIMESTAMP
break;
case DTK_TIME:
+
/*
* This might be an ISO time following a "t" field.
*/
str++;
if (*str == '\0')
- return DTERR_BAD_FORMAT; /* end of string after separator */
+ return DTERR_BAD_FORMAT; /* end of string after separator */
field[nf] = str;
if (isdigit((unsigned char) *str))
Assert(*field[i] == '-' || *field[i] == '+');
/*
- * Check for signed hh:mm or hh:mm:ss. If so, process exactly
+ * Check for signed hh:mm or hh:mm:ss. If so, process exactly
* like DTK_TIME case above, plus handling the sign.
*/
if (strchr(field[i] + 1, ':') != NULL &&
static void
NUMDesc_prepare(NUMDesc *num, FormatNode *n)
{
-
if (n->type != NODE_TYPE_ACTION)
return;
strcpy(s, str_toupper_z(localized_full_months[tm->tm_mon - 1], collid));
else
sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
- asc_toupper_z(months_full[tm->tm_mon - 1]));
+ asc_toupper_z(months_full[tm->tm_mon - 1]));
s += strlen(s);
break;
case DCH_Month:
}
else
/* find century year for dates ending in "00" */
- tm->tm_year = tmfc.cc * 100 + ((tmfc.cc >= 0) ? 0 : 1);
+ tm->tm_year = tmfc.cc * 100 + ((tmfc.cc >= 0) ? 0 : 1);
}
else
- /* If a 4-digit year is provided, we use that and ignore CC. */
+ /* If a 4-digit year is provided, we use that and ignore CC. */
{
tm->tm_year = tmfc.year;
if (tmfc.bc && tm->tm_year > 0)
tm->tm_year = -(tm->tm_year - 1);
}
}
- else if (tmfc.cc) /* use first year of century */
+ else if (tmfc.cc) /* use first year of century */
{
if (tmfc.bc)
tmfc.cc = -tmfc.cc;
if (tmfc.w)
tmfc.dd = (tmfc.w - 1) * 7 + 1;
if (tmfc.d)
- tm->tm_wday = tmfc.d - 1; /* convert to native numbering */
+ tm->tm_wday = tmfc.d - 1; /* convert to native numbering */
if (tmfc.dd)
tm->tm_mday = tmfc.dd;
if (tmfc.ddd)
JSON_PARSE_OBJECT_NEXT, /* saw object value, expecting ',' or '}' */
JSON_PARSE_OBJECT_COMMA, /* saw object ',', expecting next label */
JSON_PARSE_END /* saw the end of a document, expect nothing */
-} JsonParseContext;
+} JsonParseContext;
static inline void json_lex(JsonLexContext *lex);
static inline void json_lex_string(JsonLexContext *lex);
JSON_SEARCH_OBJECT = 1,
JSON_SEARCH_ARRAY,
JSON_SEARCH_PATH
-} JsonSearch;
+} JsonSearch;
/* state for json_object_keys */
typedef struct okeysState
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("cannot extract field from a non-object")));
- /*
- * initialize array count for this nesting level
- * Note: the lex_level seen by array_start is one less than that seen by
- * the elements of the array.
+
+ /*
+ * initialize array count for this nesting level Note: the lex_level seen
+ * by array_start is one less than that seen by the elements of the array.
*/
if (_state->search_type == JSON_SEARCH_PATH &&
lex_level < _state->npath)
/*
* BackendPidGetProc returns NULL if the pid isn't valid; but by the time
- * we reach kill(), a process for which we get a valid proc here might have
- * terminated on its own. There's no way to acquire a lock on an arbitrary
- * process to prevent that. But since so far all the callers of this
- * mechanism involve some request for ending the process anyway, that it
- * might end on its own first is not a problem.
+ * we reach kill(), a process for which we get a valid proc here might
+ * have terminated on its own. There's no way to acquire a lock on an
+ * arbitrary process to prevent that. But since so far all the callers of
+ * this mechanism involve some request for ending the process anyway, that
+ * it might end on its own first is not a problem.
*/
if (proc == NULL)
{
dest->sign = NUMERIC_SIGN(num);
dest->dscale = NUMERIC_DSCALE(num);
dest->digits = NUMERIC_DIGITS(num);
- dest->buf = NULL; /* digits array is not palloc'd */
+ dest->buf = NULL; /* digits array is not palloc'd */
}
* Convert a Windows setlocale() argument to a Unix-style one.
*
* Regardless of platform, we install message catalogs under a Unix-style
- * LL[_CC][.ENCODING][@VARIANT] naming convention. Only LC_MESSAGES settings
+ * LL[_CC][.ENCODING][@VARIANT] naming convention. Only LC_MESSAGES settings
* following that style will elicit localized interface strings.
*
* Before Visual Studio 2012 (msvcr110.dll), Windows setlocale() accepted "C"
* (but not "c") and strings of the form [_][.],
* case-insensitive. setlocale() returns the fully-qualified form; for
- * example, setlocale("thaI") returns "Thai_Thailand.874". Internally,
+ * example, setlocale("thaI") returns "Thai_Thailand.874". Internally,
* setlocale() and _create_locale() select a "locale identifier"[1] and store
* it in an undocumented _locale_t field. From that LCID, we can retrieve the
* ISO 639 language and the ISO 3166 country. Character encoding does not
* Studio 2012, setlocale() accepts locale names in addition to the strings it
* accepted historically. It does not standardize them; setlocale("Th-tH")
* returns "Th-tH". setlocale(category, "") still returns a traditional
- * string. Furthermore, msvcr110.dll changed the undocumented _locale_t
+ * string. Furthermore, msvcr110.dll changed the undocumented _locale_t
* content to carry locale names instead of locale identifiers.
*
* MinGW headers declare _create_locale(), but msvcrt.dll lacks that symbol.
* IsoLocaleName() always fails in a MinGW-built postgres.exe, so only
- * Unix-style values of the lc_messages GUC can elicit localized messages. In
+ * Unix-style values of the lc_messages GUC can elicit localized messages. In
* particular, every lc_messages setting that initdb can select automatically
* will yield only C-locale messages. XXX This could be fixed by running the
* fully-qualified locale name through a lookup table.
* need not standardize letter case here. So long as we do not ship
* message catalogs for which it would matter, we also need not
* translate the script/variant portion, e.g. uz-Cyrl-UZ to
- * uz_UZ@cyrillic. Simply replace the hyphen with an underscore.
+ * uz_UZ@cyrillic. Simply replace the hyphen with an underscore.
*
* Note that the locale name can be less-specific than the value we
* would derive under earlier Visual Studio releases. For example,
/*
- * event_trigger_in - input routine for pseudo-type event_trigger.
+ * event_trigger_in - input routine for pseudo-type event_trigger.
*/
Datum
event_trigger_in(PG_FUNCTION_ARGS)
cmp = range_cmp_bound_values(typcache, &boundA, &boundB);
if (cmp < 0)
{
- RangeType *r;
+ RangeType *r;
/*
* Bounds do not overlap; see if there are points in between.
else if (cmp == 0)
return boundA.inclusive != boundB.inclusive;
else
- return false; /* bounds overlap */
+ return false; /* bounds overlap */
}
/* adjacent to (but not overlapping)? (internal version) */
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid range bound flags"),
- errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
+ errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
switch (flags_str[0])
{
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid range bound flags"),
- errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
+ errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
}
switch (flags_str[1])
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("invalid range bound flags"),
- errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
+ errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
}
return flags;
else
{
TypeCacheEntry *typcache;
+
typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
*result = range_eq_internal(typcache, r1, r2);
if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
return false;
return (!range_overright_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeType(query)));
case RANGESTRAT_OVERLEFT:
if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
return false;
return (!range_after_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeType(query)));
case RANGESTRAT_OVERLAPS:
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_OVERRIGHT:
if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
return false;
return (!range_before_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeType(query)));
case RANGESTRAT_AFTER:
if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
return false;
return (!range_overleft_internal(typcache, key,
- DatumGetRangeType(query)));
+ DatumGetRangeType(query)));
case RANGESTRAT_ADJACENT:
if (RangeIsEmpty(key) || RangeIsEmpty(DatumGetRangeType(query)))
return false;
if (range_adjacent_internal(typcache, key,
- DatumGetRangeType(query)))
+ DatumGetRangeType(query)))
return true;
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINS:
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINED_BY:
/*
if (RangeIsOrContainsEmpty(key))
return true;
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINS_ELEM:
return range_contains_elem_internal(typcache, key, query);
case RANGESTRAT_EQ:
if (RangeIsEmpty(DatumGetRangeType(query)))
return RangeIsOrContainsEmpty(key);
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
default:
elog(ERROR, "unrecognized range strategy: %d", strategy);
- return false; /* keep compiler quiet */
+ return false; /* keep compiler quiet */
}
}
{
case RANGESTRAT_BEFORE:
return range_before_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_OVERLEFT:
return range_overleft_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_OVERLAPS:
return range_overlaps_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_OVERRIGHT:
return range_overright_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_AFTER:
return range_after_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_ADJACENT:
return range_adjacent_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINS:
return range_contains_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINED_BY:
return range_contained_by_internal(typcache, key,
- DatumGetRangeType(query));
+ DatumGetRangeType(query));
case RANGESTRAT_CONTAINS_ELEM:
return range_contains_elem_internal(typcache, key, query);
case RANGESTRAT_EQ:
return range_eq_internal(typcache, key, DatumGetRangeType(query));
default:
elog(ERROR, "unrecognized range strategy: %d", strategy);
- return false; /* keep compiler quiet */
+ return false; /* keep compiler quiet */
}
}
RangeBound *hist1, RangeBound *hist2);
static float8 get_len_position(double value, double hist1, double hist2);
static float8 get_distance(TypeCacheEntry *typcache, RangeBound *bound1,
- RangeBound *bound2);
+ RangeBound *bound2);
static int length_hist_bsearch(Datum *length_hist_values,
int length_hist_nvalues, double value, bool equal);
static double calc_length_hist_frac(Datum *length_hist_values,
- int length_hist_nvalues, double length1, double length2, bool equal);
+ int length_hist_nvalues, double length1, double length2, bool equal);
static double calc_hist_selectivity_contained(TypeCacheEntry *typcache,
RangeBound *lower, RangeBound *upper,
RangeBound *hist_lower, int hist_nvalues,
- Datum *length_hist_values, int length_hist_nvalues);
+ Datum *length_hist_values, int length_hist_nvalues);
static double calc_hist_selectivity_contains(TypeCacheEntry *typcache,
RangeBound *lower, RangeBound *upper,
RangeBound *hist_lower, int hist_nvalues,
- Datum *length_hist_values, int length_hist_nvalues);
+ Datum *length_hist_values, int length_hist_nvalues);
/*
* Returns a default selectivity estimate for given operator, when we don't
return 0.005;
case OID_RANGE_CONTAINS_ELEM_OP:
+
/*
* "range @> elem" is more or less identical to a scalar
* inequality "A >= b AND A <= c".
*
* If the operator is "range @> element", the constant should be of the
* element type of the range column. Convert it to a range that includes
- * only that single point, so that we don't need special handling for
- * that in what follows.
+ * only that single point, so that we don't need special handling for that
+ * in what follows.
*/
if (operator == OID_RANGE_CONTAINS_ELEM_OP)
{
if (((Const *) other)->consttype == typcache->rngelemtype->type_id)
{
- RangeBound lower, upper;
+ RangeBound lower,
+ upper;
+
lower.inclusive = true;
lower.val = ((Const *) other)->constvalue;
lower.infinite = false;
/*
* If we got a valid constant on one side of the operator, proceed to
- * estimate using statistics. Otherwise punt and return a default
- * constant estimate.
+ * estimate using statistics. Otherwise punt and return a default constant
+ * estimate.
*/
if (constrange)
selec = calc_rangesel(typcache, &vardata, constrange, operator);
{
double hist_selec;
double selec;
- float4 empty_frac, null_frac;
+ float4 empty_frac,
+ null_frac;
/*
* First look up the fraction of NULLs and empty ranges from pg_statistic.
/* Try to get fraction of empty ranges */
if (get_attstatsslot(vardata->statsTuple,
vardata->atttype, vardata->atttypmod,
- STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM, InvalidOid,
+ STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM, InvalidOid,
NULL,
NULL, NULL,
&numbers, &nnumbers))
{
if (nnumbers != 1)
- elog(ERROR, "invalid empty fraction statistic"); /* shouldn't happen */
+ elog(ERROR, "invalid empty fraction statistic"); /* shouldn't happen */
empty_frac = numbers[0];
}
else
{
/*
* No stats are available. Follow through the calculations below
- * anyway, assuming no NULLs and no empty ranges. This still allows
- * us to give a better-than-nothing estimate based on whether the
+ * anyway, assuming no NULLs and no empty ranges. This still allows us
+ * to give a better-than-nothing estimate based on whether the
* constant is an empty range or not.
*/
null_frac = 0.0;
case OID_RANGE_CONTAINED_OP:
case OID_RANGE_LESS_EQUAL_OP:
case OID_RANGE_GREATER_EQUAL_OP:
+
/*
* these return true when both args are empty, false if only
* one is empty
case OID_RANGE_CONTAINS_ELEM_OP:
default:
elog(ERROR, "unexpected operator %u", operator);
- selec = 0.0; /* keep compiler quiet */
+ selec = 0.0; /* keep compiler quiet */
break;
}
}
/* Extract the bounds of the constant value. */
range_deserialize(typcache, constval, &const_lower, &const_upper, &empty);
- Assert (!empty);
+ Assert(!empty);
/*
* Calculate selectivity comparing the lower or upper bound of the
switch (operator)
{
case OID_RANGE_LESS_OP:
+
/*
* The regular b-tree comparison operators (<, <=, >, >=) compare
* the lower bounds first, and the upper bounds for values with
case OID_RANGE_OVERLAP_OP:
case OID_RANGE_CONTAINS_ELEM_OP:
+
/*
* A && B <=> NOT (A << B OR A >> B).
*
- * Since A << B and A >> B are mutually exclusive events we can sum
- * their probabilities to find probability of (A << B OR A >> B).
+ * Since A << B and A >> B are mutually exclusive events we can
+ * sum their probabilities to find probability of (A << B OR A >>
+ * B).
*
* "range @> elem" is equivalent to "range && [elem,elem]". The
* caller already constructed the singular range from the element
nhist, false);
hist_selec +=
(1.0 - calc_hist_selectivity_scalar(typcache, &const_upper, hist_lower,
- nhist, true));
+ nhist, true));
hist_selec = 1.0 - hist_selec;
break;
case OID_RANGE_CONTAINS_OP:
hist_selec =
calc_hist_selectivity_contains(typcache, &const_lower,
- &const_upper, hist_lower, nhist,
- length_hist_values, length_nhist);
+ &const_upper, hist_lower, nhist,
+ length_hist_values, length_nhist);
break;
case OID_RANGE_CONTAINED_OP:
{
hist_selec =
1.0 - calc_hist_selectivity_scalar(typcache, &const_lower,
- hist_lower, nhist, false);
+ hist_lower, nhist, false);
}
else
{
hist_selec =
calc_hist_selectivity_contained(typcache, &const_lower,
- &const_upper, hist_lower, nhist,
- length_hist_values, length_nhist);
+ &const_upper, hist_lower, nhist,
+ length_hist_values, length_nhist);
}
break;
default:
elog(ERROR, "unknown range operator %u", operator);
- hist_selec = -1.0; /* keep compiler quiet */
+ hist_selec = -1.0; /* keep compiler quiet */
break;
}
calc_hist_selectivity_scalar(TypeCacheEntry *typcache, RangeBound *constbound,
RangeBound *hist, int hist_nvalues, bool equal)
{
- Selectivity selec;
+ Selectivity selec;
int index;
/*
*/
static int
rbound_bsearch(TypeCacheEntry *typcache, RangeBound *value, RangeBound *hist,
- int hist_length, bool equal)
+ int hist_length, bool equal)
{
int lower = -1,
upper = hist_length - 1,
while (lower < upper)
{
- double middleval;
+ double middleval;
middle = (lower + upper + 1) / 2;
hist2->val,
hist1->val));
if (bin_width <= 0.0)
- return 0.5; /* zero width bin */
+ return 0.5; /* zero width bin */
position = DatumGetFloat8(FunctionCall2Coll(
&typcache->rng_subdiff_finfo,
else if (is_infinite(hist1) && !is_infinite(hist2))
{
/*
- * Lower bin boundary is -infinite, upper is finite.
- * Return 1.0 to indicate the value is infinitely far from the lower
- * bound.
+ * Lower bin boundary is -infinite, upper is finite. Return 1.0 to
+ * indicate the value is infinitely far from the lower bound.
*/
return 1.0;
}
/*
* If both bin boundaries are infinite, they should be equal to each
* other, and the value should also be infinite and equal to both
- * bounds. (But don't Assert that, to avoid crashing unnecessarily
- * if the caller messes up)
+ * bounds. (But don't Assert that, to avoid crashing unnecessarily if
+ * the caller messes up)
*
* Assume the value to lie in the middle of the infinite bounds.
*/
static float8
get_distance(TypeCacheEntry *typcache, RangeBound *bound1, RangeBound *bound2)
{
- bool has_subdiff = OidIsValid(typcache->rng_subdiff_finfo.fn_oid);
+ bool has_subdiff = OidIsValid(typcache->rng_subdiff_finfo.fn_oid);
if (!bound1->infinite && !bound2->infinite)
{
double length1, double length2, bool equal)
{
double frac;
- double A, B, PA, PB;
+ double A,
+ B,
+ PA,
+ PB;
double pos;
int i;
double area;
Assert(length2 >= length1);
if (length2 < 0.0)
- return 0.0; /* shouldn't happen, but doesn't hurt to check */
+ return 0.0; /* shouldn't happen, but doesn't hurt to check */
/* All lengths in the table are <= infinite. */
if (is_infinite(length2) && equal)
* The average of a function between A and B can be calculated by the
* formula:
*
- * B
- * 1 /
- * ------- | P(x)dx
- * B - A /
- * A
+ * B
+ * 1 /
+ * ------- | P(x)dx
+ * B - A /
+ * A
*
* The geometrical interpretation of the integral is the area under the
* graph of P(x). P(x) is defined by the length histogram. We calculate
* the area in a piecewise fashion, iterating through the length histogram
* bins. Each bin is a trapezoid:
*
- * P(x2)
- * /|
- * / |
+ * P(x2)
+ * /|
+ * / |
* P(x1)/ |
- * | |
- * | |
- * ---+---+--
- * x1 x2
+ * | |
+ * | |
+ * ---+---+--
+ * x1 x2
*
* where x1 and x2 are the boundaries of the current histogram, and P(x1)
* and P(x1) are the cumulative fraction of tuples at the boundaries.
* boundary to calculate P(x1). Likewise for the last bin: we use linear
* interpolation to calculate P(x2). For the bins in between, x1 and x2
* lie on histogram bin boundaries, so P(x1) and P(x2) are simply:
- * P(x1) = (bin index) / (number of bins)
+ * P(x1) = (bin index) / (number of bins)
* P(x2) = (bin index + 1 / (number of bins)
*/
B = length1;
/*
- * In the degenerate case that length1 == length2, simply return P(length1).
- * This is not merely an optimization: if length1 == length2, we'd divide
- * by zero later on.
+ * In the degenerate case that length1 == length2, simply return
+ * P(length1). This is not merely an optimization: if length1 == length2,
+ * we'd divide by zero later on.
*/
if (length2 == length1)
return PB;
area = 0.0;
for (; i < length_hist_nvalues - 1; i++)
{
- double bin_upper = DatumGetFloat8(length_hist_values[i + 1]);
+ double bin_upper = DatumGetFloat8(length_hist_values[i + 1]);
/* check if we've reached the last bin */
if (!(bin_upper < length2 || (equal && bin_upper <= length2)))
break;
/* the upper bound of previous bin is the lower bound of this bin */
- A = B; PA = PB;
+ A = B;
+ PA = PB;
B = bin_upper;
PB = (double) i / (double) (length_hist_nvalues - 1);
/*
* Add the area of this trapezoid to the total. The point of the
- * if-check is to avoid NaN, in the corner case that PA == PB == 0, and
- * B - A == Inf. The area of a zero-height trapezoid (PA == PB == 0) is
- * zero, regardless of the width (B - A).
+ * if-check is to avoid NaN, in the corner case that PA == PB == 0,
+ * and B - A == Inf. The area of a zero-height trapezoid (PA == PB ==
+ * 0) is zero, regardless of the width (B - A).
*/
if (PA > 0 || PB > 0)
area += 0.5 * (PB + PA) * (B - A);
}
/* Last bin */
- A = B; PA = PB;
+ A = B;
+ PA = PB;
- B = length2; /* last bin ends at the query upper bound */
+ B = length2; /* last bin ends at the query upper bound */
if (i >= length_hist_nvalues - 1)
pos = 0.0;
else
static double
calc_hist_selectivity_contained(TypeCacheEntry *typcache,
RangeBound *lower, RangeBound *upper,
- RangeBound *hist_lower, int hist_nvalues,
- Datum *length_hist_values, int length_hist_nvalues)
+ RangeBound *hist_lower, int hist_nvalues,
+ Datum *length_hist_values, int length_hist_nvalues)
{
int i,
upper_index;
if (range_cmp_bounds(typcache, &hist_lower[i], lower) < 0)
{
dist = get_distance(typcache, lower, upper);
+
/*
- * Subtract from bin_width the portion of this bin that we want
- * to ignore.
+ * Subtract from bin_width the portion of this bin that we want to
+ * ignore.
*/
bin_width -= get_position(typcache, lower, &hist_lower[i],
&hist_lower[i + 1]);
prev_dist, dist, true);
/*
- * Add the fraction of tuples in this bin, with a suitable length,
- * to the total.
+ * Add the fraction of tuples in this bin, with a suitable length, to
+ * the total.
*/
sum_frac += length_hist_frac * bin_width / (double) (hist_nvalues - 1);
calc_hist_selectivity_contains(TypeCacheEntry *typcache,
RangeBound *lower, RangeBound *upper,
RangeBound *hist_lower, int hist_nvalues,
- Datum *length_hist_values, int length_hist_nvalues)
+ Datum *length_hist_values, int length_hist_nvalues)
{
int i,
lower_index;
*/
if (lower_index >= 0 && lower_index < hist_nvalues - 1)
lower_bin_width = get_position(typcache, lower, &hist_lower[lower_index],
- &hist_lower[lower_index + 1]);
+ &hist_lower[lower_index + 1]);
else
lower_bin_width = 0.0;
/*
* Loop through all the lower bound bins, smaller than the query lower
- * bound. In the loop, dist and prev_dist are the distance of the "current"
- * bin's lower and upper bounds from the constant upper bound. We begin
- * from query lower bound, and walk backwards, so the first bin's upper
- * bound is the query lower bound, and its distance to the query upper
- * bound is the length of the query range.
+ * bound. In the loop, dist and prev_dist are the distance of the
+ * "current" bin's lower and upper bounds from the constant upper bound.
+ * We begin from query lower bound, and walk backwards, so the first bin's
+ * upper bound is the query lower bound, and its distance to the query
+ * upper bound is the length of the query range.
*
* bin_width represents the width of the current bin. Normally it is 1.0,
* meaning a full width bin, except for the first bin, which is only
double length_hist_frac;
/*
- * dist -- distance from upper bound of query range to current
- * value of lower bound histogram or lower bound of query range (if
- * we've reach it).
+ * dist -- distance from upper bound of query range to current value
+ * of lower bound histogram or lower bound of query range (if we've
+ * reach it).
*/
dist = get_distance(typcache, &hist_lower[i], upper);
/*
* A node with no centroid divides ranges purely on whether they're empty
- * or not. All empty ranges go to child node 0, all non-empty ranges go
- * to node 1.
+ * or not. All empty ranges go to child node 0, all non-empty ranges go to
+ * node 1.
*/
if (!in->hasPrefix)
{
/*
* For adjacent search we need also previous centroid (if any) to improve
- * the precision of the consistent check. In this case needPrevious flag is
- * set and centroid is passed into reconstructedValues. This is not the
+ * the precision of the consistent check. In this case needPrevious flag
+ * is set and centroid is passed into reconstructedValues. This is not the
* intended purpose of reconstructedValues (because we already have the
* full value available at the leaf), but it's a convenient place to store
* state while traversing the tree.
break;
case RANGESTRAT_CONTAINS:
+
/*
- * All ranges contain an empty range. Only non-empty ranges
- * can contain a non-empty range.
+ * All ranges contain an empty range. Only non-empty
+ * ranges can contain a non-empty range.
*/
if (!empty)
which &= (1 << 2);
break;
case RANGESTRAT_CONTAINED_BY:
+
/*
- * Only an empty range is contained by an empty range. Both
- * empty and non-empty ranges can be contained by a
+ * Only an empty range is contained by an empty range.
+ * Both empty and non-empty ranges can be contained by a
* non-empty range.
*/
if (empty)
upper;
bool empty;
RangeType *range = NULL;
+
/* Restrictions on range bounds according to scan strategy */
RangeBound *minLower = NULL,
*maxLower = NULL,
*minUpper = NULL,
*maxUpper = NULL;
+
/* Are the restrictions on range bounds inclusive? */
bool inclusive = true;
bool strictEmpty = true;
/*
* Most strategies are handled by forming a bounding box from the
- * search key, defined by a minLower, maxLower, minUpper, maxUpper.
- * Some modify 'which' directly, to specify exactly which quadrants
- * need to be visited.
+ * search key, defined by a minLower, maxLower, minUpper,
+ * maxUpper. Some modify 'which' directly, to specify exactly
+ * which quadrants need to be visited.
*
* For most strategies, nothing matches an empty search key, and
* an empty range never matches a non-empty key. If a strategy
switch (strategy)
{
case RANGESTRAT_BEFORE:
+
/*
* Range A is before range B if upper bound of A is lower
* than lower bound of B.
break;
case RANGESTRAT_OVERLEFT:
+
/*
* Range A is overleft to range B if upper bound of A is
* less or equal to upper bound of B.
break;
case RANGESTRAT_OVERLAPS:
+
/*
* Non-empty ranges overlap, if lower bound of each range
* is lower or equal to upper bound of the other range.
break;
case RANGESTRAT_OVERRIGHT:
+
/*
* Range A is overright to range B if lower bound of A is
* greater or equal to lower bound of B.
break;
case RANGESTRAT_AFTER:
+
/*
* Range A is after range B if lower bound of A is greater
* than upper bound of B.
case RANGESTRAT_ADJACENT:
if (empty)
- break; /* Skip to strictEmpty check. */
+ break; /* Skip to strictEmpty check. */
/*
* which1 is bitmask for possibility to be adjacent with
* lower bound of argument. which2 is bitmask for
- * possibility to be adjacent with upper bound of argument.
+ * possibility to be adjacent with upper bound of
+ * argument.
*/
which1 = which2 = (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4);
/*
* For a range's lower bound to be adjacent to the
* argument's upper bound, it will be found along the
- * line adjacent to (and just right of)
- * X=upper. Therefore, if the argument's upper bound is
- * less than (and not adjacent to) the centroid's upper
+ * line adjacent to (and just right of) X=upper.
+ * Therefore, if the argument's upper bound is less
+ * than (and not adjacent to) the centroid's upper
* bound, the line falls in quadrants 3 and 4; if
* greater or equal to, the line falls in quadrants 1
* and 2.
break;
case RANGESTRAT_CONTAINS:
+
/*
* Non-empty range A contains non-empty range B if lower
* bound of A is lower or equal to lower bound of range B
break;
case RANGESTRAT_EQ:
+
/*
* Equal range can be only in the same quadrant where
* argument would be placed to.
if (minLower)
{
/*
- * If the centroid's lower bound is less than or equal to
- * the minimum lower bound, anything in the 3rd and 4th
- * quadrants will have an even smaller lower bound, and thus
- * can't match.
+ * If the centroid's lower bound is less than or equal to the
+ * minimum lower bound, anything in the 3rd and 4th quadrants
+ * will have an even smaller lower bound, and thus can't
+ * match.
*/
if (range_cmp_bounds(typcache, ¢roidLower, minLower) <= 0)
which &= (1 << 1) | (1 << 2) | (1 << 5);
* If the centroid's lower bound is greater than the maximum
* lower bound, anything in the 1st and 2nd quadrants will
* also have a greater than or equal lower bound, and thus
- * can't match. If the centroid's lower bound is equal to
- * the maximum lower bound, we can still exclude the 1st and
- * 2nd quadrants if we're looking for a value strictly greater
+ * can't match. If the centroid's lower bound is equal to the
+ * maximum lower bound, we can still exclude the 1st and 2nd
+ * quadrants if we're looking for a value strictly greater
* than the maximum.
*/
int cmp;
if (minUpper)
{
/*
- * If the centroid's upper bound is less than or equal to
- * the minimum upper bound, anything in the 2nd and 3rd
- * quadrants will have an even smaller upper bound, and thus
- * can't match.
+ * If the centroid's upper bound is less than or equal to the
+ * minimum upper bound, anything in the 2nd and 3rd quadrants
+ * will have an even smaller upper bound, and thus can't
+ * match.
*/
if (range_cmp_bounds(typcache, ¢roidUpper, minUpper) <= 0)
which &= (1 << 1) | (1 << 4) | (1 << 5);
* If the centroid's upper bound is greater than the maximum
* upper bound, anything in the 1st and 4th quadrants will
* also have a greater than or equal upper bound, and thus
- * can't match. If the centroid's upper bound is equal to
- * the maximum upper bound, we can still exclude the 1st and
- * 4th quadrants if we're looking for a value strictly greater
+ * can't match. If the centroid's upper bound is equal to the
+ * maximum upper bound, we can still exclude the 1st and 4th
+ * quadrants if we're looking for a value strictly greater
* than the maximum.
*/
int cmp;
break;
case RANGESTRAT_ADJACENT:
res = range_adjacent_internal(typcache, leafRange,
- DatumGetRangeType(keyDatum));
+ DatumGetRangeType(keyDatum));
break;
case RANGESTRAT_CONTAINS:
res = range_contains_internal(typcache, leafRange,
#include "utils/builtins.h"
#include "utils/rangetypes.h"
-static int float8_qsort_cmp(const void *a1, const void *a2);
-static int range_bound_qsort_cmp(const void *a1, const void *a2, void *arg);
+static int float8_qsort_cmp(const void *a1, const void *a2);
+static int range_bound_qsort_cmp(const void *a1, const void *a2, void *arg);
static void compute_range_stats(VacAttrStats *stats,
AnalyzeAttrFetchFunc fetchfunc, int samplerows, double totalrows);
typcache = range_get_typcache(fcinfo, stats->attrtypid);
if (attr->attstattarget < 0)
- attr->attstattarget = default_statistics_target;
+ attr->attstattarget = default_statistics_target;
stats->compute_stats = compute_range_stats;
stats->extra_data = typcache;
static int
range_bound_qsort_cmp(const void *a1, const void *a2, void *arg)
{
- RangeBound *b1 = (RangeBound *)a1;
- RangeBound *b2 = (RangeBound *)a2;
- TypeCacheEntry *typcache = (TypeCacheEntry *)arg;
+ RangeBound *b1 = (RangeBound *) a1;
+ RangeBound *b2 = (RangeBound *) a2;
+ TypeCacheEntry *typcache = (TypeCacheEntry *) arg;
return range_cmp_bounds(typcache, b1, b2);
}
int num_bins = stats->attr->attstattarget;
int num_hist;
float8 *lengths;
- RangeBound *lowers, *uppers;
+ RangeBound *lowers,
+ *uppers;
double total_width = 0;
/* Allocate memory to hold range bounds and lengths of the sample ranges. */
* and lower bound values.
*/
length = DatumGetFloat8(FunctionCall2Coll(
- &typcache->rng_subdiff_finfo,
- typcache->rng_collation,
- upper.val, lower.val));
+ &typcache->rng_subdiff_finfo,
+ typcache->rng_collation,
+ upper.val, lower.val));
}
else
{
/*
* The object of this loop is to construct ranges from first and
* last entries in lowers[] and uppers[] along with evenly-spaced
- * values in between. So the i'th value is a range of
- * lowers[(i * (nvals - 1)) / (num_hist - 1)] and
- * uppers[(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 add
- * (nvals - 1) / (num_hist - 1) to pos at each step, tracking the
- * integral and fractional parts of the sum separately.
+ * values in between. So the i'th value is a range of lowers[(i *
+ * (nvals - 1)) / (num_hist - 1)] and uppers[(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 add (nvals - 1) / (num_hist - 1) to pos
+ * at each step, tracking the integral and fractional parts of the
+ * sum separately.
*/
delta = (non_empty_cnt - 1) / (num_hist - 1);
deltafrac = (non_empty_cnt - 1) % (num_hist - 1);
for (i = 0; i < num_hist; i++)
{
bound_hist_values[i] = PointerGetDatum(range_serialize(
- typcache, &lowers[pos], &uppers[pos], false));
+ typcache, &lowers[pos], &uppers[pos], false));
pos += delta;
posfrac += deltafrac;
if (posfrac >= (num_hist - 1))
* The object of this loop is to copy the first and last lengths[]
* entries along with evenly-spaced values in between. So the i'th
* value is lengths[(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 add
- * (nvals - 1) / (num_hist - 1) to pos at each step, tracking the
- * integral and fractional parts of the sum separately.
+ * computing that subscript directly risks integer overflow when
+ * the stats target is more than a couple thousand. Instead we
+ * add (nvals - 1) / (num_hist - 1) to pos at each step, tracking
+ * the integral and fractional parts of the sum separately.
*/
delta = (non_empty_cnt - 1) / (num_hist - 1);
deltafrac = (non_empty_cnt - 1) % (num_hist - 1);
/* 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.
* Routine to produce regprocedure names; see format_procedure above.
*
* force_qualify says whether to schema-qualify; if true, the name is always
- * qualified regardless of search_path visibility. Otherwise the name is only
+ * qualified regardless of search_path visibility. Otherwise the name is only
* qualified if the function is not in path.
*/
static char *
/*
* Would this oper be found (given the right args) by regoperatorin?
- * If not, or if caller explicitely requests it, we need to qualify it.
+ * If not, or if caller explicitely requests it, we need to qualify
+ * it.
*/
if (force_qualify || !OperatorIsVisible(operator_oid))
{
#define RI_PLAN_RESTRICT_UPD_CHECKREF 6
#define RI_PLAN_SETNULL_DEL_DOUPDATE 7
#define RI_PLAN_SETNULL_UPD_DOUPDATE 8
-#define RI_PLAN_SETDEFAULT_DEL_DOUPDATE 9
-#define RI_PLAN_SETDEFAULT_UPD_DOUPDATE 10
+#define RI_PLAN_SETDEFAULT_DEL_DOUPDATE 9
+#define RI_PLAN_SETDEFAULT_UPD_DOUPDATE 10
#define MAX_QUOTED_NAME_LEN (NAMEDATALEN*2+3)
#define MAX_QUOTED_REL_NAME_LEN (MAX_QUOTED_NAME_LEN*2)
typedef struct RI_QueryKey
{
Oid constr_id; /* OID of pg_constraint entry */
- int32 constr_queryno; /* query type ID, see RI_PLAN_XXX above */
+ int32 constr_queryno; /* query type ID, see RI_PLAN_XXX above */
} RI_QueryKey;
/* ----------
* The query string built is
* SELECT 1 FROM ONLY
x WHERE pkatt1 = $1 [AND ...]- * FOR KEY SHARE OF x
+ * FOR KEY SHARE OF x
* The type id's for the $ parameters are those of the
* corresponding FK attributes.
* ----------
/* ----------
* The query string built is
* SELECT 1 FROM ONLY
x WHERE pkatt1 = $1 [AND ...]- * FOR KEY SHARE OF x
+ * FOR KEY SHARE OF x
* The type id's for the $ parameters are those of the
* PK attributes themselves.
* ----------
}
/*
- * If another PK row now exists providing the old key values,
- * we should not do anything. However, this check should only be
+ * If another PK row now exists providing the old key values, we
+ * should not do anything. However, this check should only be
* made in the NO ACTION case; in RESTRICT cases we don't wish to
* allow another row to be substituted.
*/
/* ----------
* The query string built is
* SELECT 1 FROM ONLY x WHERE $1 = fkatt1 [AND ...]
- * FOR KEY SHARE OF x
+ * FOR KEY SHARE OF x
* The type id's for the $ parameters are those of the
* corresponding PK attributes.
* ----------
}
/*
- * If another PK row now exists providing the old key values,
- * we should not do anything. However, this check should only be
+ * If another PK row now exists providing the old key values, we
+ * should not do anything. However, this check should only be
* made in the NO ACTION case; in RESTRICT cases we don't wish to
* allow another row to be substituted.
*/
* believe no check is necessary. So we need to do another lookup
* now and in case a reference still exists, abort the operation.
* That is already implemented in the NO ACTION trigger, so just
- * run it. (This recheck is only needed in the SET DEFAULT case,
+ * run it. (This recheck is only needed in the SET DEFAULT case,
* since CASCADE would remove such rows, while SET NULL is certain
* to result in rows that satisfy the FK constraint.)
*/
* believe no check is necessary. So we need to do another lookup
* now and in case a reference still exists, abort the operation.
* That is already implemented in the NO ACTION trigger, so just
- * run it. (This recheck is only needed in the SET DEFAULT case,
+ * run it. (This recheck is only needed in the SET DEFAULT case,
* since CASCADE must change the FK key values, while SET NULL is
* certain to result in rows that satisfy the FK constraint.)
*/
switch (riinfo->confmatchtype)
{
case FKCONSTR_MATCH_SIMPLE:
+
/*
* If any new key value is NULL, the row must satisfy the
* constraint, so no check is needed.
return true;
case FKCONSTR_MATCH_FULL:
+
/*
* If all new key values are NULL, the row must satisfy the
* constraint, so no check is needed. On the other hand, if only
/*
* The columns to look at in the result tuple are 1..N, not whatever
- * they are in the fk_rel. Hack up riinfo so that the subroutines
+ * they are in the fk_rel. Hack up riinfo so that the subroutines
* called here will behave properly.
*
* In addition to this, we have to pass the correct tupdesc to
int32 constr_queryno)
{
/*
- * We assume struct RI_QueryKey contains no padding bytes, else we'd
- * need to use memset to clear them.
+ * We assume struct RI_QueryKey contains no padding bytes, else we'd need
+ * to use memset to clear them.
*/
key->constr_id = riinfo->constraint_id;
key->constr_queryno = constr_queryno;
elog(ERROR, "cache lookup failed for constraint %u", constraintOid);
conForm = (Form_pg_constraint) GETSTRUCT(tup);
- if (conForm->contype != CONSTRAINT_FOREIGN) /* should not happen */
+ if (conForm->contype != CONSTRAINT_FOREIGN) /* should not happen */
elog(ERROR, "constraint %u is not a foreign key constraint",
constraintOid);
/* And extract data */
Assert(riinfo->constraint_id == constraintOid);
riinfo->oidHashValue = GetSysCacheHashValue1(CONSTROID,
- ObjectIdGetDatum(constraintOid));
+ ObjectIdGetDatum(constraintOid));
memcpy(&riinfo->conname, &conForm->conname, sizeof(NameData));
riinfo->pk_relid = conForm->confrelid;
riinfo->fk_relid = conForm->conrelid;
/*
* The values for the query are taken from the table on which the trigger
- * is called - it is normally the other one with respect to query_rel.
- * An exception is ri_Check_Pk_Match(), which uses the PK table for both
- * (and sets queryno to RI_PLAN_CHECK_LOOKUPPK_FROM_PK). We might
- * eventually need some less klugy way to determine this.
+ * is called - it is normally the other one with respect to query_rel. An
+ * exception is ri_Check_Pk_Match(), which uses the PK table for both (and
+ * sets queryno to RI_PLAN_CHECK_LOOKUPPK_FROM_PK). We might eventually
+ * need some less klugy way to determine this.
*/
if (qkey->constr_queryno == RI_PLAN_CHECK_LOOKUPPK)
{
prettyFlags = PRETTYFLAG_INDENT;
PG_RETURN_TEXT_P(string_to_text(pg_get_constraintdef_worker(constraintId,
false,
- prettyFlags)));
+ prettyFlags)));
}
Datum
prettyFlags = pretty ? PRETTYFLAG_PAREN | PRETTYFLAG_INDENT : PRETTYFLAG_INDENT;
PG_RETURN_TEXT_P(string_to_text(pg_get_constraintdef_worker(constraintId,
false,
- prettyFlags)));
+ prettyFlags)));
}
/* Internal version that returns a palloc'd C string; no pretty-printing */
{
case LCS_FORKEYSHARE:
appendContextKeyword(context, " FOR KEY SHARE",
- -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
+ -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
break;
case LCS_FORSHARE:
appendContextKeyword(context, " FOR SHARE",
- -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
+ -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
break;
case LCS_FORNOKEYUPDATE:
appendContextKeyword(context, " FOR NO KEY UPDATE",
- -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
+ -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
break;
case LCS_FORUPDATE:
appendContextKeyword(context, " FOR UPDATE",
- -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
+ -PRETTYINDENT_STD, PRETTYINDENT_STD, 0);
break;
}
/*
* If it's an unnamed join, look at the expansion of the alias variable.
* If it's a simple reference to one of the input vars, then recursively
- * print the name of that var instead. When it's not a simple reference,
- * we have to just print the unqualified join column name. (This can only
+ * print the name of that var instead. When it's not a simple reference,
+ * we have to just print the unqualified join column name. (This can only
* happen with columns that were merged by USING or NATURAL clauses in a
* FULL JOIN; we took pains previously to make the unqualified column name
* unique in such cases.)
* means a FuncExpr and not some other way of calling the function), then
* was_variadic must specify whether VARIADIC appeared in the original call,
* and *use_variadic_p will be set to indicate whether to print VARIADIC in
- * the output. For non-FuncExpr cases, was_variadic should be FALSE and
+ * the output. For non-FuncExpr cases, was_variadic should be FALSE and
* use_variadic_p can be NULL.
*
* The result includes all necessary quoting and schema-prefixing.
VariableStatData *vardata,
Oid vartype, Oid opfamily, Const *prefixcon);
static Selectivity like_selectivity(const char *patt, int pattlen,
- bool case_insensitive);
+ bool case_insensitive);
static Selectivity regex_selectivity(const char *patt, int pattlen,
- bool case_insensitive,
- int fixed_prefix_len);
+ bool case_insensitive,
+ int fixed_prefix_len);
static Datum string_to_datum(const char *str, Oid datatype);
static Const *string_to_const(const char *str, Oid datatype);
static Const *string_to_bytea_const(const char *str, size_t str_len);
Pattern_Prefix_Status pstatus;
Const *patt;
Const *prefix = NULL;
- Selectivity rest_selec = 0;
+ Selectivity rest_selec = 0;
double result;
/*
/*
* Pull out any fixed prefix implied by the pattern, and estimate the
- * fractional selectivity of the remainder of the pattern. Unlike many of
+ * fractional selectivity of the remainder of the pattern. Unlike many of
* the other functions in this file, we use the pattern operator's actual
* collation for this step. This is not because we expect the collation
* to make a big difference in the selectivity estimate (it seldom would),
s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
clause->inputcollid,
PointerGetDatum(root),
- ObjectIdGetDatum(operator),
+ ObjectIdGetDatum(operator),
PointerGetDatum(args),
Int16GetDatum(jointype),
- PointerGetDatum(sjinfo)));
+ PointerGetDatum(sjinfo)));
else
s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
clause->inputcollid,
PointerGetDatum(root),
- ObjectIdGetDatum(operator),
+ ObjectIdGetDatum(operator),
PointerGetDatum(args),
- Int32GetDatum(varRelid)));
+ Int32GetDatum(varRelid)));
if (useOr)
{
s2 = DatumGetFloat8(FunctionCall5Coll(&oprselproc,
clause->inputcollid,
PointerGetDatum(root),
- ObjectIdGetDatum(operator),
+ ObjectIdGetDatum(operator),
PointerGetDatum(args),
Int16GetDatum(jointype),
- PointerGetDatum(sjinfo)));
+ PointerGetDatum(sjinfo)));
else
s2 = DatumGetFloat8(FunctionCall4Coll(&oprselproc,
clause->inputcollid,
PointerGetDatum(root),
- ObjectIdGetDatum(operator),
+ ObjectIdGetDatum(operator),
PointerGetDatum(args),
- Int32GetDatum(varRelid)));
+ Int32GetDatum(varRelid)));
if (useOr)
{
if (rest_selec != NULL)
{
- char *patt = TextDatumGetCString(patt_const->constvalue);
+ char *patt = TextDatumGetCString(patt_const->constvalue);
*rest_selec = regex_selectivity(patt, strlen(patt),
case_insensitive,
}
else
{
- char *patt = TextDatumGetCString(patt_const->constvalue);
+ char *patt = TextDatumGetCString(patt_const->constvalue);
*rest_selec = regex_selectivity(patt, strlen(patt),
case_insensitive,
* genericcostestimate is a general-purpose estimator that can be used for
* most index types. In some cases we use genericcostestimate as the base
* code and then incorporate additional index-type-specific knowledge in
- * the type-specific calling function. To avoid code duplication, we make
+ * the type-specific calling function. To avoid code duplication, we make
* genericcostestimate return a number of intermediate values as well as
* its preliminary estimates of the output cost values. The GenericCosts
* struct includes all these values.
{
/* These are the values the cost estimator must return to the planner */
Cost indexStartupCost; /* index-related startup cost */
- Cost indexTotalCost; /* total index-related scan cost */
- Selectivity indexSelectivity; /* selectivity of index */
+ Cost indexTotalCost; /* total index-related scan cost */
+ Selectivity indexSelectivity; /* selectivity of index */
double indexCorrelation; /* order correlation of index */
/* Intermediate values we obtain along the way */
- double numIndexPages; /* number of leaf pages visited */
- double numIndexTuples; /* number of leaf tuples visited */
+ double numIndexPages; /* number of leaf pages visited */
+ double numIndexTuples; /* number of leaf tuples visited */
double spc_random_page_cost; /* relevant random_page_cost value */
- double num_sa_scans; /* # indexscans from ScalarArrayOps */
+ double num_sa_scans; /* # indexscans from ScalarArrayOps */
} GenericCosts;
static void
List *indexOrderBys = path->indexorderbys;
Cost indexStartupCost;
Cost indexTotalCost;
- Selectivity indexSelectivity;
+ Selectivity indexSelectivity;
double indexCorrelation;
double numIndexPages;
double numIndexTuples;
*
* In practice access to upper index levels is often nearly free because
* those tend to stay in cache under load; moreover, the cost involved is
- * highly dependent on index type. We therefore ignore such costs here
+ * highly dependent on index type. We therefore ignore such costs here
* and leave it to the caller to add a suitable charge if needed.
*/
if (index->pages > 1 && index->tuples > 1)
* because the hash AM makes sure that's always one page.
*
* Likewise, we could consider charging some CPU for each index tuple in
- * the bucket, if we knew how many there were. But the per-tuple cost is
+ * the bucket, if we knew how many there were. But the per-tuple cost is
* just a hash value comparison, not a general datatype-dependent
* comparison, so any such charge ought to be quite a bit less than
* cpu_operator_cost; which makes it probably not worth worrying about.
* Although this computation isn't really expensive enough to require
* caching, we might as well use index->tree_height to cache it.
*/
- if (index->tree_height < 0) /* unknown? */
+ if (index->tree_height < 0) /* unknown? */
{
if (index->pages > 1) /* avoid computing log(0) */
index->tree_height = (int) (log(index->pages) / log(100.0));
}
/*
- * Add a CPU-cost component to represent the costs of initial descent.
- * We just use log(N) here not log2(N) since the branching factor isn't
- * necessarily two anyway. As for btree, charge once per SA scan.
+ * Add a CPU-cost component to represent the costs of initial descent. We
+ * just use log(N) here not log2(N) since the branching factor isn't
+ * necessarily two anyway. As for btree, charge once per SA scan.
*/
if (index->tuples > 1) /* avoid computing log(0) */
{
* Although this computation isn't really expensive enough to require
* caching, we might as well use index->tree_height to cache it.
*/
- if (index->tree_height < 0) /* unknown? */
+ if (index->tree_height < 0) /* unknown? */
{
if (index->pages > 1) /* avoid computing log(0) */
index->tree_height = (int) (log(index->pages) / log(100.0));
}
/*
- * Add a CPU-cost component to represent the costs of initial descent.
- * We just use log(N) here not log2(N) since the branching factor isn't
- * necessarily two anyway. As for btree, charge once per SA scan.
+ * Add a CPU-cost component to represent the costs of initial descent. We
+ * just use log(N) here not log2(N) since the branching factor isn't
+ * necessarily two anyway. As for btree, charge once per SA scan.
*/
if (index->tuples > 1) /* avoid computing log(0) */
{
collation = DEFAULT_COLLATION_OID;
OidFunctionCall7Coll(extractProcOid,
- collation,
- query,
- PointerGetDatum(&nentries),
- UInt16GetDatum(strategy_op),
- PointerGetDatum(&partial_matches),
- PointerGetDatum(&extra_data),
- PointerGetDatum(&nullFlags),
- PointerGetDatum(&searchMode));
+ collation,
+ query,
+ PointerGetDatum(&nentries),
+ UInt16GetDatum(strategy_op),
+ PointerGetDatum(&partial_matches),
+ PointerGetDatum(&extra_data),
+ PointerGetDatum(&nullFlags),
+ PointerGetDatum(&searchMode));
if (nentries <= 0 && searchMode == GIN_SEARCH_MODE_DEFAULT)
{
int64
GetCurrentIntegerTimestamp(void)
{
- int64 result;
+ int64 result;
struct timeval tp;
gettimeofday(&tp, NULL);
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("interval units \"%s\" not supported "
- "because months usually have fractional weeks",
+ "because months usually have fractional weeks",
lowunits)));
else
ereport(ERROR,
if (zone->month != 0 || zone->day != 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("interval time zone \"%s\" must not include months or days",
- DatumGetCString(DirectFunctionCall1(interval_out,
+ errmsg("interval time zone \"%s\" must not include months or days",
+ DatumGetCString(DirectFunctionCall1(interval_out,
PointerGetDatum(zone))))));
#ifdef HAVE_INT64_TIMESTAMP
if (zone->month != 0 || zone->day != 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("interval time zone \"%s\" must not include months or days",
- DatumGetCString(DirectFunctionCall1(interval_out,
+ errmsg("interval time zone \"%s\" must not include months or days",
+ DatumGetCString(DirectFunctionCall1(interval_out,
PointerGetDatum(zone))))));
#ifdef HAVE_INT64_TIMESTAMP
static QTNode *
findeq(QTNode *node, QTNode *ex, QTNode *subs, bool *isfind)
{
-
if ((node->sign & ex->sign) != ex->sign ||
node->valnode->type != ex->valnode->type)
return node;
static QTNode *
dropvoidsubtree(QTNode *root)
{
-
if (!root)
return NULL;
/*
* Get the appropriate typOutput function, reusing previous one if
- * same type as previous argument. That's particularly useful in the
+ * same type as previous argument. That's particularly useful in the
* variadic-array case, but often saves work even for ordinary calls.
*/
if (typid != prev_type)
/* should not get here, because of previous check */
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("unrecognized conversion type specifier \"%c\"",
- *cp)));
+ errmsg("unrecognized conversion type specifier \"%c\"",
+ *cp)));
break;
}
}
/*
* xmlPgEntityLoader --- entity loader callback function
*
- * Silently prevent any external entity URL from being loaded. We don't want
+ * Silently prevent any external entity URL from being loaded. We don't want
* to throw an error, so instead make the entity appear to expand to an empty
* string.
*
case XML_FROM_NONE:
case XML_FROM_MEMORY:
case XML_FROM_IO:
+
/*
* Suppress warnings about undeclared entities. We need to do
* this to avoid problems due to not loading DTD definitions.
char *str;
/*
- * Flatten domains; the special-case treatments below should apply
- * to, eg, domains over boolean not just boolean.
+ * Flatten domains; the special-case treatments below should apply to,
+ * eg, domains over boolean not just boolean.
*/
type = getBaseType(type);
static void
CatCachePrintStats(int code, Datum arg)
{
- slist_iter iter;
+ slist_iter iter;
long cc_searches = 0;
long cc_hits = 0;
long cc_neg_hits = 0;
void
CatalogCacheIdInvalidate(int cacheId, uint32 hashValue)
{
- slist_iter cache_iter;
+ slist_iter cache_iter;
CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
#ifdef USE_ASSERT_CHECKING
if (assert_enabled)
{
- slist_iter cache_iter;
+ slist_iter cache_iter;
slist_foreach(cache_iter, &CacheHdr->ch_caches)
{
CatCache *ccp = slist_container(CatCache, cc_next, cache_iter.cur);
- dlist_iter iter;
+ dlist_iter iter;
int i;
/* Check CatCLists */
void
ResetCatalogCaches(void)
{
- slist_iter iter;
+ slist_iter iter;
CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
void
CatalogCacheFlushCatalog(Oid catId)
{
- slist_iter iter;
+ slist_iter iter;
CACHE2_elog(DEBUG2, "CatalogCacheFlushCatalog called for %u", catId);
{
ScanKeyData cur_skey[CATCACHE_MAXKEYS];
uint32 lHashValue;
- dlist_iter iter;
+ dlist_iter iter;
CatCList *cl;
CatCTup *ct;
List *volatile ctlist;
HeapTuple newtuple,
void (*function) (int, uint32, Oid))
{
- slist_iter iter;
+ slist_iter iter;
Oid reloid;
CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
typedef struct
{
- EventTriggerEvent event;
+ EventTriggerEvent event;
List *triggerlist;
} EventTriggerCacheEntry;
static void BuildEventTriggerCache(void);
static void InvalidateEventCacheCallback(Datum arg,
int cacheid, uint32 hashvalue);
-static int DecodeTextArrayToCString(Datum array, char ***cstringp);
+static int DecodeTextArrayToCString(Datum array, char ***cstringp);
/*
* Search the event cache by trigger event.
static void
BuildEventTriggerCache(void)
{
- HASHCTL ctl;
- HTAB *cache;
- MemoryContext oldcontext;
- Relation rel;
- Relation irel;
- SysScanDesc scan;
+ HASHCTL ctl;
+ HTAB *cache;
+ MemoryContext oldcontext;
+ Relation rel;
+ Relation irel;
+ SysScanDesc scan;
if (EventTriggerCacheContext != NULL)
{
else
{
/*
- * This is our first time attempting to build the cache, so we need
- * to set up the memory context and register a syscache callback to
+ * This is our first time attempting to build the cache, so we need to
+ * set up the memory context and register a syscache callback to
* capture future invalidation events.
*/
if (CacheMemoryContext == NULL)
HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
/*
- * Prepare to scan pg_event_trigger in name order. We use an MVCC
- * snapshot to avoid getting inconsistent results if the table is
- * being concurrently updated.
+ * Prepare to scan pg_event_trigger in name order. We use an MVCC
+ * snapshot to avoid getting inconsistent results if the table is being
+ * concurrently updated.
*/
rel = relation_open(EventTriggerRelationId, AccessShareLock);
irel = index_open(EventTriggerNameIndexId, AccessShareLock);
scan = systable_beginscan_ordered(rel, irel, GetLatestSnapshot(), 0, NULL);
/*
- * Build a cache item for each pg_event_trigger tuple, and append each
- * one to the appropriate cache entry.
+ * Build a cache item for each pg_event_trigger tuple, and append each one
+ * to the appropriate cache entry.
*/
for (;;)
{
- HeapTuple tup;
- Form_pg_event_trigger form;
+ HeapTuple tup;
+ Form_pg_event_trigger form;
char *evtevent;
- EventTriggerEvent event;
+ EventTriggerEvent event;
EventTriggerCacheItem *item;
Datum evttags;
bool evttags_isnull;
InvalidateEventCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
{
/*
- * If the cache isn't valid, then there might be a rebuild in progress,
- * so we can't immediately blow it away. But it's advantageous to do
- * this when possible, so as to immediately free memory.
+ * If the cache isn't valid, then there might be a rebuild in progress, so
+ * we can't immediately blow it away. But it's advantageous to do this
+ * when possible, so as to immediately free memory.
*/
if (EventTriggerCacheState == ETCS_VALID)
{
* in that context.
*
* A one-shot plan cannot be saved or copied, since we make no effort to
- * preserve the raw parse tree unmodified. There is also no support for
+ * preserve the raw parse tree unmodified. There is also no support for
* invalidation, so plan use must be completed in the current transaction,
* and DDL that might invalidate the querytree_list must be avoided as well.
*
&plansource->invalItems);
/*
- * Also save the current search_path in the query_context. (This
+ * Also save the current search_path in the query_context. (This
* should not generate much extra cruft either, since almost certainly
- * the path is already valid.) Again, we don't really need this for
+ * the path is already valid.) Again, we don't really need this for
* one-shot plans; and we *must* skip this for transaction control
* commands, because this could result in catalog accesses.
*/
/*
* For one-shot plans, we do not support revalidation checking; it's
* assumed the query is parsed, planned, and executed in one transaction,
- * so that no lock re-acquisition is necessary. Also, there is never
- * any need to revalidate plans for transaction control commands (and
- * we mustn't risk any catalog accesses when handling those).
+ * so that no lock re-acquisition is necessary. Also, there is never any
+ * need to revalidate plans for transaction control commands (and we
+ * mustn't risk any catalog accesses when handling those).
*/
if (plansource->is_oneshot || IsTransactionStmtPlan(plansource))
{
&plansource->invalItems);
/*
- * Also save the current search_path in the query_context. (This should
+ * Also save the current search_path in the query_context. (This should
* not generate much extra cruft either, since almost certainly the path
* is already valid.)
*/
* For simplicity, eoxact_list[] entries are not deleted till end of
* top-level transaction, even though we could remove them at
* subtransaction end in some cases, or remove relations from the list if
- * they are cleared for other reasons. Therefore we should expect the
+ * they are cleared for other reasons. Therefore we should expect the
* case that list entries are not found in the hashtable; if not, there's
* nothing to do for them.
*/
static void
AtEOXact_cleanup(Relation relation, bool isCommit)
{
- /*
- * The relcache entry's ref count should be back to its normal
- * not-in-a-transaction state: 0 unless it's nailed in cache.
- *
- * In bootstrap mode, this is NOT true, so don't check it --- the
- * bootstrap code expects relations to stay open across start/commit
- * transaction calls. (That seems bogus, but it's not worth fixing.)
- *
- * Note: ideally this check would be applied to every relcache entry,
- * not just those that have eoxact work to do. But it's not worth
- * forcing a scan of the whole relcache just for this. (Moreover,
- * doing so would mean that assert-enabled testing never tests the
- * hash_search code path above, which seems a bad idea.)
- */
+ /*
+ * The relcache entry's ref count should be back to its normal
+ * not-in-a-transaction state: 0 unless it's nailed in cache.
+ *
+ * In bootstrap mode, this is NOT true, so don't check it --- the
+ * bootstrap code expects relations to stay open across start/commit
+ * transaction calls. (That seems bogus, but it's not worth fixing.)
+ *
+ * Note: ideally this check would be applied to every relcache entry, not
+ * just those that have eoxact work to do. But it's not worth forcing a
+ * scan of the whole relcache just for this. (Moreover, doing so would
+ * mean that assert-enabled testing never tests the hash_search code path
+ * above, which seems a bad idea.)
+ */
#ifdef USE_ASSERT_CHECKING
- if (!IsBootstrapProcessingMode())
- {
- int expected_refcnt;
+ if (!IsBootstrapProcessingMode())
+ {
+ int expected_refcnt;
- expected_refcnt = relation->rd_isnailed ? 1 : 0;
- Assert(relation->rd_refcnt == expected_refcnt);
- }
+ expected_refcnt = relation->rd_isnailed ? 1 : 0;
+ Assert(relation->rd_refcnt == expected_refcnt);
+ }
#endif
- /*
- * Is it a relation created in the current transaction?
- *
- * During commit, reset the flag to zero, since we are now out of the
- * creating transaction. During abort, simply delete the relcache
- * entry --- it isn't interesting any longer. (NOTE: if we have
- * forgotten the new-ness of a new relation due to a forced cache
- * flush, the entry will get deleted anyway by shared-cache-inval
- * processing of the aborted pg_class insertion.)
- */
- if (relation->rd_createSubid != InvalidSubTransactionId)
+ /*
+ * Is it a relation created in the current transaction?
+ *
+ * During commit, reset the flag to zero, since we are now out of the
+ * creating transaction. During abort, simply delete the relcache entry
+ * --- it isn't interesting any longer. (NOTE: if we have forgotten the
+ * new-ness of a new relation due to a forced cache flush, the entry will
+ * get deleted anyway by shared-cache-inval processing of the aborted
+ * pg_class insertion.)
+ */
+ if (relation->rd_createSubid != InvalidSubTransactionId)
+ {
+ if (isCommit)
+ relation->rd_createSubid = InvalidSubTransactionId;
+ else
{
- if (isCommit)
- relation->rd_createSubid = InvalidSubTransactionId;
- else
- {
- RelationClearRelation(relation, false);
- return;
- }
+ RelationClearRelation(relation, false);
+ return;
}
+ }
- /*
- * Likewise, reset the hint about the relfilenode being new.
- */
- relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
+ /*
+ * Likewise, reset the hint about the relfilenode being new.
+ */
+ relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
- /*
- * Flush any temporary index list.
- */
- if (relation->rd_indexvalid == 2)
- {
- list_free(relation->rd_indexlist);
- relation->rd_indexlist = NIL;
- relation->rd_oidindex = InvalidOid;
- relation->rd_indexvalid = 0;
- }
+ /*
+ * Flush any temporary index list.
+ */
+ if (relation->rd_indexvalid == 2)
+ {
+ list_free(relation->rd_indexlist);
+ relation->rd_indexlist = NIL;
+ relation->rd_oidindex = InvalidOid;
+ relation->rd_indexvalid = 0;
+ }
}
/*
AtEOSubXact_cleanup(Relation relation, bool isCommit,
SubTransactionId mySubid, SubTransactionId parentSubid)
{
- /*
- * Is it a relation created in the current subtransaction?
- *
- * During subcommit, mark it as belonging to the parent, instead.
- * During subabort, simply delete the relcache entry.
- */
- if (relation->rd_createSubid == mySubid)
+ /*
+ * Is it a relation created in the current subtransaction?
+ *
+ * During subcommit, mark it as belonging to the parent, instead. During
+ * subabort, simply delete the relcache entry.
+ */
+ if (relation->rd_createSubid == mySubid)
+ {
+ if (isCommit)
+ relation->rd_createSubid = parentSubid;
+ else
{
- if (isCommit)
- relation->rd_createSubid = parentSubid;
- else
- {
- RelationClearRelation(relation, false);
- return;
- }
+ RelationClearRelation(relation, false);
+ return;
}
+ }
- /*
- * Likewise, update or drop any new-relfilenode-in-subtransaction
- * hint.
- */
- if (relation->rd_newRelfilenodeSubid == mySubid)
- {
- if (isCommit)
- relation->rd_newRelfilenodeSubid = parentSubid;
- else
- relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
- }
+ /*
+ * Likewise, update or drop any new-relfilenode-in-subtransaction hint.
+ */
+ if (relation->rd_newRelfilenodeSubid == mySubid)
+ {
+ if (isCommit)
+ relation->rd_newRelfilenodeSubid = parentSubid;
+ else
+ relation->rd_newRelfilenodeSubid = InvalidSubTransactionId;
+ }
- /*
- * Flush any temporary index list.
- */
- if (relation->rd_indexvalid == 2)
- {
- list_free(relation->rd_indexlist);
- relation->rd_indexlist = NIL;
- relation->rd_oidindex = InvalidOid;
- relation->rd_indexvalid = 0;
- }
+ /*
+ * Flush any temporary index list.
+ */
+ if (relation->rd_indexvalid == 2)
+ {
+ list_free(relation->rd_indexlist);
+ relation->rd_indexlist = NIL;
+ relation->rd_oidindex = InvalidOid;
+ relation->rd_indexvalid = 0;
+ }
}
RelationCacheInsert(rel);
/*
- * Flag relation as needing eoxact cleanup (to clear rd_createSubid).
- * We can't do this before storing relid in it.
+ * Flag relation as needing eoxact cleanup (to clear rd_createSubid). We
+ * can't do this before storing relid in it.
*/
EOXactListAdd(rel);
/* Can this index be referenced by a foreign key? */
isKey = indexInfo->ii_Unique &&
- indexInfo->ii_Expressions == NIL &&
- indexInfo->ii_Predicate == NIL;
+ indexInfo->ii_Expressions == NIL &&
+ indexInfo->ii_Predicate == NIL;
/* Collect simple attribute references */
for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
attrnum - FirstLowInvalidHeapAttributeNumber);
if (isKey)
uindexattrs = bms_add_member(uindexattrs,
- attrnum - FirstLowInvalidHeapAttributeNumber);
+ attrnum - FirstLowInvalidHeapAttributeNumber);
}
}
get_namespace_name(RelationGetNamespace(rel)));
err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
- return 0; /* return value does not matter */
+ return 0; /* return value does not matter */
}
/*
* given directly rather than extracted from the relation's catalog data.
*
* Don't use this directly unless errtablecol() is inconvenient for some
- * reason. This might possibly be needed during intermediate states in ALTER
+ * reason. This might possibly be needed during intermediate states in ALTER
* TABLE, for instance.
*/
int
errtable(rel);
err_generic_string(PG_DIAG_COLUMN_NAME, colname);
- return 0; /* return value does not matter */
+ return 0; /* return value does not matter */
}
/*
errtable(rel);
err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);
- return 0; /* return value does not matter */
+ return 0; /* return value does not matter */
}
},
256
},
- {EventTriggerRelationId, /* EVENTTRIGGERNAME */
+ {EventTriggerRelationId, /* EVENTTRIGGERNAME */
EventTriggerNameIndexId,
1,
{
},
8
},
- {EventTriggerRelationId, /* EVENTTRIGGEROID */
+ {EventTriggerRelationId, /* EVENTTRIGGEROID */
EventTriggerOidIndexId,
1,
{
StringInfoData buf; \
/* Internationalize the error format string */ \
if (!in_error_recursion_trouble()) \
- fmt = dngettext((domain), fmt_singular, fmt_plural, n); \
+ fmt = dngettext((domain), fmt_singular, fmt_plural, n); \
else \
fmt = (n == 1 ? fmt_singular : fmt_plural); \
/* Expand %m in format string */ \
break;
}
- return 0; /* return value does not matter */
+ return 0; /* return value does not matter */
}
/*
hashp->tabname);
/*
- * Lookup the existing element using its saved hash value. We need to
- * do this to be able to unlink it from its hash chain, but as a side
- * benefit we can verify the validity of the passed existingEntry pointer.
+ * Lookup the existing element using its saved hash value. We need to do
+ * this to be able to unlink it from its hash chain, but as a side benefit
+ * we can verify the validity of the passed existingEntry pointer.
*/
bucket = calc_bucket(hctl, existingElement->hashvalue);
oldPrevPtr = prevBucketPtr;
/*
- * Now perform the equivalent of a HASH_ENTER operation to locate the
- * hash chain we want to put the entry into.
+ * Now perform the equivalent of a HASH_ENTER operation to locate the hash
+ * chain we want to put the entry into.
*/
newhashvalue = hashp->hash(newKeyPtr, hashp->keysize);
/*
* If old and new hash values belong to the same bucket, we need not
* change any chain links, and indeed should not since this simplistic
- * update will corrupt the list if currBucket is the last element. (We
+ * update will corrupt the list if currBucket is the last element. (We
* cannot fall out earlier, however, since we need to scan the bucket to
* check for duplicate keys.)
*/
InitializeSessionUserIdStandalone(void)
{
/*
- * This function should only be called in single-user mode, in
- * autovacuum workers, and in background workers.
+ * This function should only be called in single-user mode, in autovacuum
+ * workers, and in background workers.
*/
AssertState(!IsUnderPostmaster || IsAutoVacuumWorkerProcess() || IsBackgroundWorker);
/*
* Successfully created the file, now fill it. See comment in miscadmin.h
- * about the contents. Note that we write the same first five lines into
+ * about the contents. Note that we write the same first five lines into
* both datadir and socket lockfiles; although more stuff may get added to
* the datadir lockfile later.
*/
}
/*
- * Arrange to unlink the lock file(s) at proc_exit. If this is the
- * first one, set up the on_proc_exit function to do it; then add this
- * lock file to the list of files to unlink.
+ * Arrange to unlink the lock file(s) at proc_exit. If this is the first
+ * one, set up the on_proc_exit function to do it; then add this lock file
+ * to the list of files to unlink.
*/
if (lock_files == NIL)
on_proc_exit(UnlinkLockFiles, 0);
srcbuffer[len] = '\0';
/*
- * Advance over lines we are not supposed to rewrite, then copy them
- * to destbuffer.
+ * Advance over lines we are not supposed to rewrite, then copy them to
+ * destbuffer.
*/
srcptr = srcbuffer;
for (lineno = 1; lineno < target_line; lineno++)
{
/*
* It is ok to continue if we fail to load the IDENT file, although it
- * means that you cannot log in using any of the authentication methods
- * that need a user name mapping. load_ident() already logged the
- * details of error to the log.
+ * means that you cannot log in using any of the authentication
+ * methods that need a user name mapping. load_ident() already logged
+ * the details of error to the log.
*/
}
#endif
int
pg_wchar2mb(const pg_wchar *from, char *to)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *)to, pg_wchar_strlen(from));
+ return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *) to, pg_wchar_strlen(from));
}
/* convert a wchar string to a multibyte with a limited length */
int
pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
{
- return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *)to, len);
+ return (*pg_wchar_table[DatabaseEncoding->encoding].wchar2mb_with_len) (from, (unsigned char *) to, len);
}
/* same, with any encoding */
pg_encoding_wchar2mb_with_len(int encoding,
const pg_wchar *from, char *to, int len)
{
- return (*pg_wchar_table[encoding].wchar2mb_with_len) (from, (unsigned char *)to, len);
+ return (*pg_wchar_table[encoding].wchar2mb_with_len) (from, (unsigned char *) to, len);
}
/* returns the byte length of a multibyte character */
*to |= *from++;
len -= 2;
}
- else /* must be ASCII */
+ else /* must be ASCII */
{
*to = *from++;
len--;
while (len > 0 && *from)
{
- int char_len;
+ int char_len;
unicode_to_utf8(*from, to);
char_len = pg_utf_mblen(to);
*-------------------------------------------------------------------
*/
pg_wchar_tbl pg_wchar_table[] = {
- {pg_ascii2wchar_with_len, pg_wchar2single_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII */
+ {pg_ascii2wchar_with_len, pg_wchar2single_with_len, pg_ascii_mblen, pg_ascii_dsplen, pg_ascii_verifier, 1}, /* PG_SQL_ASCII */
{pg_eucjp2wchar_with_len, pg_wchar2euc_with_len, pg_eucjp_mblen, pg_eucjp_dsplen, pg_eucjp_verifier, 3}, /* PG_EUC_JP */
{pg_euccn2wchar_with_len, pg_wchar2euc_with_len, pg_euccn_mblen, pg_euccn_dsplen, pg_euccn_verifier, 2}, /* PG_EUC_CN */
{pg_euckr2wchar_with_len, pg_wchar2euc_with_len, pg_euckr_mblen, pg_euckr_dsplen, pg_euckr_verifier, 3}, /* PG_EUC_KR */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1255 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_WIN1257 */
{pg_latin12wchar_with_len, pg_wchar2single_with_len, pg_latin1_mblen, pg_latin1_dsplen, pg_latin1_verifier, 1}, /* PG_KOI8U */
- {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2}, /* PG_SJIS */
- {0, 0, pg_big5_mblen, pg_big5_dsplen, pg_big5_verifier, 2}, /* PG_BIG5 */
- {0, 0, pg_gbk_mblen, pg_gbk_dsplen, pg_gbk_verifier, 2}, /* PG_GBK */
- {0, 0, pg_uhc_mblen, pg_uhc_dsplen, pg_uhc_verifier, 2}, /* PG_UHC */
- {0, 0, pg_gb18030_mblen, pg_gb18030_dsplen, pg_gb18030_verifier, 4}, /* PG_GB18030 */
- {0, 0, pg_johab_mblen, pg_johab_dsplen, pg_johab_verifier, 3}, /* PG_JOHAB */
- {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2} /* PG_SHIFT_JIS_2004 */
+ {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2}, /* PG_SJIS */
+ {0, 0, pg_big5_mblen, pg_big5_dsplen, pg_big5_verifier, 2}, /* PG_BIG5 */
+ {0, 0, pg_gbk_mblen, pg_gbk_dsplen, pg_gbk_verifier, 2}, /* PG_GBK */
+ {0, 0, pg_uhc_mblen, pg_uhc_dsplen, pg_uhc_verifier, 2}, /* PG_UHC */
+ {0, 0, pg_gb18030_mblen, pg_gb18030_dsplen, pg_gb18030_verifier, 4}, /* PG_GB18030 */
+ {0, 0, pg_johab_mblen, pg_johab_dsplen, pg_johab_verifier, 3}, /* PG_JOHAB */
+ {0, 0, pg_sjis_mblen, pg_sjis_dsplen, pg_sjis_verifier, 2} /* PG_SHIFT_JIS_2004 */
};
/* returns the byte length of a word for mule internal code */
gettext_noop("Detection of a checksum failure normally causes PostgreSQL to "
"report an error, aborting the current transaction. Setting "
"ignore_checksum_failure to true causes the system to ignore the failure "
- "(but still report a warning), and continue processing. This "
- "behavior could cause crashes or other serious problems. Only "
+ "(but still report a warning), and continue processing. This "
+ "behavior could cause crashes or other serious problems. Only "
"has an effect if checksums are enabled."),
GUC_NOT_IN_SAMPLE
},
int maxbuffers; /* currently allocated array size */
/* We can remember up to MAX_RESOWNER_LOCKS references to local locks. */
- int nlocks; /* number of owned locks */
- LOCALLOCK *locks[MAX_RESOWNER_LOCKS]; /* list of owned locks */
+ int nlocks; /* number of owned locks */
+ LOCALLOCK *locks[MAX_RESOWNER_LOCKS]; /* list of owned locks */
/* We have built-in support for remembering catcache references */
int ncatrefs; /* number of owned catcache pins */
* the entry.
*/
void
-ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK * locallock)
+ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK *locallock)
{
if (owner->nlocks > MAX_RESOWNER_LOCKS)
- return; /* we have already overflowed */
+ return; /* we have already overflowed */
if (owner->nlocks < MAX_RESOWNER_LOCKS)
owner->locks[owner->nlocks] = locallock;
int i;
if (owner->nlocks > MAX_RESOWNER_LOCKS)
- return; /* we have overflowed */
+ return; /* we have overflowed */
Assert(owner->nlocks > 0);
for (i = owner->nlocks - 1; i >= 0; i--)
* strategy and instead increase as much as we safely can.
*
* To stay within allowedMem, we can't increase memtupsize by more
- * than availMem / sizeof(void *) elements. In practice, we want
- * to increase it by considerably less, because we need to leave some
+ * than availMem / sizeof(void *) elements. In practice, we want to
+ * increase it by considerably less, because we need to leave some
* space for the tuples to which the new array slots will refer. We
* assume the new tuples will be about the same size as the tuples
* we've already seen, and thus we can extrapolate from the space
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return true;
- if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
return true;
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
xmax = HeapTupleGetUpdateXid(tuple);
if (!TransactionIdIsValid(xmax))
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
return true;
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return true;
- if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
return true;
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
xmax = HeapTupleGetUpdateXid(tuple);
if (!TransactionIdIsValid(xmax))
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
return true;
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return HeapTupleMayBeUpdated;
- if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
return HeapTupleMayBeUpdated;
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
xmax = HeapTupleGetUpdateXid(tuple);
if (!TransactionIdIsValid(xmax))
else
{
if (HeapTupleHeaderGetCmax(tuple) >= curcid)
- return HeapTupleSelfUpdated; /* updated after scan started */
+ return HeapTupleSelfUpdated; /* updated after scan
+ * started */
else
- return HeapTupleInvisible; /* updated before scan started */
+ return HeapTupleInvisible; /* updated before scan
+ * started */
}
}
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
{
/*
- * If it's only locked but neither EXCL_LOCK nor KEYSHR_LOCK
- * is set, it cannot possibly be running. Otherwise need to
- * check.
+ * If it's only locked but neither EXCL_LOCK nor KEYSHR_LOCK is
+ * set, it cannot possibly be running. Otherwise need to check.
*/
if ((tuple->t_infomask & (HEAP_XMAX_EXCL_LOCK |
HEAP_XMAX_KEYSHR_LOCK)) &&
if (TransactionIdIsCurrentTransactionId(xmax))
{
if (HeapTupleHeaderGetCmax(tuple) >= curcid)
- return HeapTupleSelfUpdated; /* updated after scan started */
+ return HeapTupleSelfUpdated; /* updated after scan started */
else
- return HeapTupleInvisible; /* updated before scan started */
+ return HeapTupleInvisible; /* updated before scan started */
}
if (MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple)))
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return true;
- if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
return true;
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
xmax = HeapTupleGetUpdateXid(tuple);
if (!TransactionIdIsValid(xmax))
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask))
return true;
if (tuple->t_infomask & HEAP_XMAX_INVALID) /* xid invalid */
return true;
- if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
+ if (HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask)) /* not deleter */
return true;
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
xmax = HeapTupleGetUpdateXid(tuple);
if (!TransactionIdIsValid(xmax))
else if (HeapTupleHeaderGetCmax(tuple) >= snapshot->curcid)
return true; /* updated after scan started */
else
- return false; /* updated before scan started */
+ return false; /* updated before scan started */
}
if (!TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmax(tuple)))
if (tuple->t_infomask & HEAP_XMAX_IS_MULTI)
{
- TransactionId xmax;
+ TransactionId xmax;
/* already checked above */
Assert(!HEAP_XMAX_IS_LOCKED_ONLY(tuple->t_infomask));
}
/*
- * We don't really care whether xmax did commit, abort or crash.
- * We know that xmax did lock the tuple, but it did not and will
- * never actually update it.
+ * We don't really care whether xmax did commit, abort or crash. We
+ * know that xmax did lock the tuple, but it did not and will never
+ * actually update it.
*/
return HEAPTUPLE_LIVE;
bool
HeapTupleHeaderIsOnlyLocked(HeapTupleHeader tuple)
{
- TransactionId xmax;
+ TransactionId xmax;
/* if there's no valid Xmax, then there's obviously no update either */
if (tuple->t_infomask & HEAP_XMAX_INVALID)
return true;
/*
- * if HEAP_XMAX_LOCK_ONLY is not set and not a multi, then this
- * must necessarily have been updated
+ * if HEAP_XMAX_LOCK_ONLY is not set and not a multi, then this must
+ * necessarily have been updated
*/
if (!(tuple->t_infomask & HEAP_XMAX_IS_MULTI))
return false;
#endif
static char **readfile(const char *path);
static void writefile(char *path, char **lines);
-static void walkdir(char *path, void (*action)(char *fname, bool isdir));
+static void walkdir(char *path, void (*action) (char *fname, bool isdir));
static void pre_sync_fname(char *fname, bool isdir);
static void fsync_fname(char *fname, bool isdir);
static FILE *popen_check(const char *command, const char *mode);
static bool check_locale_encoding(const char *locale, int encoding);
static void setlocales(void);
static void usage(const char *progname);
-void get_restricted_token(void);
-void setup_pgdata(void);
-void setup_bin_paths(const char *argv0);
-void setup_data_file_paths(void);
-void setup_locale_encoding(void);
-void setup_signals(void);
-void setup_text_search(void);
-void create_data_directory(void);
-void create_xlog_symlink(void);
-void warn_on_mount_point(int error);
-void initialize_data_directory(void);
+void get_restricted_token(void);
+void setup_pgdata(void);
+void setup_bin_paths(const char *argv0);
+void setup_data_file_paths(void);
+void setup_locale_encoding(void);
+void setup_signals(void);
+void setup_text_search(void);
+void create_data_directory(void);
+void create_xlog_symlink(void);
+void warn_on_mount_point(int error);
+void initialize_data_directory(void);
#ifdef WIN32
static char *
escape_quotes(const char *src)
{
- char *result = escape_single_quotes_ascii(src);
+ char *result = escape_single_quotes_ascii(src);
+
if (!result)
{
fprintf(stderr, _("%s: out of memory\n"), progname);
}
#ifdef WIN32
+
/*
* This fix is in mingw cvs (runtime/mingwex/dirent.c rev 1.4), but not in
* released version
/*
* It's important to fsync the destination directory itself as individual
* file fsyncs don't guarantee that the directory entry for the file is
- * synced. Recent versions of ext4 have made the window much wider but
+ * synced. Recent versions of ext4 have made the window much wider but
* it's been an issue for ext3 and other filesystems in the past.
*/
(*action) (path, true);
{
#if defined(HAVE_SYNC_FILE_RANGE) || \
(defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED))
- int fd;
+ int fd;
fd = open(fname, O_RDONLY | PG_BINARY);
}
/*
- * Prefer sync_file_range, else use posix_fadvise. We ignore any error
+ * Prefer sync_file_range, else use posix_fadvise. We ignore any error
* here since this operation is only a hint anyway.
*/
#if defined(HAVE_SYNC_FILE_RANGE)
* underscore (usual case) or a hyphen (Windows "locale name"; see
* comments at IsoLocaleName()).
*
- * XXX Should ' ' be a stop character? This would select "norwegian" for
+ * XXX Should ' ' be a stop character? This would select "norwegian" for
* the Windows locale "Norwegian (Nynorsk)_Norway.1252". If we do so, we
* should also accept the "nn" and "nb" Unix locales.
*
get_restricted_token(void)
{
#ifdef WIN32
+
/*
* Before we execute another program, make sure that we are running with a
* restricted token. If not, re-execute ourselves with one.
void
setup_pgdata(void)
{
- char *pgdata_get_env, *pgdata_set_env;
+ char *pgdata_get_env,
+ *pgdata_set_env;
if (strlen(pg_data) == 0)
{
void
setup_bin_paths(const char *argv0)
{
- int ret;
+ int ret;
if ((ret = find_other_exec(argv0, "postgres", PG_BACKEND_VERSIONSTR,
backend_exec)) < 0)
void
create_data_directory(void)
{
- int ret;
+ int ret;
switch ((ret = pg_check_dir(pg_data)))
{
warn_on_mount_point(ret);
else
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();
void
initialize_data_directory(void)
{
- int i;
+ int i;
setup_signals();
umask(S_IRWXG | S_IRWXO);
-
+
create_data_directory();
create_xlog_symlink();
perform_fsync();
return 0;
}
-
+
if (pwprompt && pwfilename)
{
fprintf(stderr, _("%s: password prompt and password file cannot be specified together\n"), progname);
setup_pgdata();
setup_bin_paths(argv[0]);
-
+
effective_user = get_id();
if (strlen(username) == 0)
username = effective_user;
printf(_("Data page checksums are enabled.\n"));
else
printf(_("Data page checksums are disabled.\n"));
-
+
printf("\n");
initialize_data_directory();
-
+
if (do_sync)
perform_fsync();
else
VERBOSE_FILENAME_LENGTH + 5, "");
else
{
- bool truncate = (strlen(filename) > VERBOSE_FILENAME_LENGTH);
+ bool truncate = (strlen(filename) > VERBOSE_FILENAME_LENGTH);
fprintf(stderr,
ngettext("%*s/%s kB (%d%%), %d/%d tablespace (%s%-*.*s)",
(int) strlen(totalsize_str),
totaldone_str, totalsize_str, percent,
tablespacenum, tablespacecount,
- /* Prefix with "..." if we do leading truncation */
+ /* Prefix with "..." if we do leading truncation */
truncate ? "..." : "",
- truncate ? VERBOSE_FILENAME_LENGTH - 3 : VERBOSE_FILENAME_LENGTH,
- truncate ? VERBOSE_FILENAME_LENGTH - 3 : VERBOSE_FILENAME_LENGTH,
- /* Truncate filename at beginning if it's too long */
+ truncate ? VERBOSE_FILENAME_LENGTH - 3 : VERBOSE_FILENAME_LENGTH,
+ truncate ? VERBOSE_FILENAME_LENGTH - 3 : VERBOSE_FILENAME_LENGTH,
+ /* Truncate filename at beginning if it's too long */
truncate ? filename + strlen(filename) - VERBOSE_FILENAME_LENGTH + 3 : filename);
}
}
return pg_strdup("''");
if (!need_quotes && !need_escaping)
- return pg_strdup(src); /* no quoting or escaping needed */
+ return pg_strdup(src); /* no quoting or escaping needed */
/*
* Allocate a buffer large enough for the worst case that all the source
exit(1);
/*
- * Check server version. BASE_BACKUP command was introduced in 9.1, so
- * we can't work with servers older than 9.1.
+ * Check server version. BASE_BACKUP command was introduced in 9.1, so we
+ * can't work with servers older than 9.1.
*/
minServerMajor = 901;
maxServerMajor = PG_VERSION_NUM / 100;
if (serverMajor < minServerMajor || serverMajor > maxServerMajor)
{
const char *serverver = PQparameterStatus(conn, "server_version");
+
fprintf(stderr, _("%s: incompatible server version %s\n"),
progname, serverver ? serverver : "'unknown'");
disconnect_and_exit(1);
}
strcpy(xlogstart, PQgetvalue(res, 0, 0));
+
/*
* 9.3 and later sends the TLI of the starting point. With older servers,
- * assume it's the same as the latest timeline reported by IDENTIFY_SYSTEM.
+ * assume it's the same as the latest timeline reported by
+ * IDENTIFY_SYSTEM.
*/
if (PQnfields(res) >= 2)
starttli = atoi(PQgetvalue(res, 0, 1));
else
{
fprintf(stderr,
- /* translator: check source for value for %d */
+ /* translator: check source for value for %d */
_("%s: disconnected; waiting %d seconds to try again\n"),
progname, RECONNECT_SLEEP_TIME);
pg_usleep(RECONNECT_SLEEP_TIME * 1000000);
/* fd and filename for currently open WAL file */
static int walfile = -1;
-static char current_walfile_name[MAXPGPATH] = "";
+static char current_walfile_name[MAXPGPATH] = "";
static PGresult *HandleCopyStream(PGconn *conn, XLogRecPtr startpos,
uint32 timeline, char *basedir,
- stream_stop_callback stream_stop, int standby_message_timeout,
+ stream_stop_callback stream_stop, int standby_message_timeout,
char *partial_suffix, XLogRecPtr *stoppos);
static bool ReadEndOfStreamingResult(PGresult *res, XLogRecPtr *startpos,
static int64
localGetCurrentTimestamp(void)
{
- int64 result;
+ int64 result;
struct timeval tp;
gettimeofday(&tp, NULL);
localTimestampDifference(int64 start_time, int64 stop_time,
long *secs, int *microsecs)
{
- int64 diff = stop_time - start_time;
+ int64 diff = stop_time - start_time;
if (diff <= 0)
{
int64 stop_time,
int msec)
{
- int64 diff = stop_time - start_time;
+ int64 diff = stop_time - start_time;
return (diff >= msec * INT64CONST(1000));
}
/*
* Write into a temp file name.
*/
- snprintf(tmppath, MAXPGPATH, "%s.tmp", path);
+ snprintf(tmppath, MAXPGPATH, "%s.tmp", path);
unlink(tmppath);
sendFeedback(PGconn *conn, XLogRecPtr blockpos, int64 now, bool replyRequested)
{
char replybuf[1 + 8 + 8 + 8 + 8 + 1];
- int len = 0;
+ int len = 0;
replybuf[len] = 'r';
len += 1;
- sendint64(blockpos, &replybuf[len]); /* write */
+ sendint64(blockpos, &replybuf[len]); /* write */
len += 8;
- sendint64(InvalidXLogRecPtr, &replybuf[len]); /* flush */
+ sendint64(InvalidXLogRecPtr, &replybuf[len]); /* flush */
len += 8;
- sendint64(InvalidXLogRecPtr, &replybuf[len]); /* apply */
+ sendint64(InvalidXLogRecPtr, &replybuf[len]); /* apply */
len += 8;
- sendint64(now, &replybuf[len]); /* sendTime */
+ sendint64(now, &replybuf[len]); /* sendTime */
len += 8;
- replybuf[len] = replyRequested ? 1 : 0; /* replyRequested */
+ replybuf[len] = replyRequested ? 1 : 0; /* replyRequested */
len += 1;
if (PQputCopyData(conn, replybuf, len) <= 0 || PQflush(conn))
if (serverMajor < minServerMajor || serverMajor > maxServerMajor)
{
const char *serverver = PQparameterStatus(conn, "server_version");
+
fprintf(stderr, _("%s: incompatible server version %s; streaming is only supported with server version %s\n"),
progname,
serverver ? serverver : "'unknown'",
if (timeline > atoi(PQgetvalue(res, 0, 1)))
{
fprintf(stderr,
- _("%s: starting timeline %u is not present in the server\n"),
+ _("%s: starting timeline %u is not present in the server\n"),
progname, timeline);
PQclear(res);
return false;
while (1)
{
/*
- * Fetch the timeline history file for this timeline, if we don't
- * have it already.
+ * Fetch the timeline history file for this timeline, if we don't have
+ * it already.
*/
if (!existsTimeLineHistoryFile(basedir, timeline))
{
{
/* FIXME: we might send it ok, but get an error */
fprintf(stderr, _("%s: could not send replication command \"%s\": %s"),
- progname, "TIMELINE_HISTORY", PQresultErrorMessage(res));
+ progname, "TIMELINE_HISTORY", PQresultErrorMessage(res));
PQclear(res);
return false;
}
{
fprintf(stderr,
_("%s: unexpected response to TIMELINE_HISTORY command: got %d rows and %d fields, expected %d rows and %d fields\n"),
- progname, PQntuples(res), PQnfields(res), 1, 2);
+ progname, PQntuples(res), PQnfields(res), 1, 2);
}
/* Write the history file to disk */
}
/*
- * Before we start streaming from the requested location, check
- * if the callback tells us to stop here.
+ * Before we start streaming from the requested location, check if the
+ * callback tells us to stop here.
*/
if (stream_stop(startpos, timeline, false))
return true;
/*
* Streaming finished.
*
- * There are two possible reasons for that: a controlled shutdown,
- * or we reached the end of the current timeline. In case of
+ * There are two possible reasons for that: a controlled shutdown, or
+ * we reached the end of the current timeline. In case of
* end-of-timeline, the server sends a result set after Copy has
* finished, containing information about the next timeline. Read
* that, and restart streaming from the next timeline. In case of
_("%s: server stopped streaming timeline %u at %X/%X, but reported next timeline %u to begin at %X/%X\n"),
progname,
timeline, (uint32) (stoppos >> 32), (uint32) stoppos,
- newtimeline, (uint32) (startpos >> 32), (uint32) startpos);
+ newtimeline, (uint32) (startpos >> 32), (uint32) startpos);
goto error;
}
if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr,
- _("%s: unexpected termination of replication stream: %s"),
+ _("%s: unexpected termination of replication stream: %s"),
progname, PQresultErrorMessage(res));
goto error;
}
PQclear(res);
/*
- * Loop back to start streaming from the new timeline.
- * Always start streaming at the beginning of a segment.
+ * Loop back to start streaming from the new timeline. Always
+ * start streaming at the beginning of a segment.
*/
timeline = newtimeline;
startpos = startpos - (startpos % XLOG_SEG_SIZE);
/*----------
* The result set consists of one row and two columns, e.g:
*
- * next_tli | next_tli_startpos
+ * next_tli | next_tli_startpos
* ----------+-------------------
- * 4 | 0/9949AE0
+ * 4 | 0/9949AE0
*
* next_tli is the timeline ID of the next timeline after the one that
* just finished streaming. next_tli_startpos is the XLOG position where
&startpos_xrecoff) != 2)
{
fprintf(stderr,
- _("%s: could not parse next timeline's starting point \"%s\"\n"),
+ _("%s: could not parse next timeline's starting point \"%s\"\n"),
progname, PQgetvalue(res, 0, 1));
return false;
}
if (r == 0)
{
/*
- * No data available. Wait for some to appear, but not longer
- * than the specified timeout, so that we can ping the server.
+ * No data available. Wait for some to appear, but not longer than
+ * the specified timeout, so that we can ping the server.
*/
fd_set input_mask;
struct timeval timeout;
{
/*
* Got a timeout or signal. Continue the loop and either
- * deliver a status packet to the server or just go back
- * into blocking.
+ * deliver a status packet to the server or just go back into
+ * blocking.
*/
continue;
}
/* Check the message type. */
if (copybuf[0] == 'k')
{
- int pos;
- bool replyRequested;
+ int pos;
+ bool replyRequested;
/*
* Parse the keepalive message, enclosed in the CopyData message.
* We just check if the server requested a reply, and ignore the
* rest.
*/
- pos = 1; /* skip msgtype 'k' */
- pos += 8; /* skip walEnd */
- pos += 8; /* skip sendTime */
+ pos = 1; /* skip msgtype 'k' */
+ pos += 8; /* skip walEnd */
+ pos += 8; /* skip sendTime */
if (r < pos + 1)
{
* CopyData message. We only need the WAL location field
* (dataStart), the rest of the header is ignored.
*/
- hdr_len = 1; /* msgtype 'w' */
- hdr_len += 8; /* dataStart */
- hdr_len += 8; /* walEnd */
- hdr_len += 8; /* sendTime */
+ hdr_len = 1; /* msgtype 'w' */
+ hdr_len += 8; /* dataStart */
+ hdr_len += 8; /* walEnd */
+ hdr_len += 8; /* sendTime */
if (r < hdr_len + 1)
{
fprintf(stderr, _("%s: streaming header too small: %d\n"),
xlogoff = blockpos % XLOG_SEG_SIZE;
/*
- * Verify that the initial location in the stream matches where
- * we think we are.
+ * Verify that the initial location in the stream matches where we
+ * think we are.
*/
if (walfile == -1)
{
if (lseek(walfile, 0, SEEK_CUR) != xlogoff)
{
fprintf(stderr,
- _("%s: got WAL data offset %08x, expected %08x\n"),
- progname, xlogoff, (int) lseek(walfile, 0, SEEK_CUR));
+ _("%s: got WAL data offset %08x, expected %08x\n"),
+ progname, xlogoff, (int) lseek(walfile, 0, SEEK_CUR));
goto error;
}
}
goto error;
}
still_sending = false;
- break; /* ignore the rest of this XLogData packet */
+ break; /* ignore the rest of this XLogData packet */
}
}
}
/*
* Merge the connection info inputs given in form of connection string,
- * options and default values (dbname=replication, replication=true,
- * etc.)
+ * options and default values (dbname=replication, replication=true, etc.)
*/
i = 0;
if (connection_string)
int i;
int n;
int len;
- struct stat statbuf;
+ struct stat statbuf;
/*
* Slurp the file into memory.
{
if (buffer[i] == '\n')
{
- int slen = &buffer[i] - linebegin + 1;
- char *linebuf = pg_malloc(slen + 1);
+ int slen = &buffer[i] - linebegin + 1;
+ char *linebuf = pg_malloc(slen + 1);
+
memcpy(linebuf, linebegin, slen);
linebuf[slen] = '\0';
result[n++] = linebuf;
}
/*
- * For 9.3 onwards, use fast promotion as the default option.
- * Promotion with a full checkpoint is still possible by writing
- * a file called "promote", e.g.
- * snprintf(promote_file, MAXPGPATH, "%s/promote", pg_data);
+ * For 9.3 onwards, use fast promotion as the default option. Promotion
+ * with a full checkpoint is still possible by writing a file called
+ * "promote", e.g. snprintf(promote_file, MAXPGPATH, "%s/promote",
+ * pg_data);
*/
snprintf(promote_file, MAXPGPATH, "%s/fast_promote", pg_data);
#ifdef WIN32
static void shutdown_parallel_dump_utils(int code, void *unused);
-bool parallel_init_done = false;
+bool parallel_init_done = false;
static DWORD tls_index;
-DWORD mainThreadId;
+DWORD mainThreadId;
#endif
if (i)
break;
}
-
#else /* UNIX */
for (;;)
continue;
break;
}
-
#endif
return i;
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)
{
write_msg(modulename, "pgpipe could not bind: %ui",
WSAGetLastError());
closesocket(s);
return -1;
}
- if (getsockname(s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR)
+ if (getsockname(s, (SOCKADDR *) &serv_addr, &len) == SOCKET_ERROR)
{
write_msg(modulename, "pgpipe could not getsockname: %ui",
WSAGetLastError());
return -1;
}
- if (connect(handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR)
+ if (connect(handles[1], (SOCKADDR *) &serv_addr, len) == SOCKET_ERROR)
{
write_msg(modulename, "pgpipe could not 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)
{
write_msg(modulename, "pgpipe could not accept socket: %ui",
WSAGetLastError());
WRKR_IDLE,
WRKR_WORKING,
WRKR_FINISHED
-} T_WorkerStatus;
+} T_WorkerStatus;
/* Arguments needed for a worker process */
typedef struct ParallelArgs
{
struct _archiveHandle *AH;
struct _tocEntry *te;
-} ParallelArgs;
+} ParallelArgs;
/* State for each parallel activity slot */
typedef struct ParallelSlot
* our work is finished, the master process will assign us a new work item.
*/
int
-parallel_restore(ParallelArgs * args)
+parallel_restore(ParallelArgs *args)
{
ArchiveHandle *AH = args->AH;
TocEntry *te = args->te;
typedef char *(*MasterStartParallelItemPtr) (struct _archiveHandle * AH, struct _tocEntry * te,
T_Action act);
typedef int (*MasterEndParallelItemPtr) (struct _archiveHandle * AH, struct _tocEntry * te,
- const char *str, T_Action act);
+ const char *str, T_Action act);
typedef size_t (*CustomOutPtr) (struct _archiveHandle * AH, const void *buf, size_t len);
int nLockDeps; /* number of such dependencies */
} TocEntry;
-extern int parallel_restore(struct ParallelArgs * args);
+extern int parallel_restore(struct ParallelArgs *args);
extern void on_exit_close_archive(Archive *AHX);
extern void warn_or_exit_horribly(ArchiveHandle *AH, const char *modulename, const char *fmt,...) __attribute__((format(PG_PRINTF_ATTRIBUTE, 3, 4)));
if (numWorkers > 1 && fout->remoteVersion < 90200
&& !no_synchronized_snapshots)
exit_horribly(NULL,
- "Synchronized snapshots are not supported by this server version.\n"
- "Run with --no-synchronized-snapshots instead if you do not need\n"
+ "Synchronized snapshots are not supported by this server version.\n"
+ "Run with --no-synchronized-snapshots instead if you do not need\n"
"synchronized snapshots.\n");
/* Find the last built-in OID, if needed */
appendPQExpBuffer(q, "\nOPTIONS (\n %s\n)", ftoptions);
/*
- * For materialized views, create the AS clause just like a view.
- * At this point, we always mark the view as not populated.
+ * For materialized views, create the AS clause just like a view. At
+ * this point, we always mark the view as not populated.
*/
if (tbinfo->relkind == RELKIND_MATVIEW)
{
/* check table explicitly requested */
if (table_include_oids.head != NULL &&
simple_oid_list_member(&table_include_oids,
- configtbloid))
+ configtbloid))
dumpobj = true;
/* check table's schema explicitly requested */
/* check table excluded by an exclusion switch */
if (table_exclude_oids.head != NULL &&
simple_oid_list_member(&table_exclude_oids,
- configtbloid))
+ configtbloid))
dumpobj = false;
/* check schema excluded by an exclusion switch */
if (simple_oid_list_member(&schema_exclude_oids,
- configtbl->dobj.namespace->dobj.catId.oid))
+ configtbl->dobj.namespace->dobj.catId.oid))
dumpobj = false;
if (dumpobj)
{
/*
- * Note: config tables are dumped without OIDs regardless of
- * the --oids setting. This is because row filtering
+ * Note: config tables are dumped without OIDs regardless
+ * of the --oids setting. This is because row filtering
* conditions aren't compatible with dumping OIDs.
*/
makeTableDataInfo(configtbl, false);
char *relacl;
char relkind;
char relpersistence; /* relation persistence */
- bool relispopulated; /* relation is populated */
+ bool relispopulated; /* relation is populated */
char *reltablespace; /* relation tablespace */
char *reloptions; /* options specified by WITH (...) */
char *toast_reloptions; /* ditto, for the TOAST table */
fprintf(stderr, _("%s: multitransaction ID (-m) must not be 0\n"), progname);
exit(1);
}
+
/*
* XXX It'd be nice to have more sanity checks here, e.g. so
* that oldest is not wrapped around w.r.t. nextMulti.
DllInstall(BOOL bInstall,
LPCWSTR pszCmdLine)
{
-
if (pszCmdLine && *pszCmdLine != '\0')
wcstombs(event_source, pszCmdLine, sizeof(event_source));
if (!o_conn && (!dbname || !user || !host || !port))
{
/*
- * We don't know the supplied connection parameters and don't want
- * to connect to the wrong database by using defaults, so require
- * all parameters to be specified.
+ * We don't know the supplied connection parameters and don't want to
+ * connect to the wrong database by using defaults, so require all
+ * parameters to be specified.
*/
psql_error("All connection parameters must be supplied because no "
"database connection exists\n");
* \copy ( select stmt ) to filename [options]
*
* where 'filename' can be one of the following:
- * '' | PROGRAM '' | stdin | stdout | pstdout | pstdout
+ * '' | PROGRAM '' | stdin | stdout | pstdout | pstdout
*
* An undocumented fact is that you can still write BINARY before the
* tablename; this is a hangover from the pre-7.3 syntax. The options
if (pg_strcasecmp(token, "program") == 0)
{
- int toklen;
+ int toklen;
token = strtokx(NULL, whitespace, NULL, "'",
0, false, false, pset.encoding);
goto error;
/*
- * The shell command must be quoted. This isn't fool-proof, but catches
- * most quoting errors.
+ * The shell command must be quoted. This isn't fool-proof, but
+ * catches most quoting errors.
*/
toklen = strlen(token);
if (token[0] != '\'' || toklen < 2 || token[toklen - 1] != '\'')
{
if (options->program)
{
- int pclose_rc = pclose(copystream);
+ int pclose_rc = pclose(copystream);
+
if (pclose_rc != 0)
{
if (pclose_rc < 0)
strerror(errno));
else
{
- char *reason = wait_result_to_str(pclose_rc);
+ char *reason = wait_result_to_str(pclose_rc);
+
psql_error("%s: %s\n", options->file,
reason ? reason : "");
if (reason)
#define QL_HELP_COUNT "
- . scalar(keys %entries)
- . " /* number of help items */
+ . scalar(keys %entries) . " /* number of help items */
#define QL_MAX_CMD_LEN $maxlen /* largest strlen(cmd) */
if (pset.sversion < 80000)
{
psql_error("The server (version %d.%d) does not support tablespaces.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (showWindow && pset.sversion < 80400)
{
psql_error("\\df does not take a \"w\" option with server version %d.%d\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (verbose)
appendPQExpBuffer(&buf,
- ",\n CASE WHEN prosecdef THEN '%s' ELSE '%s' END AS \"%s\""
+ ",\n CASE WHEN prosecdef THEN '%s' ELSE '%s' END AS \"%s\""
",\n CASE\n"
" WHEN p.provolatile = 'i' THEN '%s'\n"
" WHEN p.provolatile = 's' THEN '%s'\n"
if (pset.sversion < 90000)
{
psql_error("The server (version %d.%d) does not support altering default privileges.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
{
if (!pset.quiet)
psql_error("Did not find any relation named \"%s\".\n",
- pattern);
+ pattern);
PQclear(res);
return false;
}
bool havewhere;
printfPQExpBuffer(&buf, "SELECT rolname AS \"%s\", datname AS \"%s\",\n"
- "pg_catalog.array_to_string(setconfig, E'\\n') AS \"%s\"\n"
+ "pg_catalog.array_to_string(setconfig, E'\\n') AS \"%s\"\n"
"FROM pg_db_role_setting AS s\n"
"LEFT JOIN pg_database ON pg_database.oid = setdatabase\n"
"LEFT JOIN pg_roles ON pg_roles.oid = setrole\n",
PGresult *res;
printQueryOpt myopt = pset.popt;
static const bool translate_columns[] =
- {false, false, false, true, false, false, false};
+ {false, false, false, true, false, false, false};
initPQExpBuffer(&buf);
" when 'D' then 'disabled' end as \"%s\", "
"e.evtfoid::regproc as \"%s\", "
"array_to_string(array(select x "
- " from unnest(evttags) as t(x)), ', ') as \"%s\" ",
+ " from unnest(evttags) as t(x)), ', ') as \"%s\" ",
gettext_noop("Name"),
gettext_noop("Event"),
gettext_noop("Owner"),
gettext_noop("Tags"));
if (verbose)
appendPQExpBuffer(&buf,
- ",\npg_catalog.obj_description(e.oid, 'pg_event_trigger') as \"%s\"",
+ ",\npg_catalog.obj_description(e.oid, 'pg_event_trigger') as \"%s\"",
gettext_noop("Description"));
appendPQExpBuffer(&buf,
"\nFROM pg_event_trigger e ");
if (pset.sversion < 90100)
{
psql_error("The server (version %d.%d) does not support collations.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 80300)
{
psql_error("The server (version %d.%d) does not support full text search.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
{
if (!pset.quiet)
psql_error("Did not find any text search parser named \"%s\".\n",
- pattern);
+ pattern);
PQclear(res);
return false;
}
if (pset.sversion < 80300)
{
psql_error("The server (version %d.%d) does not support full text search.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 80300)
{
psql_error("The server (version %d.%d) does not support full text search.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 80300)
{
psql_error("The server (version %d.%d) does not support full text search.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
{
if (!pset.quiet)
psql_error("Did not find any text search configuration named \"%s\".\n",
- pattern);
+ pattern);
PQclear(res);
return false;
}
if (pset.sversion < 80400)
{
psql_error("The server (version %d.%d) does not support foreign-data wrappers.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 80400)
{
psql_error("The server (version %d.%d) does not support foreign servers.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 80400)
{
psql_error("The server (version %d.%d) does not support user mappings.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 90100)
{
psql_error("The server (version %d.%d) does not support foreign tables.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 90100)
{
psql_error("The server (version %d.%d) does not support extensions.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
if (pset.sversion < 90100)
{
psql_error("The server (version %d.%d) does not support extensions.\n",
- pset.sversion / 10000, (pset.sversion / 100) % 100);
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
return true;
}
{
if (pattern)
psql_error("Did not find any extension named \"%s\".\n",
- pattern);
+ pattern);
else
psql_error("Did not find any extensions.\n");
}
{
fputs("p{", fout);
fwrite(next_opt_table_attr_char, strcspn(next_opt_table_attr_char,
- LONGTABLE_WHITESPACE), 1, fout);
+ LONGTABLE_WHITESPACE), 1, fout);
last_opt_table_attr_char = next_opt_table_attr_char;
next_opt_table_attr_char += strcspn(next_opt_table_attr_char,
- LONGTABLE_WHITESPACE);
+ LONGTABLE_WHITESPACE);
fputs("\\textwidth}", fout);
}
/* use previous value */
{
fputs("p{", fout);
fwrite(last_opt_table_attr_char, strcspn(last_opt_table_attr_char,
- LONGTABLE_WHITESPACE), 1, fout);
+ LONGTABLE_WHITESPACE), 1, fout);
fputs("\\textwidth}", fout);
}
else
parse_psql_options(argc, argv, &options);
/*
- * If no action was specified and we're in non-interactive mode, treat
- * it as if the user had specified "-f -". This lets single-transaction
- * mode work in this case.
+ * If no action was specified and we're in non-interactive mode, treat it
+ * as if the user had specified "-f -". This lets single-transaction mode
+ * work in this case.
*/
if (options.action == ACT_NOTHING && pset.notty)
{
if (options.single_txn && options.action != ACT_FILE)
{
if (options.action == ACT_NOTHING)
- fprintf(stderr,_("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
+ fprintf(stderr, _("%s: -1 can only be used in non-interactive mode\n"), pset.progname);
else
- fprintf(stderr,_("%s: -1 is incompatible with -c and -l\n"), pset.progname);
+ fprintf(stderr, _("%s: -1 is incompatible with -c and -l\n"), pset.progname);
exit(EXIT_FAILURE);
}
if (envrc != NULL && strlen(envrc) > 0)
{
/* might need to free() this */
- char *envrc_alloc = pstrdup(envrc);
+ char *envrc_alloc = pstrdup(envrc);
expand_tilde(&envrc_alloc);
process_psqlrc_file(envrc_alloc);
/* selcondition */
"c.conrelid <> 0",
/* viscondition */
- "true", /* there is no pg_constraint_is_visible */
+ "true", /* there is no pg_constraint_is_visible */
/* namespace */
"c.connamespace",
/* result */
" and pg_catalog.pg_type_is_visible(t.oid)"
/* the silly-looking length condition is just to eat up the current word */
-#define Query_for_list_of_tables_for_constraint \
+#define Query_for_list_of_tables_for_constraint \
"SELECT pg_catalog.quote_ident(relname) "\
" FROM pg_catalog.pg_class"\
" WHERE (%d = pg_catalog.length('%s'))"\
pg_strcasecmp(prev2_wd, "DROP") == 0 &&
pg_strcasecmp(prev_wd, "COLUMN") == 0)
COMPLETE_WITH_ATTR(prev3_wd, "");
- /* If we have ALTER TABLE DROP|RENAME|VALIDATE CONSTRAINT, provide list of constraints */
+
+ /*
+ * If we have ALTER TABLE DROP|RENAME|VALIDATE CONSTRAINT, provide
+ * list of constraints
+ */
else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
pg_strcasecmp(prev4_wd, "TABLE") == 0 &&
(pg_strcasecmp(prev2_wd, "DROP") == 0 ||
* If we have CLUSTER VERBOSE USING, then add the index as well.
*/
else if (pg_strcasecmp(prev4_wd, "CLUSTER") == 0 &&
- pg_strcasecmp(prev3_wd, "VERBOSE") == 0 &&
+ pg_strcasecmp(prev3_wd, "VERBOSE") == 0 &&
pg_strcasecmp(prev_wd, "USING") == 0)
{
completion_info_charp = prev2_wd;
static const char *const list_SECURITY_LABEL[] =
{"LANGUAGE", "SCHEMA", "SEQUENCE", "TABLE", "TYPE", "VIEW",
"MATERIALIZED VIEW", "COLUMN", "AGGREGATE", "FUNCTION", "DOMAIN",
- "LARGE OBJECT", NULL};
+ "LARGE OBJECT", NULL};
COMPLETE_WITH_LIST(list_SECURITY_LABEL);
}
#include "postgres_fe.h"
#include "common.h"
-#define DEFAULT_CONNECT_TIMEOUT "3"
+#define DEFAULT_CONNECT_TIMEOUT "3"
static void
-help(const char *progname);
+ help(const char *progname);
int
main(int argc, char **argv)
{
- int c,optindex,opt_index = 2;
+ int c,
+ optindex,
+ opt_index = 2;
const char *progname;
const char *pgdbname = NULL;
const char *connect_timeout = DEFAULT_CONNECT_TIMEOUT;
- const char *keywords[7] = { NULL };
- const char *values[7] = { NULL };
+ const char *keywords[7] = {NULL};
+ const char *values[7] = {NULL};
- bool quiet = false;
+ bool quiet = false;
- PGPing rv;
- PQconninfoOption *connect_options, *conn_opt_ptr;
+ PGPing rv;
+ PQconninfoOption *connect_options,
+ *conn_opt_ptr;
/*
- * We accept user and database as options to avoid
- * useless errors from connecting with invalid params
+ * We accept user and database as options to avoid useless errors from
+ * connecting with invalid params
*/
static struct option long_options[] = {
- {"dbname", required_argument, NULL, 'd'},
- {"host", required_argument, NULL, 'h'},
- {"port", required_argument, NULL, 'p'},
- {"quiet", no_argument, NULL, 'q'},
- {"timeout", required_argument, NULL, 't'},
- {"username", required_argument, NULL, 'U'},
- {NULL, 0, NULL, 0}
- };
+ {"dbname", required_argument, NULL, 'd'},
+ {"host", required_argument, NULL, 'h'},
+ {"port", required_argument, NULL, 'p'},
+ {"quiet", no_argument, NULL, 'q'},
+ {"timeout", required_argument, NULL, 't'},
+ {"username", required_argument, NULL, 'U'},
+ {NULL, 0, NULL, 0}
+ };
progname = get_progname(argv[0]);
set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pgscripts"));
break;
default:
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
+
/*
* We need to make sure we don't return 1 here because someone
* checking the return code might infer unintended meaning
fprintf(stderr, _("%s: too many command-line arguments (first is \"%s\")\n"),
progname, argv[optind]);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
+
/*
* We need to make sure we don't return 1 here because someone
* checking the return code might infer unintended meaning
void *
pg_realloc(void *ptr, size_t size)
{
- void *tmp;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (ptr == NULL && size == 0)
- size = 1;
- tmp = realloc(ptr, size);
- if (!tmp)
- {
+ void *tmp;
+
+ /* Avoid unportable behavior of realloc(NULL, 0) */
+ if (ptr == NULL && size == 0)
+ size = 1;
+ tmp = realloc(ptr, size);
+ if (!tmp)
+ {
fprintf(stderr, _("out of memory\n"));
exit(EXIT_FAILURE);
- }
- return tmp;
+ }
+ return tmp;
}
/*
/*-------------------------------------------------------------------------
* relpath.c
- * Shared frontend/backend code to find out pathnames of relation files
+ * Shared frontend/backend code to find out pathnames of relation files
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * src/common/relpath.c
+ * src/common/relpath.c
*
*-------------------------------------------------------------------------
*/
}
return path;
}
-
#define F_FOLLOW_RIGHT (1 << 3) /* page to the right has no downlink */
typedef XLogRecPtr GistNSN;
+
/*
* For on-disk compatibility with pre-9.3 servers, NSN is stored as two
* 32-bit fields on disk, same as LSNs.
typedef struct GISTPageOpaqueData
{
- PageGistNSN nsn; /* this value must change on page split */
+ PageGistNSN nsn; /* this value must change on page split */
BlockNumber rightlink; /* next page if any */
uint16 flags; /* see bit definitions above */
uint16 gist_page_id; /* for identification of GiST indexes */
* the union keys for each side.
*
* If spl_ldatum_exists and spl_rdatum_exists are true, then we are performing
- * a "secondary split" using a non-first index column. In this case some
+ * a "secondary split" using a non-first index column. In this case some
* decisions have already been made about a page split, and the set of tuples
* being passed to PickSplit is just the tuples about which we are undecided.
* spl_ldatum/spl_rdatum then contain the union keys for the tuples already
- * chosen to go left or right. Ideally the PickSplit method should take those
+ * chosen to go left or right. Ideally the PickSplit method should take those
* keys into account while deciding what to do with the remaining tuples, ie
* it should try to "build out" from those unions so as to minimally expand
* them. If it does so, it should union the given tuples' keys into the
* replacement is really a match.
* cmax is the outdating command's CID, but only when the failure code is
* HeapTupleSelfUpdated (i.e., something in the current transaction outdated
- * the tuple); otherwise cmax is zero. (We make this restriction because
+ * the tuple); otherwise cmax is zero. (We make this restriction because
* HeapTupleHeaderGetCmax doesn't work for tuples outdated in other
* transactions.)
*/
typedef struct HeapUpdateFailureData
{
- ItemPointerData ctid;
- TransactionId xmax;
- CommandId cmax;
+ ItemPointerData ctid;
+ TransactionId xmax;
+ CommandId cmax;
} HeapUpdateFailureData;
TransactionId old_xmax; /* xmax of the old tuple */
TransactionId new_xmax; /* xmax of the new tuple */
ItemPointerData newtid; /* new inserted tuple id */
- uint8 old_infobits_set; /* infomask bits to set on old tuple */
+ uint8 old_infobits_set; /* infomask bits to set on old tuple */
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 AND TUPLE DATA FOLLOWS AT END OF STRUCT */
typedef struct xl_heap_lock_updated
{
xl_heaptid target;
- TransactionId xmax;
+ TransactionId xmax;
uint8 infobits_set;
} xl_heap_lock_updated;
/* MORE DATA FOLLOWS AT END OF STRUCT */
};
+
/* typedef appears in tupbasics.h */
/*
#define HEAP_XMAX_EXCL_LOCK 0x0040 /* xmax is exclusive locker */
#define HEAP_XMAX_LOCK_ONLY 0x0080 /* xmax, if valid, is only a locker */
- /* xmax is a shared locker */
+ /* xmax is a shared locker */
#define HEAP_XMAX_SHR_LOCK (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)
#define HEAP_LOCK_MASK (HEAP_XMAX_SHR_LOCK | HEAP_XMAX_EXCL_LOCK | \
* Use these to test whether a particular lock is applied to a tuple
*/
#define HEAP_XMAX_IS_SHR_LOCKED(infomask) \
- (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK)
+ (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK)
#define HEAP_XMAX_IS_EXCL_LOCKED(infomask) \
- (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK)
+ (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK)
#define HEAP_XMAX_IS_KEYSHR_LOCKED(infomask) \
- (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK)
+ (((infomask) & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK)
/* turn these all off when Xmax is to change */
#define HEAP_XMAX_BITS (HEAP_XMAX_COMMITTED | HEAP_XMAX_INVALID | \
/* MORE DATA FOLLOWS AT END OF STRUCT */
};
+
/* typedef appears in htup.h */
typedef struct MultiXactMember
{
- TransactionId xid;
- MultiXactStatus status;
+ TransactionId xid;
+ MultiXactStatus status;
} MultiXactMember;
extern MultiXactId ReadNextMultiXactId(void);
extern bool MultiXactIdIsRunning(MultiXactId multi);
extern void MultiXactIdSetOldestMember(void);
-extern int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **xids,
+extern int GetMultiXactIdMembers(MultiXactId multi, MultiXactMember **xids,
bool allow_old);
extern bool MultiXactIdPrecedes(MultiXactId multi1, MultiXactId multi2);
{
#include "access/rmgrlist.h"
RM_NEXT_ID
-} RmgrIds;
+} RmgrIds;
#undef PG_RMGR
#define TableOidAttributeNumber (-7)
#define FirstLowInvalidHeapAttributeNumber (-8)
-
#endif /* SYSATTR_H */
typedef struct
{
TimeLineID tli;
- XLogRecPtr begin; /* inclusive */
- XLogRecPtr end; /* exclusive, 0 means infinity */
+ XLogRecPtr begin; /* inclusive */
+ XLogRecPtr end; /* exclusive, 0 means infinity */
} TimeLineHistoryEntry;
extern List *readTimeLineHistory(TimeLineID targetTLI);
extern void XLogFlush(XLogRecPtr RecPtr);
extern bool XLogBackgroundFlush(void);
extern bool XLogNeedsFlush(XLogRecPtr RecPtr);
-extern int XLogFileInit(XLogSegNo segno, bool *use_existent, bool use_lock);
+extern int XLogFileInit(XLogSegNo segno, bool *use_existent, bool use_lock);
extern int XLogFileOpen(XLogSegNo segno);
extern XLogRecPtr XLogSaveBufferForHint(Buffer buffer);
* for deciding which segment to write given a pointer to a record end,
* for example.
*/
-#define XLByteToSeg(xlrp, logSegNo) \
+#define XLByteToSeg(xlrp, logSegNo) \
logSegNo = (xlrp) / XLogSegSize
-#define XLByteToPrevSeg(xlrp, logSegNo) \
+#define XLByteToPrevSeg(xlrp, logSegNo) \
logSegNo = ((xlrp) - 1) / XLogSegSize
/*
* For XLByteInSeg, do the computation at face value. For XLByteInPrevSeg,
* a boundary byte is taken to be in the previous segment.
*/
-#define XLByteInSeg(xlrp, logSegNo) \
+#define XLByteInSeg(xlrp, logSegNo) \
(((xlrp) / XLogSegSize) == (logSegNo))
-#define XLByteInPrevSeg(xlrp, logSegNo) \
+#define XLByteInPrevSeg(xlrp, logSegNo) \
((((xlrp) - 1) / XLogSegSize) == (logSegNo))
/* Check if an XLogRecPtr value is in a plausible range */
do { \
uint32 log; \
uint32 seg; \
- sscanf(fname, "%08X%08X%08X", tli, &log, &seg); \
- *logSegNo = (uint64) log * XLogSegmentsPerXLogId + seg; \
+ sscanf(fname, "%08X%08X%08X", tli, &log, &seg); \
+ *logSegNo = (uint64) log * XLogSegmentsPerXLogId + seg; \
} while (0)
#define XLogFilePath(path, tli, logSegNo) \
extern void GetOldestRestartPoint(XLogRecPtr *oldrecptr, TimeLineID *oldtli);
/*
- * Exported for the functions in timeline.c and xlogarchive.c. Only valid
+ * Exported for the functions in timeline.c and xlogarchive.c. Only valid
* in the startup process.
*/
extern bool ArchiveRecoveryRequested;
bool cleanupEnabled);
extern void ExecuteRecoveryCommand(char *command, char *commandName,
bool failOnerror);
-extern void KeepFileRestoredFromArchive(char *path, char *xlogfname);
+extern void KeepFileRestoredFromArchive(char *path, char *xlogfname);
extern void XLogArchiveNotify(const char *xlog);
extern void XLogArchiveNotifySeg(XLogSegNo segno);
extern void XLogArchiveForceDone(const char *xlog);
#include "pg_config.h"
#include "pg_config_manual.h" /* must be after pg_config.h */
-#if !defined(WIN32) && !defined(__CYGWIN__) /* win32 includes further down */
+#if !defined(WIN32) && !defined(__CYGWIN__) /* win32 includes further down */
#include "pg_config_os.h" /* must be before any system header files */
#endif
#define AssertMacro(condition) ((void)true)
#define AssertArg(condition)
#define AssertState(condition)
-
#elif defined(FRONTEND)
#define AssertMacro(p) ((void) assert(p))
#define AssertArg(condition) assert(condition)
#define AssertState(condition) assert(condition)
-
-#else /* USE_ASSERT_CHECKING && !FRONTEND */
+#else /* USE_ASSERT_CHECKING && !FRONTEND */
/*
* Trap
#define AssertState(condition) \
Trap(!(condition), "BadState")
-
-#endif /* USE_ASSERT_CHECKING && !FRONTEND */
+#endif /* USE_ASSERT_CHECKING && !FRONTEND */
/*
* throw a compile error using the "errmessage" (a string literal).
*
* gcc 4.6 and up supports _Static_assert(), but there are bizarre syntactic
- * placement restrictions. These macros make it safe to use as a statement
+ * placement restrictions. These macros make it safe to use as a statement
* or in an expression, respectively.
*
* Otherwise we fall back on a kluge that assumes the compiler will complain
do { _Static_assert(condition, errmessage); } while(0)
#define StaticAssertExpr(condition, errmessage) \
({ StaticAssertStmt(condition, errmessage); true; })
-#else /* !HAVE__STATIC_ASSERT */
+#else /* !HAVE__STATIC_ASSERT */
#define StaticAssertStmt(condition, errmessage) \
((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; }))
#define StaticAssertExpr(condition, errmessage) \
StaticAssertStmt(condition, errmessage)
-#endif /* HAVE__STATIC_ASSERT */
+#endif /* HAVE__STATIC_ASSERT */
/*
#define AssertVariableIsOfTypeMacro(varname, typename) \
((void) StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \
CppAsString(varname) " does not have type " CppAsString(typename)))
-#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */
+#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */
#define AssertVariableIsOfType(varname, typename) \
StaticAssertStmt(sizeof(varname) == sizeof(typename), \
CppAsString(varname) " does not have type " CppAsString(typename))
#define AssertVariableIsOfTypeMacro(varname, typename) \
((void) StaticAssertExpr(sizeof(varname) == sizeof(typename), \
CppAsString(varname) " does not have type " CppAsString(typename)))
-#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */
+#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */
/* ----------------------------------------------------------------
*
* The function bodies must be defined in the module header prefixed by
* STATIC_IF_INLINE, protected by a cpp symbol that the module's .c file must
- * define. If the compiler doesn't support inline functions, the function
+ * define. If the compiler doesn't support inline functions, the function
* definitions are pulled in by the .c file as regular (not inline) symbols.
*
* The header must also declare the functions' prototypes, protected by
#define STATIC_IF_INLINE static inline
#else
#define STATIC_IF_INLINE
-#endif /* PG_USE_INLINE */
+#endif /* PG_USE_INLINE */
/* ----------------------------------------------------------------
* Section 8: random stuff
bool is_internal);
extern void StoreAttrDefault(Relation rel, AttrNumber attnum,
- Node *expr, bool is_internal);
+ Node *expr, bool is_internal);
extern Node *cookDefault(ParseState *pstate,
Node *raw_default,
DECLARE_UNIQUE_INDEX(pg_event_trigger_evtname_index, 3467, on pg_event_trigger using btree(evtname name_ops));
#define EventTriggerNameIndexId 3467
DECLARE_UNIQUE_INDEX(pg_event_trigger_oid_index, 3468, on pg_event_trigger using btree(oid oid_ops));
-#define EventTriggerOidIndexId 3468
+#define EventTriggerOidIndexId 3468
DECLARE_UNIQUE_INDEX(pg_ts_config_cfgname_index, 3608, on pg_ts_config using btree(cfgname name_ops, cfgnamespace oid_ops));
#define TSConfigNameNspIndexId 3608
typedef struct
{
/*
- * This flag informs extensions whether the context of this creation
- * is invoked by user's operations, or not. E.g, it shall be dealt
- * as internal stuff on toast tables or indexes due to type changes.
+ * This flag informs extensions whether the context of this creation is
+ * invoked by user's operations, or not. E.g, it shall be dealt as
+ * internal stuff on toast tables or indexes due to type changes.
*/
bool is_internal;
} ObjectAccessPostCreate;
typedef struct
{
/*
- * This identifier is used when system catalog takes two IDs
- * to identify a particular tuple of the catalog.
- * It is only used when the caller want to identify an entry
- * of pg_inherits, pg_db_role_setting or pg_user_mapping.
- * Elsewhere, InvalidOid should be set.
+ * This identifier is used when system catalog takes two IDs to identify a
+ * particular tuple of the catalog. It is only used when the caller want
+ * to identify an entry of pg_inherits, pg_db_role_setting or
+ * pg_user_mapping. Elsewhere, InvalidOid should be set.
*/
Oid auxiliary_id;
/*
* If this flag is set, the user hasn't requested that the object be
* altered, but we're doing it anyway for some internal reason.
- * Permissions-checking hooks may want to skip checks if, say, we're
- * alter the constraints of a temporary heap during CLUSTER.
+ * Permissions-checking hooks may want to skip checks if, say, we're alter
+ * the constraints of a temporary heap during CLUSTER.
*/
bool is_internal;
} ObjectAccessPostAlter;
bool ereport_on_violation;
/*
- * This is, in essence, an out parameter. Core code should
- * initialize this to true, and any extension that wants to deny
- * access should reset it to false. But an extension should be
- * careful never to store a true value here, so that in case there are
- * multiple extensions access is only allowed if all extensions
- * agree.
+ * This is, in essence, an out parameter. Core code should initialize
+ * this to true, and any extension that wants to deny access should reset
+ * it to false. But an extension should be careful never to store a true
+ * value here, so that in case there are multiple extensions access is
+ * only allowed if all extensions agree.
*/
bool result;
} ObjectAccessNamespaceSearch;
/* Core code uses these functions to call the hook (see macros below). */
extern void RunObjectPostCreateHook(Oid classId, Oid objectId, int subId,
- bool is_internal);
+ bool is_internal);
extern void RunObjectDropHook(Oid classId, Oid objectId, int subId,
- int dropflags);
+ int dropflags);
extern void RunObjectPostAlterHook(Oid classId, Oid objectId, int subId,
- Oid auxiliaryId, bool is_internal);
+ Oid auxiliaryId, bool is_internal);
extern bool RunNamespaceSearchHook(Oid objectId, bool ereport_on_volation);
extern void RunFunctionExecuteHook(Oid objectId);
extern Oid get_object_namespace(const ObjectAddress *address);
-extern bool is_objectclass_supported(Oid class_id);
-extern Oid get_object_oid_index(Oid class_id);
-extern int get_object_catcache_oid(Oid class_id);
-extern int get_object_catcache_name(Oid class_id);
-extern AttrNumber get_object_attnum_name(Oid class_id);
-extern AttrNumber get_object_attnum_namespace(Oid class_id);
-extern AttrNumber get_object_attnum_owner(Oid class_id);
-extern AttrNumber get_object_attnum_acl(Oid class_id);
-extern AclObjectKind get_object_aclkind(Oid class_id);
-extern bool get_object_namensp_unique(Oid class_id);
-
-extern HeapTuple get_catalog_object_by_oid(Relation catalog,
+extern bool is_objectclass_supported(Oid class_id);
+extern Oid get_object_oid_index(Oid class_id);
+extern int get_object_catcache_oid(Oid class_id);
+extern int get_object_catcache_name(Oid class_id);
+extern AttrNumber get_object_attnum_name(Oid class_id);
+extern AttrNumber get_object_attnum_namespace(Oid class_id);
+extern AttrNumber get_object_attnum_owner(Oid class_id);
+extern AttrNumber get_object_attnum_acl(Oid class_id);
+extern AclObjectKind get_object_aclkind(Oid class_id);
+extern bool get_object_namensp_unique(Oid class_id);
+
+extern HeapTuple get_catalog_object_by_oid(Relation catalog,
Oid objectId);
extern char *getObjectDescription(const ObjectAddress *object);
bool relhasrules; /* has (or has had) any rules */
bool relhastriggers; /* has (or has had) any TRIGGERs */
bool relhassubclass; /* has (or has had) derived classes */
- bool relispopulated; /* matview currently holds query results */
+ bool relispopulated; /* matview currently holds query results */
TransactionId relfrozenxid; /* all Xids < this are frozen in this rel */
TransactionId relminmxid; /* all multixacts in this rel are >= this.
* this is really a MultiXactId */
List *others);
extern void AlterConstraintNamespaces(Oid ownerId, Oid oldNspId,
- Oid newNspId, bool isType, ObjectAddresses *objsMoved);
+ Oid newNspId, bool isType, ObjectAddresses *objsMoved);
extern Oid get_relation_constraint_oid(Oid relid, const char *conname, bool missing_ok);
extern Oid get_domain_constraint_oid(Oid typid, const char *conname, bool missing_ok);
MultiXactOffset nextMultiOffset; /* next free MultiXact offset */
TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */
Oid oldestXidDB; /* database with minimum datfrozenxid */
- MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
+ MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */
Oid oldestMultiDB; /* database with minimum datminmxid */
pg_time_t time; /* time stamp of checkpoint */
CheckPoint checkPointCopy; /* copy of last check point record */
- XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
+ XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */
/*
* These two values determine the minimum point we must recover up to
extern void EnumValuesCreate(Oid enumTypeOid, List *vals);
extern void EnumValuesDelete(Oid enumTypeOid);
extern void AddEnumLabel(Oid enumTypeOid, const char *newVal,
- const char *neighbor, bool newValIsAfter,
- bool skipIfExists);
+ const char *neighbor, bool newValIsAfter,
+ bool skipIfExists);
#endif /* PG_ENUM_H */
* typedef struct FormData_pg_event_trigger
* ----------------
*/
-#define EventTriggerRelationId 3466
+#define EventTriggerRelationId 3466
CATALOG(pg_event_trigger,3466)
{
Oid evtfoid; /* OID of function to be called */
char evtenabled; /* trigger's firing configuration WRT
* session_replication_role */
+
#ifdef CATALOG_VARLEN
- text evttags[1]; /* command TAGs this event trigger targets */
+ text evttags[1]; /* command TAGs this event trigger targets */
#endif
} FormData_pg_event_trigger;
DESCR("get json array element");
DATA(insert OID = 3965 ( "->>" PGNSP PGUID b f f 114 23 25 0 0 json_array_element_text - - ));
DESCR("get json array element as text");
-DATA(insert OID = 3966 ( "#>" PGNSP PGUID b f f 114 1009 114 0 0 json_extract_path_op - - ));
+DATA(insert OID = 3966 ( "#>" PGNSP PGUID b f f 114 1009 114 0 0 json_extract_path_op - - ));
DESCR("get value from json with path elements");
DATA(insert OID = 3967 ( "#>>" PGNSP PGUID b f f 114 1009 25 0 0 json_extract_path_text_op - - ));
DESCR("get value from json as text with path elements");
DESCR("expand array to set of rows");
DATA(insert OID = 3167 ( array_remove PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2277 "2277 2283" _null_ _null_ _null_ _null_ array_remove _null_ _null_ _null_ ));
DESCR("remove any occurrences of an element from an array");
-DATA(insert OID = 3168 ( array_replace PGNSP PGUID 12 1 0 0 0 f f f f f f i 3 0 2277 "2277 2283 2283" _null_ _null_ _null_ _null_ array_replace _null_ _null_ _null_ ));
+DATA(insert OID = 3168 ( array_replace PGNSP PGUID 12 1 0 0 0 f f f f f f i 3 0 2277 "2277 2283 2283" _null_ _null_ _null_ _null_ array_replace _null_ _null_ _null_ ));
DESCR("replace any occurrences of an element in an array");
DATA(insert OID = 2333 ( array_agg_transfn PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2283" _null_ _null_ _null_ _null_ array_agg_transfn _null_ _null_ _null_ ));
DESCR("aggregate transition function");
DESCR("large object position (64 bit)");
DATA(insert OID = 1004 ( lo_truncate PGNSP PGUID 12 1 0 0 0 f 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 = 3172 ( lo_truncate64 PGNSP PGUID 12 1 0 0 0 f f f f t f v 2 0 23 "23 20" _null_ _null_ _null_ _null_ lo_truncate64 _null_ _null_ _null_ ));
+DATA(insert OID = 3172 ( lo_truncate64 PGNSP PGUID 12 1 0 0 0 f f f f t f v 2 0 23 "23 20" _null_ _null_ _null_ _null_ lo_truncate64 _null_ _null_ _null_ ));
DESCR("truncate large object (64 bit)");
DATA(insert OID = 959 ( on_pl PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 16 "600 628" _null_ _null_ _null_ _null_ on_pl _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 3594 ( event_trigger_in PGNSP PGUID 12 1 0 0 0 f f f f f f i 1 0 3838 "2275" _null_ _null_ _null_ _null_ event_trigger_in _null_ _null_ _null_ ));
DESCR("I/O");
-DATA(insert OID = 3595 ( event_trigger_out PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2275 "3838" _null_ _null_ _null_ _null_ event_trigger_out _null_ _null_ _null_ ));
+DATA(insert OID = 3595 ( event_trigger_out PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 2275 "3838" _null_ _null_ _null_ _null_ event_trigger_out _null_ _null_ _null_ ));
DESCR("I/O");
DATA(insert OID = 2302 ( language_handler_in PGNSP PGUID 12 1 0 0 0 f f f f f f i 1 0 2280 "2275" _null_ _null_ _null_ _null_ language_handler_in _null_ _null_ _null_ ));
DESCR("I/O");
DESCR("map row to json");
DATA(insert OID = 3156 ( row_to_json PGNSP PGUID 12 1 0 0 0 f f f f t f s 2 0 114 "2249 16" _null_ _null_ _null_ _null_ row_to_json_pretty _null_ _null_ _null_ ));
DESCR("map row to json with optional pretty printing");
-DATA(insert OID = 3173 ( json_agg_transfn PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2283" _null_ _null_ _null_ _null_ json_agg_transfn _null_ _null_ _null_ ));
+DATA(insert OID = 3173 ( json_agg_transfn PGNSP PGUID 12 1 0 0 0 f f f f f f i 2 0 2281 "2281 2283" _null_ _null_ _null_ _null_ json_agg_transfn _null_ _null_ _null_ ));
DESCR("json aggregate transition function");
-DATA(insert OID = 3174 ( json_agg_finalfn PGNSP PGUID 12 1 0 0 0 f f f f f f i 1 0 114 "2281" _null_ _null_ _null_ _null_ json_agg_finalfn _null_ _null_ _null_ ));
+DATA(insert OID = 3174 ( json_agg_finalfn PGNSP PGUID 12 1 0 0 0 f f f f f f i 1 0 114 "2281" _null_ _null_ _null_ _null_ json_agg_finalfn _null_ _null_ _null_ ));
DESCR("json aggregate final function");
DATA(insert OID = 3175 ( json_agg PGNSP PGUID 12 1 0 0 0 t f f f f f i 1 0 114 "2283" _null_ _null_ _null_ _null_ aggregate_dummy _null_ _null_ _null_ ));
DESCR("aggregate input into json");
DATA(insert OID = 3176 ( to_json PGNSP PGUID 12 1 0 0 0 f f f f t f s 1 0 114 "2283" _null_ _null_ _null_ _null_ to_json _null_ _null_ _null_ ));
DESCR("map input to json");
-DATA(insert OID = 3947 ( json_object_field PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 25" _null_ _null_ "{from_json, field_name}" _null_ json_object_field _null_ _null_ _null_ ));
+DATA(insert OID = 3947 ( json_object_field PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 25" _null_ _null_ "{from_json, field_name}" _null_ json_object_field _null_ _null_ _null_ ));
DESCR("get json object field");
-DATA(insert OID = 3948 ( json_object_field_text PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 25" _null_ _null_ "{from_json, field_name}" _null_ json_object_field_text _null_ _null_ _null_ ));
+DATA(insert OID = 3948 ( json_object_field_text PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 25" _null_ _null_ "{from_json, field_name}" _null_ json_object_field_text _null_ _null_ _null_ ));
DESCR("get json object field as text");
-DATA(insert OID = 3949 ( json_array_element PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 23" _null_ _null_ "{from_json, element_index}" _null_ json_array_element _null_ _null_ _null_ ));
+DATA(insert OID = 3949 ( json_array_element PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 23" _null_ _null_ "{from_json, element_index}" _null_ json_array_element _null_ _null_ _null_ ));
DESCR("get json array element");
-DATA(insert OID = 3950 ( json_array_element_text PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 23" _null_ _null_ "{from_json, element_index}" _null_ json_array_element_text _null_ _null_ _null_ ));
+DATA(insert OID = 3950 ( json_array_element_text PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 23" _null_ _null_ "{from_json, element_index}" _null_ json_array_element_text _null_ _null_ _null_ ));
DESCR("get json array element as text");
-DATA(insert OID = 3951 ( json_extract_path PGNSP PGUID 12 1 0 25 0 f f f f t f i 2 0 114 "114 1009" "{114,1009}" "{i,v}" "{from_json,path_elems}" _null_ json_extract_path _null_ _null_ _null_ ));
+DATA(insert OID = 3951 ( json_extract_path PGNSP PGUID 12 1 0 25 0 f f f f t f i 2 0 114 "114 1009" "{114,1009}" "{i,v}" "{from_json,path_elems}" _null_ json_extract_path _null_ _null_ _null_ ));
DESCR("get value from json with path elements");
-DATA(insert OID = 3952 ( json_extract_path_op PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 1009" _null_ _null_ "{from_json,path_elems}" _null_ json_extract_path _null_ _null_ _null_ ));
+DATA(insert OID = 3952 ( json_extract_path_op PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 114 "114 1009" _null_ _null_ "{from_json,path_elems}" _null_ json_extract_path _null_ _null_ _null_ ));
DESCR("get value from json with path elements");
DATA(insert OID = 3953 ( json_extract_path_text PGNSP PGUID 12 1 0 25 0 f f f f t f i 2 0 25 "114 1009" "{114,1009}" "{i,v}" "{from_json,path_elems}" _null_ json_extract_path_text _null_ _null_ _null_ ));
DESCR("get value from json as text with path elements");
-DATA(insert OID = 3954 ( json_extract_path_text_op PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 1009" _null_ _null_ "{from_json,path_elems}" _null_ json_extract_path_text _null_ _null_ _null_ ));
+DATA(insert OID = 3954 ( json_extract_path_text_op PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 25 "114 1009" _null_ _null_ "{from_json,path_elems}" _null_ json_extract_path_text _null_ _null_ _null_ ));
DESCR("get value from json as text with path elements");
-DATA(insert OID = 3955 ( json_array_elements PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 114 "114" "{114,114}" "{i,o}" "{from_json,value}" _null_ json_array_elements _null_ _null_ _null_ ));
+DATA(insert OID = 3955 ( json_array_elements PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 114 "114" "{114,114}" "{i,o}" "{from_json,value}" _null_ json_array_elements _null_ _null_ _null_ ));
DESCR("key value pairs of a json object");
-DATA(insert OID = 3956 ( json_array_length PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 23 "114" _null_ _null_ _null_ _null_ json_array_length _null_ _null_ _null_ ));
+DATA(insert OID = 3956 ( json_array_length PGNSP PGUID 12 1 0 0 0 f f f f t f i 1 0 23 "114" _null_ _null_ _null_ _null_ json_array_length _null_ _null_ _null_ ));
DESCR("length of json array");
-DATA(insert OID = 3957 ( json_object_keys PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 25 "114" _null_ _null_ _null_ _null_ json_object_keys _null_ _null_ _null_ ));
+DATA(insert OID = 3957 ( json_object_keys PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 25 "114" _null_ _null_ _null_ _null_ json_object_keys _null_ _null_ _null_ ));
DESCR("get json object keys");
-DATA(insert OID = 3958 ( json_each PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 2249 "114" "{114,25,114}" "{i,o,o}" "{from_json,key,value}" _null_ json_each _null_ _null_ _null_ ));
+DATA(insert OID = 3958 ( json_each PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 2249 "114" "{114,25,114}" "{i,o,o}" "{from_json,key,value}" _null_ json_each _null_ _null_ _null_ ));
DESCR("key value pairs of a json object");
-DATA(insert OID = 3959 ( json_each_text PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 2249 "114" "{114,25,25}" "{i,o,o}" "{from_json,key,value}" _null_ json_each_text _null_ _null_ _null_ ));
+DATA(insert OID = 3959 ( json_each_text PGNSP PGUID 12 1 100 0 0 f f f f t t i 1 0 2249 "114" "{114,25,25}" "{i,o,o}" "{from_json,key,value}" _null_ json_each_text _null_ _null_ _null_ ));
DESCR("key value pairs of a json object");
-DATA(insert OID = 3960 ( json_populate_record PGNSP PGUID 12 1 0 0 0 f f f f f f s 3 0 2283 "2283 114 16" _null_ _null_ _null_ _null_ json_populate_record _null_ _null_ _null_ ));
+DATA(insert OID = 3960 ( json_populate_record PGNSP PGUID 12 1 0 0 0 f f f f f f s 3 0 2283 "2283 114 16" _null_ _null_ _null_ _null_ json_populate_record _null_ _null_ _null_ ));
DESCR("get record fields from a json object");
DATA(insert OID = 3961 ( json_populate_recordset PGNSP PGUID 12 1 100 0 0 f f f f f t s 3 0 2283 "2283 114 16" _null_ _null_ _null_ _null_ json_populate_recordset _null_ _null_ _null_ ));
DESCR("get set of records with fields from a json array of objects");
DATA(insert OID = 4031 ( spg_text_leaf_consistent PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 16 "2281 2281" _null_ _null_ _null_ _null_ spg_text_leaf_consistent _null_ _null_ _null_ ));
DESCR("SP-GiST support for radix tree over text");
-DATA(insert OID = 3469 ( spg_range_quad_config PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ spg_range_quad_config _null_ _null_ _null_ ));
+DATA(insert OID = 3469 ( spg_range_quad_config PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ spg_range_quad_config _null_ _null_ _null_ ));
DESCR("SP-GiST support for quad tree over range");
-DATA(insert OID = 3470 ( spg_range_quad_choose PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ spg_range_quad_choose _null_ _null_ _null_ ));
+DATA(insert OID = 3470 ( spg_range_quad_choose PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ spg_range_quad_choose _null_ _null_ _null_ ));
DESCR("SP-GiST support for quad tree over range");
DATA(insert OID = 3471 ( spg_range_quad_picksplit PGNSP PGUID 12 1 0 0 0 f f f f t f i 2 0 2278 "2281 2281" _null_ _null_ _null_ _null_ spg_range_quad_picksplit _null_ _null_ _null_ ));
DESCR("SP-GiST support for quad tree over range");
* Unlike a regular scalar histogram, this is actually two histograms combined
* into a single array, with the lower bounds of each value forming a
* histogram of lower bounds, and the upper bounds a histogram of upper
- * bounds. Only non-NULL, non-empty ranges are included.
+ * bounds. Only non-NULL, non-empty ranges are included.
*/
#define STATISTIC_KIND_BOUNDS_HISTOGRAM 7
#include "nodes/parsenodes.h"
#include "utils/relcache.h"
-extern Oid ExecRenameStmt(RenameStmt *stmt);
+extern Oid ExecRenameStmt(RenameStmt *stmt);
-extern Oid ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt);
+extern Oid ExecAlterObjectSchemaStmt(AlterObjectSchemaStmt *stmt);
extern Oid AlterObjectNamespace_oid(Oid classId, Oid objid, Oid nspOid,
ObjectAddresses *objsMoved);
-extern Oid ExecAlterOwnerStmt(AlterOwnerStmt *stmt);
+extern Oid ExecAlterOwnerStmt(AlterOwnerStmt *stmt);
extern void AlterObjectOwner_internal(Relation catalog, Oid objectId,
Oid new_ownerId);
#include "nodes/parsenodes.h"
-extern Oid DefineCollation(List *names, List *parameters);
+extern Oid DefineCollation(List *names, List *parameters);
extern void IsThereCollationInNamespace(const char *collname, Oid nspOid);
#endif /* COLLATIONCMDS_H */
*------------------------------------------------------------------
*/
-extern Oid CommentObject(CommentStmt *stmt);
+extern Oid CommentObject(CommentStmt *stmt);
extern void DeleteComments(Oid oid, Oid classoid, int32 subid);
#include "nodes/parsenodes.h"
-extern Oid CreateConversionCommand(CreateConversionStmt *parsetree);
+extern Oid CreateConversionCommand(CreateConversionStmt *parsetree);
#endif /* CONVERSIONCMDS_H */
typedef struct CopyStateData *CopyState;
extern Oid DoCopy(const CopyStmt *stmt, const char *queryString,
- uint64 *processed);
+ uint64 *processed);
extern void ProcessCopyOptions(CopyState cstate, bool is_from, List *options);
extern CopyState BeginCopyFrom(Relation rel, const char *filename,
Oid tablespace_id;
} xl_dbase_drop_rec;
-extern Oid createdb(const CreatedbStmt *stmt);
+extern Oid createdb(const CreatedbStmt *stmt);
extern void dropdb(const char *dbname, bool missing_ok);
-extern Oid RenameDatabase(const char *oldname, const char *newname);
-extern Oid AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel);
-extern Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
-extern Oid AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
+extern Oid RenameDatabase(const char *oldname, const char *newname);
+extern Oid AlterDatabase(AlterDatabaseStmt *stmt, bool isTopLevel);
+extern Oid AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
+extern Oid AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
extern Oid get_database_oid(const char *dbname, bool missingok);
extern char *get_database_name(Oid dbid);
bool check_rights,
bool skip_build,
bool quiet);
-extern Oid ReindexIndex(RangeVar *indexRelation);
-extern Oid ReindexTable(RangeVar *relation);
+extern Oid ReindexIndex(RangeVar *indexRelation);
+extern Oid ReindexTable(RangeVar *relation);
extern Oid ReindexDatabase(const char *databaseName,
bool do_system, bool do_user);
extern char *makeObjectName(const char *name1, const char *name2,
extern Oid GetDefaultOpClass(Oid type_id, Oid am_id);
/* commands/functioncmds.c */
-extern Oid CreateFunction(CreateFunctionStmt *stmt, const char *queryString);
+extern Oid CreateFunction(CreateFunctionStmt *stmt, const char *queryString);
extern void RemoveFunctionById(Oid funcOid);
extern void SetFunctionReturnType(Oid funcOid, Oid newRetType);
extern void SetFunctionArgType(Oid funcOid, int argIndex, Oid newArgType);
-extern Oid AlterFunction(AlterFunctionStmt *stmt);
-extern Oid CreateCast(CreateCastStmt *stmt);
+extern Oid AlterFunction(AlterFunctionStmt *stmt);
+extern Oid CreateCast(CreateCastStmt *stmt);
extern void DropCastById(Oid castOid);
extern void IsThereFunctionInNamespace(const char *proname, int pronargs,
oidvector proargtypes, Oid nspOid);
extern Oid get_cast_oid(Oid sourcetypeid, Oid targettypeid, bool missing_ok);
/* commands/operatorcmds.c */
-extern Oid DefineOperator(List *names, List *parameters);
+extern Oid DefineOperator(List *names, List *parameters);
extern void RemoveOperatorById(Oid operOid);
/* commands/aggregatecmds.c */
List *parameters);
/* commands/opclasscmds.c */
-extern Oid DefineOpClass(CreateOpClassStmt *stmt);
-extern Oid DefineOpFamily(CreateOpFamilyStmt *stmt);
-extern Oid AlterOpFamily(AlterOpFamilyStmt *stmt);
+extern Oid DefineOpClass(CreateOpClassStmt *stmt);
+extern Oid DefineOpFamily(CreateOpFamilyStmt *stmt);
+extern Oid AlterOpFamily(AlterOpFamilyStmt *stmt);
extern void RemoveOpClassById(Oid opclassOid);
extern void RemoveOpFamilyById(Oid opfamilyOid);
extern void RemoveAmOpEntryById(Oid entryOid);
extern void RemoveAmProcEntryById(Oid entryOid);
extern void IsThereOpClassInNamespace(const char *opcname, Oid opcmethod,
- Oid opcnamespace);
+ Oid opcnamespace);
extern void IsThereOpFamilyInNamespace(const char *opfname, Oid opfmethod,
- Oid opfnamespace);
+ Oid opfnamespace);
extern Oid get_am_oid(const char *amname, bool missing_ok);
extern Oid get_opclass_oid(Oid amID, List *opclassname, bool missing_ok);
extern Oid get_opfamily_oid(Oid amID, List *opfamilyname, bool missing_ok);
/* commands/tsearchcmds.c */
-extern Oid DefineTSParser(List *names, List *parameters);
+extern Oid DefineTSParser(List *names, List *parameters);
extern void RemoveTSParserById(Oid prsId);
-extern Oid DefineTSDictionary(List *names, List *parameters);
+extern Oid DefineTSDictionary(List *names, List *parameters);
extern void RemoveTSDictionaryById(Oid dictId);
-extern Oid AlterTSDictionary(AlterTSDictionaryStmt *stmt);
+extern Oid AlterTSDictionary(AlterTSDictionaryStmt *stmt);
-extern Oid DefineTSTemplate(List *names, List *parameters);
+extern Oid DefineTSTemplate(List *names, List *parameters);
extern void RemoveTSTemplateById(Oid tmplId);
-extern Oid DefineTSConfiguration(List *names, List *parameters);
+extern Oid DefineTSConfiguration(List *names, List *parameters);
extern void RemoveTSConfigurationById(Oid cfgId);
-extern Oid AlterTSConfiguration(AlterTSConfigurationStmt *stmt);
+extern Oid AlterTSConfiguration(AlterTSConfigurationStmt *stmt);
extern text *serialize_deflist(List *deflist);
extern List *deserialize_deflist(Datum txt);
/* commands/foreigncmds.c */
-extern Oid AlterForeignServerOwner(const char *name, Oid newOwnerId);
+extern Oid AlterForeignServerOwner(const char *name, Oid newOwnerId);
extern void AlterForeignServerOwner_oid(Oid, Oid newOwnerId);
-extern Oid AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId);
+extern Oid AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId);
extern void AlterForeignDataWrapperOwner_oid(Oid fwdId, Oid newOwnerId);
-extern Oid CreateForeignDataWrapper(CreateFdwStmt *stmt);
-extern Oid AlterForeignDataWrapper(AlterFdwStmt *stmt);
+extern Oid CreateForeignDataWrapper(CreateFdwStmt *stmt);
+extern Oid AlterForeignDataWrapper(AlterFdwStmt *stmt);
extern void RemoveForeignDataWrapperById(Oid fdwId);
-extern Oid CreateForeignServer(CreateForeignServerStmt *stmt);
-extern Oid AlterForeignServer(AlterForeignServerStmt *stmt);
+extern Oid CreateForeignServer(CreateForeignServerStmt *stmt);
+extern Oid AlterForeignServer(AlterForeignServerStmt *stmt);
extern void RemoveForeignServerById(Oid srvId);
-extern Oid CreateUserMapping(CreateUserMappingStmt *stmt);
-extern Oid AlterUserMapping(AlterUserMappingStmt *stmt);
-extern Oid RemoveUserMapping(DropUserMappingStmt *stmt);
+extern Oid CreateUserMapping(CreateUserMappingStmt *stmt);
+extern Oid AlterUserMapping(AlterUserMappingStmt *stmt);
+extern Oid RemoveUserMapping(DropUserMappingStmt *stmt);
extern void RemoveUserMappingById(Oid umId);
extern void CreateForeignTable(CreateForeignTableStmt *stmt, Oid relid);
extern Datum transformGenericOptions(Oid catalogId,
typedef struct EventTriggerData
{
NodeTag type;
- const char *event; /* event name */
- Node *parsetree; /* parse tree */
- const char *tag; /* command tag */
+ const char *event; /* event name */
+ Node *parsetree; /* parse tree */
+ const char *tag; /* command tag */
} EventTriggerData;
/*
#define CALLED_AS_EVENT_TRIGGER(fcinfo) \
((fcinfo)->context != NULL && IsA((fcinfo)->context, EventTriggerData))
-extern Oid CreateEventTrigger(CreateEventTrigStmt *stmt);
+extern Oid CreateEventTrigger(CreateEventTrigStmt *stmt);
extern void RemoveEventTriggerById(Oid ctrigOid);
extern Oid get_event_trigger_oid(const char *trigname, bool missing_ok);
-extern Oid AlterEventTrigger(AlterEventTrigStmt *stmt);
-extern Oid AlterEventTriggerOwner(const char *name, Oid newOwnerId);
+extern Oid AlterEventTrigger(AlterEventTrigStmt *stmt);
+extern Oid AlterEventTriggerOwner(const char *name, Oid newOwnerId);
extern void AlterEventTriggerOwner_oid(Oid, Oid newOwnerId);
extern bool EventTriggerSupportsObjectType(ObjectType obtype);
extern Oid CurrentExtensionObject;
-extern Oid CreateExtension(CreateExtensionStmt *stmt);
+extern Oid CreateExtension(CreateExtensionStmt *stmt);
extern void RemoveExtensionById(Oid extId);
Datum extConfig, Datum extCondition,
List *requiredExtensions);
-extern Oid ExecAlterExtensionStmt(AlterExtensionStmt *stmt);
+extern Oid ExecAlterExtensionStmt(AlterExtensionStmt *stmt);
-extern Oid ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt);
+extern Oid ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt);
extern Oid get_extension_oid(const char *extname, bool missing_ok);
extern char *get_extension_name(Oid ext_oid);
-extern Oid AlterExtensionNamespace(List *names, const char *newschema);
+extern Oid AlterExtensionNamespace(List *names, const char *newschema);
extern void AlterExtensionOwner_oid(Oid extensionOid, Oid newOwnerId);
extern void SetMatViewPopulatedState(Relation relation, bool newstate);
extern void ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
- ParamListInfo params, char *completionTag);
+ ParamListInfo params, char *completionTag);
extern DestReceiver *CreateTransientRelDestReceiver(Oid oid);
#include "nodes/parsenodes.h"
-extern Oid CreateProceduralLanguage(CreatePLangStmt *stmt);
+extern Oid CreateProceduralLanguage(CreatePLangStmt *stmt);
extern void DropProceduralLanguageById(Oid langOid);
extern bool PLTemplateExists(const char *languageName);
extern Oid get_language_oid(const char *langname, bool missing_ok);
extern void RemoveSchemaById(Oid schemaOid);
-extern Oid RenameSchema(const char *oldname, const char *newname);
-extern Oid AlterSchemaOwner(const char *name, Oid newOwnerId);
+extern Oid RenameSchema(const char *oldname, const char *newname);
+extern Oid AlterSchemaOwner(const char *name, Oid newOwnerId);
extern void AlterSchemaOwner_oid(Oid schemaOid, Oid newOwnerId);
#endif /* SCHEMACMDS_H */
/*
* Statement and ESP hook support
*/
-extern Oid ExecSecLabelStmt(SecLabelStmt *stmt);
+extern Oid ExecSecLabelStmt(SecLabelStmt *stmt);
typedef void (*check_object_relabel_type) (const ObjectAddress *object,
const char *seclabel);
extern Datum pg_sequence_parameters(PG_FUNCTION_ARGS);
-extern Oid DefineSequence(CreateSeqStmt *stmt);
-extern Oid AlterSequence(AlterSeqStmt *stmt);
+extern Oid DefineSequence(CreateSeqStmt *stmt);
+extern Oid AlterSequence(AlterSeqStmt *stmt);
extern void ResetSequence(Oid seq_relid);
extern void seq_redo(XLogRecPtr lsn, XLogRecord *rptr);
extern void AlterTableInternal(Oid relid, List *cmds, bool recurse);
-extern Oid AlterTableNamespace(AlterObjectSchemaStmt *stmt);
+extern Oid AlterTableNamespace(AlterObjectSchemaStmt *stmt);
extern void AlterTableNamespaceInternal(Relation rel, Oid oldNspOid,
Oid nspOid, ObjectAddresses *objsMoved);
extern void SetRelationHasSubclass(Oid relationId, bool relhassubclass);
-extern Oid renameatt(RenameStmt *stmt);
+extern Oid renameatt(RenameStmt *stmt);
-extern Oid RenameConstraint(RenameStmt *stmt);
+extern Oid RenameConstraint(RenameStmt *stmt);
-extern Oid RenameRelation(RenameStmt *stmt);
+extern Oid RenameRelation(RenameStmt *stmt);
extern void RenameRelationInternal(Oid myrelid,
const char *newrelname, bool is_internal);
float8 seq_page_cost;
} TableSpaceOpts;
-extern Oid CreateTableSpace(CreateTableSpaceStmt *stmt);
+extern Oid CreateTableSpace(CreateTableSpaceStmt *stmt);
extern void DropTableSpace(DropTableSpaceStmt *stmt);
-extern Oid RenameTableSpace(const char *oldname, const char *newname);
-extern Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt);
+extern Oid RenameTableSpace(const char *oldname, const char *newname);
+extern Oid AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt);
extern void TablespaceCreateDbspace(Oid spcNode, Oid dbNode, bool isRedo);
extern void RemoveTriggerById(Oid trigOid);
extern Oid get_trigger_oid(Oid relid, const char *name, bool missing_ok);
-extern Oid renametrig(RenameStmt *stmt);
+extern Oid renametrig(RenameStmt *stmt);
extern void EnableDisableTrigger(Relation rel, const char *tgname,
char fires_when, bool skip_system);
#define DEFAULT_TYPDELIM ','
-extern Oid DefineType(List *names, List *parameters);
+extern Oid DefineType(List *names, List *parameters);
extern void RemoveTypeById(Oid typeOid);
-extern Oid DefineDomain(CreateDomainStmt *stmt);
-extern Oid DefineEnum(CreateEnumStmt *stmt);
-extern Oid DefineRange(CreateRangeStmt *stmt);
-extern Oid AlterEnum(AlterEnumStmt *stmt, bool isTopLevel);
+extern Oid DefineDomain(CreateDomainStmt *stmt);
+extern Oid DefineEnum(CreateEnumStmt *stmt);
+extern Oid DefineRange(CreateRangeStmt *stmt);
+extern Oid AlterEnum(AlterEnumStmt *stmt, bool isTopLevel);
extern Oid DefineCompositeType(RangeVar *typevar, List *coldeflist);
extern Oid AssignTypeArrayOid(void);
-extern Oid AlterDomainDefault(List *names, Node *defaultRaw);
-extern Oid AlterDomainNotNull(List *names, bool notNull);
-extern Oid AlterDomainAddConstraint(List *names, Node *constr);
-extern Oid AlterDomainValidateConstraint(List *names, char *constrName);
+extern Oid AlterDomainDefault(List *names, Node *defaultRaw);
+extern Oid AlterDomainNotNull(List *names, bool notNull);
+extern Oid AlterDomainAddConstraint(List *names, Node *constr);
+extern Oid AlterDomainValidateConstraint(List *names, char *constrName);
extern Oid AlterDomainDropConstraint(List *names, const char *constrName,
DropBehavior behavior, bool missing_ok);
extern List *GetDomainConstraints(Oid typeOid);
-extern Oid RenameType(RenameStmt *stmt);
-extern Oid AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype);
+extern Oid RenameType(RenameStmt *stmt);
+extern Oid AlterTypeOwner(List *names, Oid newOwnerId, ObjectType objecttype);
extern void AlterTypeOwnerInternal(Oid typeOid, Oid newOwnerId,
bool hasDependEntry);
-extern Oid AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype);
+extern Oid AlterTypeNamespace(List *names, const char *newschema, ObjectType objecttype);
extern Oid AlterTypeNamespace_oid(Oid typeOid, Oid nspOid, ObjectAddresses *objsMoved);
-extern Oid AlterTypeNamespaceInternal(Oid typeOid, Oid nspOid,
+extern Oid AlterTypeNamespaceInternal(Oid typeOid, Oid nspOid,
bool isImplicitArray,
bool errorOnTableType,
ObjectAddresses *objsMoved);
extern PGDLLIMPORT check_password_hook_type check_password_hook;
-extern Oid CreateRole(CreateRoleStmt *stmt);
-extern Oid AlterRole(AlterRoleStmt *stmt);
-extern Oid AlterRoleSet(AlterRoleSetStmt *stmt);
+extern Oid CreateRole(CreateRoleStmt *stmt);
+extern Oid AlterRole(AlterRoleStmt *stmt);
+extern Oid AlterRoleSet(AlterRoleSetStmt *stmt);
extern void DropRole(DropRoleStmt *stmt);
extern void GrantRole(GrantRoleStmt *stmt);
-extern Oid RenameRole(const char *oldname, const char *newname);
+extern Oid RenameRole(const char *oldname, const char *newname);
extern void DropOwnedObjects(DropOwnedStmt *stmt);
extern void ReassignOwnedObjects(ReassignOwnedStmt *stmt);
#include "nodes/parsenodes.h"
-extern Oid DefineView(ViewStmt *stmt, const char *queryString);
+extern Oid DefineView(ViewStmt *stmt, const char *queryString);
extern void StoreViewQuery(Oid viewOid, Query *viewParse, bool replace);
extern void *pg_malloc(size_t size);
extern void *pg_malloc0(size_t size);
extern void *pg_realloc(void *pointer, size_t size);
-extern void pg_free(void *pointer);
+extern void pg_free(void *pointer);
#include "utils/palloc.h"
/*-------------------------------------------------------------------------
*
* relpath.h
- * Declarations for relpath() and friends
+ * Declarations for relpath() and friends
*
* Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
#define relpathperm(rnode, forknum) \
relpathbackend((rnode), InvalidBackendId, (forknum))
-#endif /* RELPATH_H */
+#endif /* RELPATH_H */
binaryheap_comparator bh_compare;
void *bh_arg;
Datum bh_nodes[FLEXIBLE_ARRAY_MEMBER];
-} binaryheap;
+} binaryheap;
extern binaryheap *binaryheap_allocate(int capacity,
- binaryheap_comparator compare,
- void *arg);
+ binaryheap_comparator compare,
+ void *arg);
extern void binaryheap_free(binaryheap *heap);
extern void binaryheap_add_unordered(binaryheap *heap, Datum d);
extern void binaryheap_build(binaryheap *heap);
typedef struct IdentLine
{
- int linenumber;
+ int linenumber;
char *usermap;
char *ident_user;
char *pg_role;
- regex_t re;
+ regex_t re;
} IdentLine;
/* kluge to avoid including libpq/libpq-be.h here */
/*
* prototypes for functions in pqcomm.c
*/
-extern int StreamServerPort(int family, char *hostName,
+extern int StreamServerPort(int family, char *hostName,
unsigned short portNumber, char *unixSocketDir,
pgsocket ListenSocket[], int MaxListen);
extern int StreamConnection(pgsocket server_fd, Port *port);
/*
* The maximum workable length of a socket path is what will fit into
- * struct sockaddr_un. This is usually only 100 or so bytes :-(.
+ * struct sockaddr_un. This is usually only 100 or so bytes :-(.
*
* For consistency, always pass a MAXPGPATH-sized buffer to UNIXSOCK_PATH(),
* then complain if the resulting string is >= UNIXSOCK_PATH_BUFLEN bytes.
* MULE Internal Encoding (MIC)
*
* This encoding follows the design used within XEmacs; it is meant to
- * subsume many externally-defined character sets. Each character includes
+ * subsume many externally-defined character sets. Each character includes
* identification of the character set it belongs to, so the encoding is
* general but somewhat bulky.
*
* Currently PostgreSQL supports 5 types of MULE character sets:
*
- * 1) 1-byte ASCII characters. Each byte is below 0x80.
+ * 1) 1-byte ASCII characters. Each byte is below 0x80.
*
* 2) "Official" single byte charsets such as ISO-8859-1 (Latin1).
- * Each MULE character consists of 2 bytes: LC1 + C1, where LC1 is
- * an identifier for the charset (in the range 0x81 to 0x8d) and C1
- * is the character code (in the range 0xa0 to 0xff).
+ * Each MULE character consists of 2 bytes: LC1 + C1, where LC1 is
+ * an identifier for the charset (in the range 0x81 to 0x8d) and C1
+ * is the character code (in the range 0xa0 to 0xff).
*
* 3) "Private" single byte charsets such as SISHENG. Each MULE
- * character consists of 3 bytes: LCPRV1 + LC12 + C1, where LCPRV1
- * is a private-charset flag, LC12 is an identifier for the charset,
- * and C1 is the character code (in the range 0xa0 to 0xff).
- * LCPRV1 is either 0x9a (if LC12 is in the range 0xa0 to 0xdf)
- * or 0x9b (if LC12 is in the range 0xe0 to 0xef).
+ * character consists of 3 bytes: LCPRV1 + LC12 + C1, where LCPRV1
+ * is a private-charset flag, LC12 is an identifier for the charset,
+ * and C1 is the character code (in the range 0xa0 to 0xff).
+ * LCPRV1 is either 0x9a (if LC12 is in the range 0xa0 to 0xdf)
+ * or 0x9b (if LC12 is in the range 0xe0 to 0xef).
*
- * 4) "Official" multibyte charsets such as JIS X0208. Each MULE
- * character consists of 3 bytes: LC2 + C1 + C2, where LC2 is
- * an identifier for the charset (in the range 0x90 to 0x99) and C1
- * and C2 form the character code (each in the range 0xa0 to 0xff).
+ * 4) "Official" multibyte charsets such as JIS X0208. Each MULE
+ * character consists of 3 bytes: LC2 + C1 + C2, where LC2 is
+ * an identifier for the charset (in the range 0x90 to 0x99) and C1
+ * and C2 form the character code (each in the range 0xa0 to 0xff).
*
* 5) "Private" multibyte charsets such as CNS 11643-1992 Plane 3.
- * Each MULE character consists of 4 bytes: LCPRV2 + LC22 + C1 + C2,
- * where LCPRV2 is a private-charset flag, LC22 is an identifier for
- * the charset, and C1 and C2 form the character code (each in the range
- * 0xa0 to 0xff). LCPRV2 is either 0x9c (if LC22 is in the range 0xf0
- * to 0xf4) or 0x9d (if LC22 is in the range 0xf5 to 0xfe).
+ * Each MULE character consists of 4 bytes: LCPRV2 + LC22 + C1 + C2,
+ * where LCPRV2 is a private-charset flag, LC22 is an identifier for
+ * the charset, and C1 and C2 form the character code (each in the range
+ * 0xa0 to 0xff). LCPRV2 is either 0x9c (if LC22 is in the range 0xf0
+ * to 0xf4) or 0x9d (if LC22 is in the range 0xf5 to 0xfe).
*
* "Official" encodings are those that have been assigned code numbers by
* the XEmacs project; "private" encodings have Postgres-specific charset
#define LC_JISX0212 0x94 /* Japanese Kanji (JIS X 0212) */
#define LC_CNS11643_1 0x95 /* CNS 11643-1992 Plane 1 */
#define LC_CNS11643_2 0x96 /* CNS 11643-1992 Plane 2 */
-#define LC_JISX0213_1 0x97 /* Japanese Kanji (JIS X 0213 Plane 1) (not supported) */
+#define LC_JISX0213_1 0x97/* Japanese Kanji (JIS X 0213 Plane 1) (not
+ * supported) */
#define LC_BIG5_1 0x98 /* Plane 1 Chinese traditional (not supported) */
#define LC_BIG5_2 0x99 /* Plane 1 Chinese traditional (not supported) */
/*
* Charset IDs for private single byte encodings (0xa0-0xef)
*/
-#define LC_SISHENG 0xa0 /* Chinese SiSheng characters for
- * PinYin/ZhuYin (not supported) */
-#define LC_IPA 0xa1 /* IPA (International Phonetic Association)
- * (not supported) */
-#define LC_VISCII_LOWER 0xa2 /* Vietnamese VISCII1.1 lower-case (not
- * supported) */
-#define LC_VISCII_UPPER 0xa3 /* Vietnamese VISCII1.1 upper-case (not
- * supported) */
+#define LC_SISHENG 0xa0/* Chinese SiSheng characters for
+ * PinYin/ZhuYin (not supported) */
+#define LC_IPA 0xa1/* IPA (International Phonetic Association)
+ * (not supported) */
+#define LC_VISCII_LOWER 0xa2/* Vietnamese VISCII1.1 lower-case (not
+ * supported) */
+#define LC_VISCII_UPPER 0xa3/* Vietnamese VISCII1.1 upper-case (not
+ * supported) */
#define LC_ARABIC_DIGIT 0xa4 /* Arabic digit (not supported) */
#define LC_ARABIC_1_COLUMN 0xa5 /* Arabic 1-column (not supported) */
#define LC_ASCII_RIGHT_TO_LEFT 0xa6 /* ASCII (left half of ISO8859-1) with
* right-to-left direction (not
* supported) */
-#define LC_LAO 0xa7 /* Lao characters (ISO10646 0E80..0EDF)
- * (not supported) */
+#define LC_LAO 0xa7/* Lao characters (ISO10646 0E80..0EDF) (not
+ * supported) */
#define LC_ARABIC_2_COLUMN 0xa8 /* Arabic 1-column (not supported) */
/*
* Charset IDs for private multibyte encodings (0xf0-0xff)
*/
-#define LC_INDIAN_1_COLUMN 0xf0 /* Indian charset for 1-column width glyphs
- * (not supported) */
-#define LC_TIBETAN_1_COLUMN 0xf1 /* Tibetan 1-column width glyphs
- * (not supported) */
-#define LC_UNICODE_SUBSET_2 0xf2 /* Unicode characters of the range U+2500..U+33FF.
- * (not supported) */
-#define LC_UNICODE_SUBSET_3 0xf3 /* Unicode characters of the range U+E000..U+FFFF.
- * (not supported) */
-#define LC_UNICODE_SUBSET 0xf4 /* Unicode characters of the range U+0100..U+24FF.
- * (not supported) */
+#define LC_INDIAN_1_COLUMN 0xf0/* Indian charset for 1-column width glyphs
+ * (not supported) */
+#define LC_TIBETAN_1_COLUMN 0xf1/* Tibetan 1-column width glyphs (not
+ * supported) */
+#define LC_UNICODE_SUBSET_2 0xf2/* Unicode characters of the range
+ * U+2500..U+33FF. (not supported) */
+#define LC_UNICODE_SUBSET_3 0xf3/* Unicode characters of the range
+ * U+E000..U+FFFF. (not supported) */
+#define LC_UNICODE_SUBSET 0xf4/* Unicode characters of the range
+ * U+0100..U+24FF. (not supported) */
#define LC_ETHIOPIC 0xf5 /* Ethiopic characters (not supported) */
#define LC_CNS11643_3 0xf6 /* CNS 11643-1992 Plane 3 */
#define LC_CNS11643_4 0xf7 /* CNS 11643-1992 Plane 4 */
#define LC_CNS11643_5 0xf8 /* CNS 11643-1992 Plane 5 */
#define LC_CNS11643_6 0xf9 /* CNS 11643-1992 Plane 6 */
#define LC_CNS11643_7 0xfa /* CNS 11643-1992 Plane 7 */
-#define LC_INDIAN_2_COLUMN 0xfb /* Indian charset for 2-column width glyphs
- * (not supported) */
+#define LC_INDIAN_2_COLUMN 0xfb/* Indian charset for 2-column width glyphs
+ * (not supported) */
#define LC_TIBETAN 0xfc /* Tibetan (not supported) */
/* #define FREE 0xfd free (unused) */
/* #define FREE 0xfe free (unused) */
* pg_wchar stuff
*/
typedef int (*mb2wchar_with_len_converter) (const unsigned char *from,
- pg_wchar *to,
- int len);
+ pg_wchar *to,
+ int len);
typedef int (*wchar2mb_with_len_converter) (const pg_wchar *from,
unsigned char *to,
typedef struct
{
- mb2wchar_with_len_converter mb2wchar_with_len; /* convert a multibyte
- * string to a wchar */
- wchar2mb_with_len_converter wchar2mb_with_len; /* convert a wchar
- * string to a multibyte */
+ mb2wchar_with_len_converter mb2wchar_with_len; /* convert a multibyte
+ * string to a wchar */
+ wchar2mb_with_len_converter wchar2mb_with_len; /* convert a wchar
+ * string to a multibyte */
mblen_converter mblen; /* get byte length of a char */
mbdisplaylen_converter dsplen; /* get display width of a char */
mbverifier mbverify; /* verify multibyte sequence */
extern void report_invalid_encoding(int encoding, const char *mbstr, int len) __attribute__((noreturn));
extern void report_untranslatable_char(int src_encoding, int dest_encoding,
- const char *mbstr, int len) __attribute__((noreturn));
+ const char *mbstr, int len) __attribute__((noreturn));
extern void pg_ascii2mic(const unsigned char *l, unsigned char *p, int len);
extern void pg_mic2ascii(const unsigned char *mic, unsigned char *p, int len);
extern ProcessingMode Mode;
-#define IsBootstrapProcessingMode() (Mode == BootstrapProcessing)
+#define IsBootstrapProcessingMode() (Mode == BootstrapProcessing)
#define IsInitProcessingMode() (Mode == InitProcessing)
#define IsNormalProcessingMode() (Mode == NormalProcessing)
/*
- * Auxiliary-process type identifiers. These used to be in bootstrap.h
+ * Auxiliary-process type identifiers. These used to be in bootstrap.h
* but it seems saner to have them here, with the ProcessingMode stuff.
* The MyAuxProcType global is defined and set in bootstrap.c.
*/
#define AmBootstrapProcess() (MyAuxProcType == BootstrapProcess)
#define AmStartupProcess() (MyAuxProcType == StartupProcess)
-#define AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess)
+#define AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess)
#define AmCheckpointerProcess() (MyAuxProcType == CheckpointerProcess)
#define AmWalWriterProcess() (MyAuxProcType == WalWriterProcess)
#define AmWalReceiverProcess() (MyAuxProcType == WalReceiverProcess)
/*
* LockingClause - raw representation of FOR [NO KEY] UPDATE/[KEY] SHARE
- * options
+ * options
*
* Note: lockedRels == NIL means "all relations in query". Otherwise it
* is a list of RangeVar nodes. (We use RangeVar mainly because it carries
typedef enum ConstrType /* types of constraints */
{
- CONSTR_NULL, /* not standard SQL, but a lot of people expect it */
+ CONSTR_NULL, /* not standard SQL, but a lot of people
+ * expect it */
CONSTR_NOTNULL,
CONSTR_DEFAULT,
CONSTR_CHECK,
* NB: equal() ignores CoercionForm fields, therefore this *must* not carry
* any semantically significant information. We need that behavior so that
* the planner will consider equivalent implicit and explicit casts to be
- * equivalent. In cases where those actually behave differently, the coercion
+ * equivalent. In cases where those actually behave differently, the coercion
* function's arguments will be different.
*/
typedef enum CoercionForm
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 *lateral_info_list; /* list of LateralJoinInfos */
+ List *lateral_info_list; /* list of LateralJoinInfos */
List *append_rel_list; /* list of AppendRelInfos */
bool hasInheritedTarget; /* true if parse->resultRelation is an
* inheritance child rel */
bool hasJoinRTEs; /* true if any RTEs are RTE_JOIN kind */
- bool hasLateralRTEs; /* true if any RTEs are marked LATERAL */
+ bool hasLateralRTEs; /* true if any RTEs are marked LATERAL */
bool hasHavingQual; /* true if havingQual was non-null */
bool hasPseudoConstantQuals; /* true if any RestrictInfo has
* pseudoconstant = true */
int width; /* estimated avg width of result tuples */
/* per-relation planner control flags */
- bool consider_startup; /* keep cheap-startup-cost paths? */
+ bool consider_startup; /* keep cheap-startup-cost paths? */
/* materialization information */
List *reltargetlist; /* Vars to be output by scan of relation */
Relids *attr_needed; /* array indexed [min_attr .. max_attr] */
int32 *attr_widths; /* array indexed [min_attr .. max_attr] */
List *lateral_vars; /* LATERAL Vars and PHVs referenced by rel */
- Relids lateral_relids; /* minimum parameterization of rel */
+ Relids lateral_relids; /* minimum parameterization of rel */
List *indexlist; /* list of IndexOptInfo */
BlockNumber pages; /* size estimates derived from pg_class */
double tuples;
/* use "struct Plan" to avoid including plannodes.h here */
struct Plan *subplan; /* if subquery */
PlannerInfo *subroot; /* if subquery */
- List *subplan_params; /* if subquery */
+ List *subplan_params; /* if subquery */
/* use "struct FdwRoutine" to avoid including fdwapi.h here */
struct FdwRoutine *fdwroutine; /* if foreign table */
void *fdw_private; /* if foreign table */
*
* A Var: the slot represents a variable of this level that must be passed
* down because subqueries have outer references to it, or must be passed
- * from a NestLoop node to its inner scan. The varlevelsup value in the Var
+ * from a NestLoop node to its inner scan. The varlevelsup value in the Var
* will always be zero.
*
* A PlaceHolderVar: this works much like the Var case, except that the
PlannerInfo **subroot);
extern void add_tlist_costs_to_plan(PlannerInfo *root, Plan *plan,
- List *tlist);
+ List *tlist);
extern bool is_dummy_plan(Plan *plan);
*/
typedef enum ParseExprKind
{
- EXPR_KIND_NONE = 0, /* "not in an expression" */
- EXPR_KIND_OTHER, /* reserved for extensions */
- EXPR_KIND_JOIN_ON, /* JOIN ON */
- EXPR_KIND_JOIN_USING, /* JOIN USING */
- EXPR_KIND_FROM_SUBSELECT, /* sub-SELECT in FROM clause */
- EXPR_KIND_FROM_FUNCTION, /* function in FROM clause */
- EXPR_KIND_WHERE, /* WHERE */
- EXPR_KIND_HAVING, /* HAVING */
- EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */
- EXPR_KIND_WINDOW_ORDER, /* window definition ORDER BY */
- EXPR_KIND_WINDOW_FRAME_RANGE, /* window frame clause with RANGE */
+ EXPR_KIND_NONE = 0, /* "not in an expression" */
+ EXPR_KIND_OTHER, /* reserved for extensions */
+ EXPR_KIND_JOIN_ON, /* JOIN ON */
+ EXPR_KIND_JOIN_USING, /* JOIN USING */
+ EXPR_KIND_FROM_SUBSELECT, /* sub-SELECT in FROM clause */
+ EXPR_KIND_FROM_FUNCTION, /* function in FROM clause */
+ EXPR_KIND_WHERE, /* WHERE */
+ EXPR_KIND_HAVING, /* HAVING */
+ EXPR_KIND_WINDOW_PARTITION, /* window definition PARTITION BY */
+ EXPR_KIND_WINDOW_ORDER, /* window definition ORDER BY */
+ EXPR_KIND_WINDOW_FRAME_RANGE, /* window frame clause with RANGE */
EXPR_KIND_WINDOW_FRAME_ROWS, /* window frame clause with ROWS */
- EXPR_KIND_SELECT_TARGET, /* SELECT target list item */
- EXPR_KIND_INSERT_TARGET, /* INSERT target list item */
- EXPR_KIND_UPDATE_SOURCE, /* UPDATE assignment source item */
- EXPR_KIND_UPDATE_TARGET, /* UPDATE assignment target item */
- EXPR_KIND_GROUP_BY, /* GROUP BY */
- EXPR_KIND_ORDER_BY, /* ORDER BY */
- EXPR_KIND_DISTINCT_ON, /* DISTINCT ON */
- EXPR_KIND_LIMIT, /* LIMIT */
- EXPR_KIND_OFFSET, /* OFFSET */
- EXPR_KIND_RETURNING, /* RETURNING */
- EXPR_KIND_VALUES, /* VALUES */
- EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */
- EXPR_KIND_DOMAIN_CHECK, /* CHECK constraint for a domain */
- EXPR_KIND_COLUMN_DEFAULT, /* default value for a table column */
- EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */
- EXPR_KIND_INDEX_EXPRESSION, /* index expression */
- EXPR_KIND_INDEX_PREDICATE, /* index predicate */
- EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */
+ EXPR_KIND_SELECT_TARGET, /* SELECT target list item */
+ EXPR_KIND_INSERT_TARGET, /* INSERT target list item */
+ EXPR_KIND_UPDATE_SOURCE, /* UPDATE assignment source item */
+ EXPR_KIND_UPDATE_TARGET, /* UPDATE assignment target item */
+ EXPR_KIND_GROUP_BY, /* GROUP BY */
+ EXPR_KIND_ORDER_BY, /* ORDER BY */
+ EXPR_KIND_DISTINCT_ON, /* DISTINCT ON */
+ EXPR_KIND_LIMIT, /* LIMIT */
+ EXPR_KIND_OFFSET, /* OFFSET */
+ EXPR_KIND_RETURNING, /* RETURNING */
+ EXPR_KIND_VALUES, /* VALUES */
+ EXPR_KIND_CHECK_CONSTRAINT, /* CHECK constraint for a table */
+ EXPR_KIND_DOMAIN_CHECK, /* CHECK constraint for a domain */
+ EXPR_KIND_COLUMN_DEFAULT, /* default value for a table column */
+ EXPR_KIND_FUNCTION_DEFAULT, /* default parameter value for function */
+ EXPR_KIND_INDEX_EXPRESSION, /* index expression */
+ EXPR_KIND_INDEX_PREDICATE, /* index predicate */
+ EXPR_KIND_ALTER_COL_TRANSFORM, /* transform expr in ALTER COLUMN TYPE */
EXPR_KIND_EXECUTE_PARAMETER, /* parameter value in EXECUTE */
- EXPR_KIND_TRIGGER_WHEN /* WHEN condition in CREATE TRIGGER */
+ EXPR_KIND_TRIGGER_WHEN /* WHEN condition in CREATE TRIGGER */
} ParseExprKind;
*
* While processing the FROM clause, namespace items may appear with
* p_lateral_only set, meaning they are visible only to LATERAL
- * subexpressions. (The pstate's p_lateral_active flag tells whether we are
- * inside such a subexpression at the moment.) If p_lateral_ok is not set,
+ * subexpressions. (The pstate's p_lateral_active flag tells whether we are
+ * inside such a subexpression at the moment.) If p_lateral_ok is not set,
* it's an error to actually use such a namespace item. One might think it
* would be better to just exclude such items from visibility, but the wording
* of SQL:2008 requires us to do it this way.
{
RangeTblEntry *p_rte; /* The relation's rangetable entry */
bool p_rel_visible; /* Relation name is visible? */
- bool p_cols_visible; /* Column names visible as unqualified refs? */
+ bool p_cols_visible; /* Column names visible as unqualified refs? */
bool p_lateral_only; /* Is only visible to LATERAL expressions? */
bool p_lateral_ok; /* If so, does join type allow use? */
} ParseNamespaceItem;
bool addToRelNameSpace, bool addToVarNameSpace);
extern void errorMissingRTE(ParseState *pstate, RangeVar *relation) __attribute__((noreturn));
extern void errorMissingColumn(ParseState *pstate,
- char *relname, char *colname, int location) __attribute__((noreturn));
+ char *relname, char *colname, int location) __attribute__((noreturn));
extern void expandRTE(RangeTblEntry *rte, int rtindex, int sublevels_up,
int location, bool include_dropped,
List **colnames, List **colvars);
extern void pg_qsort(void *base, size_t nel, size_t elsize,
int (*cmp) (const void *, const void *));
-extern int pg_qsort_strcmp(const void *a, const void *b);
+extern int pg_qsort_strcmp(const void *a, const void *b);
#define qsort(a,b,c,d) pg_qsort(a,b,c,d)
* http://msdn.microsoft.com/en-us/library/8fskxacy(v=vs.80).aspx
* http://msdn.microsoft.com/en-us/library/a90k134d(v=vs.80).aspx
*/
-
+
#if defined(WIN32) || defined(__CYGWIN__)
#ifdef BUILDING_DLL
/*
* MultiXactIdGetDatum
- * Returns datum representation for a multixact identifier.
+ * Returns datum representation for a multixact identifier.
*/
#define MultiXactIdGetDatum(X) ((Datum) SET_4_BYTES((X)))
/*--------------------------------------------------------------------
* bgworker.h
- * POSTGRES pluggable background workers interface
+ * POSTGRES pluggable background workers interface
*
* A background worker is a process able to run arbitrary, user-supplied code,
* including normal transactions.
*
* Any external module loaded via shared_preload_libraries can register a
- * worker. Then, at the appropriate time, the worker process is forked from
+ * worker. Then, at the appropriate time, the worker process is forked from
* the postmaster and runs the user-supplied "main" function. This code may
- * connect to a database and run transactions. Once started, it stays active
+ * connect to a database and run transactions. Once started, it stays active
* until shutdown or crash. The process should sleep during periods of
* inactivity.
*
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * src/include/postmaster/bgworker.h
+ * src/include/postmaster/bgworker.h
*--------------------------------------------------------------------
*/
#ifndef BGWORKER_H
#define BGWORKER_BACKEND_DATABASE_CONNECTION 0x0002
-typedef void (*bgworker_main_type)(void *main_arg);
-typedef void (*bgworker_sighdlr_type)(SIGNAL_ARGS);
+typedef void (*bgworker_main_type) (void *main_arg);
+typedef void (*bgworker_sighdlr_type) (SIGNAL_ARGS);
/*
* Points in time at which a bgworker can request to be started
typedef struct BackgroundWorker
{
char *bgw_name;
- int bgw_flags;
+ int bgw_flags;
BgWorkerStartTime bgw_start_time;
int bgw_restart_time; /* in seconds, or BGW_NEVER_RESTART */
- bgworker_main_type bgw_main;
+ bgworker_main_type bgw_main;
void *bgw_main_arg;
bgworker_sighdlr_type bgw_sighup;
bgworker_sighdlr_type bgw_sigterm;
extern void BackgroundWorkerBlockSignals(void);
extern void BackgroundWorkerUnblockSignals(void);
-#endif /* BGWORKER_H */
+#endif /* BGWORKER_H */
extern int MaxLivePostmasterChildren(void);
-extern int GetNumShmemAttachedBgworkers(void);
+extern int GetNumShmemAttachedBgworkers(void);
#ifdef EXEC_BACKEND
extern pid_t postmaster_forkexec(int argc, char *argv[]);
-extern void SubPostmasterMain(int argc, char *argv[]) __attribute__((noreturn));
+extern void SubPostmasterMain(int argc, char *argv[]) __attribute__((noreturn));
extern Size ShmemBackendArraySize(void);
extern void ShmemBackendArrayAllocation(void);
pg_time_t startTime;
/*
- * receiveStart and receiveStartTLI indicate the first byte position
- * and timeline that will be received. When startup process starts the
- * walreceiver, it sets these to the point where it wants the streaming
- * to begin.
+ * receiveStart and receiveStartTLI indicate the first byte position and
+ * timeline that will be received. When startup process starts the
+ * walreceiver, it sets these to the point where it wants the streaming to
+ * begin.
*/
XLogRecPtr receiveStart;
TimeLineID receiveStartTLI;
/*
* receivedUpto-1 is the last byte position that has already been
- * received, and receivedTLI is the timeline it came from. At the first
+ * received, and receivedTLI is the timeline it came from. At the first
* startup of walreceiver, these are set to receiveStart and
* receiveStartTLI. After that, walreceiver updates these whenever it
* flushes the received WAL to disk.
#define RULE_FIRES_ON_REPLICA 'R'
#define RULE_DISABLED 'D'
-extern Oid DefineRule(RuleStmt *stmt, const char *queryString);
+extern Oid DefineRule(RuleStmt *stmt, const char *queryString);
extern Oid DefineQueryRewrite(char *rulename,
Oid event_relid,
{
REPLACEVARS_REPORT_ERROR, /* throw error if no match */
REPLACEVARS_CHANGE_VARNO, /* change the Var's varno, nothing else */
- REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
+ REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
} ReplaceVarsNoMatchOption;
#define PageXLogRecPtrGet(val) \
((uint64) (val).xlogid << 32 | (val).xrecoff)
#define PageXLogRecPtrSet(ptr, lsn) \
- ((ptr).xlogid = (uint32) ((lsn) >> 32), (ptr).xrecoff = (uint32) (lsn))
+ ((ptr).xlogid = (uint32) ((lsn) >> 32), (ptr).xrecoff = (uint32) (lsn))
/*
* disk page organization
* space management information generic to any page
*
* pd_lsn - identifies xlog record for last change to this page.
- * pd_checksum - page checksum, if set.
+ * pd_checksum - page checksum, if set.
* pd_flags - flag bits.
* pd_lower - offset to start of free space.
* pd_upper - offset to end of free space.
typedef struct PageHeaderData
{
/* XXX LSN is member of *any* block, not only page-organized ones */
- PageXLogRecPtr pd_lsn; /* LSN: next byte after last byte of xlog
+ PageXLogRecPtr pd_lsn; /* LSN: next byte after last byte of xlog
* record for last change to this page */
uint16 pd_checksum; /* checksum */
uint16 pd_flags; /* flag bits, see below */
#define LOBLKSIZE (BLCKSZ / 4)
/*
- * Maximum length in bytes for a large object. To make this larger, we'd
+ * Maximum length in bytes for a large object. To make this larger, we'd
* have to widen pg_largeobject.pageno as well as various internal variables.
*/
#define MAX_LARGE_OBJECT_SIZE ((int64) INT_MAX * LOBLKSIZE)
*/
extern PredicateLockData *GetPredicateLockStatusData(void);
-
#endif /* PREDICATE_INTERNALS_H */
* is a "mapped" relation, whose current true filenode number is available
* from relmapper.c. Again, this case is NOT allowed in RelFileNodes.
*
- * Note: various places use RelFileNode in hashtable keys. Therefore,
+ * Note: various places use RelFileNode in hashtable keys. Therefore,
* there *must not* be any unused padding bytes in this struct. That
* should be safe as long as all the fields are of type Oid.
*/
/*
* Augmenting a relfilenode with the backend ID provides all the information
- * we need to locate the physical storage. The backend ID is InvalidBackendId
+ * we need to locate the physical storage. The backend ID is InvalidBackendId
* for regular relations (those accessible to more than one backend), or the
* owning backend's ID for backend-local relations. Backend-local relations
* are always transient and removed in case of a database crash; they are
typedef struct xl_running_xacts
{
int xcnt; /* # of xact ids in xids[] */
- int subxcnt; /* # of subxact ids in xids[] */
+ int subxcnt; /* # of subxact ids in xids[] */
bool subxid_overflow; /* snapshot overflowed, subxids missing */
TransactionId nextXid; /* copy of ShmemVariableCache->nextXid */
TransactionId oldestRunningXid; /* *not* oldestXmin */
typedef struct RunningTransactionsData
{
int xcnt; /* # of xact ids in xids[] */
- int subxcnt; /* # of subxact ids in xids[] */
+ int subxcnt; /* # of subxact ids in xids[] */
bool subxid_overflow; /* snapshot overflowed, subxids missing */
TransactionId nextXid; /* copy of ShmemVariableCache->nextXid */
TransactionId oldestRunningXid; /* *not* oldestXmin */
typedef enum
{
- PROCESS_UTILITY_TOPLEVEL, /* toplevel interactive command */
- PROCESS_UTILITY_QUERY, /* a complete query, but not toplevel */
- PROCESS_UTILITY_SUBCOMMAND /* a portion of a query */
+ PROCESS_UTILITY_TOPLEVEL, /* toplevel interactive command */
+ PROCESS_UTILITY_QUERY, /* a complete query, but not toplevel */
+ PROCESS_UTILITY_SUBCOMMAND /* a portion of a query */
} ProcessUtilityContext;
/* Hook for plugins to get control in ProcessUtility() */
typedef void (*ProcessUtility_hook_type) (Node *parsetree,
- const char *queryString, ProcessUtilityContext context,
- ParamListInfo params,
- DestReceiver *dest, char *completionTag);
+ const char *queryString, ProcessUtilityContext context,
+ ParamListInfo params,
+ DestReceiver *dest, char *completionTag);
extern PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook;
extern void ProcessUtility(Node *parsetree, const char *queryString,
extern Datum regexp_split_to_array(PG_FUNCTION_ARGS);
extern Datum regexp_split_to_array_no_flags(PG_FUNCTION_ARGS);
extern char *regexp_fixed_prefix(text *text_re, bool case_insensitive,
- Oid collation, bool *exact);
+ Oid collation, bool *exact);
/* regproc.c */
extern Datum regprocin(PG_FUNCTION_ARGS);
if (__builtin_constant_p(elevel) && (elevel) >= ERROR) \
pg_unreachable(); \
} while(0)
-#else /* !HAVE__BUILTIN_CONSTANT_P */
+#else /* !HAVE__BUILTIN_CONSTANT_P */
#define ereport_domain(elevel, domain, rest) \
do { \
const int elevel_ = (elevel); \
if (elevel_ >= ERROR) \
pg_unreachable(); \
} while(0)
-#endif /* HAVE__BUILTIN_CONSTANT_P */
+#endif /* HAVE__BUILTIN_CONSTANT_P */
#define ereport(elevel, rest) \
ereport_domain(elevel, TEXTDOMAIN, rest)
* set_errcontext_domain() first sets the domain to be used, and
* errcontext_msg() passes the actual message.
*/
-#define errcontext set_errcontext_domain(TEXTDOMAIN), errcontext_msg
+#define errcontext set_errcontext_domain(TEXTDOMAIN), errcontext_msg
extern int set_errcontext_domain(const char *domain);
extern int
if (__builtin_constant_p(elevel) && (elevel) >= ERROR) \
pg_unreachable(); \
} while(0)
-#else /* !HAVE__BUILTIN_CONSTANT_P */
+#else /* !HAVE__BUILTIN_CONSTANT_P */
#define elog(elevel, ...) \
do { \
int elevel_; \
if (elevel_ >= ERROR) \
pg_unreachable(); \
} while(0)
-#endif /* HAVE__BUILTIN_CONSTANT_P */
-#else /* !HAVE__VA_ARGS */
+#endif /* HAVE__BUILTIN_CONSTANT_P */
+#else /* !HAVE__VA_ARGS */
#define elog \
elog_start(__FILE__, __LINE__, PG_FUNCNAME_MACRO), \
elog_finish
-#endif /* HAVE__VA_ARGS */
+#endif /* HAVE__VA_ARGS */
extern void elog_start(const char *filename, int lineno, const char *funcname);
extern void
int lineno; /* __LINE__ of ereport() call */
const char *funcname; /* __func__ of ereport() call */
const char *domain; /* message domain */
- const char *context_domain; /* message domain for context message */
+ const char *context_domain; /* message domain for context message */
int sqlerrcode; /* encoded ERRSTATE */
char *message; /* primary error message */
char *detail; /* detail error message */
typedef struct
{
- Oid fnoid; /* function to be called */
- char enabled; /* as SESSION_REPLICATION_ROLE_* */
- int ntags; /* number of command tags */
- char **tag; /* command tags in SORTED order */
+ Oid fnoid; /* function to be called */
+ char enabled; /* as SESSION_REPLICATION_ROLE_* */
+ int ntags; /* number of command tags */
+ char **tag; /* command tags in SORTED order */
} EventTriggerCacheItem;
extern List *EventCacheLookup(EventTriggerEvent event);
extern bool config_enum_lookup_by_name(struct config_enum * record,
const char *value, int *retval);
-
#endif /* GUC_TABLES_H */
JSON_TOKEN_FALSE,
JSON_TOKEN_NULL,
JSON_TOKEN_END,
-} JsonTokenType;
+} JsonTokenType;
/*
json_aelem_action array_element_start;
json_aelem_action array_element_end;
json_scalar_action scalar;
-} jsonSemAction, *JsonSemAction;
+} jsonSemAction,
+ *JsonSemAction;
/*
* parse_json will parse the string in the lex calling the
* allocated in a context, not with malloc().
*/
extern char *MemoryContextStrdup(MemoryContext context, const char *string);
-#endif /* !FRONTEND */
+#endif /* !FRONTEND */
extern char *pstrdup(const char *in);
extern char *pnstrdup(const char *in, Size len);
* allows the query tree to be discarded easily when it is invalidated.
*
* Some callers wish to use the CachedPlan API even with one-shot queries
- * that have no reason to be saved at all. We therefore support a "oneshot"
- * variant that does no data copying or invalidation checking. In this case
+ * that have no reason to be saved at all. We therefore support a "oneshot"
+ * variant that does no data copying or invalidation checking. In this case
* there are no separate memory contexts: the CachedPlanSource struct and
* all subsidiary data live in the caller's CurrentMemoryContext, and there
- * is no way to free memory short of clearing that entire context. A oneshot
+ * is no way to free memory short of clearing that entire context. A oneshot
* plan is always treated as unsaved.
*
* Note: the string referenced by commandTag is not subsidiary storage;
const char *query_string,
const char *commandTag);
extern CachedPlanSource *CreateOneShotCachedPlan(Node *raw_parse_tree,
- const char *query_string,
- const char *commandTag);
+ const char *query_string,
+ const char *commandTag);
extern void CompleteCachedPlan(CachedPlanSource *plansource,
List *querytree_list,
MemoryContext querytree_context,
/*
* rd_createSubid is the ID of the highest subtransaction the rel has
* survived into; or zero if the rel was not created in the current top
- * transaction. This can be now be relied on, whereas previously it
- * could be "forgotten" in earlier releases.
- * Likewise, rd_newRelfilenodeSubid is the ID of the highest
- * subtransaction the relfilenode change has survived into, or zero if not
- * changed in the current transaction (or we have forgotten changing it).
- * rd_newRelfilenodeSubid can be forgotten when a relation has multiple
- * new relfilenodes within a single transaction, with one of them occuring
- * in a subsequently aborted subtransaction, e.g.
- * BEGIN;
- * TRUNCATE t;
- * SAVEPOINT save;
- * TRUNCATE t;
- * ROLLBACK TO save;
- * -- rd_newRelfilenode is now forgotten
+ * transaction. This can be now be relied on, whereas previously it could
+ * be "forgotten" in earlier releases. Likewise, rd_newRelfilenodeSubid is
+ * the ID of the highest subtransaction the relfilenode change has
+ * survived into, or zero if not changed in the current transaction (or we
+ * have forgotten changing it). rd_newRelfilenodeSubid can be forgotten
+ * when a relation has multiple new relfilenodes within a single
+ * transaction, with one of them occuring in a subsequently aborted
+ * subtransaction, e.g. BEGIN; TRUNCATE t; SAVEPOINT save; TRUNCATE t;
+ * ROLLBACK TO save; -- rd_newRelfilenode is now forgotten
*/
SubTransactionId rd_createSubid; /* rel was created in current xact */
SubTransactionId rd_newRelfilenodeSubid; /* new relfilenode assigned in
* foreign-table support
*
* rd_fdwroutine must point to a single memory chunk palloc'd in
- * CacheMemoryContext. It will be freed and reset to NULL on a relcache
+ * CacheMemoryContext. It will be freed and reset to NULL on a relcache
* reset.
*/
/*
* RelationIsScannable
- * Currently can only be false for a materialized view which has not been
- * populated by its query. This is likely to get more complicated later,
- * so use a macro which looks like a function.
+ * Currently can only be false for a materialized view which has not been
+ * populated by its query. This is likely to get more complicated later,
+ * so use a macro which looks like a function.
*/
#define RelationIsScannable(relation) ((relation)->rd_rel->relispopulated)
/*
* RelationIsPopulated
- * Currently, we don't physically distinguish the "populated" and
+ * Currently, we don't physically distinguish the "populated" and
* "scannable" properties of matviews, but that may change later.
* Hence, use the appropriate one of these macros in code tests.
*/
bool trig_truncate_after_statement;
} TriggerDesc;
-
#endif /* RELTRIGGER_H */
int
decdiv(decimal *n1, decimal *n2, decimal *result)
{
-
int i;
errno = 0;
default:
abort();
}
- return ""; /* keep MSC compiler happy */
+ return ""; /* keep MSC compiler happy */
}
int
date
PGTYPESdate_from_asc(char *str, char **endptr)
{
-
date dDate;
fsec_t fsec;
struct tm tt,
int
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
PGTYPESnumeric_cmp(numeric *var1, numeric *var2)
{
-
/* use cmp_abs function to calculate the result */
/* both are positive: normal comparation with cmp_abs */
PGTYPEStimestamp_add_interval(timestamp * tin, interval * span, timestamp * tout)
{
-
if (TIMESTAMP_NOT_FINITE(*tin))
*tout = *tin;
*/
struct ECPGstruct_member *p,
*ind_p = NULL;
- char *pbuf = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 3);
- char *ind_pbuf = (char *) mm_alloc(strlen(ind_name) + ((ind_prefix == NULL) ? 0 : strlen(ind_prefix)) + 3);
+ char *pbuf = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 3);
+ char *ind_pbuf = (char *) mm_alloc(strlen(ind_name) + ((ind_prefix == NULL) ? 0 : strlen(ind_prefix)) + 3);
if (atoi(arrsiz) == 1)
sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
}
retval = krb5_sendauth(info.pg_krb5_context, &auth_context,
- (krb5_pointer) &conn->sock, (char *) conn->krbsrvname,
+ (krb5_pointer) & conn->sock, (char *) conn->krbsrvname,
info.pg_krb5_client, server,
AP_OPTS_MUTUAL_REQUIRED,
NULL, 0, /* no creds, use ccache instead */
char sebuf[256];
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("could not restore nonblocking mode on socket: %s\n"),
+ libpq_gettext("could not restore nonblocking mode on socket: %s\n"),
pqStrerror(errno, sebuf, sizeof(sebuf)));
ret = STATUS_ERROR;
}
* ---
*/
off_t connofs; /* Offset into PGconn struct, -1 if not there */
-} internalPQconninfoOption;
+} internalPQconninfoOption;
static const internalPQconninfoOption PQconninfoOptions[] = {
/*
* pqDropConnection
*
* Close any physical connection to the server, and reset associated
- * state inside the connection object. We don't release state that
+ * state inside the connection object. We don't release state that
* would be needed to reconnect, though.
*/
void
{
appendPQExpBuffer(&conn->errorMessage,
libpq_gettext("Unix-domain socket path \"%s\" is too long (maximum %d bytes)\n"),
- portstr,
- (int) (UNIXSOCK_PATH_BUFLEN - 1));
+ portstr,
+ (int) (UNIXSOCK_PATH_BUFLEN - 1));
conn->options_valid = false;
goto connect_errReturn;
}
if (nParams < 0 || nParams > 65535)
{
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("number of parameters must be between 0 and 65535\n"));
+ libpq_gettext("number of parameters must be between 0 and 65535\n"));
return 0;
}
if (nParams < 0 || nParams > 65535)
{
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("number of parameters must be between 0 and 65535\n"));
+ libpq_gettext("number of parameters must be between 0 and 65535\n"));
return 0;
}
if (nParams < 0 || nParams > 65535)
{
printfPQExpBuffer(&conn->errorMessage,
- libpq_gettext("number of parameters must be between 0 and 65535\n"));
+ libpq_gettext("number of parameters must be between 0 and 65535\n"));
return 0;
}
unsigned char *fieldNotNum, int *fieldMax,
const int fieldMaxLen, FILE *fout)
{
-
const char *pval,
*p;
int plen;
const char **fieldNames, unsigned char *fieldNotNum,
const int fs_len, const PGresult *res)
{
-
int j; /* for loop index */
char *border = NULL;
unsigned char *fieldNotNum, int *fieldMax, char *border,
const int row_index)
{
-
int field_index; /* for loop index */
if (po->html3)
case 'd': /* Copy Data, pass it back to caller */
return msgLength;
case 'c':
+
/*
* If this is a CopyDone message, exit COPY_OUT mode and let
* caller read status with PQgetResult(). If we're in
conn->asyncStatus = PGASYNC_BUSY;
return -1;
default: /* treat as end of copy */
+
/*
* Any other message terminates either COPY_IN or COPY_BOTH
* mode.
#endif
/* Callback Event Ids */
- typedef enum
+typedef enum
{
PGEVT_REGISTER,
PGEVT_CONNRESET,
*
* The refcount field counts the struct's reference from the hash table shown
* below, plus one reference for each function call level that is using the
- * struct. We can release the struct, and the associated Perl sub, when the
+ * struct. We can release the struct, and the associated Perl sub, when the
* refcount goes to zero.
**********************************************************************/
typedef struct plperl_proc_desc
RETPUSHYES;
DIE(aTHX_ "Unable to load %s into plperl", name);
+
/*
* In most Perl versions, DIE() expands to a return statement, so the next
- * line is not necessary. But in versions between but not including 5.11.1
- * and 5.13.3 it does not, so the next line is necessary to avoid a
+ * line is not necessary. But in versions between but not including
+ * 5.11.1 and 5.13.3 it does not, so the next line is necessary to avoid a
* "control reaches end of non-void function" warning from gcc. Other
* compilers such as Solaris Studio will, however, issue a "statement not
* reached" warning instead.
void plperl_spi_cursor_close(char *);
char *plperl_sv_to_literal(SV *, char *);
-
-
#endif /* PL_PERL_H */
utf_e2u(const char *str)
{
char *ret =
- (char *) pg_do_encoding_conversion((unsigned char *) str, strlen(str),
- GetDatabaseEncoding(), PG_UTF8);
+ (char *) pg_do_encoding_conversion((unsigned char *) str, strlen(str),
+ GetDatabaseEncoding(), PG_UTF8);
if (ret == str)
ret = pstrdup(ret);
/*
* Request the string from Perl, in UTF-8 encoding; but if we're in a
- * SQL_ASCII database, just request the byte soup without trying to make it
- * UTF8, because that might fail.
+ * SQL_ASCII database, just request the byte soup without trying to make
+ * it UTF8, because that might fail.
*/
if (GetDatabaseEncoding() == PG_SQL_ASCII)
val = SvPV(sv, len);
* Beware of using yyerror for other purposes, as the cursor position might
* be misleading!
*/
-void __attribute__((noreturn))
+void
+__attribute__((noreturn))
plpgsql_yyerror(const char *message)
{
char *yytext = core_yy.scanbuf + plpgsql_yylloc;
extern HeapTuple plpgsql_exec_trigger(PLpgSQL_function *func,
TriggerData *trigdata);
extern void plpgsql_exec_event_trigger(PLpgSQL_function *func,
- EventTriggerData *trigdata);
+ EventTriggerData *trigdata);
extern void plpgsql_xact_cb(XactEvent event, void *arg);
extern void plpgsql_subxact_cb(SubXactEvent event, SubTransactionId mySubid,
SubTransactionId parentSubid, void *arg);
static void
PLy_get_spi_sqlerrcode(PyObject *exc, int *sqlerrcode)
{
- PyObject *sqlstate;
- char *buffer;
+ PyObject *sqlstate;
+ char *buffer;
sqlstate = PyObject_GetAttrString(exc, "sqlstate");
if (sqlstate == NULL)
PyObject *
PLyUnicode_Bytes(PyObject *unicode)
{
- PyObject *bytes, *rv;
- char *utf8string, *encoded;
+ PyObject *bytes,
+ *rv;
+ char *utf8string,
+ *encoded;
/* First encode the Python unicode object with UTF-8. */
bytes = PyUnicode_AsUTF8String(unicode);
PLy_elog(ERROR, "could not convert Python Unicode object to bytes");
utf8string = PyBytes_AsString(bytes);
- if (utf8string == NULL) {
+ if (utf8string == NULL)
+ {
Py_DECREF(bytes);
PLy_elog(ERROR, "could not extract bytes from encoded string");
}
PG_TRY();
{
encoded = (char *) pg_do_encoding_conversion(
- (unsigned char *) utf8string,
- strlen(utf8string),
- PG_UTF8,
- GetDatabaseEncoding());
+ (unsigned char *) utf8string,
+ strlen(utf8string),
+ PG_UTF8,
+ GetDatabaseEncoding());
}
PG_CATCH();
{
}
#ifdef WIN32
+
/*
* This fix is in mingw cvs (runtime/mingwex/dirent.c rev 1.4), but not in
* released version
#endif /* !HAVE_POSIX_SIGNALS */
}
-#endif /* !defined(WIN32) || defined(FRONTEND) */
+#endif /* !defined(WIN32) || defined(FRONTEND) */
* automatically converts text between these code pages when writing to a
* console. To identify such file descriptors, it calls GetConsoleMode()
* on the underlying HANDLE, which in turn requires GENERIC_READ access on
- * the HANDLE. Opening termout in mode "w+" allows that detection to
+ * the HANDLE. Opening termout in mode "w+" allows that detection to
* succeed. Otherwise, write() would not recognize the descriptor as a
* console, and non-ASCII characters would display incorrectly.
*
#endif
if (!termin || !termout
#ifdef WIN32
+
/*
* Direct console I/O does not work from the MSYS 1.0.10 console. Writes
* reach nowhere user-visible; reads block indefinitely. XXX This affects
* most Windows terminal environments, including rxvt, mintty, Cygwin
- * xterm, Cygwin sshd, and PowerShell ISE. Switch to a more-generic test.
+ * xterm, Cygwin sshd, and PowerShell ISE. Switch to a more-generic test.
*/
|| (getenv("OSTYPE") && strcmp(getenv("OSTYPE"), "msys") == 0)
#endif
else
snprintf(str, sizeof(str),
_("child process exited with unrecognized status %d"),
- exitstatus);
+ exitstatus);
return pstrdup(str);
}
typedef struct
{
char **setupsqls;
- int nsetupsqls;
+ int nsetupsqls;
char *teardownsql;
Session **sessions;
int nsessions;
if (print_abbrevs && pass == 2 &&
(ats[i] >= print_cutoff || i == typecnt - 1))
{
- char *thisabbrev = &thischars[indmap[abbrinds[i]]];
+ char *thisabbrev = &thischars[indmap[abbrinds[i]]];
/* filter out assorted junk entries */
if (strcmp(thisabbrev, GRANDPARENTED) != 0 &&
sub wanted
{
+
# prevent corruption of git indexes by ignoring any .git/
if (basename($_) eq '.git')
{
return;
}
- return if ! -f $File::Find::name || -l $File::Find::name;
+ return if !-f $File::Find::name || -l $File::Find::name;
# skip file names with binary extensions
# How are these updated? bjm 2012-01-02
# (We could get this from "git branches", but not worth the trouble.)
# NB: master must be first!
my @BRANCHES = qw(master
- REL9_2_STABLE REL9_1_STABLE REL9_0_STABLE
- REL8_4_STABLE REL8_3_STABLE REL8_2_STABLE REL8_1_STABLE REL8_0_STABLE
- REL7_4_STABLE REL7_3_STABLE REL7_2_STABLE REL7_1_STABLE REL7_0_PATCHES
- REL6_5_PATCHES REL6_4);
+ REL9_2_STABLE REL9_1_STABLE REL9_0_STABLE
+ REL8_4_STABLE REL8_3_STABLE REL8_2_STABLE REL8_1_STABLE REL8_0_STABLE
+ REL7_4_STABLE REL7_3_STABLE REL7_2_STABLE REL7_1_STABLE REL7_0_PATCHES
+ REL6_5_PATCHES REL6_4);
# Might want to make this parameter user-settable.
my $timestamp_slop = 600;
my $details_after = 0;
-my $post_date = 0;
-my $master_only = 0;
-my $oldest_first = 0;
+my $post_date = 0;
+my $master_only = 0;
+my $oldest_first = 0;
my $since;
my @output_buffer;
my $output_line = '';
-Getopt::Long::GetOptions('details-after' => \$details_after,
- 'master-only' => \$master_only,
- 'post-date' => \$post_date,
- 'oldest-first' => \$oldest_first,
- 'since=s' => \$since) || usage();
+Getopt::Long::GetOptions(
+ 'details-after' => \$details_after,
+ 'master-only' => \$master_only,
+ 'post-date' => \$post_date,
+ 'oldest-first' => \$oldest_first,
+ 'since=s' => \$since) || usage();
usage() if @ARGV;
my @git = qw(git log --format=fuller --date=iso);
{
my $cmd = "git for-each-ref refs/tags";
my $pid = IPC::Open2::open2(my $git_out, my $git_in, $cmd)
- || die "can't run $cmd: $!";
- while (my $line = <$git_out>) {
- if ($line =~ m|^([a-f0-9]+)\s+commit\s+refs/tags/(\S+)|) {
- my $commit = $1;
- my $tag = $2;
- if ($tag =~ /^REL\d+_\d+$/ ||
- $tag =~ /^REL\d+_\d+_\d+$/) {
- $rel_tags{$commit} = $tag;
- }
+ || die "can't run $cmd: $!";
+ while (my $line = <$git_out>)
+ {
+ if ($line =~ m|^([a-f0-9]+)\s+commit\s+refs/tags/(\S+)|)
+ {
+ my $commit = $1;
+ my $tag = $2;
+ if ( $tag =~ /^REL\d+_\d+$/
+ || $tag =~ /^REL\d+_\d+_\d+$/)
+ {
+ $rel_tags{$commit} = $tag;
+ }
}
}
waitpid($pid, 0);
# Collect the commit data
my %all_commits;
my %all_commits_by_branch;
+
# This remembers where each branch sprouted from master. Note the values
# will be wrong if --since terminates the log listing before the branch
# sprouts; but in that case it doesn't matter since we also won't reach
# the part of master where it would matter.
my %sprout_tags;
-for my $branch (@BRANCHES) {
+for my $branch (@BRANCHES)
+{
my @cmd = @git;
- if ($branch eq "master") {
- push @cmd, "origin/$branch";
- } else {
- push @cmd, "--parents";
- push @cmd, "master..origin/$branch";
+ if ($branch eq "master")
+ {
+ push @cmd, "origin/$branch";
+ }
+ else
+ {
+ push @cmd, "--parents";
+ push @cmd, "master..origin/$branch";
}
my $pid = IPC::Open2::open2(my $git_out, my $git_in, @cmd)
- || die "can't run @cmd: $!";
+ || die "can't run @cmd: $!";
my $last_tag = undef;
my $last_parent;
my %commit;
- while (my $line = <$git_out>) {
- if ($line =~ /^commit\s+(\S+)/) {
+ while (my $line = <$git_out>)
+ {
+ if ($line =~ /^commit\s+(\S+)/)
+ {
push_commit(\%commit) if %commit;
$last_tag = $rel_tags{$1} if defined $rel_tags{$1};
%commit = (
- 'branch' => $branch,
- 'commit' => $1,
+ 'branch' => $branch,
+ 'commit' => $1,
'last_tag' => $last_tag,
- 'message' => '',
- );
- if ($line =~ /^commit\s+\S+\s+(\S+)/) {
+ 'message' => '',);
+ if ($line =~ /^commit\s+\S+\s+(\S+)/)
+ {
$last_parent = $1;
- } else {
+ }
+ else
+ {
$last_parent = undef;
}
}
- elsif ($line =~ /^Author:\s+(.*)/) {
+ elsif ($line =~ /^Author:\s+(.*)/)
+ {
$commit{'author'} = $1;
}
- elsif ($line =~ /^CommitDate:\s+(.*)/) {
+ elsif ($line =~ /^CommitDate:\s+(.*)/)
+ {
$commit{'date'} = $1;
}
- elsif ($line =~ /^\s\s/) {
+ elsif ($line =~ /^\s\s/)
+ {
$commit{'message'} .= $line;
}
}
{
my $last_tag = undef;
my %sprouted_branches;
- for my $cc (@{$all_commits_by_branch{'master'}}) {
- my $commit = $cc->{'commit'};
- my $c = $cc->{'commits'}->[0];
- $last_tag = $rel_tags{$commit} if defined $rel_tags{$commit};
- if (defined $sprout_tags{$commit}) {
- $last_tag = $sprout_tags{$commit};
- # normalize branch names for making sprout tags
- $last_tag =~ s/^(REL\d+_\d+).*/$1_BR/;
- }
- $c->{'last_tag'} = $last_tag;
- if ($post_date) {
- if (defined $sprout_tags{$commit}) {
- $sprouted_branches{$sprout_tags{$commit}} = 1;
+ for my $cc (@{ $all_commits_by_branch{'master'} })
+ {
+ my $commit = $cc->{'commit'};
+ my $c = $cc->{'commits'}->[0];
+ $last_tag = $rel_tags{$commit} if defined $rel_tags{$commit};
+ if (defined $sprout_tags{$commit})
+ {
+ $last_tag = $sprout_tags{$commit};
+
+ # normalize branch names for making sprout tags
+ $last_tag =~ s/^(REL\d+_\d+).*/$1_BR/;
}
- # insert new commits between master and any other commits
- my @new_commits = ( shift @{$cc->{'commits'}} );
- for my $branch (reverse sort keys %sprouted_branches) {
- my $ccopy = {%{$c}};
- $ccopy->{'branch'} = $branch;
- push @new_commits, $ccopy;
+ $c->{'last_tag'} = $last_tag;
+ if ($post_date)
+ {
+ if (defined $sprout_tags{$commit})
+ {
+ $sprouted_branches{ $sprout_tags{$commit} } = 1;
+ }
+
+ # insert new commits between master and any other commits
+ my @new_commits = (shift @{ $cc->{'commits'} });
+ for my $branch (reverse sort keys %sprouted_branches)
+ {
+ my $ccopy = { %{$c} };
+ $ccopy->{'branch'} = $branch;
+ push @new_commits, $ccopy;
+ }
+ $cc->{'commits'} = [ @new_commits, @{ $cc->{'commits'} } ];
}
- $cc->{'commits'} = [ @new_commits, @{$cc->{'commits'}} ];
- }
}
}
my %position;
-for my $branch (@BRANCHES) {
+for my $branch (@BRANCHES)
+{
$position{$branch} = 0;
}
-while (1) {
+while (1)
+{
my $best_branch;
my $best_timestamp;
- for my $branch (@BRANCHES) {
- my $leader = $all_commits_by_branch{$branch}->[$position{$branch}];
+ for my $branch (@BRANCHES)
+ {
+ my $leader = $all_commits_by_branch{$branch}->[ $position{$branch} ];
next if !defined $leader;
- if (!defined $best_branch ||
- $leader->{'timestamp'} > $best_timestamp) {
- $best_branch = $branch;
+ if (!defined $best_branch
+ || $leader->{'timestamp'} > $best_timestamp)
+ {
+ $best_branch = $branch;
$best_timestamp = $leader->{'timestamp'};
}
}
last if !defined $best_branch;
my $winner =
- $all_commits_by_branch{$best_branch}->[$position{$best_branch}];
+ $all_commits_by_branch{$best_branch}->[ $position{$best_branch} ];
# check for master-only
- if (! $master_only || ($winner->{'commits'}[0]->{'branch'} eq 'master' &&
- @{$winner->{'commits'}} == 1)) {
- output_details($winner) if (! $details_after);
+ if (!$master_only
+ || ($winner->{'commits'}[0]->{'branch'} eq 'master'
+ && @{ $winner->{'commits'} } == 1))
+ {
+ output_details($winner) if (!$details_after);
output_str("%s", $winner->{'message'} . "\n");
output_details($winner) if ($details_after);
unshift(@output_buffer, $output_line) if ($oldest_first);
}
$winner->{'done'} = 1;
- for my $branch (@BRANCHES) {
- my $leader = $all_commits_by_branch{$branch}->[$position{$branch}];
- if (defined $leader && $leader->{'done'}) {
+ for my $branch (@BRANCHES)
+ {
+ my $leader = $all_commits_by_branch{$branch}->[ $position{$branch} ];
+ if (defined $leader && $leader->{'done'})
+ {
++$position{$branch};
redo;
}
print @output_buffer if ($oldest_first);
-sub push_commit {
+sub push_commit
+{
my ($c) = @_;
- my $ht = hash_commit($c);
- my $ts = parse_datetime($c->{'date'});
+ my $ht = hash_commit($c);
+ my $ts = parse_datetime($c->{'date'});
my $cc;
+
# Note that this code will never merge two commits on the same branch,
# even if they have the same hash (author/message) and nearby
# timestamps. This means that there could be multiple potential
# matches when we come to add a commit from another branch. Prefer
# the closest-in-time one.
- for my $candidate (@{$all_commits{$ht}}) {
+ for my $candidate (@{ $all_commits{$ht} })
+ {
my $diff = abs($ts - $candidate->{'timestamp'});
- if ($diff < $timestamp_slop &&
- !exists $candidate->{'branch_position'}{$c->{'branch'}})
+ if ($diff < $timestamp_slop
+ && !exists $candidate->{'branch_position'}{ $c->{'branch'} })
{
- if (!defined $cc ||
- $diff < abs($ts - $cc->{'timestamp'})) {
- $cc = $candidate;
- }
+ if (!defined $cc
+ || $diff < abs($ts - $cc->{'timestamp'}))
+ {
+ $cc = $candidate;
+ }
}
}
- if (!defined $cc) {
+ if (!defined $cc)
+ {
$cc = {
- 'author' => $c->{'author'},
- 'message' => $c->{'message'},
- 'commit' => $c->{'commit'},
- 'commits' => [],
- 'timestamp' => $ts
- };
- push @{$all_commits{$ht}}, $cc;
+ 'author' => $c->{'author'},
+ 'message' => $c->{'message'},
+ 'commit' => $c->{'commit'},
+ 'commits' => [],
+ 'timestamp' => $ts };
+ push @{ $all_commits{$ht} }, $cc;
}
+
# stash only the fields we'll need later
my $smallc = {
- 'branch' => $c->{'branch'},
- 'commit' => $c->{'commit'},
- 'date' => $c->{'date'},
- 'last_tag' => $c->{'last_tag'}
- };
- push @{$cc->{'commits'}}, $smallc;
- push @{$all_commits_by_branch{$c->{'branch'}}}, $cc;
- $cc->{'branch_position'}{$c->{'branch'}} =
- -1+@{$all_commits_by_branch{$c->{'branch'}}};
+ 'branch' => $c->{'branch'},
+ 'commit' => $c->{'commit'},
+ 'date' => $c->{'date'},
+ 'last_tag' => $c->{'last_tag'} };
+ push @{ $cc->{'commits'} }, $smallc;
+ push @{ $all_commits_by_branch{ $c->{'branch'} } }, $cc;
+ $cc->{'branch_position'}{ $c->{'branch'} } =
+ -1 + @{ $all_commits_by_branch{ $c->{'branch'} } };
}
-sub hash_commit {
+sub hash_commit
+{
my ($c) = @_;
return $c->{'author'} . "\0" . $c->{'message'};
}
-sub parse_datetime {
+sub parse_datetime
+{
my ($dt) = @_;
- $dt =~ /^(\d\d\d\d)-(\d\d)-(\d\d)\s+(\d\d):(\d\d):(\d\d)\s+([-+])(\d\d)(\d\d)$/;
- my $gm = Time::Local::timegm($6, $5, $4, $3, $2-1, $1);
+ $dt =~
+/^(\d\d\d\d)-(\d\d)-(\d\d)\s+(\d\d):(\d\d):(\d\d)\s+([-+])(\d\d)(\d\d)$/;
+ my $gm = Time::Local::timegm($6, $5, $4, $3, $2 - 1, $1);
my $tzoffset = ($8 * 60 + $9) * 60;
- $tzoffset = - $tzoffset if $7 eq '-';
+ $tzoffset = -$tzoffset if $7 eq '-';
return $gm - $tzoffset;
}
-sub output_str {
+sub output_str
+{
($oldest_first) ? ($output_line .= sprintf(shift, @_)) : printf(@_);
}
-sub output_details {
+sub output_details
+{
my $item = shift;
- if ($details_after) {
+ if ($details_after)
+ {
$item->{'author'} =~ m{^(.*?)\s*<[^>]*>$};
+
# output only author name, not email address
output_str("(%s)\n", $1);
- } else {
+ }
+ else
+ {
output_str("Author: %s\n", $item->{'author'});
}
- foreach my $c (@{$item->{'commits'}}) {
- output_str("Branch: %s ", $c->{'branch'}) if (! $master_only);
- if (defined $c->{'last_tag'}) {
- output_str("Release: %s ", $c->{'last_tag'});
- }
- output_str("[%s] %s\n", substr($c->{'commit'}, 0, 9), $c->{'date'});
+ foreach my $c (@{ $item->{'commits'} })
+ {
+ output_str("Branch: %s ", $c->{'branch'}) if (!$master_only);
+ if (defined $c->{'last_tag'})
+ {
+ output_str("Release: %s ", $c->{'last_tag'});
+ }
+ output_str("[%s] %s\n", substr($c->{'commit'}, 0, 9), $c->{'date'});
}
output_str("\n");
}
-sub usage {
+sub usage
+{
print STDERR <
Usage: git_changelog [--details-after/-d] [--master-only/-m] [--oldest-first/-o] [--post-date/-p] [--since=SINCE]
--details-after Show branch and author info after the commit description
$| = 1;
my $target = shift;
+
# if called from vcregress, the config will be passed to us
# so no need to re-include these
our $config = shift;
unless ($config)
{
+
# suppress warning about harmless redeclaration of $config
- no warnings 'misc';
+ no warnings 'misc';
require "config_default.pl";
require "config.pl" if (-f "config.pl");
}
"src");
CopySetOfFiles('config files', $sample_files, $target . '/share/');
CopyFiles(
- 'Import libraries', $target . '/lib/',
- "$conf\\", "postgres\\postgres.lib",
- "libpq\\libpq.lib", "libecpg\\libecpg.lib",
+ 'Import libraries',
+ $target . '/lib/',
+ "$conf\\",
+ "postgres\\postgres.lib",
+ "libpq\\libpq.lib",
+ "libecpg\\libecpg.lib",
"libpgcommon\\libpgcommon.lib",
- "libpgport\\libpgport.lib", "libpgtypes\\libpgtypes.lib",
+ "libpgport\\libpgport.lib",
+ "libpgtypes\\libpgtypes.lib",
"libecpg_compat\\libecpg_compat.lib");
CopySetOfFiles(
'timezone names',
'include/internal/libpq', 'include/server', 'include/server/parser');
CopyFiles(
- 'Public headers',
- $target . '/include/',
- 'src/include/', 'postgres_ext.h',
- 'pg_config.h', 'pg_config_ext.h', 'pg_config_os.h',
- 'pg_config_manual.h');
+ 'Public headers', $target . '/include/',
+ 'src/include/', 'postgres_ext.h',
+ 'pg_config.h', 'pg_config_ext.h',
+ 'pg_config_os.h', 'pg_config_manual.h');
lcopy('src/include/libpq/libpq-fs.h', $target . '/include/libpq/')
|| croak 'Could not copy libpq-fs.h';
# We have to use this flag on 32 bit targets because the 32bit perls
# are built with it and sometimes crash if we don't.
- my $use_32bit_time_t =
+ my $use_32bit_time_t =
$self->{platform} eq 'Win32' ? '_USE_32BIT_TIME_T;' : '';
$self->WriteItemDefinitionGroup(
sub new
{
- my $classname = shift;
- my $self = $classname->SUPER::_new(@_);
- bless($self, $classname);
+ my $classname = shift;
+ my $self = $classname->SUPER::_new(@_);
+ bless($self, $classname);
- $self->{vcver} = '11.00';
+ $self->{vcver} = '11.00';
- return $self;
+ return $self;
}
# This override adds the
element # to the PropertyGroup labeled "Configuration"
sub WriteConfigurationPropertyGroup
{
- my ($self, $f, $cfgname, $p) = @_;
- my $cfgtype =
- ($self->{type} eq "exe")
- ?'Application'
- :($self->{type} eq "dll"?'DynamicLibrary':'StaticLibrary');
+ my ($self, $f, $cfgname, $p) = @_;
+ my $cfgtype =
+ ($self->{type} eq "exe")
+ ? 'Application'
+ : ($self->{type} eq "dll" ? 'DynamicLibrary' : 'StaticLibrary');
-
print $f <
+ print $f <
{platform}'" Label="Configuration">
$cfgtype
false
{ 'tsearch2' => ['contrib/tsearch2'], 'dblink' => ['src/backend'] };
my $contrib_extrasource = {
'cube' => [ 'cubescan.l', 'cubeparse.y' ],
- 'seg' => [ 'segscan.l', 'segparse.y' ],
- };
+ 'seg' => [ 'segscan.l', 'segparse.y' ], };
my @contrib_excludes = ('pgcrypto', 'intagg', 'sepgsql');
sub mkvcbuild
win32error.c win32setlocale.c);
our @pgcommonallfiles = qw(
- relpath.c);
+ relpath.c);
- our @pgcommonfrontendfiles = (@pgcommonallfiles,
- qw(fe_memutils.c));
+ our @pgcommonfrontendfiles = (@pgcommonallfiles, qw(fe_memutils.c));
our @pgcommonbkndfiles = @pgcommonallfiles;
'src\backend\port\win32_shmem.c');
$postgres->ReplaceFile('src\backend\port\pg_latch.c',
'src\backend\port\win32_latch.c');
- $postgres->AddFiles('src\port', @pgportfiles);
+ $postgres->AddFiles('src\port', @pgportfiles);
$postgres->AddFiles('src\common', @pgcommonbkndfiles);
$postgres->AddDir('src\timezone');
$postgres->AddFiles('src\backend\parser', 'scan.l', 'gram.y');
# fix up pg_xlogdump once it's been set up
# files symlinked on Unix are copied on windows
- my $pg_xlogdump = (grep {$_->{name} eq 'pg_xlogdump'}
- @{$solution->{projects}->{contrib}} )[0];
+ my $pg_xlogdump =
+ (grep { $_->{name} eq 'pg_xlogdump' }
+ @{ $solution->{projects}->{contrib} })[0];
$pg_xlogdump->AddDefine('FRONTEND');
- foreach my $xf (glob('src/backend/access/rmgrdesc/*desc.c') )
+ foreach my $xf (glob('src/backend/access/rmgrdesc/*desc.c'))
{
my $bf = basename $xf;
- copy($xf,"contrib/pg_xlogdump/$bf");
+ copy($xf, "contrib/pg_xlogdump/$bf");
$pg_xlogdump->AddFile("contrib\\pg_xlogdump\\$bf");
}
- copy('src/backend/access/transam/xlogreader.c',
- 'contrib/pg_xlogdump/xlogreader.c');
+ copy(
+ 'src/backend/access/transam/xlogreader.c',
+ 'contrib/pg_xlogdump/xlogreader.c');
$solution->Save();
return $solution->{vcver};
if ($filter eq "LIBOBJS")
{
- if (grep(/$p/, @main::pgportfiles, @main::pgcommonfiles) == 1)
+ if (grep(/$p/, @main::pgportfiles, @main::pgcommonfiles)
+ == 1)
{
$p =~ s/\.c/\.o/;
$matches .= $p . " ";
}
if (IsNewer(
- "src\\include\\pg_config_ext.h", "src\\include\\pg_config_ext.h.win32"))
+ "src\\include\\pg_config_ext.h",
+ "src\\include\\pg_config_ext.h.win32"))
{
print "Copying pg_config_ext.h...\n";
- copyFile("src\\include\\pg_config_ext.h.win32",
+ copyFile(
+ "src\\include\\pg_config_ext.h.win32",
"src\\include\\pg_config_ext.h");
}
"perl -I ../catalog Gen_fmgrtab.pl ../../../src/include/catalog/pg_proc.h");
chdir('..\..\..');
}
- if (IsNewer('src\include\utils\fmgroids.h', 'src\backend\utils\fmgroids.h'))
+ if (IsNewer(
+ 'src\include\utils\fmgroids.h',
+ 'src\backend\utils\fmgroids.h'))
{
copyFile('src\backend\utils\fmgroids.h',
'src\include\utils\fmgroids.h');
sub new
{
- my $classname = shift;
- my $self = $classname->SUPER::_new(@_);
- bless($self, $classname);
+ my $classname = shift;
+ my $self = $classname->SUPER::_new(@_);
+ bless($self, $classname);
- $self->{solutionFileVersion} = '12.00';
- $self->{vcver} = '11.00';
- $self->{visualStudioName} = 'Visual Studio 2012';
+ $self->{solutionFileVersion} = '12.00';
+ $self->{vcver} = '11.00';
+ $self->{visualStudioName} = 'Visual Studio 2012';
- return $self;
+ return $self;
}
1;
# We have to use this flag on 32 bit targets because the 32bit perls
# are built with it and sometimes crash if we don't.
- my $use_32bit_time_t =
+ my $use_32bit_time_t =
$self->{platform} eq 'Win32' ? '_USE_32BIT_TIME_T;' : '';
my $what = shift || "";
if ($what =~
- /^(check|installcheck|plcheck|contribcheck|ecpgcheck|isolationcheck|upgradecheck)$/i)
+/^(check|installcheck|plcheck|contribcheck|ecpgcheck|isolationcheck|upgradecheck)$/i
+ )
{
$what = uc $what;
}
ECPGCHECK => \&ecpgcheck,
CONTRIBCHECK => \&contribcheck,
ISOLATIONCHECK => \&isolationcheck,
- UPGRADECHECK => \&upgradecheck,);
+ UPGRADECHECK => \&upgradecheck,);
my $proc = $command{$what};
my $tmp_install = "$tmp_root/install";
print "Setting up temp install\n\n";
Install($tmp_install, $config);
+
# Install does a chdir, so change back after that
chdir $cwd;
- my ($bindir,$libdir,$oldsrc,$newsrc) =
+ my ($bindir, $libdir, $oldsrc, $newsrc) =
("$tmp_install/bin", "$tmp_install/lib", $topdir, $topdir);
$ENV{PATH} = "$bindir;$ENV{PATH}";
my $data = "$tmp_root/data";
system("pg_ctl start -l $logdir/postmaster1.log -w") == 0 or exit 1;
print "\nSetting up data for upgrading\n\n";
installcheck();
+
# now we can chdir into the source dir
chdir "$topdir/contrib/pg_upgrade";
print "\nDumping old cluster\n\n";
print "\nSetting up new cluster\n\n";
system("initdb") == 0 or exit 1;
print "\nRunning pg_upgrade\n\n";
- system("pg_upgrade -d $data.old -D $data -b $bindir -B $bindir") == 0
+ system("pg_upgrade -d $data.old -D $data -b $bindir -B $bindir") == 0
or exit 1;
print "\nStarting new cluster\n\n";
system("pg_ctl -l $logdir/postmaster2.log -w start") == 0 or exit 1;
# cause a lot of false-positive results.
#
open PIPE, "$FIND * -type f -name '*.c' |"
- or die "can't fork: $!";
- chomp;
- push @cfiles, $_;
+ or die "can't fork: $!";
+{
+ chomp;
+ push @cfiles, $_;
}
close PIPE or die "$FIND failed: $!";
open PIPE, "$FIND * -type f -name '*.h' |"
- or die "can't fork: $!";
- chomp;
- push @hfiles, $_ unless
- m|^src/include/port/| ||
- m|^src/backend/port/\w+/|;
+ or die "can't fork: $!";
+{
+ chomp;
+ push @hfiles, $_
+ unless m|^src/include/port/|
+ || m|^src/backend/port/\w+/|;
}
close PIPE or die "$FIND failed: $!";
# a hash table. To cover the possibility of multiple .h files defining
# the same symbol, we make each hash entry a hash of filenames.
#
-foreach $hfile (@hfiles) {
- open HFILE, $hfile
- or die "can't open $hfile: $!";
- while () {
- if (m/^\s*#\s*define\s+(\w+)/) {
- $defines{$1}{$hfile} = 1;
+foreach $hfile (@hfiles)
+{
+ open HFILE, $hfile
+ or die "can't open $hfile: $!";
+ while ()
+ {
+ if (m/^\s*#\s*define\s+(\w+)/)
+ {
+ $defines{$1}{$hfile} = 1;
+ }
}
- }
- close HFILE;
+ close HFILE;
}
#
# files it #include's. Then extract all the symbols it tests for defined-ness,
# and check each one against the previously built hashtable.
#
-foreach $file (@hfiles, @cfiles) {
- ($fname, $fpath) = fileparse($file);
- chdir $fpath or die "can't chdir to $fpath: $!";
- #
- # Ask 'make' to parse the makefile so we can get the correct flags to
- # use. CPPFLAGS in particular varies for each subdirectory. If we are
- # processing a .h file, we might be in a subdirectory that has no
- # Makefile, in which case we have to fake it. Note that there seems
- # no easy way to prevent make from recursing into subdirectories and
- # hence printing multiple definitions --- we keep the last one, which
- # should come from the current Makefile.
- #
- if (-f "Makefile" || -f "GNUmakefile") {
- $MAKECMD = "$MAKE -qp";
- } else {
- $subdir = $fpath;
- chop $subdir;
- $top_builddir = "..";
- $tmp = $fpath;
- while (($tmp = dirname($tmp)) ne '.') {
- $top_builddir = $top_builddir . "/..";
- }
- $MAKECMD = "$MAKE -qp 'subdir=$subdir' 'top_builddir=$top_builddir' -f '$top_builddir/src/Makefile.global'";
- }
- open PIPE, "$MAKECMD |"
- or die "can't fork: $!";
- if (m/^CPPFLAGS :?= (.*)/) {
- $CPPFLAGS = $1;
- } elsif (m/^CFLAGS :?= (.*)/) {
- $CFLAGS = $1;
- } elsif (m/^CFLAGS_SL :?= (.*)/) {
- $CFLAGS_SL = $1;
- } elsif (m/^PTHREAD_CFLAGS :?= (.*)/) {
- $PTHREAD_CFLAGS = $1;
- } elsif (m/^CC :?= (.*)/) {
- $CC = $1;
- }
- }
- # If make exits with status 1, it's not an error, it just means make
- # thinks some files may not be up-to-date. Only complain on status 2.
- close PIPE;
- die "$MAKE failed in $fpath\n" if $? != 0 && $? != 256;
-
- # Expand out stuff that might be referenced in CFLAGS
- $CFLAGS =~ s/\$\(CFLAGS_SL\)/$CFLAGS_SL/;
- $CFLAGS =~ s/\$\(PTHREAD_CFLAGS\)/$PTHREAD_CFLAGS/;
-
- #
- # Run the compiler (which had better be gcc) to get the inclusions.
- # "gcc -H" reports inclusions on stderr as "... filename" where the
- # number of dots varies according to nesting depth.
- #
- @includes = ();
- $COMPILE = "$CC $CPPFLAGS $CFLAGS -H -E $fname";
- open PIPE, "$COMPILE 2>&1 >/dev/null |"
- or die "can't fork: $!";
- if (m/^\.+ (.*)/) {
- $include = $1;
- # Ignore system headers (absolute paths); but complain if a
- # .c file includes a system header before any PG header.
- if ($include =~ m|^/|) {
- warn "$file includes $include before any Postgres inclusion\n"
- if $#includes == -1 && $file =~ m/\.c$/;
- next;
- }
- # Strip any "./" (assume this appears only at front)
- $include =~ s|^\./||;
- # Make path relative to top of tree
- $ipath = $fpath;
- while ($include =~ s|^\.\./||) {
- $ipath = dirname($ipath) . "/";
- }
- $ipath =~ s|^\./||;
- push @includes, $ipath . $include;
- } else {
- warn "$CC: $_";
+foreach $file (@hfiles, @cfiles)
+{
+ ($fname, $fpath) = fileparse($file);
+ chdir $fpath or die "can't chdir to $fpath: $!";
+
+ #
+ # Ask 'make' to parse the makefile so we can get the correct flags to
+ # use. CPPFLAGS in particular varies for each subdirectory. If we are
+ # processing a .h file, we might be in a subdirectory that has no
+ # Makefile, in which case we have to fake it. Note that there seems
+ # no easy way to prevent make from recursing into subdirectories and
+ # hence printing multiple definitions --- we keep the last one, which
+ # should come from the current Makefile.
+ #
+ if (-f "Makefile" || -f "GNUmakefile")
+ {
+ $MAKECMD = "$MAKE -qp";
}
- }
- # The compiler might fail, particularly if we are checking a file that's
- # not supposed to be compiled at all on the current platform, so don't
- # quit on nonzero status.
- close PIPE or warn "$COMPILE failed in $fpath\n";
-
- #
- # Scan the file to find #ifdef, #ifndef, and #if defined() constructs
- # We assume #ifdef isn't continued across lines, and that defined(foo)
- # isn't split across lines either
- #
- open FILE, $fname
- or die "can't open $file: $!";
- $inif = 0;
- while () {
- $line = $_;
- if ($line =~ m/^\s*#\s*ifdef\s+(\w+)/) {
- $symbol = $1;
- &checkit;
+ else
+ {
+ $subdir = $fpath;
+ chop $subdir;
+ $top_builddir = "..";
+ $tmp = $fpath;
+ while (($tmp = dirname($tmp)) ne '.')
+ {
+ $top_builddir = $top_builddir . "/..";
+ }
+ $MAKECMD =
+"$MAKE -qp 'subdir=$subdir' 'top_builddir=$top_builddir' -f '$top_builddir/src/Makefile.global'";
}
- if ($line =~ m/^\s*#\s*ifndef\s+(\w+)/) {
- $symbol = $1;
- &checkit;
+ open PIPE, "$MAKECMD |"
+ or die "can't fork: $!";
+ {
+ if (m/^CPPFLAGS :?= (.*)/)
+ {
+ $CPPFLAGS = $1;
+ }
+ elsif (m/^CFLAGS :?= (.*)/)
+ {
+ $CFLAGS = $1;
+ }
+ elsif (m/^CFLAGS_SL :?= (.*)/)
+ {
+ $CFLAGS_SL = $1;
+ }
+ elsif (m/^PTHREAD_CFLAGS :?= (.*)/)
+ {
+ $PTHREAD_CFLAGS = $1;
+ }
+ elsif (m/^CC :?= (.*)/)
+ {
+ $CC = $1;
+ }
}
- if ($line =~ m/^\s*#\s*if\s+/) {
- $inif = 1;
+
+ # If make exits with status 1, it's not an error, it just means make
+ # thinks some files may not be up-to-date. Only complain on status 2.
+ close PIPE;
+ die "$MAKE failed in $fpath\n" if $? != 0 && $? != 256;
+
+ # Expand out stuff that might be referenced in CFLAGS
+ $CFLAGS =~ s/\$\(CFLAGS_SL\)/$CFLAGS_SL/;
+ $CFLAGS =~ s/\$\(PTHREAD_CFLAGS\)/$PTHREAD_CFLAGS/;
+
+ #
+ # Run the compiler (which had better be gcc) to get the inclusions.
+ # "gcc -H" reports inclusions on stderr as "... filename" where the
+ # number of dots varies according to nesting depth.
+ #
+ @includes = ();
+ $COMPILE = "$CC $CPPFLAGS $CFLAGS -H -E $fname";
+ open PIPE, "$COMPILE 2>&1 >/dev/null |"
+ or die "can't fork: $!";
+ {
+ if (m/^\.+ (.*)/)
+ {
+ $include = $1;
+
+ # Ignore system headers (absolute paths); but complain if a
+ # .c file includes a system header before any PG header.
+ if ($include =~ m|^/|)
+ {
+ warn "$file includes $include before any Postgres inclusion\n"
+ if $#includes == -1 && $file =~ m/\.c$/;
+ next;
+ }
+
+ # Strip any "./" (assume this appears only at front)
+ $include =~ s|^\./||;
+
+ # Make path relative to top of tree
+ $ipath = $fpath;
+ while ($include =~ s|^\.\./||)
+ {
+ $ipath = dirname($ipath) . "/";
+ }
+ $ipath =~ s|^\./||;
+ push @includes, $ipath . $include;
+ }
+ else
+ {
+ warn "$CC: $_";
+ }
}
- if ($inif) {
- while ($line =~ s/\bdefined(\s+|\s*\(\s*)(\w+)//) {
- $symbol = $2;
- &checkit;
- }
- if (!($line =~ m/\\$/)) {
- $inif = 0;
- }
+
+ # The compiler might fail, particularly if we are checking a file that's
+ # not supposed to be compiled at all on the current platform, so don't
+ # quit on nonzero status.
+ close PIPE or warn "$COMPILE failed in $fpath\n";
+
+ #
+ # Scan the file to find #ifdef, #ifndef, and #if defined() constructs
+ # We assume #ifdef isn't continued across lines, and that defined(foo)
+ # isn't split across lines either
+ #
+ open FILE, $fname
+ or die "can't open $file: $!";
+ $inif = 0;
+ while ()
+ {
+ $line = $_;
+ if ($line =~ m/^\s*#\s*ifdef\s+(\w+)/)
+ {
+ $symbol = $1;
+ &checkit;
+ }
+ if ($line =~ m/^\s*#\s*ifndef\s+(\w+)/)
+ {
+ $symbol = $1;
+ &checkit;
+ }
+ if ($line =~ m/^\s*#\s*if\s+/)
+ {
+ $inif = 1;
+ }
+ if ($inif)
+ {
+ while ($line =~ s/\bdefined(\s+|\s*\(\s*)(\w+)//)
+ {
+ $symbol = $2;
+ &checkit;
+ }
+ if (!($line =~ m/\\$/))
+ {
+ $inif = 0;
+ }
+ }
}
- }
- close FILE;
+ close FILE;
- chdir $topdir or die "can't chdir to $topdir: $!";
+ chdir $topdir or die "can't chdir to $topdir: $!";
}
exit 0;
# Check an is-defined reference
-sub checkit {
- # Ignore if symbol isn't defined in any PG include files
- if (! defined $defines{$symbol}) {
- return;
- }
- #
- # Try to match source(s) of symbol to the inclusions of the current file
- # (including itself). We consider it OK if any one matches.
- #
- # Note: these tests aren't bulletproof; in theory the inclusion might
- # occur after the use of the symbol. Given our normal file layout,
- # however, the risk is minimal.
- #
- foreach $deffile (keys %{ $defines{$symbol} }) {
- return if $deffile eq $file;
- foreach $reffile (@includes) {
- return if $deffile eq $reffile;
+sub checkit
+{
+
+ # Ignore if symbol isn't defined in any PG include files
+ if (!defined $defines{$symbol})
+ {
+ return;
+ }
+
+ #
+ # Try to match source(s) of symbol to the inclusions of the current file
+ # (including itself). We consider it OK if any one matches.
+ #
+ # Note: these tests aren't bulletproof; in theory the inclusion might
+ # occur after the use of the symbol. Given our normal file layout,
+ # however, the risk is minimal.
+ #
+ foreach $deffile (keys %{ $defines{$symbol} })
+ {
+ return if $deffile eq $file;
+ foreach $reffile (@includes)
+ {
+ return if $deffile eq $reffile;
+ }
}
- }
- #
- # If current file is a .h file, it's OK for it to assume that one of the
- # base headers (postgres.h or postgres_fe.h) has been included.
- #
- if ($file =~ m/\.h$/) {
- foreach $deffile (keys %{ $defines{$symbol} }) {
- return if $deffile eq 'src/include/c.h';
- return if $deffile eq 'src/include/postgres.h';
- return if $deffile eq 'src/include/postgres_fe.h';
- return if $deffile eq 'src/include/pg_config.h';
- return if $deffile eq 'src/include/pg_config_manual.h';
+
+ #
+ # If current file is a .h file, it's OK for it to assume that one of the
+ # base headers (postgres.h or postgres_fe.h) has been included.
+ #
+ if ($file =~ m/\.h$/)
+ {
+ foreach $deffile (keys %{ $defines{$symbol} })
+ {
+ return if $deffile eq 'src/include/c.h';
+ return if $deffile eq 'src/include/postgres.h';
+ return if $deffile eq 'src/include/postgres_fe.h';
+ return if $deffile eq 'src/include/pg_config.h';
+ return if $deffile eq 'src/include/pg_config_manual.h';
+ }
}
- }
- #
- @places = keys %{ $defines{$symbol} };
- print "$file references $symbol, defined in @places\n";
- # print "includes: @includes\n";
+
+ #
+ @places = keys %{ $defines{$symbol} };
+ print "$file references $symbol, defined in @places\n";
+
+ # print "includes: @includes\n";
}
7) Remove any files that generate errors and restore their original
versions.
-8) Do a full test build:
-
- > run configure
- # stop is only necessary if it's going to install in a location with an
- # already running server
- pg_ctl stop
- gmake -C src install
- gmake -C contrib install
- pg_ctl start
- gmake installcheck-world
-
-9) Indent the Perl code:
+8) Indent the Perl code:
(
find . -name \*.pl -o -name \*.pm
sort -u |
xargs perltidy --profile=src/tools/pgindent/perltidyrc
+9) Do a full test build:
+
+ > run configure
+ # stop is only necessary if it's going to install in a location with an
+ # already running server
+ pg_ctl stop
+ gmake -C src install
+ gmake -C contrib install
+ pg_ctl start
+ gmake installcheck-world
+
+10) Remove Perl backup files after testing
+
---------------------------------------------------------------------------
BSD indent
$tdtry = "$tdtry/..";
}
die "cannot locate typedefs file \"$typedefs_file\"\n"
- unless $typedefs_file && -f $typedefs_file;
+ unless $typedefs_file && -f $typedefs_file;
open(my $typedefs_fh, '<', $typedefs_file)
|| die "cannot open typedefs file \"$typedefs_file\": $!\n";
{
if ($excludes && @files)
{
- open(my $eh, '<', $excludes) || die "cannot open exclude file \"$excludes\"\n";
+ open(my $eh, '<', $excludes)
+ || die "cannot open exclude file \"$excludes\"\n";
while (my $line = <$eh>)
{
chomp $line;
# FILE: ../../../src/backend/rewrite/rewriteHandler.c
# Error@2259:
# Stuff missing from end of file
- $source =~ s!(\}|[ \t])else[ \t]*(/\*)(.*\*/)[ \t]*$!$1else\n $2 _PGMV$3!gm;
+ $source =~
+ s!(\}|[ \t])else[ \t]*(/\*)(.*\*/)[ \t]*$!$1else\n $2 _PGMV$3!gm;
# Indent multi-line after-'else' comment so BSD indent will move it
# properly. We already moved down single-line comments above.
chdir "$code_base/src/tools/pgindent";
- my $typedefs_list_url = "http://buildfarm.postgresql.org/cgi-bin/typedefs.pl";
+ my $typedefs_list_url =
+ "http://buildfarm.postgresql.org/cgi-bin/typedefs.pl";
my $rv = getstore($typedefs_list_url, "tmp_typedefs.list");
- die "cannot fetch typedefs list from $typedefs_list_url\n" unless is_success($rv);
+ die "cannot fetch typedefs list from $typedefs_list_url\n"
+ unless is_success($rv);
$ENV{PGTYPEDEFS} = abs_path('tmp_typedefs.list');
- my $pg_bsd_indent_url = "ftp://ftp.postgresql.org/pub/dev/pg_bsd_indent-" .
- $INDENT_VERSION . ".tar.gz";
+ my $pg_bsd_indent_url =
+ "ftp://ftp.postgresql.org/pub/dev/pg_bsd_indent-"
+ . $INDENT_VERSION
+ . ".tar.gz";
$rv = getstore($pg_bsd_indent_url, "pg_bsd_indent.tgz");
- die "cannot fetch BSD indent tarfile from $pg_bsd_indent_url\n" unless is_success($rv);
+ die "cannot fetch BSD indent tarfile from $pg_bsd_indent_url\n"
+ unless is_success($rv);
# XXX add error checking here
AclResult
AcquireSampleRowsFunc
ActiveSnapshotElt
+AddForeignUpdateTargets_function
AffixNode
AffixNodeData
AfterTriggerEvent
AggStatePerGroup
AggStatePerGroupData
AggStrategy
+AggVals
Aggref
AggrefExprState
+AlenState
Alias
AllocBlock
AllocChunk
AlterDefaultPrivilegesStmt
AlterDomainStmt
AlterEnumStmt
+AlterEventTrigStmt
AlterExtensionContentsStmt
AlterExtensionStmt
AlterFdwStmt
BackendId
BackendParameters
BackendState
+BackgroundWorker
BaseBackupCmd
+BeginForeignModify_function
BeginForeignScan_function
+BgWorkerStartTime
BitmapAnd
BitmapAndPath
BitmapAndState
CollateClause
CollateExpr
CollateStrength
+ColorTrgm
+ColorTrgmInfo
ColumnCompareData
ColumnDef
ColumnIOData
CompressionAlgorithm
CompressorState
ConfigVariable
+ConnCacheEntry
+ConnCacheKey
ConnStatusType
ConnType
ConsiderSplitContext
ControlFileData
ConvInfo
ConvProcInfo
+ConversionLocation
ConvertRowtypeExpr
ConvertRowtypeExprState
CookedConstraint
CreateConversionStmt
CreateDomainStmt
CreateEnumStmt
+CreateEventTrigStmt
CreateExtensionStmt
CreateFdwStmt
CreateForeignServerStmt
CustomOutPtr
CycleCtr
DBState
+DBWriteRequest
DCHCacheEntry
DEADLOCK_INFO
DECountItem
DR_intorel
DR_printtup
DR_sqlfunction
+DR_transientrel
DWORD
DataDumperPtr
DataPageDeleteStack
DictSubState
DictSyn
DictThesaurus
+DisableTimeoutParams
DiscardMode
DiscardStmt
DistinctExpr
-Dlelem
-Dllist
DoStmt
DocRepresentation
DomainConstraintState
EVP_MD
EVP_MD_CTX
EVP_PKEY
+EachState
Edge
+ElementsState
+EnableTimeoutParams
EndBlobPtr
EndBlobsPtr
EndDataPtr
+EndForeignModify_function
EndForeignScan_function
EnumItem
EolType
EquivalenceMember
ErrorContextCallback
ErrorData
+EventTriggerCacheEntry
+EventTriggerCacheItem
+EventTriggerCacheStateType
+EventTriggerData
+EventTriggerEvent
+EventTriggerInfo
+EventTriggerQueryState
ExceptionLabelMap
ExceptionMap
ExecAuxRowMark
+ExecForeignDelete_function
+ExecForeignInsert_function
+ExecForeignUpdate_function
ExecRowMark
ExecScanAccessMtd
ExecScanRecheckMtd
ExecutorFinish_hook_type
ExecutorRun_hook_type
ExecutorStart_hook_type
+ExplainForeignModify_function
ExplainForeignScan_function
ExplainFormat
ExplainOneQuery_hook_type
ExtensionInfo
ExtensionVersionInfo
Extention
+FDWCollateState
FD_SET
FILE
FILETIME
FormData_pg_default_acl
FormData_pg_depend
FormData_pg_enum
+FormData_pg_event_trigger
FormData_pg_extension
FormData_pg_foreign_data_wrapper
FormData_pg_foreign_server
Form_pg_default_acl
Form_pg_depend
Form_pg_enum
+Form_pg_event_trigger
Form_pg_extension
Form_pg_foreign_data_wrapper
Form_pg_foreign_server
GIST_SPLITVEC
GV
Gene
+GenericCosts
GenericExprState
GeqoPrivateData
GetForeignPaths_function
GetForeignPlan_function
GetForeignRelSize_function
+GetState
GiSTOptions
GinBtree
GinBtreeData
GinBuildState
GinChkVal
GinEntryAccumulator
+GinIndexStat
GinMetaPageData
GinNullCategory
GinOptions
HbaToken
HeadlineParsedText
HeadlineWordEntry
-HeapPosition
HeapScanDesc
HeapTuple
HeapTupleData
HeapTupleFields
HeapTupleHeader
HeapTupleHeaderData
+HeapUpdateFailureData
HistControl
HotStandbyState
I32
IPCompareMethod
ITEM
IV
+IdentLine
IdentifierLookup
IdentifySystemCmd
IncrementVarSublevelsUp_context
IndexScan
IndexScanDesc
IndexScanState
+IndexStateFlagsAction
IndexStmt
IndexTuple
IndexTupleData
ItemPointer
ItemPointerData
IterateForeignScan_function
+JHashState
JOBOBJECTINFOCLASS
JOBOBJECT_BASIC_LIMIT_INFORMATION
JOBOBJECT_BASIC_UI_RESTRICTIONS
JoinPath
JoinState
JoinType
+JsonHashEntry
JsonLexContext
-JsonParseStack
-JsonParseState
-JsonStackOp
-JsonValueType
+JsonParseContext
+JsonSearch
+JsonSemAction
+JsonTokenType
JunkFilter
KeyArray
KeySuffix
LARGE_INTEGER
LDAP
LDAPMessage
+LDAPURLDesc
LDAP_TIMEVAL
LINE
LOCALLOCK
LabelProvider
LargeObjectDesc
Latch
+LateralJoinInfo
LexDescr
LexemeEntry
LexemeHashKey
LocalTransactionId
LocationIndex
LockAcquireResult
+LockClauseStrength
LockData
LockInfoData
LockInstanceData
MINIDUMPWRITEDUMP
MINIDUMP_TYPE
MJEvalResult
+MasterEndParallelItemPtr
+MasterStartParallelItemPtr
Material
MaterialPath
MaterialState
ModifyTableState
MsgType
MultiXactId
+MultiXactMember
MultiXactOffset
MultiXactStateData
+MultiXactStatus
MyData
NDBOX
NODE
Numeric
NumericDigit
NumericVar
+OM_uint32
OP
OSInfo
OSSLDigest
OSVERSIONINFO
OVERLAPPED
ObjectAccessDrop
+ObjectAccessNamespaceSearch
+ObjectAccessPostAlter
+ObjectAccessPostCreate
ObjectAccessType
ObjectAddress
ObjectAddressExtra
OffsetVarNodes_context
Oid
OidOptions
+OkeysState
OldSerXidControl
OldToNewMapping
OldToNewMappingData
PLpgSQL_stmt_return_next
PLpgSQL_stmt_return_query
PLpgSQL_stmt_while
+PLpgSQL_trigtype
PLpgSQL_type
PLpgSQL_var
PLpgSQL_variable
PLyPlanObject
PLyProcedure
PLyProcedureEntry
+PLyProcedureKey
PLyResultObject
PLySubtransactionData
PLySubtransactionObject
PQnoticeProcessor
PQnoticeReceiver
PQprintOpt
-PQrowProcessor
PREDICATELOCK
PREDICATELOCKTAG
PREDICATELOCKTARGET
PX_HMAC
PX_MD
Page
+PageGistNSN
PageHeader
PageHeaderData
PageSplitRecord
+PageXLogRecPtr
PagetableEntry
Pairs
+ParallelArgs
ParallelSlot
ParallelState
-ParallelStateEntry
Param
ParamExecData
ParamExternData
ParamRef
ParentMapEntry
ParseCallbackState
+ParseExprKind
+ParseNamespaceItem
ParseParamRefHook
ParseState
ParsedLex
Pattern_Prefix_Status
Pattern_Type
PendingOperationEntry
-PendingOperationTag
PendingRelDelete
PendingUnlinkEntry
PerlInterpreter
Perl_ppaddr_t
PgBackendStatus
+PgFdwAnalyzeState
+PgFdwModifyState
+PgFdwOption
+PgFdwRelationInfo
+PgFdwScanState
PgIfAddrCallback
PgStat_BackendFunctionEntry
PgStat_Counter
PlaceHolderInfo
PlaceHolderVar
Plan
+PlanForeignModify_function
PlanInvalItem
PlanRowMark
PlanState
Point
Pointer
Pool
+PopulateRecordsetState
Port
Portal
PortalHashEnt
PrepareStmt
PreparedParamsData
PreparedStatement
-PrimaryKeepaliveMessage
PrintExtraTocPtr
PrintTocDataPtr
PrintfArgType
ProcSignalReason
ProcSignalSlot
ProcState
+ProcessUtilityContext
ProcessUtility_hook_type
ProcessingMode
ProjectionInfo
RecursionContext
RecursiveUnion
RecursiveUnionState
+RefreshMatViewStmt
RegProcedure
Regis
RegisNode
+RegisteredBgWorker
ReindexStmt
RelFileNode
RelFileNodeBackend
RelocationBufferInfo
RenameStmt
ReopenPtr
+ReplaceVarsFromTargetList_context
+ReplaceVarsNoMatchOption
ResTarget
-ResolveNew_context
ResourceOwner
ResourceReleaseCallback
ResourceReleaseCallbackItem
ResourceReleasePhase
-RestoreArgs
RestoreOptions
RestrictInfo
Result
RewriteRule
RewriteState
RmgrData
+RmgrDescData
RmgrId
RoleStmtType
RowCompareExpr
SISeg
SMgrRelation
SMgrRelationData
+SOCKADDR
SOCKET
SPELL
SPIPlanPtr
SPNode
SPNodeData
SPPageDesc
+SQLDropObject
SQLFunctionCache
SQLFunctionCachePtr
SQLFunctionParseInfoPtr
SetOperation
SetOperationStmt
SetToDefault
+SetupWorkerPtr
SharedDependencyType
SharedInvalCatalogMsg
SharedInvalCatcacheMsg
SplitedPageLayout
StackElem
StandardChunkHeader
-StandbyHSFeedbackMessage
-StandbyReplyMessage
StartBlobPtr
StartBlobsPtr
StartDataPtr
SubXactEvent
SubqueryScan
SubqueryScanState
-SuffixChar
Syn
SysScanDesc
SyscacheCallbackFunction
TStoreState
TTOffList
TYPCATEGORY
+T_Action
+T_WorkerStatus
TabStatusArray
TableDataInfo
TableInfo
TimeADT
TimeInterval
TimeIntervalData
+TimeLineHistoryCmd
+TimeLineHistoryEntry
TimeLineID
TimeOffset
TimeStamp
TimeTzADT
TimeZoneAbbrevTable
+TimeoutId
+TimeoutType
Timestamp
TimestampTz
TmFromChar
TransactionStateData
TransactionStmt
TransactionStmtKind
+TrgmArc
+TrgmArcInfo
+TrgmColor
+TrgmColorInfo
+TrgmNFA
+TrgmPackArcInfo
+TrgmPackedArc
+TrgmPackedGraph
+TrgmPackedState
+TrgmPrefix
+TrgmState
+TrgmStateKey
+TrieChar
Trigger
TriggerData
TriggerDesc
WSADATA
WSANETWORKEVENTS
WSAPROTOCOL_INFO
-WalDataMessageHeader
WalLevel
WalRcvData
WalRcvState
WalSnd
WalSndCtlData
WalSndState
-WalSndrMessage
+WholeRowVarExprState
WindowAgg
WindowAggState
WindowClause
WorkTableScan
WorkTableScanState
WorkerInfo
+WorkerInfoData
+WorkerJobDumpPtr
+WorkerJobRestorePtr
Working_State
WriteBufPtr
WriteBytePtr
X509_NAME_ENTRY
X509_STORE
X509_STORE_CTX
-XLogContRecord
XLogCtlData
XLogCtlInsert
XLogCtlWrite
+XLogDumpConfig
+XLogDumpPrivate
XLogLongPageHeader
XLogLongPageHeaderData
XLogPageHeader
XLogPageHeaderData
+XLogPageReadCB
+XLogPageReadPrivate
+XLogReaderState
XLogRecData
XLogRecPtr
XLogRecord
+XLogSegNo
+XLogSource
XLogwrtResult
XLogwrtRqst
XPVIV
backslashResult
base_yy_extra_type
basebackup_options
+bgworker_main_type
+bgworker_sighdlr_type
+binaryheap
+binaryheap_comparator
bitmapword
bits16
bits32
cashKEY
celt
cfp
+check_agg_arguments_context
check_network_data
check_object_relabel_type
check_password_hook_type
dateKEY
datetkn
decimal
+deparse_columns
deparse_context
+deparse_expr_cxt
deparse_namespace
destructor
dev_t
directory_fctx
+dlist_head
+dlist_iter
+dlist_mutable_iter
+dlist_node
ds_state
eLogType
ean13
eary
+ec_matches_callback_type
+ec_member_foreign_arg
+ec_member_matches_arg
emit_log_hook_type
eval_const_expressions_context
+event_trigger_command_tag_check_result
+event_trigger_support_data
+exec_thread_arg
execution_state
explain_get_index_name_hook_type
f_smgr
fd_set
finalize_primnode_context
find_expr_references_context
-find_minimum_var_level_context
fix_join_expr_context
fix_scan_expr_context
fix_upper_expr_context
fmNodePtr
fmStringInfo
fmgr_hook_type
+foreign_glob_cxt
+foreign_loc_cxt
freeaddrinfo_ptr_t
freefunc
fsec_t
ginxlogUpdateMeta
ginxlogVacuumPage
gistxlogPage
-gistxlogPageDelete
gistxlogPageSplit
gistxlogPageUpdate
gseg_picksplit_item
+gss_OID
gss_buffer_desc
+gss_cred_id_t
+gss_ctx_id_t
+gss_name_t
+gtrgm_consistent_cache
gzFile
hashfunc
hbaPort
inet_struct
inline_error_callback_arg
ino_t
+inquiry
instr_time
int16
int16KEY
-int2
int2vector
int32
int32KEY
int32_t
-int4
int64
int64KEY
int8
+internalPQconninfoOption
intptr_t
intvKEY
itemIdSort
itemIdSortData
jmp_buf
join_search_hook_type
+jsonSemAction
+json_aelem_action
+json_ofield_action
+json_scalar_action
+json_struct_action
keyEntryData
key_t
-krb5_auth_context
-krb5_ccache
-krb5_context
-krb5_error
-krb5_error_code
-krb5_keytab
-krb5_pointer
-krb5_principal
-krb5_ticket
lclContext
lclTocEntry
line_t
locale_t
locate_agg_of_level_context
locate_var_of_level_context
-locate_var_of_relation_context
locate_windowfunc_context
logstreamer_param
lquery
mXactCacheEnt
macKEY
macaddr
+map_variable_attnos_context
mb2wchar_with_len_converter
mbcharacter_incrementer
mbdisplaylen_converter
mp_size
mp_word
mpz_t
+mxact
+mxtruncinfo
needs_fmgr_hook_type
nodeitem
normal_rand_fctx
pg_enc2name
pg_encname
pg_gssinfo
+pg_int64
pg_local_to_utf
pg_local_to_utf_combined
pg_locale_t
pull_var_clause_context
pull_varattnos_context
pull_varnos_context
+pull_vars_context
pullup_replace_vars_context
qsort_arg_comparator
+query_pathkeys_callback
radius_attribute
radius_packet
rangeTableEntry_used_context
rb_comparator
rb_freefunc
reduce_outer_joins_state
+regex_arc_t
regex_t
-regexp
regexp_matches_ctx
regmatch_t
regoff_t
signedbitmapword
sigset_t
size_t
+slist_head
+slist_iter
+slist_mutable_iter
+slist_node
slock_t
smgrid
spgBulkDeleteState
ss_scan_location_t
ss_scan_locations_t
ssize_t
+standard_qp_extra
stemmer_module
stmtCacheEntry
storeInfo
text
timeKEY
time_t
+timeout_handler_proc
+timeout_params
timerCA
timezone_extra
tlist_vinfo
transferMode
+transfer_thread_arg
trgm
+trgm_mb_char
tsKEY
ts_db_fctx
ts_tokentype
varattrib_4b
walrcv_connect_type
walrcv_disconnect_type
+walrcv_endstreaming_type
+walrcv_identify_system_type
+walrcv_readtimelinehistoryfile_type
walrcv_receive_type
walrcv_send_type
+walrcv_startstreaming_type
+wchar2mb_with_len_converter
wchar_t
win32_deadchild_waitinfo
win32_pthread
wint_t
+worktable
xl_btree_delete
xl_btree_delete_page
xl_btree_insert
xl_btreetid
xl_dbase_create_rec
xl_dbase_drop_rec
+xl_end_of_recovery
xl_heap_clean
xl_heap_cleanup_info
xl_heap_delete
xl_heap_inplace
xl_heap_insert
xl_heap_lock
+xl_heap_lock_updated
xl_heap_multi_insert
xl_heap_newpage
xl_heap_update
xmlChar
xmlDocPtr
xmlErrorPtr
+xmlExternalEntityLoader
xmlGenericErrorFunc
xmlNodePtr
xmlNodeSetPtr
xmlXPathObjectPtr
xmltype
xpath_workspace
+xsltSecurityPrefsPtr
xsltStylesheetPtr
+xsltTransformContextPtr
yy_parser
yy_size_t
yyscan_t
projects / postgresql.git / commitdiff