database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-18 13:44:19 +03:00
Code

Pre-beta mechanical code beautification.

Browse Source 
Run pgindent, pgperltidy, and reformat-dat-files.
I manually fixed a couple of comments that pgindent uglified.
This commit is contained in:
Tom Lane 2022-05-12 15:17:30 -04:00
parent 93909599cd
commit 23e7b38bfe
287 changed files with 5193 additions and 3549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
config/check_modules.pl
View File

@ -21,8 +21,7 @@ diag("Test::More::VERSION: $Test::More::VERSION");
diag("Time::HiRes::VERSION: $Time::HiRes::VERSION");
# Check that if prove is using msys perl it is for an msys target
ok(($ENV{__CONFIG_HOST_OS__} || "") eq 'msys',
"Msys perl used for correct target")
if $Config{osname} eq 'msys';
ok( ($ENV{__CONFIG_HOST_OS__} || "") eq 'msys',
"Msys perl used for correct target") if $Config{osname} eq 'msys';
ok(1);
done_testing();

6
contrib/amcheck/verify_heapam.c
View File

@ -1402,17 +1402,17 @@ check_tuple_attribute(HeapCheckContext *ctx)
cmid = TOAST_COMPRESS_METHOD(&toast_pointer);
switch (cmid)
{
/* List of all valid compression method IDs */
/* List of all valid compression method IDs */
case TOAST_PGLZ_COMPRESSION_ID:
case TOAST_LZ4_COMPRESSION_ID:
valid = true;
break;
/* Recognized but invalid compression method ID */
/* Recognized but invalid compression method ID */
case TOAST_INVALID_COMPRESSION_ID:
break;
/* Intentionally no default here */
/* Intentionally no default here */
}
if (!valid)
report_corruption(ctx,

27
contrib/basebackup_to_shell/basebackup_to_shell.c
View File

@ -37,13 +37,13 @@ typedef struct bbsink_shell
FILE *pipe;
} bbsink_shell;
void _PG_init(void);
void _PG_init(void);
static void *shell_check_detail(char *target, char *target_detail);
static bbsink *shell_get_sink(bbsink *next_sink, void *detail_arg);
static void bbsink_shell_begin_archive(bbsink *sink,
const char *archive_name);
const char *archive_name);
static void bbsink_shell_archive_contents(bbsink *sink, size_t len);
static void bbsink_shell_end_archive(bbsink *sink);
static void bbsink_shell_begin_manifest(bbsink *sink);
@ -101,7 +101,7 @@ shell_check_detail(char *target, char *target_detail)
{
if (shell_required_role[0] != '\0')
{
Oid roleid;
Oid roleid;
StartTransactionCommand();
roleid = get_role_oid(shell_required_role, true);
@ -125,8 +125,8 @@ static bbsink *
shell_get_sink(bbsink *next_sink, void *detail_arg)
{
bbsink_shell *sink;
bool has_detail_escape = false;
char *c;
bool has_detail_escape = false;
char *c;
/*
* Set up the bbsink.
@ -171,15 +171,15 @@ shell_get_sink(bbsink *next_sink, void *detail_arg)
/*
* Since we're passing the string provided by the user to popen(), it will
* be interpreted by the shell, which is a potential security
* vulnerability, since the user invoking this module is not necessarily
* a superuser. To stay out of trouble, we must disallow any shell
* vulnerability, since the user invoking this module is not necessarily a
* superuser. To stay out of trouble, we must disallow any shell
* metacharacters here; to be conservative and keep things simple, we
* allow only alphanumerics.
*/
if (sink->target_detail != NULL)
{
char *d;
bool scary = false;
char *d;
bool scary = false;
for (d = sink->target_detail; *d != '\0'; ++d)
{
@ -210,7 +210,7 @@ static char *
shell_construct_command(char *base_command, const char *filename,
char *target_detail)
{
StringInfoData buf;
StringInfoData buf;
char *c;
initStringInfo(&buf);
@ -271,7 +271,7 @@ shell_construct_command(char *base_command, const char *filename,
static void
shell_finish_command(bbsink_shell *sink)
{
int pclose_rc;
int pclose_rc;
/* There should be a command running. */
Assert(sink->current_command != NULL);
@ -335,9 +335,8 @@ shell_send_data(bbsink_shell *sink, size_t len)
{
/*
* The error we're about to throw would shut down the command
* anyway, but we may get a more meaningful error message by
* doing this. If not, we'll fall through to the generic error
* below.
* anyway, but we may get a more meaningful error message by doing
* this. If not, we'll fall through to the generic error below.
*/
shell_finish_command(sink);
errno = EPIPE;

71
contrib/basebackup_to_shell/t/001_basic.pl
View File

@ -20,11 +20,12 @@ my $node = PostgreSQL::Test::Cluster->new('primary');
# Make sure pg_hba.conf is set up to allow connections from backupuser.
# This is only needed on Windows machines that don't use UNIX sockets.
$node->init('allows_streaming' => 1,
'auth_extra' => [ '--create-role', 'backupuser' ]);
$node->init(
'allows_streaming' => 1,
'auth_extra' => [ '--create-role', 'backupuser' ]);
$node->append_conf('postgresql.conf',
"shared_preload_libraries = 'basebackup_to_shell'");
"shared_preload_libraries = 'basebackup_to_shell'");
$node->start;
$node->safe_psql('postgres', 'CREATE USER backupuser REPLICATION');
$node->safe_psql('postgres', 'CREATE ROLE trustworthy');
@ -41,61 +42,61 @@ my @pg_basebackup_cmd = (@pg_basebackup_defs, '-U', 'backupuser', '-Xfetch');
# Can't use this module without setting basebackup_to_shell.command.
$node->command_fails_like(
[ @pg_basebackup_cmd, '--target', 'shell' ],
[ @pg_basebackup_cmd, '--target', 'shell' ],
qr/shell command for backup is not configured/,
'fails if basebackup_to_shell.command is not set');
# Configure basebackup_to_shell.command and reload the configuation file.
my $backup_path = PostgreSQL::Test::Utils::tempdir;
my $backup_path = PostgreSQL::Test::Utils::tempdir;
my $escaped_backup_path = $backup_path;
$escaped_backup_path =~ s{\\}{\\\\}g if ($PostgreSQL::Test::Utils::windows_os);
$escaped_backup_path =~ s{\\}{\\\\}g
if ($PostgreSQL::Test::Utils::windows_os);
my $shell_command =
$PostgreSQL::Test::Utils::windows_os
? qq{$gzip --fast > "$escaped_backup_path\\\\%f.gz"}
: qq{$gzip --fast > "$escaped_backup_path/%f.gz"};
$PostgreSQL::Test::Utils::windows_os
? qq{$gzip --fast > "$escaped_backup_path\\\\%f.gz"}
: qq{$gzip --fast > "$escaped_backup_path/%f.gz"};
$node->append_conf('postgresql.conf',
"basebackup_to_shell.command='$shell_command'");
"basebackup_to_shell.command='$shell_command'");
$node->reload();
# Should work now.
$node->command_ok(
[ @pg_basebackup_cmd, '--target', 'shell' ],
[ @pg_basebackup_cmd, '--target', 'shell' ],
'backup with no detail: pg_basebackup');
verify_backup('', $backup_path, "backup with no detail");
# Should fail with a detail.
$node->command_fails_like(
[ @pg_basebackup_cmd, '--target', 'shell:foo' ],
[ @pg_basebackup_cmd, '--target', 'shell:foo' ],
qr/a target detail is not permitted because the configured command does not include %d/,
'fails if detail provided without %d');
# Reconfigure to restrict access and require a detail.
$shell_command =
$PostgreSQL::Test::Utils::windows_os
? qq{$gzip --fast > "$escaped_backup_path\\\\%d.%f.gz"}
: qq{$gzip --fast > "$escaped_backup_path/%d.%f.gz"};
$PostgreSQL::Test::Utils::windows_os
? qq{$gzip --fast > "$escaped_backup_path\\\\%d.%f.gz"}
: qq{$gzip --fast > "$escaped_backup_path/%d.%f.gz"};
$node->append_conf('postgresql.conf',
"basebackup_to_shell.command='$shell_command'");
"basebackup_to_shell.command='$shell_command'");
$node->append_conf('postgresql.conf',
"basebackup_to_shell.required_role='trustworthy'");
"basebackup_to_shell.required_role='trustworthy'");
$node->reload();
# Should fail due to lack of permission.
$node->command_fails_like(
[ @pg_basebackup_cmd, '--target', 'shell' ],
[ @pg_basebackup_cmd, '--target', 'shell' ],
qr/permission denied to use basebackup_to_shell/,
'fails if required_role not granted');
# Should fail due to lack of a detail.
$node->safe_psql('postgres', 'GRANT trustworthy TO backupuser');
$node->command_fails_like(
[ @pg_basebackup_cmd, '--target', 'shell' ],
[ @pg_basebackup_cmd, '--target', 'shell' ],
qr/a target detail is required because the configured command includes %d/,
'fails if %d is present and detail not given');
# Should work.
$node->command_ok(
[ @pg_basebackup_cmd, '--target', 'shell:bar' ],
$node->command_ok([ @pg_basebackup_cmd, '--target', 'shell:bar' ],
'backup with detail: pg_basebackup');
verify_backup('bar.', $backup_path, "backup with detail");
@ -105,30 +106,34 @@ sub verify_backup
{
my ($prefix, $backup_dir, $test_name) = @_;
ok(-f "$backup_dir/${prefix}backup_manifest.gz",
"$test_name: backup_manifest.gz was created");
ok(-f "$backup_dir/${prefix}base.tar.gz",
"$test_name: base.tar.gz was created");
ok( -f "$backup_dir/${prefix}backup_manifest.gz",
"$test_name: backup_manifest.gz was created");
ok( -f "$backup_dir/${prefix}base.tar.gz",
"$test_name: base.tar.gz was created");
SKIP: {
SKIP:
{
my $tar = $ENV{TAR};
skip "no tar program available", 1 if (!defined $tar || $tar eq '');
# Decompress.
system_or_bail($gzip, '-d',
$backup_dir . '/' . $prefix . 'backup_manifest.gz');
$backup_dir . '/' . $prefix . 'backup_manifest.gz');
system_or_bail($gzip, '-d',
$backup_dir . '/' . $prefix . 'base.tar.gz');
$backup_dir . '/' . $prefix . 'base.tar.gz');
# Untar.
my $extract_path = PostgreSQL::Test::Utils::tempdir;
system_or_bail($tar, 'xf', $backup_dir . '/' . $prefix . 'base.tar',
'-C', $extract_path);
'-C', $extract_path);
# Verify.
$node->command_ok([ 'pg_verifybackup', '-n',
'-m', "${backup_dir}/${prefix}backup_manifest",
'-e', $extract_path ],
"$test_name: backup verifies ok");
$node->command_ok(
[
'pg_verifybackup', '-n',
'-m', "${backup_dir}/${prefix}backup_manifest",
'-e', $extract_path
],
"$test_name: backup verifies ok");
}
}

51
contrib/basic_archive/basic_archive.c
View File

@ -40,8 +40,8 @@
PG_MODULE_MAGIC;
void _PG_init(void);
void _PG_archive_module_init(ArchiveModuleCallbacks *cb);
void _PG_init(void);
void _PG_archive_module_init(ArchiveModuleCallbacks *cb);
static char *archive_directory = NULL;
static MemoryContext basic_archive_context;
@ -102,8 +102,8 @@ check_archive_directory(char **newval, void **extra, GucSource source)
/*
* The default value is an empty string, so we have to accept that value.
* Our check_configured callback also checks for this and prevents archiving
* from proceeding if it is still empty.
* Our check_configured callback also checks for this and prevents
* archiving from proceeding if it is still empty.
*/
if (*newval == NULL || *newval[0] == '\0')
return true;
@ -119,7 +119,7 @@ check_archive_directory(char **newval, void **extra, GucSource source)
}
/*
* Do a basic sanity check that the specified archive directory exists. It
* Do a basic sanity check that the specified archive directory exists. It
* could be removed at some point in the future, so we still need to be
* prepared for it not to exist in the actual archiving logic.
*/
@ -155,18 +155,19 @@ basic_archive_file(const char *file, const char *path)
MemoryContext oldcontext;
/*
* We run basic_archive_file_internal() in our own memory context so that we
* can easily reset it during error recovery (thus avoiding memory leaks).
* We run basic_archive_file_internal() in our own memory context so that
* we can easily reset it during error recovery (thus avoiding memory
* leaks).
*/
oldcontext = MemoryContextSwitchTo(basic_archive_context);
/*
* Since the archiver operates at the bottom of the exception stack, ERRORs
* turn into FATALs and cause the archiver process to restart. However,
* using ereport(ERROR, ...) when there are problems is easy to code and
* maintain. Therefore, we create our own exception handler to catch ERRORs
* and return false instead of restarting the archiver whenever there is a
* failure.
* Since the archiver operates at the bottom of the exception stack,
* ERRORs turn into FATALs and cause the archiver process to restart.
* However, using ereport(ERROR, ...) when there are problems is easy to
* code and maintain. Therefore, we create our own exception handler to
* catch ERRORs and return false instead of restarting the archiver
* whenever there is a failure.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
@ -228,14 +229,14 @@ basic_archive_file_internal(const char *file, const char *path)
snprintf(destination, MAXPGPATH, "%s/%s", archive_directory, file);
/*
* First, check if the file has already been archived. If it already exists
* and has the same contents as the file we're trying to archive, we can
* return success (after ensuring the file is persisted to disk). This
* scenario is possible if the server crashed after archiving the file but
* before renaming its .ready file to .done.
* First, check if the file has already been archived. If it already
* exists and has the same contents as the file we're trying to archive,
* we can return success (after ensuring the file is persisted to disk).
* This scenario is possible if the server crashed after archiving the
* file but before renaming its .ready file to .done.
*
* If the archive file already exists but has different contents, something
* might be wrong, so we just fail.
* If the archive file already exists but has different contents,
* something might be wrong, so we just fail.
*/
if (stat(destination, &st) == 0)
{
@ -274,8 +275,8 @@ basic_archive_file_internal(const char *file, const char *path)
archive_directory, "archtemp", file, MyProcPid, epoch);
/*
* Copy the file to its temporary destination. Note that this will fail if
* temp already exists.
* Copy the file to its temporary destination. Note that this will fail
* if temp already exists.
*/
copy_file(unconstify(char *, path), temp);
@ -318,9 +319,9 @@ compare_files(const char *file1, const char *file2)
for (;;)
{
int nbytes = 0;
int buf1_len = 0;
int buf2_len = 0;
int nbytes = 0;
int buf1_len = 0;
int buf2_len = 0;
while (buf1_len < CMP_BUF_SIZE)
{

4
contrib/btree_gist/btree_bool.c
View File

@ -53,8 +53,8 @@ gbt_boollt(const void *a, const void *b, FmgrInfo *flinfo)
static int
gbt_boolkey_cmp(const void *a, const void *b, FmgrInfo *flinfo)
{
boolKEY *ia = (boolKEY *) (((const Nsrt *) a)->t);
boolKEY *ib = (boolKEY *) (((const Nsrt *) b)->t);
boolKEY *ia = (boolKEY *) (((const Nsrt *) a)->t);
boolKEY *ib = (boolKEY *) (((const Nsrt *) b)->t);
if (ia->lower == ib->lower)
{

4
contrib/hstore_plpython/hstore_plpython.c
View File

@ -99,7 +99,7 @@ hstore_to_plpython(PG_FUNCTION_ARGS)
PyObject *key;
key = PLyUnicode_FromStringAndSize(HSTORE_KEY(entries, base, i),
HSTORE_KEYLEN(entries, i));
HSTORE_KEYLEN(entries, i));
if (HSTORE_VALISNULL(entries, i))
PyDict_SetItem(dict, key, Py_None);
else
@ -107,7 +107,7 @@ hstore_to_plpython(PG_FUNCTION_ARGS)
PyObject *value;
value = PLyUnicode_FromStringAndSize(HSTORE_VAL(entries, base, i),
HSTORE_VALLEN(entries, i));
HSTORE_VALLEN(entries, i));
PyDict_SetItem(dict, key, value);
Py_XDECREF(value);
}

24
contrib/pageinspect/brinfuncs.c
View File

@ -63,12 +63,12 @@ brin_page_type(PG_FUNCTION_ARGS)
/* verify the special space has the expected size */
if (PageGetSpecialSize(page) != MAXALIGN(sizeof(BrinSpecialSpace)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "BRIN"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(BrinSpecialSpace)),
(int) PageGetSpecialSize(page))));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "BRIN"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(BrinSpecialSpace)),
(int) PageGetSpecialSize(page))));
switch (BrinPageType(page))
{
@ -103,12 +103,12 @@ verify_brin_page(bytea *raw_page, uint16 type, const char *strtype)
/* verify the special space has the expected size */
if (PageGetSpecialSize(page) != MAXALIGN(sizeof(BrinSpecialSpace)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "BRIN"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(BrinSpecialSpace)),
(int) PageGetSpecialSize(page))));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "BRIN"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(BrinSpecialSpace)),
(int) PageGetSpecialSize(page))));
/* verify the special space says this page is what we want */
if (BrinPageType(page) != type)

48
contrib/pageinspect/gistfuncs.c
View File

@ -60,21 +60,21 @@ gist_page_opaque_info(PG_FUNCTION_ARGS)
/* verify the special space has the expected size */
if (PageGetSpecialSize(page) != MAXALIGN(sizeof(GISTPageOpaqueData)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(GISTPageOpaqueData)),
(int) PageGetSpecialSize(page))));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(GISTPageOpaqueData)),
(int) PageGetSpecialSize(page))));
opaq = GistPageGetOpaque(page);
if (opaq->gist_page_id != GIST_PAGE_ID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected %08x, got %08x.",
GIST_PAGE_ID,
opaq->gist_page_id)));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected %08x, got %08x.",
GIST_PAGE_ID,
opaq->gist_page_id)));
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
@ -138,21 +138,21 @@ gist_page_items_bytea(PG_FUNCTION_ARGS)
/* verify the special space has the expected size */
if (PageGetSpecialSize(page) != MAXALIGN(sizeof(GISTPageOpaqueData)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(GISTPageOpaqueData)),
(int) PageGetSpecialSize(page))));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected special size %d, got %d.",
(int) MAXALIGN(sizeof(GISTPageOpaqueData)),
(int) PageGetSpecialSize(page))));
opaq = GistPageGetOpaque(page);
if (opaq->gist_page_id != GIST_PAGE_ID)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected %08x, got %08x.",
GIST_PAGE_ID,
opaq->gist_page_id)));
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("input page is not a valid %s page", "GiST"),
errdetail("Expected %08x, got %08x.",
GIST_PAGE_ID,
opaq->gist_page_id)));
/* Avoid bogus PageGetMaxOffsetNumber() call with deleted pages */
if (GistPageIsDeleted(page))

5
contrib/pg_stat_statements/pg_stat_statements.c
View File

@ -1533,7 +1533,10 @@ pg_stat_statements_internal(FunctionCallInfo fcinfo,
HASH_SEQ_STATUS hash_seq;
pgssEntry *entry;
/* Superusers or roles with the privileges of pg_read_all_stats members are allowed */
/*
* Superusers or roles with the privileges of pg_read_all_stats members
* are allowed
*/
is_allowed_role = has_privs_of_role(userid, ROLE_PG_READ_ALL_STATS);
/* hash table must exist already */

60
contrib/pg_walinspect/pg_walinspect.c
View File

@ -47,7 +47,7 @@ static XLogRecPtr ValidateInputLSNs(bool till_end_of_wal,
XLogRecPtr start_lsn, XLogRecPtr end_lsn);
static void GetWALRecordsInfo(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
XLogRecPtr end_lsn);
static void GetXLogSummaryStats(XLogStats * stats, ReturnSetInfo *rsinfo,
static void GetXLogSummaryStats(XLogStats *stats, ReturnSetInfo *rsinfo,
Datum *values, bool *nulls, uint32 ncols,
bool stats_per_record);
static void FillXLogStatsRow(const char *name, uint64 n, uint64 total_count,
@ -102,7 +102,7 @@ InitXLogReaderState(XLogRecPtr lsn, XLogRecPtr *first_record)
LSN_FORMAT_ARGS(lsn))));
private_data = (ReadLocalXLogPageNoWaitPrivate *)
palloc0(sizeof(ReadLocalXLogPageNoWaitPrivate));
palloc0(sizeof(ReadLocalXLogPageNoWaitPrivate));
xlogreader = XLogReaderAllocate(wal_segment_size, NULL,
XL_ROUTINE(.page_read = &read_local_xlog_page_no_wait,
@ -143,7 +143,7 @@ static XLogRecord *
ReadNextXLogRecord(XLogReaderState *xlogreader, XLogRecPtr first_record)
{
XLogRecord *record;
char *errormsg;
char *errormsg;
record = XLogReadRecord(xlogreader, &errormsg);
@ -153,7 +153,7 @@ ReadNextXLogRecord(XLogReaderState *xlogreader, XLogRecPtr first_record)
/* return NULL, if end of WAL is reached */
private_data = (ReadLocalXLogPageNoWaitPrivate *)
xlogreader->private_data;
xlogreader->private_data;
if (private_data->end_of_wal)
return NULL;
@ -181,12 +181,12 @@ GetWALRecordInfo(XLogReaderState *record, XLogRecPtr lsn,
Datum *values, bool *nulls, uint32 ncols)
{
const char *id;
RmgrData desc;
uint32 fpi_len = 0;
RmgrData desc;
uint32 fpi_len = 0;
StringInfoData rec_desc;
StringInfoData rec_blk_ref;
uint32 main_data_len;
int i = 0;
uint32 main_data_len;
int i = 0;
desc = GetRmgr(XLogRecGetRmid(record));
id = desc.rm_identify(XLogRecGetInfo(record));
@ -228,9 +228,9 @@ Datum
pg_get_wal_record_info(PG_FUNCTION_ARGS)
{
#define PG_GET_WAL_RECORD_INFO_COLS 11
Datum result;
Datum values[PG_GET_WAL_RECORD_INFO_COLS];
bool nulls[PG_GET_WAL_RECORD_INFO_COLS];
Datum result;
Datum values[PG_GET_WAL_RECORD_INFO_COLS];
bool nulls[PG_GET_WAL_RECORD_INFO_COLS];
XLogRecPtr lsn;
XLogRecPtr curr_lsn;
XLogRecPtr first_record;
@ -334,8 +334,8 @@ GetWALRecordsInfo(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
XLogRecPtr first_record;
XLogReaderState *xlogreader;
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
Datum values[PG_GET_WAL_RECORDS_INFO_COLS];
bool nulls[PG_GET_WAL_RECORDS_INFO_COLS];
Datum values[PG_GET_WAL_RECORDS_INFO_COLS];
bool nulls[PG_GET_WAL_RECORDS_INFO_COLS];
SetSingleFuncCall(fcinfo, 0);
@ -418,11 +418,11 @@ FillXLogStatsRow(const char *name,
uint64 tot_len, uint64 total_len,
Datum *values, bool *nulls, uint32 ncols)
{
double n_pct,
rec_len_pct,
fpi_len_pct,
tot_len_pct;
int i = 0;
double n_pct,
rec_len_pct,
fpi_len_pct,
tot_len_pct;
int i = 0;
n_pct = 0;
if (total_count != 0)
@ -461,11 +461,11 @@ GetXLogSummaryStats(XLogStats *stats, ReturnSetInfo *rsinfo,
Datum *values, bool *nulls, uint32 ncols,
bool stats_per_record)
{
uint64 total_count = 0;
uint64 total_rec_len = 0;
uint64 total_fpi_len = 0;
uint64 total_len = 0;
int ri;
uint64 total_count = 0;
uint64 total_rec_len = 0;
uint64 total_fpi_len = 0;
uint64 total_len = 0;
int ri;
/*
* Each row shows its percentages of the total, so make a first pass to
@ -488,7 +488,7 @@ GetXLogSummaryStats(XLogStats *stats, ReturnSetInfo *rsinfo,
uint64 rec_len;
uint64 fpi_len;
uint64 tot_len;
RmgrData desc;
RmgrData desc;
if (!RmgrIdIsValid(ri))
continue;
@ -500,7 +500,7 @@ GetXLogSummaryStats(XLogStats *stats, ReturnSetInfo *rsinfo,
if (stats_per_record)
{
int rj;
int rj;
for (rj = 0; rj < MAX_XLINFO_TYPES; rj++)
{
@ -556,10 +556,10 @@ GetWalStats(FunctionCallInfo fcinfo, XLogRecPtr start_lsn,
#define PG_GET_WAL_STATS_COLS 9
XLogRecPtr first_record;
XLogReaderState *xlogreader;
XLogStats stats;
XLogStats stats;
ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
Datum values[PG_GET_WAL_STATS_COLS];
bool nulls[PG_GET_WAL_STATS_COLS];
Datum values[PG_GET_WAL_STATS_COLS];
bool nulls[PG_GET_WAL_STATS_COLS];
SetSingleFuncCall(fcinfo, 0);
@ -599,7 +599,7 @@ pg_get_wal_stats(PG_FUNCTION_ARGS)
{
XLogRecPtr start_lsn;
XLogRecPtr end_lsn;
bool stats_per_record;
bool stats_per_record;
start_lsn = PG_GETARG_LSN(0);
end_lsn = PG_GETARG_LSN(1);
@ -623,7 +623,7 @@ pg_get_wal_stats_till_end_of_wal(PG_FUNCTION_ARGS)
{
XLogRecPtr start_lsn;
XLogRecPtr end_lsn = InvalidXLogRecPtr;
bool stats_per_record;
bool stats_per_record;
start_lsn = PG_GETARG_LSN(0);
stats_per_record = PG_GETARG_BOOL(1);

6
contrib/pgcrypto/openssl.c
View File

@ -373,7 +373,8 @@ gen_ossl_decrypt(PX_Cipher *c, int padding, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen)
{
OSSLCipher *od = c->ptr;
int outlen, outlen2;
int outlen,
outlen2;
if (!od->init)
{
@ -402,7 +403,8 @@ gen_ossl_encrypt(PX_Cipher *c, int padding, const uint8 *data, unsigned dlen,
uint8 *res, unsigned *rlen)
{
OSSLCipher *od = c->ptr;
int outlen, outlen2;
int outlen,
outlen2;
if (!od->init)
{

68
contrib/pgstattuple/pgstattuple.c
View File

@ -255,46 +255,46 @@ pgstat_relation(Relation rel, FunctionCallInfo fcinfo)
if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind) ||
rel->rd_rel->relkind == RELKIND_SEQUENCE)
{
return pgstat_heap(rel, fcinfo);
return pgstat_heap(rel, fcinfo);
}
else if (rel->rd_rel->relkind == RELKIND_INDEX)
{
switch (rel->rd_rel->relam)
{
case BTREE_AM_OID:
return pgstat_index(rel, BTREE_METAPAGE + 1,
pgstat_btree_page, fcinfo);
case HASH_AM_OID:
return pgstat_index(rel, HASH_METAPAGE + 1,
pgstat_hash_page, fcinfo);
case GIST_AM_OID:
return pgstat_index(rel, GIST_ROOT_BLKNO + 1,
pgstat_gist_page, fcinfo);
case GIN_AM_OID:
err = "gin index";
break;
case SPGIST_AM_OID:
err = "spgist index";
break;
case BRIN_AM_OID:
err = "brin index";
break;
default:
err = "unknown index";
break;
}
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("index \"%s\" (%s) is not supported",
RelationGetRelationName(rel), err)));
switch (rel->rd_rel->relam)
{
case BTREE_AM_OID:
return pgstat_index(rel, BTREE_METAPAGE + 1,
pgstat_btree_page, fcinfo);
case HASH_AM_OID:
return pgstat_index(rel, HASH_METAPAGE + 1,
pgstat_hash_page, fcinfo);
case GIST_AM_OID:
return pgstat_index(rel, GIST_ROOT_BLKNO + 1,
pgstat_gist_page, fcinfo);
case GIN_AM_OID:
err = "gin index";
break;
case SPGIST_AM_OID:
err = "spgist index";
break;
case BRIN_AM_OID:
err = "brin index";
break;
default:
err = "unknown index";
break;
}
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("index \"%s\" (%s) is not supported",
RelationGetRelationName(rel), err)));
}
else
{
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot get tuple-level statistics for relation \"%s\"",
RelationGetRelationName(rel)),
errdetail_relkind_not_supported(rel->rd_rel->relkind)));
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot get tuple-level statistics for relation \"%s\"",
RelationGetRelationName(rel)),
errdetail_relkind_not_supported(rel->rd_rel->relkind)));
}
return 0; /* should not happen */

10
contrib/postgres_fdw/connection.c
View File

@ -654,10 +654,10 @@ do_sql_command_end(PGconn *conn, const char *sql, bool consume_input)
PGresult *res;
/*
* If requested, consume whatever data is available from the socket.
* (Note that if all data is available, this allows pgfdw_get_result to
* call PQgetResult without forcing the overhead of WaitLatchOrSocket,
* which would be large compared to the overhead of PQconsumeInput.)
* If requested, consume whatever data is available from the socket. (Note
* that if all data is available, this allows pgfdw_get_result to call
* PQgetResult without forcing the overhead of WaitLatchOrSocket, which
* would be large compared to the overhead of PQconsumeInput.)
*/
if (consume_input && !PQconsumeInput(conn))
pgfdw_report_error(ERROR, NULL, conn, false, sql);
@ -1560,6 +1560,7 @@ pgfdw_finish_pre_commit_cleanup(List *pending_entries)
entry = (ConnCacheEntry *) lfirst(lc);
Assert(entry->changing_xact_state);
/*
* We might already have received the result on the socket, so pass
* consume_input=true to try to consume it first
@ -1634,6 +1635,7 @@ pgfdw_finish_pre_subcommit_cleanup(List *pending_entries, int curlevel)
entry = (ConnCacheEntry *) lfirst(lc);
Assert(entry->changing_xact_state);
/*
* We might already have received the result on the socket, so pass
* consume_input=true to try to consume it first

10
contrib/postgres_fdw/postgres_fdw.c
View File

@ -1243,9 +1243,9 @@ postgresGetForeignPlan(PlannerInfo *root,
if (best_path->fdw_private)
{
has_final_sort = boolVal(list_nth(best_path->fdw_private,
FdwPathPrivateHasFinalSort));
FdwPathPrivateHasFinalSort));
has_limit = boolVal(list_nth(best_path->fdw_private,
FdwPathPrivateHasLimit));
FdwPathPrivateHasLimit));
}
if (IS_SIMPLE_REL(foreignrel))
@ -1926,7 +1926,7 @@ postgresBeginForeignModify(ModifyTableState *mtstate,
values_end_len = intVal(list_nth(fdw_private,
FdwModifyPrivateLen));
has_returning = boolVal(list_nth(fdw_private,
FdwModifyPrivateHasReturning));
FdwModifyPrivateHasReturning));
retrieved_attrs = (List *) list_nth(fdw_private,
FdwModifyPrivateRetrievedAttrs);
@ -2686,11 +2686,11 @@ postgresBeginDirectModify(ForeignScanState *node, int eflags)
dmstate->query = strVal(list_nth(fsplan->fdw_private,
FdwDirectModifyPrivateUpdateSql));
dmstate->has_returning = boolVal(list_nth(fsplan->fdw_private,
FdwDirectModifyPrivateHasReturning));
FdwDirectModifyPrivateHasReturning));
dmstate->retrieved_attrs = (List *) list_nth(fsplan->fdw_private,
FdwDirectModifyPrivateRetrievedAttrs);
dmstate->set_processed = boolVal(list_nth(fsplan->fdw_private,
FdwDirectModifyPrivateSetProcessed));
FdwDirectModifyPrivateSetProcessed));
/* Create context for per-tuple temp workspace. */
dmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,

8
contrib/test_decoding/test_decoding.c
View File

@ -300,8 +300,8 @@ pg_decode_begin_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn)
txn->output_plugin_private = txndata;
/*
* If asked to skip empty transactions, we'll emit BEGIN at the point where
* the first operation is received for this transaction.
* If asked to skip empty transactions, we'll emit BEGIN at the point
* where the first operation is received for this transaction.
*/
if (data->skip_empty_xacts)
return;
@ -360,8 +360,8 @@ pg_decode_begin_prepare_txn(LogicalDecodingContext *ctx, ReorderBufferTXN *txn)
txn->output_plugin_private = txndata;
/*
* If asked to skip empty transactions, we'll emit BEGIN at the point where
* the first operation is received for this transaction.
* If asked to skip empty transactions, we'll emit BEGIN at the point
* where the first operation is received for this transaction.
*/
if (data->skip_empty_xacts)
return;

6
src/backend/access/common/toast_internals.c
View File

@ -663,9 +663,9 @@ init_toast_snapshot(Snapshot toast_snapshot)
/*
* Catalog snapshots can be returned by GetOldestSnapshot() even if not
* registered or active. That easily hides bugs around not having a
* snapshot set up - most of the time there is a valid catalog
* snapshot. So additionally insist that the current snapshot is
* registered or active.
* snapshot set up - most of the time there is a valid catalog snapshot.
* So additionally insist that the current snapshot is registered or
* active.
*/
Assert(HaveRegisteredOrActiveSnapshot());

12
src/backend/access/heap/pruneheap.c
View File

@ -68,9 +68,9 @@ typedef struct
/*
* Tuple visibility is only computed once for each tuple, for correctness
* and efficiency reasons; see comment in heap_page_prune() for
* details. This is of type int8[,] instead of HTSV_Result[], so we can use
* -1 to indicate no visibility has been computed, e.g. for LP_DEAD items.
* and efficiency reasons; see comment in heap_page_prune() for details.
* This is of type int8[], instead of HTSV_Result[], so we can use -1 to
* indicate no visibility has been computed, e.g. for LP_DEAD items.
*
* Same indexing as ->marked.
*/
@ -203,8 +203,8 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
*/
if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree)
{
int ndeleted,
nnewlpdead;
int ndeleted,
nnewlpdead;
ndeleted = heap_page_prune(relation, buffer, vistest, limited_xmin,
limited_ts, &nnewlpdead, NULL);
@ -267,7 +267,7 @@ heap_page_prune(Relation relation, Buffer buffer,
GlobalVisState *vistest,
TransactionId old_snap_xmin,
TimestampTz old_snap_ts,
int *nnewlpdead,
int *nnewlpdead,
OffsetNumber *off_loc)
{
int ndeleted = 0;

14
src/backend/access/heap/vacuumlazy.c
View File

@ -326,7 +326,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
PGRUsage ru0;
TimestampTz starttime = 0;
PgStat_Counter startreadtime = 0,
startwritetime = 0;
startwritetime = 0;
WalUsage startwalusage = pgWalUsage;
int64 StartPageHit = VacuumPageHit,
StartPageMiss = VacuumPageMiss,
@ -2232,12 +2232,12 @@ lazy_vacuum(LVRelState *vacrel)
* dead_items space is not CPU cache resident.
*
* We don't take any special steps to remember the LP_DEAD items (such
* as counting them in our final update to the stats system) when
* the optimization is applied. Though the accounting used in
* analyze.c's acquire_sample_rows() will recognize the same LP_DEAD
* items as dead rows in its own stats report, that's okay.
* The discrepancy should be negligible. If this optimization is ever
* expanded to cover more cases then this may need to be reconsidered.
* as counting them in our final update to the stats system) when the
* optimization is applied. Though the accounting used in analyze.c's
* acquire_sample_rows() will recognize the same LP_DEAD items as dead
* rows in its own stats report, that's okay. The discrepancy should
* be negligible. If this optimization is ever expanded to cover more
* cases then this may need to be reconsidered.
*/
threshold = (double) vacrel->rel_pages * BYPASS_THRESHOLD_PAGES;
bypass = (vacrel->lpdead_item_pages < threshold &&

4
src/backend/access/rmgrdesc/xactdesc.c
View File

@ -411,8 +411,8 @@ xact_desc_prepare(StringInfo buf, uint8 info, xl_xact_prepare *xlrec, RepOriginI
parsed.tsId, xlrec->initfileinval);
/*
* Check if the replication origin has been set in this record in the
* same way as PrepareRedoAdd().
* Check if the replication origin has been set in this record in the same
* way as PrepareRedoAdd().
*/
if (origin_id != InvalidRepOriginId)
appendStringInfo(buf, "; origin: node %u, lsn %X/%X, at %s",

2
src/backend/access/rmgrdesc/xlogdesc.c
View File

@ -210,7 +210,7 @@ XLogRecGetBlockRefInfo(XLogReaderState *record, bool pretty,
bool detailed_format, StringInfo buf,
uint32 *fpi_len)
{
int block_id;
int block_id;
Assert(record != NULL);

6
src/backend/access/transam/rmgr.c
View File

@ -38,7 +38,7 @@
#define PG_RMGR(symname,name,redo,desc,identify,startup,cleanup,mask,decode) \
{ name, redo, desc, identify, startup, cleanup, mask, decode },
RmgrData RmgrTable[RM_MAX_ID + 1] = {
RmgrData RmgrTable[RM_MAX_ID + 1] = {
#include "access/rmgrlist.h"
};
@ -125,8 +125,8 @@ RegisterCustomRmgr(RmgrId rmid, RmgrData *rmgr)
if (!pg_strcasecmp(RmgrTable[existing_rmid].rm_name, rmgr->rm_name))
ereport(ERROR,
(errmsg("failed to register custom resource manager \"%s\" with ID %d", rmgr->rm_name, rmid),
errdetail("Existing resource manager with ID %d has the same name.", existing_rmid)));
(errmsg("failed to register custom resource manager \"%s\" with ID %d", rmgr->rm_name, rmid),
errdetail("Existing resource manager with ID %d has the same name.", existing_rmid)));
}
/* register it */

6
src/backend/access/transam/twophase.c
View File

@ -1119,7 +1119,7 @@ StartPrepare(GlobalTransaction gxact)
if (hdr.nabortstats > 0)
{
save_state_data(abortstats,
hdr.nabortstats * sizeof(xl_xact_stats_item));
hdr.nabortstats * sizeof(xl_xact_stats_item));
pfree(abortstats);
}
if (hdr.ninvalmsgs > 0)
@ -1529,9 +1529,9 @@ FinishPreparedTransaction(const char *gid, bool isCommit)
bufptr += MAXALIGN(hdr->ncommitrels * sizeof(RelFileNode));
abortrels = (RelFileNode *) bufptr;
bufptr += MAXALIGN(hdr->nabortrels * sizeof(RelFileNode));
commitstats = (xl_xact_stats_item*) bufptr;
commitstats = (xl_xact_stats_item *) bufptr;
bufptr += MAXALIGN(hdr->ncommitstats * sizeof(xl_xact_stats_item));
abortstats = (xl_xact_stats_item*) bufptr;
abortstats = (xl_xact_stats_item *) bufptr;
bufptr += MAXALIGN(hdr->nabortstats * sizeof(xl_xact_stats_item));
invalmsgs = (SharedInvalidationMessage *) bufptr;
bufptr += MAXALIGN(hdr->ninvalmsgs * sizeof(SharedInvalidationMessage));

28
src/backend/access/transam/xlog.c
View File

@ -435,10 +435,10 @@ typedef struct XLogCtlInsert
bool fullPageWrites;
/*
* runningBackups is a counter indicating the number of backups currently in
* progress. forcePageWrites is set to true when runningBackups is non-zero.
* lastBackupStart is the latest checkpoint redo location used as a starting
* point for an online backup.
* runningBackups is a counter indicating the number of backups currently
* in progress. forcePageWrites is set to true when runningBackups is
* non-zero. lastBackupStart is the latest checkpoint redo location used
* as a starting point for an online backup.
*/
int runningBackups;
XLogRecPtr lastBackupStart;
@ -5307,14 +5307,14 @@ StartupXLOG(void)
* When recovering from a backup (we are in recovery, and archive recovery
* was requested), complain if we did not roll forward far enough to reach
* the point where the database is consistent. For regular online
* backup-from-primary, that means reaching the end-of-backup WAL record (at
* which point we reset backupStartPoint to be Invalid), for
* backup-from-primary, that means reaching the end-of-backup WAL record
* (at which point we reset backupStartPoint to be Invalid), for
* backup-from-replica (which can't inject records into the WAL stream),
* that point is when we reach the minRecoveryPoint in pg_control (which
* we purposfully copy last when backing up from a replica). For pg_rewind
* (which creates a backup_label with a method of "pg_rewind") or
* snapshot-style backups (which don't), backupEndRequired will be set to
* false.
* we purposefully copy last when backing up from a replica). For
* pg_rewind (which creates a backup_label with a method of "pg_rewind")
* or snapshot-style backups (which don't), backupEndRequired will be set
* to false.
*
* Note: it is indeed okay to look at the local variable
* LocalMinRecoveryPoint here, even though ControlFile->minRecoveryPoint
@ -5328,8 +5328,8 @@ StartupXLOG(void)
/*
* Ran off end of WAL before reaching end-of-backup WAL record, or
* minRecoveryPoint. That's a bad sign, indicating that you tried to
* recover from an online backup but never called pg_backup_stop(),
* or you didn't archive all the WAL needed.
* recover from an online backup but never called pg_backup_stop(), or
* you didn't archive all the WAL needed.
*/
if (ArchiveRecoveryRequested || ControlFile->backupEndRequired)
{
@ -8481,8 +8481,8 @@ do_pg_backup_stop(char *labelfile, bool waitforarchive, TimeLineID *stoptli_p)
WALInsertLockAcquireExclusive();
/*
* It is expected that each do_pg_backup_start() call is matched by exactly
* one do_pg_backup_stop() call.
* It is expected that each do_pg_backup_start() call is matched by
* exactly one do_pg_backup_stop() call.
*/
Assert(XLogCtl->Insert.runningBackups > 0);
XLogCtl->Insert.runningBackups--;

16
src/backend/access/transam/xlogarchive.c
View File

@ -497,15 +497,15 @@ XLogArchiveNotify(const char *xlog)
}
/*
* Timeline history files are given the highest archival priority to
* lower the chance that a promoted standby will choose a timeline that
* is already in use. However, the archiver ordinarily tries to gather
* Timeline history files are given the highest archival priority to lower
* the chance that a promoted standby will choose a timeline that is
* already in use. However, the archiver ordinarily tries to gather
* multiple files to archive from each scan of the archive_status
* directory, which means that newly created timeline history files
* could be left unarchived for a while. To ensure that the archiver
* picks up timeline history files as soon as possible, we force the
* archiver to scan the archive_status directory the next time it looks
* for a file to archive.
* directory, which means that newly created timeline history files could
* be left unarchived for a while. To ensure that the archiver picks up
* timeline history files as soon as possible, we force the archiver to
* scan the archive_status directory the next time it looks for a file to
* archive.
*/
if (IsTLHistoryFileName(xlog))
PgArchForceDirScan();

8
src/backend/access/transam/xlogfuncs.c
View File

@ -74,8 +74,8 @@ pg_backup_start(PG_FUNCTION_ARGS)
errmsg("a backup is already in progress in this session")));
/*
* Label file and tablespace map file need to be long-lived, since
* they are read in pg_backup_stop.
* Label file and tablespace map file need to be long-lived, since they
* are read in pg_backup_stop.
*/
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
label_file = makeStringInfo();
@ -127,8 +127,8 @@ pg_backup_stop(PG_FUNCTION_ARGS)
errhint("Did you call pg_backup_start()?")));
/*
* Stop the backup. Return a copy of the backup label and tablespace map so
* they can be written to disk by the caller.
* Stop the backup. Return a copy of the backup label and tablespace map
* so they can be written to disk by the caller.
*/
stoppoint = do_pg_backup_stop(label_file->data, waitforarchive, NULL);

15
src/backend/access/transam/xlogrecovery.c
View File

@ -1205,9 +1205,9 @@ read_backup_label(XLogRecPtr *checkPointLoc, TimeLineID *backupLabelTLI,
* method was used) or if this label came from somewhere else (the only
* other option today being from pg_rewind). If this was a streamed
* backup then we know that we need to play through until we get to the
* end of the WAL which was generated during the backup (at which point
* we will have reached consistency and backupEndRequired will be reset
* to be false).
* end of the WAL which was generated during the backup (at which point we
* will have reached consistency and backupEndRequired will be reset to be
* false).
*/
if (fscanf(lfp, "BACKUP METHOD: %19s\n", backuptype) == 1)
{
@ -2055,10 +2055,9 @@ CheckRecoveryConsistency(void)
/*
* Have we passed our safe starting point? Note that minRecoveryPoint is
* known to be incorrectly set if recovering from a backup, until
* the XLOG_BACKUP_END arrives to advise us of the correct
* minRecoveryPoint. All we know prior to that is that we're not
* consistent yet.
* known to be incorrectly set if recovering from a backup, until the
* XLOG_BACKUP_END arrives to advise us of the correct minRecoveryPoint.
* All we know prior to that is that we're not consistent yet.
*/
if (!reachedConsistency && !backupEndRequired &&
minRecoveryPoint <= lastReplayedEndRecPtr)
@ -3802,7 +3801,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess,
HandleStartupProcInterrupts();
}
return XLREAD_FAIL; /* not reached */
return XLREAD_FAIL; /* not reached */
}

10
src/backend/access/transam/xlogstats.c
View File

@ -22,7 +22,7 @@ void
XLogRecGetLen(XLogReaderState *record, uint32 *rec_len,
uint32 *fpi_len)
{
int block_id;
int block_id;
/*
* Calculate the amount of FPI data in the record.
@ -53,10 +53,10 @@ XLogRecGetLen(XLogReaderState *record, uint32 *rec_len,
void
XLogRecStoreStats(XLogStats *stats, XLogReaderState *record)
{
RmgrId rmid;
uint8 recid;
uint32 rec_len;
uint32 fpi_len;
RmgrId rmid;
uint8 recid;
uint32 rec_len;
uint32 fpi_len;
Assert(stats != NULL && record != NULL);

13
src/backend/access/transam/xlogutils.c
View File

@ -80,10 +80,9 @@ typedef struct xl_invalid_page
static HTAB *invalid_page_tab = NULL;
static int
read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
int reqLen, XLogRecPtr targetRecPtr,
char *cur_page, bool wait_for_wal);
static int read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
int reqLen, XLogRecPtr targetRecPtr,
char *cur_page, bool wait_for_wal);
/* Report a reference to an invalid page */
static void
@ -940,8 +939,8 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
* archive in the timeline will get renamed to .partial by
* StartupXLOG().
*
* If that happens after our caller determined the TLI but before
* we actually read the xlog page, we might still try to read from the
* If that happens after our caller determined the TLI but before we
* actually read the xlog page, we might still try to read from the
* old (now renamed) segment and fail. There's not much we can do
* about this, but it can only happen when we're a leaf of a cascading
* standby whose primary gets promoted while we're decoding, so a
@ -965,7 +964,7 @@ read_local_xlog_page_guts(XLogReaderState *state, XLogRecPtr targetPagePtr,
* end of WAL has been reached.
*/
private_data = (ReadLocalXLogPageNoWaitPrivate *)
state->private_data;
state->private_data;
private_data->end_of_wal = true;
break;
}

23
src/backend/catalog/Catalog.pm
View File

@ -41,12 +41,12 @@ sub ParseHeader
my $is_varlen = 0;
my $is_client_code = 0;
$catalog{columns} = [];
$catalog{toasting} = [];
$catalog{indexing} = [];
$catalog{other_oids} = [];
$catalog{columns} = [];
$catalog{toasting} = [];
$catalog{indexing} = [];
$catalog{other_oids} = [];
$catalog{foreign_keys} = [];
$catalog{client_code} = [];
$catalog{client_code} = [];
open(my $ifh, '<', $input_file) || die "$input_file: $!";
@ -96,7 +96,9 @@ sub ParseHeader
push @{ $catalog{toasting} },
{ parent_table => $1, toast_oid => $2, toast_index_oid => $3 };
}
elsif (/^DECLARE_TOAST_WITH_MACRO\(\s*(\w+),\s*(\d+),\s*(\d+),\s*(\w+),\s*(\w+)\)/)
elsif (
/^DECLARE_TOAST_WITH_MACRO\(\s*(\w+),\s*(\d+),\s*(\d+),\s*(\w+),\s*(\w+)\)/
)
{
push @{ $catalog{toasting} },
{
@ -108,16 +110,17 @@ sub ParseHeader
};
}
elsif (
/^DECLARE_(UNIQUE_)?INDEX(_PKEY)?\(\s*(\w+),\s*(\d+),\s*(\w+),\s*(.+)\)/)
/^DECLARE_(UNIQUE_)?INDEX(_PKEY)?\(\s*(\w+),\s*(\d+),\s*(\w+),\s*(.+)\)/
)
{
push @{ $catalog{indexing} },
{
is_unique => $1 ? 1 : 0,
is_pkey => $2 ? 1 : 0,
index_name => $3,
index_oid => $4,
index_name => $3,
index_oid => $4,
index_oid_macro => $5,
index_decl => $6
index_decl => $6
};
}
elsif (/^DECLARE_OID_DEFINING_MACRO\(\s*(\w+),\s*(\d+)\)/)

12
src/backend/catalog/genbki.pl
View File

@ -814,7 +814,7 @@ Catalog::RenameTempFile($schemafile, $tmpext);
Catalog::RenameTempFile($fk_info_file, $tmpext);
Catalog::RenameTempFile($constraints_file, $tmpext);
exit ($num_errors != 0 ? 1 : 0);
exit($num_errors != 0 ? 1 : 0);
#################### Subroutines ########################
@ -916,11 +916,11 @@ sub morph_row_for_pgattr
# Copy the type data from pg_type, and add some type-dependent items
my $type = $types{$atttype};
$row->{atttypid} = $type->{oid};
$row->{attlen} = $type->{typlen};
$row->{attbyval} = $type->{typbyval};
$row->{attalign} = $type->{typalign};
$row->{attstorage} = $type->{typstorage};
$row->{atttypid} = $type->{oid};
$row->{attlen} = $type->{typlen};
$row->{attbyval} = $type->{typbyval};
$row->{attalign} = $type->{typalign};
$row->{attstorage} = $type->{typstorage};
# set attndims if it's an array type
$row->{attndims} = $type->{typcategory} eq 'A' ? '1' : '0';

11
src/backend/catalog/heap.c
View File

@ -1198,7 +1198,7 @@ heap_create_with_catalog(const char *relname,
if (!OidIsValid(binary_upgrade_next_toast_pg_class_relfilenode))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("toast relfilenode value not set when in binary upgrade mode")));
errmsg("toast relfilenode value not set when in binary upgrade mode")));
relfilenode = binary_upgrade_next_toast_pg_class_relfilenode;
binary_upgrade_next_toast_pg_class_relfilenode = InvalidOid;
@ -1265,8 +1265,8 @@ heap_create_with_catalog(const char *relname,
* remove the disk file again.)
*
* NB: Note that passing create_storage = true is correct even for binary
* upgrade. The storage we create here will be replaced later, but we need
* to have something on disk in the meanwhile.
* upgrade. The storage we create here will be replaced later, but we
* need to have something on disk in the meanwhile.
*/
new_rel_desc = heap_create(relname,
relnamespace,
@ -3219,9 +3219,8 @@ restart:
/*
* If this constraint has a parent constraint which we have not seen
* yet, keep track of it for the second loop, below. Tracking parent
* constraints allows us to climb up to the top-level constraint
* and look for all possible relations referencing the partitioned
* table.
* constraints allows us to climb up to the top-level constraint and
* look for all possible relations referencing the partitioned table.
*/
if (OidIsValid(con->conparentid) &&
!list_member_oid(parent_cons, con->conparentid))

6
src/backend/catalog/index.c
View File

@ -928,9 +928,9 @@ index_create(Relation heapRelation,
binary_upgrade_next_index_pg_class_relfilenode = InvalidOid;
/*
* Note that we want create_storage = true for binary upgrade.
* The storage we create here will be replaced later, but we need
* to have something on disk in the meanwhile.
* Note that we want create_storage = true for binary upgrade. The
* storage we create here will be replaced later, but we need to
* have something on disk in the meanwhile.
*/
Assert(create_storage);
}

30
src/backend/catalog/objectaccess.c
View File

@ -156,7 +156,7 @@ RunFunctionExecuteHook(Oid objectId)
*/
void
RunObjectPostCreateHookStr(Oid classId, const char *objectName, int subId,
bool is_internal)
bool is_internal)
{
ObjectAccessPostCreate pc_arg;
@ -167,8 +167,8 @@ RunObjectPostCreateHookStr(Oid classId, const char *objectName, int subId,
pc_arg.is_internal = is_internal;
(*object_access_hook_str) (OAT_POST_CREATE,
classId, objectName, subId,
(void *) &pc_arg);
classId, objectName, subId,
(void *) &pc_arg);
}
/*
@ -178,7 +178,7 @@ RunObjectPostCreateHookStr(Oid classId, const char *objectName, int subId,
*/
void
RunObjectDropHookStr(Oid classId, const char *objectName, int subId,
int dropflags)
int dropflags)
{
ObjectAccessDrop drop_arg;
@ -189,8 +189,8 @@ RunObjectDropHookStr(Oid classId, const char *objectName, int subId,
drop_arg.dropflags = dropflags;
(*object_access_hook_str) (OAT_DROP,
classId, objectName, subId,
(void *) &drop_arg);
classId, objectName, subId,
(void *) &drop_arg);
}
/*
@ -205,8 +205,8 @@ RunObjectTruncateHookStr(const char *objectName)
Assert(object_access_hook_str != NULL);
(*object_access_hook_str) (OAT_TRUNCATE,
RelationRelationId, objectName, 0,
NULL);
RelationRelationId, objectName, 0,
NULL);
}
/*
@ -216,7 +216,7 @@ RunObjectTruncateHookStr(const char *objectName)
*/
void
RunObjectPostAlterHookStr(Oid classId, const char *objectName, int subId,
Oid auxiliaryId, bool is_internal)
Oid auxiliaryId, bool is_internal)
{
ObjectAccessPostAlter pa_arg;
@ -228,8 +228,8 @@ RunObjectPostAlterHookStr(Oid classId, const char *objectName, int subId,
pa_arg.is_internal = is_internal;
(*object_access_hook_str) (OAT_POST_ALTER,
classId, objectName, subId,
(void *) &pa_arg);
classId, objectName, subId,
(void *) &pa_arg);
}
/*
@ -250,8 +250,8 @@ RunNamespaceSearchHookStr(const char *objectName, bool ereport_on_violation)
ns_arg.result = true;
(*object_access_hook_str) (OAT_NAMESPACE_SEARCH,
NamespaceRelationId, objectName, 0,
(void *) &ns_arg);
NamespaceRelationId, objectName, 0,
(void *) &ns_arg);
return ns_arg.result;
}
@ -268,6 +268,6 @@ RunFunctionExecuteHookStr(const char *objectName)
Assert(object_access_hook_str != NULL);
(*object_access_hook_str) (OAT_FUNCTION_EXECUTE,
ProcedureRelationId, objectName, 0,
NULL);
ProcedureRelationId, objectName, 0,
NULL);
}

6
src/backend/catalog/pg_constraint.c
View File

@ -145,7 +145,7 @@ CreateConstraintEntry(const char *constraintName,
for (i = 0; i < numFkDeleteSetCols; i++)
fkdatums[i] = Int16GetDatum(fkDeleteSetCols[i]);
confdelsetcolsArray = construct_array(fkdatums, numFkDeleteSetCols,
INT2OID, 2, true, TYPALIGN_SHORT);
INT2OID, 2, true, TYPALIGN_SHORT);
}
else
confdelsetcolsArray = NULL;
@ -1291,7 +1291,7 @@ DeconstructFkConstraintRow(HeapTuple tuple, int *numfks,
}
else
{
int num_delete_cols;
int num_delete_cols;
arr = DatumGetArrayTypeP(adatum); /* ensure not toasted */
if (ARR_NDIM(arr) != 1 ||
@ -1301,7 +1301,7 @@ DeconstructFkConstraintRow(HeapTuple tuple, int *numfks,
num_delete_cols = ARR_DIMS(arr)[0];
memcpy(fk_del_set_cols, ARR_DATA_PTR(arr), num_delete_cols * sizeof(int16));
if ((Pointer) arr != DatumGetPointer(adatum))
pfree(arr); /* free de-toasted copy, if any */
pfree(arr); /* free de-toasted copy, if any */
*num_fk_del_set_cols = num_delete_cols;
}

12
src/backend/catalog/pg_publication.c
View File

@ -378,9 +378,9 @@ publication_add_relation(Oid pubid, PublicationRelInfo *pri,
check_publication_add_relation(targetrel);
/*
* Translate column names to attnums and make sure the column list contains
* only allowed elements (no system or generated columns etc.). Also build
* an array of attnums, for storing in the catalog.
* Translate column names to attnums and make sure the column list
* contains only allowed elements (no system or generated columns etc.).
* Also build an array of attnums, for storing in the catalog.
*/
publication_translate_columns(pri->relation, pri->columns,
&natts, &attarray);
@ -555,11 +555,11 @@ pub_collist_to_bitmapset(Bitmapset *columns, Datum pubcols, MemoryContext mcxt)
ArrayType *arr;
int nelems;
int16 *elems;
MemoryContext oldcxt = NULL;
MemoryContext oldcxt = NULL;
/*
* If an existing bitmap was provided, use it. Otherwise just use NULL
* and build a new bitmap.
* If an existing bitmap was provided, use it. Otherwise just use NULL and
* build a new bitmap.
*/
if (columns)
result = columns;

12
src/backend/catalog/storage.c
View File

@ -340,13 +340,13 @@ RelationTruncate(Relation rel, BlockNumber nblocks)
* is in progress.
*
* The truncation operation might drop buffers that the checkpoint
* otherwise would have flushed. If it does, then it's essential that
* the files actually get truncated on disk before the checkpoint record
* is written. Otherwise, if reply begins from that checkpoint, the
* otherwise would have flushed. If it does, then it's essential that the
* files actually get truncated on disk before the checkpoint record is
* written. Otherwise, if reply begins from that checkpoint, the
* to-be-truncated blocks might still exist on disk but have older
* contents than expected, which can cause replay to fail. It's OK for
* the blocks to not exist on disk at all, but not for them to have the
* wrong contents.
* contents than expected, which can cause replay to fail. It's OK for the
* blocks to not exist on disk at all, but not for them to have the wrong
* contents.
*/
Assert((MyProc->delayChkptFlags & DELAY_CHKPT_COMPLETE) == 0);
MyProc->delayChkptFlags |= DELAY_CHKPT_COMPLETE;

10
src/backend/commands/analyze.c
View File

@ -429,7 +429,7 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
*/
if (onerel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
List *idxs = RelationGetIndexList(onerel);
List *idxs = RelationGetIndexList(onerel);
Irel = NULL;
nindexes = 0;
@ -680,10 +680,10 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
}
/*
* Now report ANALYZE to the cumulative stats system. For regular tables, we do
* it only if not doing inherited stats. For partitioned tables, we only
* do it for inherited stats. (We're never called for not-inherited stats
* on partitioned tables anyway.)
* Now report ANALYZE to the cumulative stats system. For regular tables,
* we do it only if not doing inherited stats. For partitioned tables, we
* only do it for inherited stats. (We're never called for not-inherited
* stats on partitioned tables anyway.)
*
* Reset the changes_since_analyze counter only if we analyzed all
* columns; otherwise, there is still work for auto-analyze to do.

5
src/backend/commands/collationcmds.c
View File

@ -246,8 +246,9 @@ DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_e
/*
* Nondeterministic collations are currently only supported with ICU
* because that's the only case where it can actually make a difference.
* So we can save writing the code for the other providers.
* because that's the only case where it can actually make a
* difference. So we can save writing the code for the other
* providers.
*/
if (!collisdeterministic && collprovider != COLLPROVIDER_ICU)
ereport(ERROR,

6
src/backend/commands/copy.c
View File

@ -345,7 +345,7 @@ defGetCopyHeaderChoice(DefElem *def)
break;
default:
{
char *sval = defGetString(def);
char *sval = defGetString(def);
/*
* The set of strings accepted here should match up with the
@ -365,8 +365,8 @@ defGetCopyHeaderChoice(DefElem *def)
break;
}
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("%s requires a Boolean value or \"match\"",
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("%s requires a Boolean value or \"match\"",
def->defname)));
return COPY_HEADER_FALSE; /* keep compiler quiet */
}

3
src/backend/commands/copyfromparse.c
View File

@ -800,7 +800,8 @@ NextCopyFromRawFields(CopyFromState cstate, char ***fields, int *nfields)
errmsg("column name mismatch in header line field %d: got null value (\"%s\"), expected \"%s\"",
fldnum, cstate->opts.null_print, NameStr(attr->attname))));
if (namestrcmp(&attr->attname, colName) != 0) {
if (namestrcmp(&attr->attname, colName) != 0)
{
ereport(ERROR,
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
errmsg("column name mismatch in header line field %d: got \"%s\", expected \"%s\"",

6
src/backend/commands/copyto.c
View File

@ -439,8 +439,8 @@ BeginCopyTo(ParseState *pstate,
* locks on the source table(s).
*/
rewritten = pg_analyze_and_rewrite_fixedparams(raw_query,
pstate->p_sourcetext, NULL, 0,
NULL);
pstate->p_sourcetext, NULL, 0,
NULL);
/* check that we got back something we can work with */
if (rewritten == NIL)
@ -862,7 +862,7 @@ DoCopyTo(CopyToState cstate)
if (cstate->opts.csv_mode)
CopyAttributeOutCSV(cstate, colname, false,
list_length(cstate->attnumlist) == 1);
list_length(cstate->attnumlist) == 1);
else
CopyAttributeOutText(cstate, colname);
}

64
src/backend/commands/dbcommands.c
View File

@ -201,9 +201,9 @@ CreateDatabaseUsingWalLog(Oid src_dboid, Oid dst_dboid,
*
* We typically do not read relation data into shared_buffers without
* holding a relation lock. It's unclear what could go wrong if we
* skipped it in this case, because nobody can be modifying either
* the source or destination database at this point, and we have locks
* on both databases, too, but let's take the conservative route.
* skipped it in this case, because nobody can be modifying either the
* source or destination database at this point, and we have locks on
* both databases, too, but let's take the conservative route.
*/
dstrelid.relId = srcrelid.relId = relinfo->reloid;
LockRelationId(&srcrelid, AccessShareLock);
@ -274,9 +274,9 @@ ScanSourceDatabasePgClass(Oid tbid, Oid dbid, char *srcpath)
/*
* We can't use a real relcache entry for a relation in some other
* database, but since we're only going to access the fields related
* to physical storage, a fake one is good enough. If we didn't do this
* and used the smgr layer directly, we would have to worry about
* database, but since we're only going to access the fields related to
* physical storage, a fake one is good enough. If we didn't do this and
* used the smgr layer directly, we would have to worry about
* invalidations.
*/
rel = CreateFakeRelcacheEntry(rnode);
@ -333,10 +333,10 @@ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
char *srcpath, List *rnodelist,
Snapshot snapshot)
{
BlockNumber blkno = BufferGetBlockNumber(buf);
OffsetNumber offnum;
OffsetNumber maxoff;
HeapTupleData tuple;
BlockNumber blkno = BufferGetBlockNumber(buf);
OffsetNumber offnum;
OffsetNumber maxoff;
HeapTupleData tuple;
maxoff = PageGetMaxOffsetNumber(page);
@ -368,10 +368,10 @@ ScanSourceDatabasePgClassPage(Page page, Buffer buf, Oid tbid, Oid dbid,
CreateDBRelInfo *relinfo;
/*
* ScanSourceDatabasePgClassTuple is in charge of constructing
* a CreateDBRelInfo object for this tuple, but can also decide
* that this tuple isn't something we need to copy. If we do need
* to copy the relation, add it to the list.
* ScanSourceDatabasePgClassTuple is in charge of constructing a
* CreateDBRelInfo object for this tuple, but can also decide that
* this tuple isn't something we need to copy. If we do need to
* copy the relation, add it to the list.
*/
relinfo = ScanSourceDatabasePgClassTuple(&tuple, tbid, dbid,
srcpath);
@ -395,9 +395,9 @@ CreateDBRelInfo *
ScanSourceDatabasePgClassTuple(HeapTupleData *tuple, Oid tbid, Oid dbid,
char *srcpath)
{
CreateDBRelInfo *relinfo;
Form_pg_class classForm;
Oid relfilenode = InvalidOid;
CreateDBRelInfo *relinfo;
Form_pg_class classForm;
Oid relfilenode = InvalidOid;
classForm = (Form_pg_class) GETSTRUCT(tuple);
@ -406,11 +406,11 @@ ScanSourceDatabasePgClassTuple(HeapTupleData *tuple, Oid tbid, Oid dbid,
*
* Shared objects don't need to be copied, because they are shared.
* Objects without storage can't be copied, because there's nothing to
* copy. Temporary relations don't need to be copied either, because
* they are inaccessible outside of the session that created them,
* which must be gone already, and couldn't connect to a different database
* if it still existed. autovacuum will eventually remove the pg_class
* entries as well.
* copy. Temporary relations don't need to be copied either, because they
* are inaccessible outside of the session that created them, which must
* be gone already, and couldn't connect to a different database if it
* still existed. autovacuum will eventually remove the pg_class entries
* as well.
*/
if (classForm->reltablespace == GLOBALTABLESPACE_OID ||
!RELKIND_HAS_STORAGE(classForm->relkind) ||
@ -702,7 +702,7 @@ createdb(ParseState *pstate, const CreatedbStmt *stmt)
DefElem *dcollate = NULL;
DefElem *dctype = NULL;
DefElem *diculocale = NULL;
DefElem *dlocprovider = NULL;
DefElem *dlocprovider = NULL;
DefElem *distemplate = NULL;
DefElem *dallowconnections = NULL;
DefElem *dconnlimit = NULL;
@ -824,10 +824,10 @@ createdb(ParseState *pstate, const CreatedbStmt *stmt)
/*
* We don't normally permit new databases to be created with
* system-assigned OIDs. pg_upgrade tries to preserve database
* OIDs, so we can't allow any database to be created with an
* OID that might be in use in a freshly-initialized cluster
* created by some future version. We assume all such OIDs will
* be from the system-managed OID range.
* OIDs, so we can't allow any database to be created with an OID
* that might be in use in a freshly-initialized cluster created
* by some future version. We assume all such OIDs will be from
* the system-managed OID range.
*
* As an exception, however, we permit any OID to be assigned when
* allow_system_table_mods=on (so that initdb can assign system
@ -1348,15 +1348,15 @@ createdb(ParseState *pstate, const CreatedbStmt *stmt)
InvokeObjectPostCreateHook(DatabaseRelationId, dboid, 0);
/*
* If we're going to be reading data for the to-be-created database
* into shared_buffers, take a lock on it. Nobody should know that this
* If we're going to be reading data for the to-be-created database into
* shared_buffers, take a lock on it. Nobody should know that this
* database exists yet, but it's good to maintain the invariant that a
* lock an AccessExclusiveLock on the database is sufficient to drop all
* of its buffers without worrying about more being read later.
*
* Note that we need to do this before entering the PG_ENSURE_ERROR_CLEANUP
* block below, because createdb_failure_callback expects this lock to
* be held already.
* Note that we need to do this before entering the
* PG_ENSURE_ERROR_CLEANUP block below, because createdb_failure_callback
* expects this lock to be held already.
*/
if (dbstrategy == CREATEDB_WAL_LOG)
LockSharedObject(DatabaseRelationId, dboid, 0, AccessShareLock);

2
src/backend/commands/explain.c
View File

@ -3833,7 +3833,7 @@ ExplainTargetRel(Plan *plan, Index rti, ExplainState *es)
if (rte->tablefunc)
if (rte->tablefunc->functype == TFT_XMLTABLE)
objectname = "xmltable";
else /* Must be TFT_JSON_TABLE */
else /* Must be TFT_JSON_TABLE */
objectname = "json_table";
else
objectname = NULL;

8
src/backend/commands/extension.c
View File

@ -758,10 +758,10 @@ execute_sql_string(const char *sql)
CommandCounterIncrement();
stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
sql,
NULL,
0,
NULL);
sql,
NULL,
0,
NULL);
stmt_list = pg_plan_queries(stmt_list, sql, CURSOR_OPT_PARALLEL_OK, NULL);
foreach(lc2, stmt_list)

4
src/backend/commands/matview.c
View File

@ -332,8 +332,8 @@ ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,
/*
* Inform cumulative stats system about our activity: basically, we
* truncated the matview and inserted some new data. (The concurrent
* code path above doesn't need to worry about this because the inserts
* and deletes it issues get counted by lower-level code.)
* code path above doesn't need to worry about this because the
* inserts and deletes it issues get counted by lower-level code.)
*/
pgstat_count_truncate(matviewRel);
if (!stmt->skipData)

47
src/backend/commands/publicationcmds.c
View File

@ -297,7 +297,7 @@ contain_invalid_rfcolumn_walker(Node *node, rf_context *context)
*/
bool
pub_rf_contains_invalid_column(Oid pubid, Relation relation, List *ancestors,
bool pubviaroot)
bool pubviaroot)
{
HeapTuple rftuple;
Oid relid = RelationGetRelid(relation);
@ -373,7 +373,7 @@ pub_rf_contains_invalid_column(Oid pubid, Relation relation, List *ancestors,
*/
bool
pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestors,
bool pubviaroot)
bool pubviaroot)
{
HeapTuple tuple;
Oid relid = RelationGetRelid(relation);
@ -384,8 +384,8 @@ pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestor
/*
* For a partition, if pubviaroot is true, find the topmost ancestor that
* is published via this publication as we need to use its column list
* for the changes.
* is published via this publication as we need to use its column list for
* the changes.
*
* Note that even though the column list used is for an ancestor, the
* REPLICA IDENTITY used will be for the actual child table.
@ -399,19 +399,19 @@ pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestor
}
tuple = SearchSysCache2(PUBLICATIONRELMAP,
ObjectIdGetDatum(publish_as_relid),
ObjectIdGetDatum(pubid));
ObjectIdGetDatum(publish_as_relid),
ObjectIdGetDatum(pubid));
if (!HeapTupleIsValid(tuple))
return false;
datum = SysCacheGetAttr(PUBLICATIONRELMAP, tuple,
Anum_pg_publication_rel_prattrs,
&isnull);
Anum_pg_publication_rel_prattrs,
&isnull);
if (!isnull)
{
int x;
int x;
Bitmapset *idattrs;
Bitmapset *columns = NULL;
@ -429,8 +429,9 @@ pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestor
/*
* Attnums in the bitmap returned by RelationGetIndexAttrBitmap are
* offset (to handle system columns the usual way), while column list
* does not use offset, so we can't do bms_is_subset(). Instead, we have
* to loop over the idattrs and check all of them are in the list.
* does not use offset, so we can't do bms_is_subset(). Instead, we
* have to loop over the idattrs and check all of them are in the
* list.
*/
x = -1;
while ((x = bms_next_member(idattrs, x)) >= 0)
@ -440,14 +441,14 @@ pub_collist_contains_invalid_column(Oid pubid, Relation relation, List *ancestor
/*
* If pubviaroot is true, we are validating the column list of the
* parent table, but the bitmap contains the replica identity
* information of the child table. The parent/child attnums may not
* match, so translate them to the parent - get the attname from
* the child, and look it up in the parent.
* information of the child table. The parent/child attnums may
* not match, so translate them to the parent - get the attname
* from the child, and look it up in the parent.
*/
if (pubviaroot)
{
/* attribute name in the child table */
char *colname = get_attname(relid, attnum, false);
char *colname = get_attname(relid, attnum, false);
/*
* Determine the attnum for the attribute name in parent (we
@ -720,7 +721,7 @@ TransformPubWhereClauses(List *tables, const char *queryString,
*/
static void
CheckPubRelationColumnList(List *tables, const char *queryString,
bool pubviaroot)
bool pubviaroot)
{
ListCell *lc;
@ -864,7 +865,7 @@ CreatePublication(ParseState *pstate, CreatePublicationStmt *stmt)
publish_via_partition_root);
CheckPubRelationColumnList(rels, pstate->p_sourcetext,
publish_via_partition_root);
publish_via_partition_root);
PublicationAddTables(puboid, rels, true, NULL);
CloseTableList(rels);
@ -1198,8 +1199,8 @@ AlterPublicationTables(AlterPublicationStmt *stmt, HeapTuple tup,
/* Transform the int2vector column list to a bitmap. */
columnListDatum = SysCacheGetAttr(PUBLICATIONRELMAP, rftuple,
Anum_pg_publication_rel_prattrs,
&isnull);
Anum_pg_publication_rel_prattrs,
&isnull);
if (!isnull)
oldcolumns = pub_collist_to_bitmapset(NULL, columnListDatum, NULL);
@ -1210,15 +1211,15 @@ AlterPublicationTables(AlterPublicationStmt *stmt, HeapTuple tup,
foreach(newlc, rels)
{
PublicationRelInfo *newpubrel;
Oid newrelid;
Bitmapset *newcolumns = NULL;
Oid newrelid;
Bitmapset *newcolumns = NULL;
newpubrel = (PublicationRelInfo *) lfirst(newlc);
newrelid = RelationGetRelid(newpubrel->relation);
/*
* If the new publication has column list, transform it to
* a bitmap too.
* If the new publication has column list, transform it to a
* bitmap too.
*/
if (newpubrel->columns)
{

15
src/backend/commands/statscmds.c
View File

@ -258,9 +258,9 @@ CreateStatistics(CreateStatsStmt *stmt)
nattnums++;
ReleaseSysCache(atttuple);
}
else if (IsA(selem->expr, Var)) /* column reference in parens */
else if (IsA(selem->expr, Var)) /* column reference in parens */
{
Var *var = (Var *) selem->expr;
Var *var = (Var *) selem->expr;
TypeCacheEntry *type;
/* Disallow use of system attributes in extended stats */
@ -297,10 +297,11 @@ CreateStatistics(CreateStatsStmt *stmt)
while ((k = bms_next_member(attnums, k)) >= 0)
{
AttrNumber attnum = k + FirstLowInvalidHeapAttributeNumber;
if (attnum <= 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("statistics creation on system columns is not supported")));
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("statistics creation on system columns is not supported")));
}
/*
@ -511,9 +512,9 @@ CreateStatistics(CreateStatsStmt *stmt)
relation_close(statrel, RowExclusiveLock);
/*
* We used to create the pg_statistic_ext_data tuple too, but it's not clear
* what value should the stxdinherit flag have (it depends on whether the rel
* is partitioned, contains data, etc.)
* We used to create the pg_statistic_ext_data tuple too, but it's not
* clear what value should the stxdinherit flag have (it depends on
* whether the rel is partitioned, contains data, etc.)
*/
InvokeObjectPostCreateHook(StatisticExtRelationId, statoid, 0);

14
src/backend/commands/subscriptioncmds.c
View File

@ -1578,13 +1578,13 @@ DropSubscription(DropSubscriptionStmt *stmt, bool isTopLevel)
PG_END_TRY();
/*
* Tell the cumulative stats system that the subscription is getting dropped.
* We can safely report dropping the subscription statistics here if the
* subscription is associated with a replication slot since we cannot run
* DROP SUBSCRIPTION inside a transaction block. Subscription statistics
* will be removed later by (auto)vacuum either if it's not associated
* with a replication slot or if the message for dropping the subscription
* gets lost.
* Tell the cumulative stats system that the subscription is getting
* dropped. We can safely report dropping the subscription statistics here
* if the subscription is associated with a replication slot since we
* cannot run DROP SUBSCRIPTION inside a transaction block. Subscription
* statistics will be removed later by (auto)vacuum either if it's not
* associated with a replication slot or if the message for dropping the
* subscription gets lost.
*/
if (slotname)
pgstat_drop_subscription(subid);

28
src/backend/commands/tablecmds.c
View File

@ -495,8 +495,8 @@ static ObjectAddress addFkRecurseReferenced(List **wqueue, Constraint *fkconstra
bool old_check_ok,
Oid parentDelTrigger, Oid parentUpdTrigger);
static void validateFkOnDeleteSetColumns(int numfks, const int16 *fkattnums,
int numfksetcols, const int16 *fksetcolsattnums,
List *fksetcols);
int numfksetcols, const int16 *fksetcolsattnums,
List *fksetcols);
static void addFkRecurseReferencing(List **wqueue, Constraint *fkconstraint,
Relation rel, Relation pkrel, Oid indexOid, Oid parentConstr,
int numfks, int16 *pkattnum, int16 *fkattnum,
@ -5579,7 +5579,7 @@ ATRewriteTables(AlterTableStmt *parsetree, List **wqueue, LOCKMODE lockmode,
foreach(lc, seqlist)
{
Oid seq_relid = lfirst_oid(lc);
Oid seq_relid = lfirst_oid(lc);
SequenceChangePersistence(seq_relid, tab->newrelpersistence);
}
@ -9448,8 +9448,8 @@ validateFkOnDeleteSetColumns(int numfks, const int16 *fkattnums,
{
for (int i = 0; i < numfksetcols; i++)
{
int16 setcol_attnum = fksetcolsattnums[i];
bool seen = false;
int16 setcol_attnum = fksetcolsattnums[i];
bool seen = false;
for (int j = 0; j < numfks; j++)
{
@ -9462,7 +9462,8 @@ validateFkOnDeleteSetColumns(int numfks, const int16 *fkattnums,
if (!seen)
{
char *col = strVal(list_nth(fksetcols, i));
char *col = strVal(list_nth(fksetcols, i));
ereport(ERROR,
(errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
errmsg("column \"%s\" referenced in ON DELETE SET action must be part of foreign key", col)));
@ -15890,6 +15891,7 @@ relation_mark_replica_identity(Relation rel, char ri_type, Oid indexOid,
CatalogTupleUpdate(pg_index, &pg_index_tuple->t_self, pg_index_tuple);
InvokeObjectPostAlterHookArg(IndexRelationId, thisIndexOid, 0,
InvalidOid, is_internal);
/*
* Invalidate the relcache for the table, so that after we commit
* all sessions will refresh the table's replica identity index
@ -17931,12 +17933,12 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd,
/*
* If the partition we just attached is partitioned itself, invalidate
* relcache for all descendent partitions too to ensure that their
* rd_partcheck expression trees are rebuilt; partitions already locked
* at the beginning of this function.
* rd_partcheck expression trees are rebuilt; partitions already locked at
* the beginning of this function.
*/
if (attachrel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
ListCell *l;
ListCell *l;
foreach(l, attachrel_children)
{
@ -18652,13 +18654,13 @@ DetachPartitionFinalize(Relation rel, Relation partRel, bool concurrent,
/*
* If the partition we just detached is partitioned itself, invalidate
* relcache for all descendent partitions too to ensure that their
* rd_partcheck expression trees are rebuilt; must lock partitions
* before doing so, using the same lockmode as what partRel has been
* locked with by the caller.
* rd_partcheck expression trees are rebuilt; must lock partitions before
* doing so, using the same lockmode as what partRel has been locked with
* by the caller.
*/
if (partRel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
List *children;
List *children;
children = find_all_inheritors(RelationGetRelid(partRel),
AccessExclusiveLock, NULL);

2
src/backend/commands/tablespace.c
View File

@ -89,7 +89,7 @@ char *default_tablespace = NULL;
char *temp_tablespaces = NULL;
bool allow_in_place_tablespaces = false;
Oid binary_upgrade_next_pg_tablespace_oid = InvalidOid;
Oid binary_upgrade_next_pg_tablespace_oid = InvalidOid;
static void create_tablespace_directories(const char *location,
const Oid tablespaceoid);

4
src/backend/commands/user.c
View File

@ -798,11 +798,11 @@ AlterRole(ParseState *pstate, AlterRoleStmt *stmt)
*/
if (drolemembers)
{
List *rolemembers = (List *) drolemembers->arg;
List *rolemembers = (List *) drolemembers->arg;
CommandCounterIncrement();
if (stmt->action == +1) /* add members to role */
if (stmt->action == +1) /* add members to role */
AddRoleMems(rolename, roleid,
rolemembers, roleSpecsToIds(rolemembers),
GetUserId(), false);

4
src/backend/commands/vacuum.c
View File

@ -1409,7 +1409,7 @@ vac_update_relstats(Relation relation,
*frozenxid_updated = false;
if (TransactionIdIsNormal(frozenxid) && oldfrozenxid != frozenxid)
{
bool update = false;
bool update = false;
if (TransactionIdPrecedes(oldfrozenxid, frozenxid))
update = true;
@ -1432,7 +1432,7 @@ vac_update_relstats(Relation relation,
*minmulti_updated = false;
if (MultiXactIdIsValid(minmulti) && oldminmulti != minmulti)
{
bool update = false;
bool update = false;
if (MultiXactIdPrecedes(oldminmulti, minmulti))
update = true;

2
src/backend/commands/vacuumparallel.c
View File

@ -112,7 +112,7 @@ typedef enum PVIndVacStatus
PARALLEL_INDVAC_STATUS_NEED_BULKDELETE,
PARALLEL_INDVAC_STATUS_NEED_CLEANUP,
PARALLEL_INDVAC_STATUS_COMPLETED
} PVIndVacStatus;
} PVIndVacStatus;
/*
* Struct for index vacuum statistics of an index that is used for parallel vacuum.

4
src/backend/executor/execExpr.c
View File

@ -2504,7 +2504,7 @@ ExecInitExprRec(Expr *node, ExprState *state,
if (ctor->type == JSCTOR_JSON_SCALAR)
{
bool is_jsonb =
ctor->returning->format->format_type == JS_FORMAT_JSONB;
ctor->returning->format->format_type == JS_FORMAT_JSONB;
scratch.d.json_constructor.arg_type_cache =
palloc(sizeof(*scratch.d.json_constructor.arg_type_cache) * nargs);
@ -2666,7 +2666,7 @@ ExecInitExprRec(Expr *node, ExprState *state,
{
cstate->coercion = *coercion;
cstate->estate = *coercion ?
ExecInitExprWithCaseValue((Expr *)(*coercion)->expr,
ExecInitExprWithCaseValue((Expr *) (*coercion)->expr,
state->parent,
caseval, casenull) : NULL;
}

65
src/backend/executor/execExprInterp.c
View File

@ -3978,8 +3978,8 @@ ExecEvalJsonIsPredicate(ExprState *state, ExprEvalStep *op)
}
/*
* Do full parsing pass only for uniqueness check or for
* JSON text validation.
* Do full parsing pass only for uniqueness check or for JSON text
* validation.
*/
if (res && (pred->unique_keys || exprtype == TEXTOID))
res = json_validate(json, pred->unique_keys, false);
@ -4513,20 +4513,20 @@ ExecEvalJsonConstructor(ExprState *state, ExprEvalStep *op,
if (ctor->type == JSCTOR_JSON_ARRAY)
res = (is_jsonb ?
jsonb_build_array_worker :
json_build_array_worker)(op->d.json_constructor.nargs,
op->d.json_constructor.arg_values,
op->d.json_constructor.arg_nulls,
op->d.json_constructor.arg_types,
op->d.json_constructor.constructor->absent_on_null);
else if (ctor->type == JSCTOR_JSON_OBJECT)
res = (is_jsonb ?
jsonb_build_object_worker :
json_build_object_worker)(op->d.json_constructor.nargs,
json_build_array_worker) (op->d.json_constructor.nargs,
op->d.json_constructor.arg_values,
op->d.json_constructor.arg_nulls,
op->d.json_constructor.arg_types,
op->d.json_constructor.constructor->absent_on_null,
op->d.json_constructor.constructor->unique);
op->d.json_constructor.constructor->absent_on_null);
else if (ctor->type == JSCTOR_JSON_OBJECT)
res = (is_jsonb ?
jsonb_build_object_worker :
json_build_object_worker) (op->d.json_constructor.nargs,
op->d.json_constructor.arg_values,
op->d.json_constructor.arg_nulls,
op->d.json_constructor.arg_types,
op->d.json_constructor.constructor->absent_on_null,
op->d.json_constructor.constructor->unique);
else if (ctor->type == JSCTOR_JSON_SCALAR)
{
if (op->d.json_constructor.arg_nulls[0])
@ -4622,9 +4622,9 @@ static Datum
ExecEvalJsonExprCoercion(ExprEvalStep *op, ExprContext *econtext,
Datum res, bool *isNull, void *p, bool *error)
{
ExprState *estate = p;
ExprState *estate = p;
if (estate) /* coerce using specified expression */
if (estate) /* coerce using specified expression */
return ExecEvalExpr(estate, econtext, isNull);
if (op->d.jsonexpr.jsexpr->op != JSON_EXISTS_OP)
@ -4696,7 +4696,7 @@ EvalJsonPathVar(void *cxt, char *varName, int varNameLen,
if (!var->evaluated)
{
MemoryContext oldcxt = var->mcxt ?
MemoryContextSwitchTo(var->mcxt) : NULL;
MemoryContextSwitchTo(var->mcxt) : NULL;
var->value = ExecEvalExpr(var->estate, var->econtext, &var->isnull);
var->evaluated = true;
@ -4751,9 +4751,8 @@ ExecPrepareJsonItemCoercion(JsonbValue *item,
case jbvString:
coercion = &coercions->string;
res = PointerGetDatum(
cstring_to_text_with_len(item->val.string.val,
item->val.string.len));
res = PointerGetDatum(cstring_to_text_with_len(item->val.string.val,
item->val.string.len));
break;
case jbvNumeric:
@ -4809,8 +4808,8 @@ ExecPrepareJsonItemCoercion(JsonbValue *item,
return res;
}
typedef Datum (*JsonFunc)(ExprEvalStep *op, ExprContext *econtext,
Datum item, bool *resnull, void *p, bool *error);
typedef Datum (*JsonFunc) (ExprEvalStep *op, ExprContext *econtext,
Datum item, bool *resnull, void *p, bool *error);
static Datum
ExecEvalJsonExprSubtrans(JsonFunc func, ExprEvalStep *op,
@ -4826,8 +4825,8 @@ ExecEvalJsonExprSubtrans(JsonFunc func, ExprEvalStep *op,
return func(op, econtext, res, resnull, p, error);
/*
* We should catch exceptions of category ERRCODE_DATA_EXCEPTION
* and execute the corresponding ON ERROR behavior then.
* We should catch exceptions of category ERRCODE_DATA_EXCEPTION and
* execute the corresponding ON ERROR behavior then.
*/
oldcontext = CurrentMemoryContext;
oldowner = CurrentResourceOwner;
@ -4864,7 +4863,8 @@ ExecEvalJsonExprSubtrans(JsonFunc func, ExprEvalStep *op,
ecategory = ERRCODE_TO_CATEGORY(edata->sqlerrcode);
if (ecategory != ERRCODE_DATA_EXCEPTION && /* jsonpath and other data errors */
if (ecategory != ERRCODE_DATA_EXCEPTION && /* jsonpath and other data
* errors */
ecategory != ERRCODE_INTEGRITY_CONSTRAINT_VIOLATION) /* domain errors */
ReThrowError(edata);
@ -4918,7 +4918,7 @@ ExecEvalJsonExpr(ExprEvalStep *op, ExprContext *econtext,
if (error && *error)
return (Datum) 0;
if (!jbv) /* NULL or empty */
if (!jbv) /* NULL or empty */
break;
Assert(!empty);
@ -4949,21 +4949,23 @@ ExecEvalJsonExpr(ExprEvalStep *op, ExprContext *econtext,
*error = true;
return (Datum) 0;
}
/*
* Coercion via I/O means here that the cast to the target
* type simply does not exist.
*/
ereport(ERROR,
/*
* XXX Standard says about a separate error code
* ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE
* but does not define its number.
*/
/*
* XXX Standard says about a separate error code
* ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE but
* does not define its number.
*/
(errcode(ERRCODE_SQL_JSON_SCALAR_REQUIRED),
errmsg("SQL/JSON item cannot be cast to target type")));
}
else if (!jcstate->estate)
return res; /* no coercion */
return res; /* no coercion */
/* coerce using specific expression */
estate = jcstate->estate;
@ -5018,6 +5020,7 @@ ExecEvalJsonExpr(ExprEvalStep *op, ExprContext *econtext,
}
if (jexpr->on_empty->btype == JSON_BEHAVIOR_DEFAULT)
/*
* Execute DEFAULT expression as a coercion expression, because
* its result is already coerced to the target type.

1
src/backend/executor/nodeIndexscan.c
View File

@ -575,6 +575,7 @@ ExecReScanIndexScan(IndexScanState *node)
if (node->iss_ReorderQueue)
{
HeapTuple tuple;
while (!pairingheap_is_empty(node->iss_ReorderQueue))
{
tuple = reorderqueue_pop(node);

2
src/backend/executor/nodeMemoize.c
View File

@ -375,7 +375,7 @@ static void
cache_purge_all(MemoizeState *mstate)
{
uint64 evictions = mstate->hashtable->members;
PlanState *pstate = (PlanState *) mstate;
PlanState *pstate = (PlanState *) mstate;
/*
* Likely the most efficient way to remove all items is to just reset the

2
src/backend/executor/nodeModifyTable.c
View File

@ -831,7 +831,7 @@ ExecInsert(ModifyTableContext *context,
{
TupleDesc tdesc = CreateTupleDescCopy(slot->tts_tupleDescriptor);
TupleDesc plan_tdesc =
CreateTupleDescCopy(planSlot->tts_tupleDescriptor);
CreateTupleDescCopy(planSlot->tts_tupleDescriptor);
resultRelInfo->ri_Slots[resultRelInfo->ri_NumSlots] =
MakeSingleTupleTableSlot(tdesc, slot->tts_ops);

16
src/backend/executor/spi.c
View File

@ -2267,10 +2267,10 @@ _SPI_prepare_plan(const char *src, SPIPlanPtr plan)
else
{
stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
src,
plan->argtypes,
plan->nargs,
_SPI_current->queryEnv);
src,
plan->argtypes,
plan->nargs,
_SPI_current->queryEnv);
}
/* Finish filling in the CachedPlanSource */
@ -2504,10 +2504,10 @@ _SPI_execute_plan(SPIPlanPtr plan, const SPIExecuteOptions *options,
else
{
stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
src,
plan->argtypes,
plan->nargs,
_SPI_current->queryEnv);
src,
plan->argtypes,
plan->nargs,
_SPI_current->queryEnv);
}
/* Finish filling in the CachedPlanSource */

4
src/backend/jit/llvm/llvmjit.c
View File

@ -890,8 +890,8 @@ llvm_shutdown(int code, Datum arg)
* has occurred in the middle of LLVM code. It is not safe to call back
* into LLVM (which is why a FATAL error was thrown).
*
* We do need to shutdown LLVM in other shutdown cases, otherwise
* e.g. profiling data won't be written out.
* We do need to shutdown LLVM in other shutdown cases, otherwise e.g.
* profiling data won't be written out.
*/
if (llvm_in_fatal_on_oom())
{

6
src/backend/lib/dshash.c
View File

@ -634,9 +634,9 @@ dshash_seq_next(dshash_seq_status *status)
/*
* Not yet holding any partition locks. Need to determine the size of the
* hash table, it could have been resized since we were looking
* last. Since we iterate in partition order, we can start by
* unconditionally lock partition 0.
* hash table, it could have been resized since we were looking last.
* Since we iterate in partition order, we can start by unconditionally
* lock partition 0.
*
* Once we hold the lock, no resizing can happen until the scan ends. So
* we don't need to repeatedly call ensure_valid_bucket_pointers().

4
src/backend/libpq/pqcomm.c
View File

@ -1967,8 +1967,8 @@ retry:
* because no code should expect latches to survive across
* CHECK_FOR_INTERRUPTS().
*/
ResetLatch(MyLatch);
goto retry;
ResetLatch(MyLatch);
goto retry;
}
}

24
src/backend/nodes/copyfuncs.c
View File

@ -2343,7 +2343,7 @@ _copyJsonReturning(const JsonReturning *from)
static JsonValueExpr *
_copyJsonValueExpr(const JsonValueExpr *from)
{
JsonValueExpr *newnode = makeNode(JsonValueExpr);
JsonValueExpr *newnode = makeNode(JsonValueExpr);
COPY_NODE_FIELD(raw_expr);
COPY_NODE_FIELD(formatted_expr);
@ -2358,7 +2358,7 @@ _copyJsonValueExpr(const JsonValueExpr *from)
static JsonParseExpr *
_copyJsonParseExpr(const JsonParseExpr *from)
{
JsonParseExpr *newnode = makeNode(JsonParseExpr);
JsonParseExpr *newnode = makeNode(JsonParseExpr);
COPY_NODE_FIELD(expr);
COPY_NODE_FIELD(output);
@ -2488,7 +2488,7 @@ _copyJsonObjectAgg(const JsonObjectAgg *from)
static JsonOutput *
_copyJsonOutput(const JsonOutput *from)
{
JsonOutput *newnode = makeNode(JsonOutput);
JsonOutput *newnode = makeNode(JsonOutput);
COPY_NODE_FIELD(typeName);
COPY_NODE_FIELD(returning);
@ -2550,7 +2550,7 @@ _copyJsonArrayQueryConstructor(const JsonArrayQueryConstructor *from)
static JsonExpr *
_copyJsonExpr(const JsonExpr *from)
{
JsonExpr *newnode = makeNode(JsonExpr);
JsonExpr *newnode = makeNode(JsonExpr);
COPY_SCALAR_FIELD(op);
COPY_NODE_FIELD(formatted_expr);
@ -2614,7 +2614,7 @@ _copyJsonItemCoercions(const JsonItemCoercions *from)
static JsonFuncExpr *
_copyJsonFuncExpr(const JsonFuncExpr *from)
{
JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
COPY_SCALAR_FIELD(op);
COPY_NODE_FIELD(common);
@ -2651,7 +2651,7 @@ _copyJsonIsPredicate(const JsonIsPredicate *from)
static JsonBehavior *
_copyJsonBehavior(const JsonBehavior *from)
{
JsonBehavior *newnode = makeNode(JsonBehavior);
JsonBehavior *newnode = makeNode(JsonBehavior);
COPY_SCALAR_FIELD(btype);
COPY_NODE_FIELD(default_expr);
@ -2665,7 +2665,7 @@ _copyJsonBehavior(const JsonBehavior *from)
static JsonCommon *
_copyJsonCommon(const JsonCommon *from)
{
JsonCommon *newnode = makeNode(JsonCommon);
JsonCommon *newnode = makeNode(JsonCommon);
COPY_NODE_FIELD(expr);
COPY_NODE_FIELD(pathspec);
@ -2682,7 +2682,7 @@ _copyJsonCommon(const JsonCommon *from)
static JsonArgument *
_copyJsonArgument(const JsonArgument *from)
{
JsonArgument *newnode = makeNode(JsonArgument);
JsonArgument *newnode = makeNode(JsonArgument);
COPY_NODE_FIELD(val);
COPY_STRING_FIELD(name);
@ -2696,7 +2696,7 @@ _copyJsonArgument(const JsonArgument *from)
static JsonTable *
_copyJsonTable(const JsonTable *from)
{
JsonTable *newnode = makeNode(JsonTable);
JsonTable *newnode = makeNode(JsonTable);
COPY_NODE_FIELD(common);
COPY_NODE_FIELD(columns);
@ -5480,7 +5480,7 @@ _copyExtensibleNode(const ExtensibleNode *from)
static Integer *
_copyInteger(const Integer *from)
{
Integer *newnode = makeNode(Integer);
Integer *newnode = makeNode(Integer);
COPY_SCALAR_FIELD(ival);
@ -5500,7 +5500,7 @@ _copyFloat(const Float *from)
static Boolean *
_copyBoolean(const Boolean *from)
{
Boolean *newnode = makeNode(Boolean);
Boolean *newnode = makeNode(Boolean);
COPY_SCALAR_FIELD(boolval);
@ -5520,7 +5520,7 @@ _copyString(const String *from)
static BitString *
_copyBitString(const BitString *from)
{
BitString *newnode = makeNode(BitString);
BitString *newnode = makeNode(BitString);
COPY_STRING_FIELD(bsval);

3
src/backend/nodes/equalfuncs.c
View File

@ -2802,8 +2802,7 @@ static bool
_equalA_Const(const A_Const *a, const A_Const *b)
{
/*
* Hack for in-line val field. Also val is not valid is isnull is
* true.
* Hack for in-line val field. Also val is not valid is isnull is true.
*/
if (!a->isnull && !b->isnull &&
!equal(&a->val, &b->val))

15
src/backend/nodes/nodeFuncs.c
View File

@ -1003,7 +1003,7 @@ exprCollation(const Node *expr)
break;
case T_JsonExpr:
{
JsonExpr *jexpr = (JsonExpr *) expr;
JsonExpr *jexpr = (JsonExpr *) expr;
JsonCoercion *coercion = jexpr->result_coercion;
if (!coercion)
@ -1239,7 +1239,8 @@ exprSetCollation(Node *expr, Oid collation)
if (ctor->coercion)
exprSetCollation((Node *) ctor->coercion, collation);
else
Assert(!OidIsValid(collation)); /* result is always a json[b] type */
Assert(!OidIsValid(collation)); /* result is always a
* json[b] type */
}
break;
case T_JsonIsPredicate:
@ -1247,7 +1248,7 @@ exprSetCollation(Node *expr, Oid collation)
break;
case T_JsonExpr:
{
JsonExpr *jexpr = (JsonExpr *) expr;
JsonExpr *jexpr = (JsonExpr *) expr;
JsonCoercion *coercion = jexpr->result_coercion;
if (!coercion)
@ -2496,7 +2497,7 @@ expression_tree_walker(Node *node,
return walker(((JsonIsPredicate *) node)->expr, context);
case T_JsonExpr:
{
JsonExpr *jexpr = (JsonExpr *) node;
JsonExpr *jexpr = (JsonExpr *) node;
if (walker(jexpr->formatted_expr, context))
return true;
@ -3568,8 +3569,8 @@ expression_tree_mutator(Node *node,
break;
case T_JsonExpr:
{
JsonExpr *jexpr = (JsonExpr *) node;
JsonExpr *newnode;
JsonExpr *jexpr = (JsonExpr *) node;
JsonExpr *newnode;
FLATCOPY(newnode, jexpr, JsonExpr);
MUTATE(newnode->path_spec, jexpr->path_spec, Node *);
@ -4545,7 +4546,7 @@ raw_expression_tree_walker(Node *node,
break;
case T_JsonTableColumn:
{
JsonTableColumn *jtc = (JsonTableColumn *) node;
JsonTableColumn *jtc = (JsonTableColumn *) node;
if (walker(jtc->typeName, context))
return true;

8
src/backend/nodes/outfuncs.c
View File

@ -3613,8 +3613,8 @@ static void
_outFloat(StringInfo str, const Float *node)
{
/*
* We assume the value is a valid numeric literal and so does not
* need quoting.
* We assume the value is a valid numeric literal and so does not need
* quoting.
*/
appendStringInfoString(str, node->fval);
}
@ -3629,8 +3629,8 @@ static void
_outString(StringInfo str, const String *node)
{
/*
* We use outToken to provide escaping of the string's content,
* but we don't want it to do anything with an empty string.
* We use outToken to provide escaping of the string's content, but we
* don't want it to do anything with an empty string.
*/
appendStringInfoChar(str, '"');
if (node->sval[0] != '\0')

4
src/backend/nodes/value.c
View File

@ -22,7 +22,7 @@
Integer *
makeInteger(int i)
{
Integer *v = makeNode(Integer);
Integer *v = makeNode(Integer);
v->ival = i;
return v;
@ -48,7 +48,7 @@ makeFloat(char *numericStr)
Boolean *
makeBoolean(bool val)
{
Boolean *v = makeNode(Boolean);
Boolean *v = makeNode(Boolean);
v->boolval = val;
return v;

15
src/backend/optimizer/path/allpaths.c
View File

@ -1777,17 +1777,18 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
}
/*
* When building a fractional path, determine a cheapest fractional
* path for each child relation too. Looking at startup and total
* costs is not enough, because the cheapest fractional path may be
* dominated by two separate paths (one for startup, one for total).
* When building a fractional path, determine a cheapest
* fractional path for each child relation too. Looking at startup
* and total costs is not enough, because the cheapest fractional
* path may be dominated by two separate paths (one for startup,
* one for total).
*
* When needed (building fractional path), determine the cheapest
* fractional path too.
*/
if (root->tuple_fraction > 0)
{
double path_fraction = (1.0 / root->tuple_fraction);
double path_fraction = (1.0 / root->tuple_fraction);
cheapest_fractional =
get_cheapest_fractional_path_for_pathkeys(childrel->pathlist,
@ -1796,8 +1797,8 @@ generate_orderedappend_paths(PlannerInfo *root, RelOptInfo *rel,
path_fraction);
/*
* If we found no path with matching pathkeys, use the cheapest
* total path instead.
* If we found no path with matching pathkeys, use the
* cheapest total path instead.
*
* XXX We might consider partially sorted paths too (with an
* incremental sort on top). But we'd have to build all the

111
src/backend/optimizer/path/costsize.c
View File

@ -1794,7 +1794,7 @@ is_fake_var(Expr *expr)
static double
get_width_cost_multiplier(PlannerInfo *root, Expr *expr)
{
double width = -1.0; /* fake value */
double width = -1.0; /* fake value */
if (IsA(expr, RelabelType))
expr = (Expr *) ((RelabelType *) expr)->arg;
@ -1802,17 +1802,17 @@ get_width_cost_multiplier(PlannerInfo *root, Expr *expr)
/* Try to find actual stat in corresponding relation */
if (IsA(expr, Var))
{
Var *var = (Var *) expr;
Var *var = (Var *) expr;
if (var->varno > 0 && var->varno < root->simple_rel_array_size)
{
RelOptInfo *rel = root->simple_rel_array[var->varno];
RelOptInfo *rel = root->simple_rel_array[var->varno];
if (rel != NULL &&
var->varattno >= rel->min_attr &&
var->varattno <= rel->max_attr)
{
int ndx = var->varattno - rel->min_attr;
int ndx = var->varattno - rel->min_attr;
if (rel->attr_widths[ndx] > 0)
width = rel->attr_widths[ndx];
@ -1823,7 +1823,7 @@ get_width_cost_multiplier(PlannerInfo *root, Expr *expr)
/* Didn't find any actual stats, try using type width instead. */
if (width < 0.0)
{
Node *node = (Node*) expr;
Node *node = (Node *) expr;
width = get_typavgwidth(exprType(node), exprTypmod(node));
}
@ -1832,17 +1832,17 @@ get_width_cost_multiplier(PlannerInfo *root, Expr *expr)
* Values are passed as Datum type, so comparisons can't be cheaper than
* comparing a Datum value.
*
* FIXME I find this reasoning questionable. We may pass int2, and comparing
* it is probably a bit cheaper than comparing a bigint.
* FIXME I find this reasoning questionable. We may pass int2, and
* comparing it is probably a bit cheaper than comparing a bigint.
*/
if (width <= sizeof(Datum))
return 1.0;
/*
* We consider the cost of a comparison not to be directly proportional to
* width of the argument, because widths of the arguments could be slightly
* different (we only know the average width for the whole column). So we
* use log16(width) as an estimate.
* width of the argument, because widths of the arguments could be
* slightly different (we only know the average width for the whole
* column). So we use log16(width) as an estimate.
*/
return 1.0 + 0.125 * LOG2(width / sizeof(Datum));
}
@ -1902,23 +1902,23 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
bool heapSort)
{
Cost per_tuple_cost = 0.0;
ListCell *lc;
List *pathkeyExprs = NIL;
ListCell *lc;
List *pathkeyExprs = NIL;
double tuplesPerPrevGroup = tuples;
double totalFuncCost = 1.0;
bool has_fake_var = false;
int i = 0;
Oid prev_datatype = InvalidOid;
List *cache_varinfos = NIL;
List *cache_varinfos = NIL;
/* fallback if pathkeys is unknown */
if (list_length(pathkeys) == 0)
{
/*
* If we'll use a bounded heap-sort keeping just K tuples in memory, for
* a total number of tuple comparisons of N log2 K; but the constant
* factor is a bit higher than for quicksort. Tweak it so that the cost
* curve is continuous at the crossover point.
* If we'll use a bounded heap-sort keeping just K tuples in memory,
* for a total number of tuple comparisons of N log2 K; but the
* constant factor is a bit higher than for quicksort. Tweak it so
* that the cost curve is continuous at the crossover point.
*/
output_tuples = (heapSort) ? 2.0 * output_tuples : tuples;
per_tuple_cost += 2.0 * cpu_operator_cost * LOG2(output_tuples);
@ -1930,17 +1930,17 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
}
/*
* Computing total cost of sorting takes into account:
* - per column comparison function cost
* - we try to compute needed number of comparison per column
* Computing total cost of sorting takes into account the per-column
* comparison function cost. We try to compute the needed number of
* comparisons per column.
*/
foreach(lc, pathkeys)
{
PathKey *pathkey = (PathKey*) lfirst(lc);
EquivalenceMember *em;
double nGroups,
correctedNGroups;
Cost funcCost = 1.0;
PathKey *pathkey = (PathKey *) lfirst(lc);
EquivalenceMember *em;
double nGroups,
correctedNGroups;
Cost funcCost = 1.0;
/*
* We believe that equivalence members aren't very different, so, to
@ -1985,10 +1985,10 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
pathkeyExprs = lappend(pathkeyExprs, em->em_expr);
/*
* We need to calculate the number of comparisons for this column, which
* requires knowing the group size. So we estimate the number of groups
* by calling estimate_num_groups_incremental(), which estimates the
* group size for "new" pathkeys.
* We need to calculate the number of comparisons for this column,
* which requires knowing the group size. So we estimate the number of
* groups by calling estimate_num_groups_incremental(), which
* estimates the group size for "new" pathkeys.
*
* Note: estimate_num_groups_incremental does not handle fake Vars, so
* use a default estimate otherwise.
@ -1999,26 +1999,30 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
&cache_varinfos,
list_length(pathkeyExprs) - 1);
else if (tuples > 4.0)
/*
* Use geometric mean as estimation if there are no stats.
*
* We don't use DEFAULT_NUM_DISTINCT here, because that’s used for
* a single column, but here we’re dealing with multiple columns.
* We don't use DEFAULT_NUM_DISTINCT here, because that's used for
* a single column, but here we're dealing with multiple columns.
*/
nGroups = ceil(2.0 + sqrt(tuples) * (i + 1) / list_length(pathkeys));
else
nGroups = tuples;
/*
* Presorted keys are not considered in the cost above, but we still do
* have to compare them in the qsort comparator. So make sure to factor
* in the cost in that case.
* Presorted keys are not considered in the cost above, but we still
* do have to compare them in the qsort comparator. So make sure to
* factor in the cost in that case.
*/
if (i >= nPresortedKeys)
{
if (heapSort)
{
/* have to keep at least one group, and a multiple of group size */
/*
* have to keep at least one group, and a multiple of group
* size
*/
correctedNGroups = ceil(output_tuples / tuplesPerPrevGroup);
}
else
@ -2033,19 +2037,20 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
i++;
/*
* Uniform distributions with all groups being of the same size are the
* best case, with nice smooth behavior. Real-world distributions tend
* not to be uniform, though, and we don’t have any reliable easy-to-use
* information. As a basic defense against skewed distributions, we use
* a 1.5 factor to make the expected group a bit larger, but we need to
* be careful not to make the group larger than in the preceding step.
* Uniform distributions with all groups being of the same size are
* the best case, with nice smooth behavior. Real-world distributions
* tend not to be uniform, though, and we don't have any reliable
* easy-to-use information. As a basic defense against skewed
* distributions, we use a 1.5 factor to make the expected group a bit
* larger, but we need to be careful not to make the group larger than
* in the preceding step.
*/
tuplesPerPrevGroup = Min(tuplesPerPrevGroup,
ceil(1.5 * tuplesPerPrevGroup / nGroups));
/*
* Once we get single-row group, it means tuples in the group are unique
* and we can skip all remaining columns.
* Once we get single-row group, it means tuples in the group are
* unique and we can skip all remaining columns.
*/
if (tuplesPerPrevGroup <= 1.0)
break;
@ -2057,15 +2062,15 @@ compute_cpu_sort_cost(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
per_tuple_cost *= cpu_operator_cost;
/*
* Accordingly to "Introduction to algorithms", Thomas H. Cormen, Charles E.
* Leiserson, Ronald L. Rivest, ISBN 0-07-013143-0, quicksort estimation
* formula has additional term proportional to number of tuples (See Chapter
* 8.2 and Theorem 4.1). That affects cases with a low number of tuples,
* approximately less than 1e4. We could implement it as an additional
* multiplier under the logarithm, but we use a bit more complex formula
* which takes into account the number of unique tuples and it’s not clear
* how to combine the multiplier with the number of groups. Estimate it as
* 10 in cpu_operator_cost unit.
* Accordingly to "Introduction to algorithms", Thomas H. Cormen, Charles
* E. Leiserson, Ronald L. Rivest, ISBN 0-07-013143-0, quicksort
* estimation formula has additional term proportional to number of tuples
* (see Chapter 8.2 and Theorem 4.1). That affects cases with a low number
* of tuples, approximately less than 1e4. We could implement it as an
* additional multiplier under the logarithm, but we use a bit more
* complex formula which takes into account the number of unique tuples
* and it's not clear how to combine the multiplier with the number of
* groups. Estimate it as 10 cpu_operator_cost units.
*/
per_tuple_cost += 10 * cpu_operator_cost;
@ -2082,7 +2087,7 @@ cost_sort_estimate(PlannerInfo *root, List *pathkeys, int nPresortedKeys,
double tuples)
{
return compute_cpu_sort_cost(root, pathkeys, nPresortedKeys,
0, tuples, tuples, false);
0, tuples, tuples, false);
}
/*

6
src/backend/optimizer/path/equivclass.c
View File

@ -685,9 +685,9 @@ get_eclass_for_sort_expr(PlannerInfo *root,
/*
* Match!
*
* Copy the sortref if it wasn't set yet. That may happen if the
* ec was constructed from WHERE clause, i.e. it doesn't have a
* target reference at all.
* Copy the sortref if it wasn't set yet. That may happen if
* the ec was constructed from WHERE clause, i.e. it doesn't
* have a target reference at all.
*/
if (cur_ec->ec_sortref == 0 && sortref > 0)
cur_ec->ec_sortref = sortref;

2
src/backend/optimizer/path/joinpath.c
View File

@ -1258,7 +1258,7 @@ sort_inner_and_outer(PlannerInfo *root,
foreach(l, all_pathkeys)
{
PathKey *front_pathkey = (PathKey *) lfirst(l);
PathKey *front_pathkey = (PathKey *) lfirst(l);
List *cur_mergeclauses;
List *outerkeys;
List *innerkeys;

143
src/backend/optimizer/path/pathkeys.c
View File

@ -32,7 +32,7 @@
#include "utils/selfuncs.h"
/* Consider reordering of GROUP BY keys? */
bool enable_group_by_reordering = true;
bool enable_group_by_reordering = true;
static bool pathkey_is_redundant(PathKey *new_pathkey, List *pathkeys);
static bool matches_boolean_partition_clause(RestrictInfo *rinfo,
@ -352,7 +352,7 @@ int
group_keys_reorder_by_pathkeys(List *pathkeys, List **group_pathkeys,
List **group_clauses)
{
List *new_group_pathkeys= NIL,
List *new_group_pathkeys = NIL,
*new_group_clauses = NIL;
ListCell *lc;
int n;
@ -365,16 +365,16 @@ group_keys_reorder_by_pathkeys(List *pathkeys, List **group_pathkeys,
* there's a matching GROUP BY key. If we find one, we append it to the
* list, and do the same for the clauses.
*
* Once we find the first pathkey without a matching GROUP BY key, the rest
* of the pathkeys are useless and can't be used to evaluate the grouping,
* so we abort the loop and ignore the remaining pathkeys.
* Once we find the first pathkey without a matching GROUP BY key, the
* rest of the pathkeys are useless and can't be used to evaluate the
* grouping, so we abort the loop and ignore the remaining pathkeys.
*
* XXX Pathkeys are built in a way to allow simply comparing pointers.
*/
foreach(lc, pathkeys)
{
PathKey *pathkey = (PathKey *) lfirst(lc);
SortGroupClause *sgc;
PathKey *pathkey = (PathKey *) lfirst(lc);
SortGroupClause *sgc;
/* abort on first mismatch */
if (!list_member_ptr(*group_pathkeys, pathkey))
@ -403,13 +403,14 @@ group_keys_reorder_by_pathkeys(List *pathkeys, List **group_pathkeys,
/*
* Used to generate all permutations of a pathkey list.
*/
typedef struct PathkeyMutatorState {
typedef struct PathkeyMutatorState
{
List *elemsList;
ListCell **elemCells;
void **elems;
int *positions;
int mutatorNColumns;
int count;
int mutatorNColumns;
int count;
} PathkeyMutatorState;
@ -428,9 +429,9 @@ typedef struct PathkeyMutatorState {
static void
PathkeyMutatorInit(PathkeyMutatorState *state, List *elems, int start, int end)
{
int i;
int i;
int n = end - start;
ListCell *lc;
ListCell *lc;
memset(state, 0, sizeof(*state));
@ -438,8 +439,8 @@ PathkeyMutatorInit(PathkeyMutatorState *state, List *elems, int start, int end)
state->elemsList = list_copy(elems);
state->elems = palloc(sizeof(void*) * n);
state->elemCells = palloc(sizeof(ListCell*) * n);
state->elems = palloc(sizeof(void *) * n);
state->elemCells = palloc(sizeof(ListCell *) * n);
state->positions = palloc(sizeof(int) * n);
i = 0;
@ -459,10 +460,10 @@ PathkeyMutatorInit(PathkeyMutatorState *state, List *elems, int start, int end)
static void
PathkeyMutatorSwap(int *a, int i, int j)
{
int s = a[i];
int s = a[i];
a[i] = a[j];
a[j] = s;
a[i] = a[j];
a[j] = s;
}
/*
@ -471,7 +472,10 @@ PathkeyMutatorSwap(int *a, int i, int j)
static bool
PathkeyMutatorNextSet(int *a, int n)
{
int j, k, l, r;
int j,
k,
l,
r;
j = n - 2;
@ -507,7 +511,7 @@ PathkeyMutatorNextSet(int *a, int n)
static List *
PathkeyMutatorNext(PathkeyMutatorState *state)
{
int i;
int i;
state->count++;
@ -528,9 +532,9 @@ PathkeyMutatorNext(PathkeyMutatorState *state)
}
/* update the list cells to point to the right elements */
for(i = 0; i < state->mutatorNColumns; i++)
for (i = 0; i < state->mutatorNColumns; i++)
lfirst(state->elemCells[i]) =
(void *) state->elems[ state->positions[i] - 1 ];
(void *) state->elems[state->positions[i] - 1];
return state->elemsList;
}
@ -541,7 +545,7 @@ PathkeyMutatorNext(PathkeyMutatorState *state)
typedef struct PathkeySortCost
{
Cost cost;
PathKey *pathkey;
PathKey *pathkey;
} PathkeySortCost;
static int
@ -581,41 +585,42 @@ get_cheapest_group_keys_order(PlannerInfo *root, double nrows,
List **group_pathkeys, List **group_clauses,
int n_preordered)
{
List *new_group_pathkeys = NIL,
*new_group_clauses = NIL,
*var_group_pathkeys;
List *new_group_pathkeys = NIL,
*new_group_clauses = NIL,
*var_group_pathkeys;
ListCell *cell;
PathkeyMutatorState mstate;
double cheapest_sort_cost = -1.0;
ListCell *cell;
PathkeyMutatorState mstate;
double cheapest_sort_cost = -1.0;
int nFreeKeys;
int nToPermute;
int nFreeKeys;
int nToPermute;
/* If there are less than 2 unsorted pathkeys, we're done. */
if (list_length(*group_pathkeys) - n_preordered < 2)
return false;
/*
* We could exhaustively cost all possible orderings of the pathkeys, but for
* a large number of pathkeys it might be prohibitively expensive. So we try
* to apply simple cheap heuristics first - we sort the pathkeys by sort cost
* (as if the pathkey was sorted independently) and then check only the four
* cheapest pathkeys. The remaining pathkeys are kept ordered by cost.
* We could exhaustively cost all possible orderings of the pathkeys, but
* for a large number of pathkeys it might be prohibitively expensive. So
* we try to apply simple cheap heuristics first - we sort the pathkeys by
* sort cost (as if the pathkey was sorted independently) and then check
* only the four cheapest pathkeys. The remaining pathkeys are kept
* ordered by cost.
*
* XXX This is a very simple heuristics, but likely to work fine for most
* cases (because the number of GROUP BY clauses tends to be lower than 4).
* But it ignores how the number of distinct values in each pathkey affects
* the following steps. It might be better to use "more expensive" pathkey
* first if it has many distinct values, because it then limits the number
* of comparisons for the remaining pathkeys. But evaluating that is likely
* quite the expensive.
* cases (because the number of GROUP BY clauses tends to be lower than
* 4). But it ignores how the number of distinct values in each pathkey
* affects the following steps. It might be better to use "more expensive"
* pathkey first if it has many distinct values, because it then limits
* the number of comparisons for the remaining pathkeys. But evaluating
* that is likely quite the expensive.
*/
nFreeKeys = list_length(*group_pathkeys) - n_preordered;
nToPermute = 4;
if (nFreeKeys > nToPermute)
{
int i;
int i;
PathkeySortCost *costs = palloc(sizeof(PathkeySortCost) * nFreeKeys);
/* skip the pre-ordered pathkeys */
@ -624,7 +629,7 @@ get_cheapest_group_keys_order(PlannerInfo *root, double nrows,
/* estimate cost for sorting individual pathkeys */
for (i = 0; cell != NULL; i++, (cell = lnext(*group_pathkeys, cell)))
{
List *to_cost = list_make1(lfirst(cell));
List *to_cost = list_make1(lfirst(cell));
Assert(i < nFreeKeys);
@ -658,28 +663,29 @@ get_cheapest_group_keys_order(PlannerInfo *root, double nrows,
Assert(list_length(new_group_pathkeys) == list_length(*group_pathkeys));
/*
* Generate pathkey lists with permutations of the first nToPermute pathkeys.
* Generate pathkey lists with permutations of the first nToPermute
* pathkeys.
*
* XXX We simply calculate sort cost for each individual pathkey list, but
* there's room for two dynamic programming optimizations here. Firstly, we
* may pass the current "best" cost to cost_sort_estimate so that it can
* "abort" if the estimated pathkeys list exceeds it. Secondly, it could pass
* the return information about the position when it exceeded the cost, and
* we could skip all permutations with the same prefix.
* there's room for two dynamic programming optimizations here. Firstly,
* we may pass the current "best" cost to cost_sort_estimate so that it
* can "abort" if the estimated pathkeys list exceeds it. Secondly, it
* could pass the return information about the position when it exceeded
* the cost, and we could skip all permutations with the same prefix.
*
* Imagine we've already found ordering with cost C1, and we're evaluating
* another ordering - cost_sort_estimate() calculates cost by adding the
* pathkeys one by one (more or less), and the cost only grows. If at any
* point it exceeds C1, it can't possibly be "better" so we can discard it.
* But we also know that we can discard all ordering with the same prefix,
* because if we're estimating (a,b,c,d) and we exceed C1 at (a,b) then the
* same thing will happen for any ordering with this prefix.
* point it exceeds C1, it can't possibly be "better" so we can discard
* it. But we also know that we can discard all ordering with the same
* prefix, because if we're estimating (a,b,c,d) and we exceed C1 at (a,b)
* then the same thing will happen for any ordering with this prefix.
*/
PathkeyMutatorInit(&mstate, new_group_pathkeys, n_preordered, n_preordered + nToPermute);
while((var_group_pathkeys = PathkeyMutatorNext(&mstate)) != NIL)
while ((var_group_pathkeys = PathkeyMutatorNext(&mstate)) != NIL)
{
Cost cost;
Cost cost;
cost = cost_sort_estimate(root, var_group_pathkeys, n_preordered, nrows);
@ -694,11 +700,11 @@ get_cheapest_group_keys_order(PlannerInfo *root, double nrows,
/* Reorder the group clauses according to the reordered pathkeys. */
foreach(cell, new_group_pathkeys)
{
PathKey *pathkey = (PathKey *) lfirst(cell);
PathKey *pathkey = (PathKey *) lfirst(cell);
new_group_clauses = lappend(new_group_clauses,
get_sortgroupref_clause(pathkey->pk_eclass->ec_sortref,
*group_clauses));
get_sortgroupref_clause(pathkey->pk_eclass->ec_sortref,
*group_clauses));
}
/* Just append the rest GROUP BY clauses */
@ -745,8 +751,8 @@ get_useful_group_keys_orderings(PlannerInfo *root, double nrows,
PathKeyInfo *info;
int n_preordered = 0;
List *pathkeys = group_pathkeys;
List *clauses = group_clauses;
List *pathkeys = group_pathkeys;
List *clauses = group_clauses;
/* always return at least the original pathkeys/clauses */
info = makeNode(PathKeyInfo);
@ -756,9 +762,9 @@ get_useful_group_keys_orderings(PlannerInfo *root, double nrows,
infos = lappend(infos, info);
/*
* Should we try generating alternative orderings of the group keys? If not,
* we produce only the order specified in the query, i.e. the optimization
* is effectively disabled.
* Should we try generating alternative orderings of the group keys? If
* not, we produce only the order specified in the query, i.e. the
* optimization is effectively disabled.
*/
if (!enable_group_by_reordering)
return infos;
@ -782,8 +788,9 @@ get_useful_group_keys_orderings(PlannerInfo *root, double nrows,
}
/*
* If the path is sorted in some way, try reordering the group keys to match
* as much of the ordering as possible - we get this sort for free (mostly).
* If the path is sorted in some way, try reordering the group keys to
* match as much of the ordering as possible - we get this sort for free
* (mostly).
*
* We must not do this when there are no grouping sets, because those use
* more complex logic to decide the ordering.
@ -2400,8 +2407,8 @@ pathkeys_useful_for_ordering(PlannerInfo *root, List *pathkeys)
static int
pathkeys_useful_for_grouping(PlannerInfo *root, List *pathkeys)
{
ListCell *key;
int n = 0;
ListCell *key;
int n = 0;
/* no special ordering requested for grouping */
if (root->group_pathkeys == NIL)
@ -2414,7 +2421,7 @@ pathkeys_useful_for_grouping(PlannerInfo *root, List *pathkeys)
/* walk the pathkeys and search for matching group key */
foreach(key, pathkeys)
{
PathKey *pathkey = (PathKey *) lfirst(key);
PathKey *pathkey = (PathKey *) lfirst(key);
/* no matching group key, we're done */
if (!list_member_ptr(root->group_pathkeys, pathkey))

4
src/backend/optimizer/plan/createplan.c
View File

@ -1162,8 +1162,8 @@ mark_async_capable_plan(Plan *plan, Path *path)
case T_ProjectionPath:
/*
* If the generated plan node includes a Result node for
* the projection, we can't execute it asynchronously.
* If the generated plan node includes a Result node for the
* projection, we can't execute it asynchronously.
*/
if (IsA(plan, Result))
return false;

66
src/backend/optimizer/plan/planner.c
View File

@ -6250,7 +6250,7 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
Assert(list_length(pathkey_orderings) > 0);
/* process all potentially interesting grouping reorderings */
foreach (lc2, pathkey_orderings)
foreach(lc2, pathkey_orderings)
{
bool is_sorted;
int presorted_keys = 0;
@ -6283,8 +6283,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
else if (parse->hasAggs)
{
/*
* We have aggregation, possibly with plain GROUP BY. Make
* an AggPath.
* We have aggregation, possibly with plain GROUP BY.
* Make an AggPath.
*/
add_path(grouped_rel, (Path *)
create_agg_path(root,
@ -6301,8 +6301,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
else if (group_clauses)
{
/*
* We have GROUP BY without aggregation or grouping sets.
* Make a GroupPath.
* We have GROUP BY without aggregation or grouping
* sets. Make a GroupPath.
*/
add_path(grouped_rel, (Path *)
create_group_path(root,
@ -6321,8 +6321,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
/*
* Now we may consider incremental sort on this path, but only
* when the path is not already sorted and when incremental sort
* is enabled.
* when the path is not already sorted and when incremental
* sort is enabled.
*/
if (is_sorted || !enable_incremental_sort)
continue;
@ -6335,8 +6335,9 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
continue;
/*
* We should have already excluded pathkeys of length 1 because
* then presorted_keys > 0 would imply is_sorted was true.
* We should have already excluded pathkeys of length 1
* because then presorted_keys > 0 would imply is_sorted was
* true.
*/
Assert(list_length(root->group_pathkeys) != 1);
@ -6357,8 +6358,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
else if (parse->hasAggs)
{
/*
* We have aggregation, possibly with plain GROUP BY. Make an
* AggPath.
* We have aggregation, possibly with plain GROUP BY. Make
* an AggPath.
*/
add_path(grouped_rel, (Path *)
create_agg_path(root,
@ -6375,8 +6376,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
else if (parse->groupClause)
{
/*
* We have GROUP BY without aggregation or grouping sets. Make
* a GroupPath.
* We have GROUP BY without aggregation or grouping sets.
* Make a GroupPath.
*/
add_path(grouped_rel, (Path *)
create_group_path(root,
@ -6421,7 +6422,7 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
Assert(list_length(pathkey_orderings) > 0);
/* process all potentially interesting grouping reorderings */
foreach (lc2, pathkey_orderings)
foreach(lc2, pathkey_orderings)
{
bool is_sorted;
int presorted_keys = 0;
@ -6435,8 +6436,8 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
&presorted_keys);
/*
* Insert a Sort node, if required. But there's no point in
* sorting anything but the cheapest path.
* Insert a Sort node, if required. But there's no point
* in sorting anything but the cheapest path.
*/
if (!is_sorted)
{
@ -6471,24 +6472,30 @@ add_paths_to_grouping_rel(PlannerInfo *root, RelOptInfo *input_rel,
dNumGroups));
/*
* Now we may consider incremental sort on this path, but only
* when the path is not already sorted and when incremental
* sort is enabled.
* Now we may consider incremental sort on this path, but
* only when the path is not already sorted and when
* incremental sort is enabled.
*/
if (is_sorted || !enable_incremental_sort)
continue;
/* Restore the input path (we might have added Sort on top). */
/*
* Restore the input path (we might have added Sort on
* top).
*/
path = path_original;
/* no shared prefix, not point in building incremental sort */
/*
* no shared prefix, not point in building incremental
* sort
*/
if (presorted_keys == 0)
continue;
/*
* We should have already excluded pathkeys of length 1
* because then presorted_keys > 0 would imply is_sorted was
* true.
* because then presorted_keys > 0 would imply is_sorted
* was true.
*/
Assert(list_length(root->group_pathkeys) != 1);
@ -6741,7 +6748,7 @@ create_partial_grouping_paths(PlannerInfo *root,
Assert(list_length(pathkey_orderings) > 0);
/* process all potentially interesting grouping reorderings */
foreach (lc2, pathkey_orderings)
foreach(lc2, pathkey_orderings)
{
bool is_sorted;
int presorted_keys = 0;
@ -6874,7 +6881,7 @@ create_partial_grouping_paths(PlannerInfo *root,
Assert(list_length(pathkey_orderings) > 0);
/* process all potentially interesting grouping reorderings */
foreach (lc2, pathkey_orderings)
foreach(lc2, pathkey_orderings)
{
bool is_sorted;
int presorted_keys = 0;
@ -6924,8 +6931,8 @@ create_partial_grouping_paths(PlannerInfo *root,
/*
* Now we may consider incremental sort on this path, but only
* when the path is not already sorted and when incremental sort
* is enabled.
* when the path is not already sorted and when incremental
* sort is enabled.
*/
if (is_sorted || !enable_incremental_sort)
continue;
@ -6938,8 +6945,9 @@ create_partial_grouping_paths(PlannerInfo *root,
continue;
/*
* We should have already excluded pathkeys of length 1 because
* then presorted_keys > 0 would imply is_sorted was true.
* We should have already excluded pathkeys of length 1
* because then presorted_keys > 0 would imply is_sorted was
* true.
*/
Assert(list_length(root->group_pathkeys) != 1);

8
src/backend/optimizer/util/clauses.c
View File

@ -391,7 +391,7 @@ contain_mutable_functions_walker(Node *node, void *context)
const JsonConstructorExpr *ctor = (JsonConstructorExpr *) node;
ListCell *lc;
bool is_jsonb =
ctor->returning->format->format_type == JS_FORMAT_JSONB;
ctor->returning->format->format_type == JS_FORMAT_JSONB;
/* Check argument_type => json[b] conversions */
foreach(lc, ctor->args)
@ -899,7 +899,7 @@ max_parallel_hazard_walker(Node *node, max_parallel_hazard_context *context)
/* JsonExpr is parallel-unsafe if subtransactions can be used. */
else if (IsA(node, JsonExpr))
{
JsonExpr *jsexpr = (JsonExpr *) node;
JsonExpr *jsexpr = (JsonExpr *) node;
if (ExecEvalJsonNeedsSubTransaction(jsexpr, NULL))
{
@ -3581,7 +3581,7 @@ eval_const_expressions_mutator(Node *node,
context->case_val = raw;
formatted = eval_const_expressions_mutator((Node *) jve->formatted_expr,
context);
context);
context->case_val = save_case_val;
@ -5315,7 +5315,7 @@ pull_paramids_walker(Node *node, Bitmapset **context)
return false;
if (IsA(node, Param))
{
Param *param = (Param *)node;
Param *param = (Param *) node;
*context = bms_add_member(*context, param->paramid);
return false;

172
src/backend/optimizer/util/plancat.c
View File

@ -968,102 +968,102 @@ estimate_rel_size(Relation rel, int32 *attr_widths,
if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
{
table_relation_estimate_size(rel, attr_widths, pages, tuples,
allvisfrac);
table_relation_estimate_size(rel, attr_widths, pages, tuples,
allvisfrac);
}
else if (rel->rd_rel->relkind == RELKIND_INDEX)
{
/*
* XXX: It'd probably be good to move this into a callback, individual
* index types e.g. know if they have a metapage.
*/
/* it has storage, ok to call the smgr */
curpages = RelationGetNumberOfBlocks(rel);
/* report estimated # pages */
*pages = curpages;
/* quick exit if rel is clearly empty */
if (curpages == 0)
{
*tuples = 0;
*allvisfrac = 0;
return;
}
/* coerce values in pg_class to more desirable types */
relpages = (BlockNumber) rel->rd_rel->relpages;
reltuples = (double) rel->rd_rel->reltuples;
relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
/*
* Discount the metapage while estimating the number of tuples. This
* is a kluge because it assumes more than it ought to about index
* structure. Currently it's OK for btree, hash, and GIN indexes but
* suspect for GiST indexes.
*/
if (relpages > 0)
{
curpages--;
relpages--;
}
/* estimate number of tuples from previous tuple density */
if (reltuples >= 0 && relpages > 0)
density = reltuples / (double) relpages;
else
{
/*
* XXX: It'd probably be good to move this into a callback,
* individual index types e.g. know if they have a metapage.
* If we have no data because the relation was never vacuumed,
* estimate tuple width from attribute datatypes. We assume here
* that the pages are completely full, which is OK for tables
* (since they've presumably not been VACUUMed yet) but is
* probably an overestimate for indexes. Fortunately
* get_relation_info() can clamp the overestimate to the parent
* table's size.
*
* Note: this code intentionally disregards alignment
* considerations, because (a) that would be gilding the lily
* considering how crude the estimate is, and (b) it creates
* platform dependencies in the default plans which are kind of a
* headache for regression testing.
*
* XXX: Should this logic be more index specific?
*/
int32 tuple_width;
/* it has storage, ok to call the smgr */
curpages = RelationGetNumberOfBlocks(rel);
tuple_width = get_rel_data_width(rel, attr_widths);
tuple_width += MAXALIGN(SizeofHeapTupleHeader);
tuple_width += sizeof(ItemIdData);
/* note: integer division is intentional here */
density = (BLCKSZ - SizeOfPageHeaderData) / tuple_width;
}
*tuples = rint(density * (double) curpages);
/* report estimated # pages */
*pages = curpages;
/* quick exit if rel is clearly empty */
if (curpages == 0)
{
*tuples = 0;
*allvisfrac = 0;
return;
}
/* coerce values in pg_class to more desirable types */
relpages = (BlockNumber) rel->rd_rel->relpages;
reltuples = (double) rel->rd_rel->reltuples;
relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
/*
* Discount the metapage while estimating the number of tuples.
* This is a kluge because it assumes more than it ought to about
* index structure. Currently it's OK for btree, hash, and GIN
* indexes but suspect for GiST indexes.
*/
if (relpages > 0)
{
curpages--;
relpages--;
}
/* estimate number of tuples from previous tuple density */
if (reltuples >= 0 && relpages > 0)
density = reltuples / (double) relpages;
else
{
/*
* If we have no data because the relation was never vacuumed,
* estimate tuple width from attribute datatypes. We assume
* here that the pages are completely full, which is OK for
* tables (since they've presumably not been VACUUMed yet) but
* is probably an overestimate for indexes. Fortunately
* get_relation_info() can clamp the overestimate to the
* parent table's size.
*
* Note: this code intentionally disregards alignment
* considerations, because (a) that would be gilding the lily
* considering how crude the estimate is, and (b) it creates
* platform dependencies in the default plans which are kind
* of a headache for regression testing.
*
* XXX: Should this logic be more index specific?
*/
int32 tuple_width;
tuple_width = get_rel_data_width(rel, attr_widths);
tuple_width += MAXALIGN(SizeofHeapTupleHeader);
tuple_width += sizeof(ItemIdData);
/* note: integer division is intentional here */
density = (BLCKSZ - SizeOfPageHeaderData) / tuple_width;
}
*tuples = rint(density * (double) curpages);
/*
* We use relallvisible as-is, rather than scaling it up like we
* do for the pages and tuples counts, on the theory that any
* pages added since the last VACUUM are most likely not marked
* all-visible. But costsize.c wants it converted to a fraction.
*/
if (relallvisible == 0 || curpages <= 0)
*allvisfrac = 0;
else if ((double) relallvisible >= curpages)
*allvisfrac = 1;
else
*allvisfrac = (double) relallvisible / curpages;
/*
* We use relallvisible as-is, rather than scaling it up like we do
* for the pages and tuples counts, on the theory that any pages added
* since the last VACUUM are most likely not marked all-visible. But
* costsize.c wants it converted to a fraction.
*/
if (relallvisible == 0 || curpages <= 0)
*allvisfrac = 0;
else if ((double) relallvisible >= curpages)
*allvisfrac = 1;
else
*allvisfrac = (double) relallvisible / curpages;
}
else
{
/*
* Just use whatever's in pg_class. This covers foreign tables,
* sequences, and also relkinds without storage (shouldn't get
* here?); see initializations in AddNewRelationTuple(). Note
* that FDW must cope if reltuples is -1!
*/
*pages = rel->rd_rel->relpages;
*tuples = rel->rd_rel->reltuples;
*allvisfrac = 0;
/*
* Just use whatever's in pg_class. This covers foreign tables,
* sequences, and also relkinds without storage (shouldn't get here?);
* see initializations in AddNewRelationTuple(). Note that FDW must
* cope if reltuples is -1!
*/
*pages = rel->rd_rel->relpages;
*tuples = rel->rd_rel->reltuples;
*allvisfrac = 0;
}
}

13
src/backend/parser/analyze.c
View File

@ -104,8 +104,8 @@ static bool test_raw_expression_coverage(Node *node, void *context);
*/
Query *
parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText,
const Oid *paramTypes, int numParams,
QueryEnvironment *queryEnv)
const Oid *paramTypes, int numParams,
QueryEnvironment *queryEnv)
{
ParseState *pstate = make_parsestate(NULL);
Query *query;
@ -2076,8 +2076,8 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
ListCell *ltl;
ListCell *rtl;
const char *context;
bool recursive = (pstate->p_parent_cte &&
pstate->p_parent_cte->cterecursive);
bool recursive = (pstate->p_parent_cte &&
pstate->p_parent_cte->cterecursive);
context = (stmt->op == SETOP_UNION ? "UNION" :
(stmt->op == SETOP_INTERSECT ? "INTERSECT" :
@ -2231,7 +2231,10 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
setup_parser_errposition_callback(&pcbstate, pstate,
bestlocation);
/* If it's a recursive union, we need to require hashing support. */
/*
* If it's a recursive union, we need to require hashing
* support.
*/
op->groupClauses = lappend(op->groupClauses,
makeSortGroupClauseForSetOp(rescoltype, recursive));

2
src/backend/parser/parse_clause.c
View File

@ -2004,7 +2004,7 @@ findTargetlistEntrySQL92(ParseState *pstate, Node *node, List **tlist,
}
if (IsA(node, A_Const))
{
A_Const *aconst = castNode(A_Const, node);
A_Const *aconst = castNode(A_Const, node);
int targetlist_pos = 0;
int target_pos;

7
src/backend/parser/parse_collate.c
View File

@ -692,8 +692,11 @@ assign_collations_walker(Node *node, assign_collations_context *context)
}
break;
case T_JsonExpr:
/* Context item and PASSING arguments are already
* marked with collations in parse_expr.c. */
/*
* Context item and PASSING arguments are already
* marked with collations in parse_expr.c.
*/
break;
default:

85
src/backend/parser/parse_expr.c
View File

@ -3277,7 +3277,7 @@ transformJsonValueExprExt(ParseState *pstate, JsonValueExpr *ve,
if (exprtype == JSONOID || exprtype == JSONBOID)
{
format = JS_FORMAT_DEFAULT; /* do not format json[b] types */
format = JS_FORMAT_DEFAULT; /* do not format json[b] types */
ereport(WARNING,
(errmsg("FORMAT JSON has no effect for json and jsonb types"),
parser_errposition(pstate, ve->format->location)));
@ -3316,7 +3316,7 @@ transformJsonValueExprExt(ParseState *pstate, JsonValueExpr *ve,
format = default_format;
}
else if (exprtype == JSONOID || exprtype == JSONBOID)
format = JS_FORMAT_DEFAULT; /* do not format json[b] types */
format = JS_FORMAT_DEFAULT; /* do not format json[b] types */
else
format = default_format;
@ -3364,13 +3364,13 @@ transformJsonValueExprExt(ParseState *pstate, JsonValueExpr *ve,
FuncExpr *fexpr;
Oid fnoid;
if (cast_is_needed) /* only CAST is allowed */
if (cast_is_needed) /* only CAST is allowed */
ereport(ERROR,
(errcode(ERRCODE_CANNOT_COERCE),
errmsg("cannot cast type %s to %s",
format_type_be(exprtype),
format_type_be(targettype)),
parser_errposition(pstate, location)));
parser_errposition(pstate, location)));
fnoid = targettype == JSONOID ? F_TO_JSON : F_TO_JSONB;
fexpr = makeFuncExpr(fnoid, targettype, list_make1(expr),
@ -3444,7 +3444,7 @@ checkJsonOutputFormat(ParseState *pstate, const JsonFormat *format,
if (format->format_type == JS_FORMAT_JSON)
{
JsonEncoding enc = format->encoding != JS_ENC_DEFAULT ?
format->encoding : JS_ENC_UTF8;
format->encoding : JS_ENC_UTF8;
if (targettype != BYTEAOID &&
format->encoding != JS_ENC_DEFAULT)
@ -3583,6 +3583,7 @@ coerceJsonFuncExpr(ParseState *pstate, Node *expr,
list_make2(texpr, enc),
InvalidOid, InvalidOid,
COERCE_EXPLICIT_CALL);
fexpr->location = location;
return (Node *) fexpr;
@ -3591,7 +3592,7 @@ coerceJsonFuncExpr(ParseState *pstate, Node *expr,
/* try to coerce expression to the output type */
res = coerce_to_target_type(pstate, expr, exprtype,
returning->typid, returning->typmod,
/* XXX throwing errors when casting to char(N) */
/* XXX throwing errors when casting to char(N) */
COERCION_EXPLICIT,
COERCE_EXPLICIT_CAST,
location);
@ -3616,7 +3617,7 @@ makeJsonConstructorExpr(ParseState *pstate, JsonConstructorType type,
Node *placeholder;
Node *coercion;
Oid intermediate_typid =
returning->format->format_type == JS_FORMAT_JSONB ? JSONBOID : JSONOID;
returning->format->format_type == JS_FORMAT_JSONB ? JSONBOID : JSONOID;
jsctor->args = args;
jsctor->func = fexpr;
@ -3694,7 +3695,7 @@ static Node *
transformJsonArrayQueryConstructor(ParseState *pstate,
JsonArrayQueryConstructor *ctor)
{
SubLink *sublink = makeNode(SubLink);
SubLink *sublink = makeNode(SubLink);
SelectStmt *select = makeNode(SelectStmt);
RangeSubselect *range = makeNode(RangeSubselect);
Alias *alias = makeNode(Alias);
@ -3766,8 +3767,8 @@ transformJsonAggConstructor(ParseState *pstate, JsonAggConstructor *agg_ctor,
Oid aggfnoid;
Node *node;
Expr *aggfilter = agg_ctor->agg_filter ? (Expr *)
transformWhereClause(pstate, agg_ctor->agg_filter,
EXPR_KIND_FILTER, "FILTER") : NULL;
transformWhereClause(pstate, agg_ctor->agg_filter,
EXPR_KIND_FILTER, "FILTER") : NULL;
aggfnoid = DatumGetInt32(DirectFunctionCall1(regprocin,
CStringGetDatum(aggfn)));
@ -3809,7 +3810,7 @@ transformJsonAggConstructor(ParseState *pstate, JsonAggConstructor *agg_ctor,
aggref->aggtype = aggtype;
/* aggcollid and inputcollid will be set by parse_collate.c */
aggref->aggtranstype = InvalidOid; /* will be set by planner */
aggref->aggtranstype = InvalidOid; /* will be set by planner */
/* aggargtypes will be set by transformAggregateCall */
/* aggdirectargs and args will be set by transformAggregateCall */
/* aggorder and aggdistinct will be set by transformAggregateCall */
@ -3818,7 +3819,7 @@ transformJsonAggConstructor(ParseState *pstate, JsonAggConstructor *agg_ctor,
aggref->aggvariadic = false;
aggref->aggkind = AGGKIND_NORMAL;
/* agglevelsup will be set by transformAggregateCall */
aggref->aggsplit = AGGSPLIT_SIMPLE; /* planner might change this */
aggref->aggsplit = AGGSPLIT_SIMPLE; /* planner might change this */
aggref->location = agg_ctor->location;
transformAggregateCall(pstate, aggref, args, agg_ctor->agg_order, false);
@ -3860,14 +3861,13 @@ transformJsonObjectAgg(ParseState *pstate, JsonObjectAgg *agg)
{
if (agg->absent_on_null)
if (agg->unique)
aggfnname = "pg_catalog.jsonb_object_agg_unique_strict"; /* F_JSONB_OBJECT_AGG_UNIQUE_STRICT */
aggfnname = "pg_catalog.jsonb_object_agg_unique_strict"; /* F_JSONB_OBJECT_AGG_UNIQUE_STRICT */
else
aggfnname = "pg_catalog.jsonb_object_agg_strict"; /* F_JSONB_OBJECT_AGG_STRICT */
aggfnname = "pg_catalog.jsonb_object_agg_strict"; /* F_JSONB_OBJECT_AGG_STRICT */
else if (agg->unique)
aggfnname = "pg_catalog.jsonb_object_agg_unique"; /* F_JSONB_OBJECT_AGG_UNIQUE */
else
if (agg->unique)
aggfnname = "pg_catalog.jsonb_object_agg_unique"; /* F_JSONB_OBJECT_AGG_UNIQUE */
else
aggfnname = "pg_catalog.jsonb_object_agg"; /* F_JSONB_OBJECT_AGG */
aggfnname = "pg_catalog.jsonb_object_agg"; /* F_JSONB_OBJECT_AGG */
aggtype = JSONBOID;
}
@ -3877,12 +3877,11 @@ transformJsonObjectAgg(ParseState *pstate, JsonObjectAgg *agg)
if (agg->unique)
aggfnname = "pg_catalog.json_object_agg_unique_strict"; /* F_JSON_OBJECT_AGG_UNIQUE_STRICT */
else
aggfnname = "pg_catalog.json_object_agg_strict"; /* F_JSON_OBJECT_AGG_STRICT */
aggfnname = "pg_catalog.json_object_agg_strict"; /* F_JSON_OBJECT_AGG_STRICT */
else if (agg->unique)
aggfnname = "pg_catalog.json_object_agg_unique"; /* F_JSON_OBJECT_AGG_UNIQUE */
else
if (agg->unique)
aggfnname = "pg_catalog.json_object_agg_unique"; /* F_JSON_OBJECT_AGG_UNIQUE */
else
aggfnname = "pg_catalog.json_object_agg"; /* F_JSON_OBJECT_AGG */
aggfnname = "pg_catalog.json_object_agg"; /* F_JSON_OBJECT_AGG */
aggtype = JSONOID;
}
@ -4209,7 +4208,7 @@ coerceJsonExpr(ParseState *pstate, Node *expr, const JsonReturning *returning)
* Transform a JSON output clause of JSON_VALUE and JSON_QUERY.
*/
static void
transformJsonFuncExprOutput(ParseState *pstate, JsonFuncExpr *func,
transformJsonFuncExprOutput(ParseState *pstate, JsonFuncExpr *func,
JsonExpr *jsexpr)
{
Node *expr = jsexpr->formatted_expr;
@ -4333,19 +4332,19 @@ initJsonItemCoercions(ParseState *pstate, JsonItemCoercions *coercions,
Oid typid;
} *p,
coercionTypids[] =
{
{ &coercions->null, UNKNOWNOID },
{ &coercions->string, TEXTOID },
{ &coercions->numeric, NUMERICOID },
{ &coercions->boolean, BOOLOID },
{ &coercions->date, DATEOID },
{ &coercions->time, TIMEOID },
{ &coercions->timetz, TIMETZOID },
{ &coercions->timestamp, TIMESTAMPOID },
{ &coercions->timestamptz, TIMESTAMPTZOID },
{ &coercions->composite, contextItemTypeId },
{ NULL, InvalidOid }
};
{
{&coercions->null, UNKNOWNOID},
{&coercions->string, TEXTOID},
{&coercions->numeric, NUMERICOID},
{&coercions->boolean, BOOLOID},
{&coercions->date, DATEOID},
{&coercions->time, TIMEOID},
{&coercions->timetz, TIMETZOID},
{&coercions->timestamp, TIMESTAMPOID},
{&coercions->timestamptz, TIMESTAMPTZOID},
{&coercions->composite, contextItemTypeId},
{NULL, InvalidOid}
};
for (p = coercionTypids; p->coercion; p++)
*p->coercion = initJsonItemCoercion(pstate, p->typid, returning);
@ -4512,7 +4511,7 @@ static Node *
transformJsonParseExpr(ParseState *pstate, JsonParseExpr *jsexpr)
{
JsonReturning *returning = transformJsonConstructorRet(pstate, jsexpr->output,
"JSON()");
"JSON()");
Node *arg;
if (jsexpr->unique_keys)
@ -4544,8 +4543,8 @@ transformJsonParseExpr(ParseState *pstate, JsonParseExpr *jsexpr)
}
return makeJsonConstructorExpr(pstate, JSCTOR_JSON_PARSE, list_make1(arg), NULL,
returning, jsexpr->unique_keys, false,
jsexpr->location);
returning, jsexpr->unique_keys, false,
jsexpr->location);
}
/*
@ -4556,13 +4555,13 @@ transformJsonScalarExpr(ParseState *pstate, JsonScalarExpr *jsexpr)
{
Node *arg = transformExprRecurse(pstate, (Node *) jsexpr->expr);
JsonReturning *returning = transformJsonConstructorRet(pstate, jsexpr->output,
"JSON_SCALAR()");
"JSON_SCALAR()");
if (exprType(arg) == UNKNOWNOID)
arg = coerce_to_specific_type(pstate, arg, TEXTOID, "JSON_SCALAR");
return makeJsonConstructorExpr(pstate, JSCTOR_JSON_SCALAR, list_make1(arg), NULL,
returning, false, false, jsexpr->location);
returning, false, false, jsexpr->location);
}
/*
@ -4586,5 +4585,5 @@ transformJsonSerializeExpr(ParseState *pstate, JsonSerializeExpr *expr)
}
return makeJsonConstructorExpr(pstate, JSCTOR_JSON_SERIALIZE, list_make1(arg),
NULL, returning, false, false, expr->location);
NULL, returning, false, false, expr->location);
}

74
src/backend/parser/parse_jsontable.c
View File

@ -33,31 +33,31 @@
/* Context for JSON_TABLE transformation */
typedef struct JsonTableContext
{
ParseState *pstate; /* parsing state */
JsonTable *table; /* untransformed node */
TableFunc *tablefunc; /* transformed node */
List *pathNames; /* list of all path and columns names */
int pathNameId; /* path name id counter */
ParseState *pstate; /* parsing state */
JsonTable *table; /* untransformed node */
TableFunc *tablefunc; /* transformed node */
List *pathNames; /* list of all path and columns names */
int pathNameId; /* path name id counter */
Oid contextItemTypid; /* type oid of context item (json/jsonb) */
} JsonTableContext;
static JsonTableParent * transformJsonTableColumns(JsonTableContext *cxt,
JsonTablePlan *plan,
List *columns,
char *pathSpec,
char **pathName,
int location);
static JsonTableParent *transformJsonTableColumns(JsonTableContext *cxt,
JsonTablePlan *plan,
List *columns,
char *pathSpec,
char **pathName,
int location);
static Node *
makeStringConst(char *str, int location)
{
A_Const *n = makeNode(A_Const);
A_Const *n = makeNode(A_Const);
n->val.node.type = T_String;
n->val.sval.sval = str;
n->location = location;
return (Node *)n;
return (Node *) n;
}
/*
@ -122,7 +122,7 @@ transformJsonTableColumn(JsonTableColumn *jtc, Node *contextItemExpr,
static bool
isJsonTablePathNameDuplicate(JsonTableContext *cxt, const char *pathname)
{
ListCell *lc;
ListCell *lc;
foreach(lc, cxt->pathNames)
{
@ -342,7 +342,7 @@ transformJsonTableChildPlan(JsonTableContext *cxt, JsonTablePlan *plan,
foreach(lc, columns)
{
JsonTableColumn *jtc = castNode(JsonTableColumn, lfirst(lc));
Node *node;
Node *node;
if (jtc->coltype != JTC_NESTED)
continue;
@ -369,10 +369,10 @@ transformJsonTableChildPlan(JsonTableContext *cxt, JsonTablePlan *plan,
}
else
{
Node *node1 =
transformJsonTableChildPlan(cxt, plan->plan1, columns);
Node *node2 =
transformJsonTableChildPlan(cxt, plan->plan2, columns);
Node *node1 = transformJsonTableChildPlan(cxt, plan->plan1,
columns);
Node *node2 = transformJsonTableChildPlan(cxt, plan->plan2,
columns);
return makeJsonTableSiblingJoin(plan->join_type == JSTPJ_CROSS,
node1, node2);
@ -396,7 +396,7 @@ transformJsonTableChildPlan(JsonTableContext *cxt, JsonTablePlan *plan,
static bool
typeIsComposite(Oid typid)
{
char typtype;
char typtype;
if (typid == JSONOID ||
typid == JSONBOID ||
@ -406,7 +406,7 @@ typeIsComposite(Oid typid)
typtype = get_typtype(typid);
if (typtype == TYPTYPE_COMPOSITE)
if (typtype == TYPTYPE_COMPOSITE)
return true;
if (typtype == TYPTYPE_DOMAIN)
@ -424,7 +424,7 @@ appendJsonTableColumns(JsonTableContext *cxt, List *columns)
JsonTable *jt = cxt->table;
TableFunc *tf = cxt->tablefunc;
bool errorOnError = jt->on_error &&
jt->on_error->btype == JSON_BEHAVIOR_ERROR;
jt->on_error->btype == JSON_BEHAVIOR_ERROR;
foreach(col, columns)
{
@ -436,24 +436,23 @@ appendJsonTableColumns(JsonTableContext *cxt, List *columns)
if (rawc->name)
{
/* make sure column names are unique */
ListCell *colname;
ListCell *colname;
foreach(colname, tf->colnames)
if (!strcmp((const char *) colname, rawc->name))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("column name \"%s\" is not unique",
rawc->name),
parser_errposition(pstate, rawc->location)));
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("column name \"%s\" is not unique",
rawc->name),
parser_errposition(pstate, rawc->location)));
tf->colnames = lappend(tf->colnames,
makeString(pstrdup(rawc->name)));
}
/*
* Determine the type and typmod for the new column. FOR
* ORDINALITY columns are INTEGER by standard; the others are
* user-specified.
* Determine the type and typmod for the new column. FOR ORDINALITY
* columns are INTEGER by standard; the others are user-specified.
*/
switch (rawc->coltype)
{
@ -517,8 +516,8 @@ appendJsonTableColumns(JsonTableContext *cxt, List *columns)
tf->coltypmods = lappend_int(tf->coltypmods, typmod);
tf->colcollations = lappend_oid(tf->colcollations,
type_is_collatable(typid)
? DEFAULT_COLLATION_OID
: InvalidOid);
? DEFAULT_COLLATION_OID
: InvalidOid);
tf->colvalexprs = lappend(tf->colvalexprs, colexpr);
}
}
@ -571,7 +570,7 @@ transformJsonTableColumns(JsonTableContext *cxt, JsonTablePlan *plan,
errdetail("JSON_TABLE columns must contain "
"explicit AS pathname specification if "
"explicit PLAN clause is used"),
parser_errposition(cxt->pstate, location)));
parser_errposition(cxt->pstate, location)));
*pathName = generateJsonTablePathName(cxt);
}
@ -662,14 +661,15 @@ transformJsonTable(ParseState *pstate, JsonTable *jt)
registerAllJsonTableColumns(&cxt, jt->columns);
#if 0 /* XXX it' unclear from the standard whether root path name is mandatory or not */
#if 0 /* XXX it' unclear from the standard whether
* root path name is mandatory or not */
if (plan && plan->plan_type != JSTP_DEFAULT && !rootPathName)
{
/* Assign root path name and create corresponding plan node */
JsonTablePlan *rootNode = makeNode(JsonTablePlan);
JsonTablePlan *rootPlan = (JsonTablePlan *)
makeJsonTableJoinedPlan(JSTPJ_OUTER, (Node *) rootNode,
(Node *) plan, jt->location);
makeJsonTableJoinedPlan(JSTPJ_OUTER, (Node *) rootNode,
(Node *) plan, jt->location);
rootPathName = generateJsonTablePathName(&cxt);

79
src/backend/parser/parse_node.c
View File

@ -382,55 +382,56 @@ make_const(ParseState *pstate, A_Const *aconst)
break;
case T_Float:
{
/* could be an oversize integer as well as a float ... */
int64 val64;
char *endptr;
errno = 0;
val64 = strtoi64(aconst->val.fval.fval, &endptr, 10);
if (errno == 0 && *endptr == '\0')
{
/*
* It might actually fit in int32. Probably only INT_MIN can
* occur, but we'll code the test generally just to be sure.
*/
int32 val32 = (int32) val64;
/* could be an oversize integer as well as a float ... */
if (val64 == (int64) val32)
int64 val64;
char *endptr;
errno = 0;
val64 = strtoi64(aconst->val.fval.fval, &endptr, 10);
if (errno == 0 && *endptr == '\0')
{
val = Int32GetDatum(val32);
/*
* It might actually fit in int32. Probably only INT_MIN
* can occur, but we'll code the test generally just to be
* sure.
*/
int32 val32 = (int32) val64;
typeid = INT4OID;
typelen = sizeof(int32);
typebyval = true;
if (val64 == (int64) val32)
{
val = Int32GetDatum(val32);
typeid = INT4OID;
typelen = sizeof(int32);
typebyval = true;
}
else
{
val = Int64GetDatum(val64);
typeid = INT8OID;
typelen = sizeof(int64);
typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
}
}
else
{
val = Int64GetDatum(val64);
/* arrange to report location if numeric_in() fails */
setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
val = DirectFunctionCall3(numeric_in,
CStringGetDatum(aconst->val.fval.fval),
ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1));
cancel_parser_errposition_callback(&pcbstate);
typeid = INT8OID;
typelen = sizeof(int64);
typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
typeid = NUMERICOID;
typelen = -1; /* variable len */
typebyval = false;
}
break;
}
else
{
/* arrange to report location if numeric_in() fails */
setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
val = DirectFunctionCall3(numeric_in,
CStringGetDatum(aconst->val.fval.fval),
ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1));
cancel_parser_errposition_callback(&pcbstate);
typeid = NUMERICOID;
typelen = -1; /* variable len */
typebyval = false;
}
break;
}
case T_Boolean:
val = BoolGetDatum(boolVal(&aconst->val));

4
src/backend/parser/parse_param.c
View File

@ -65,7 +65,7 @@ static bool query_contains_extern_params_walker(Node *node, void *context);
*/
void
setup_parse_fixed_parameters(ParseState *pstate,
const Oid *paramTypes, int numParams)
const Oid *paramTypes, int numParams)
{
FixedParamState *parstate = palloc(sizeof(FixedParamState));
@ -81,7 +81,7 @@ setup_parse_fixed_parameters(ParseState *pstate,
*/
void
setup_parse_variable_parameters(ParseState *pstate,
Oid **paramTypes, int *numParams)
Oid **paramTypes, int *numParams)
{
VarParamState *parstate = palloc(sizeof(VarParamState));

2
src/backend/parser/parse_relation.c
View File

@ -1990,7 +1990,7 @@ addRangeTableEntryForTableFunc(ParseState *pstate,
{
RangeTblEntry *rte = makeNode(RangeTblEntry);
char *refname = alias ? alias->aliasname :
pstrdup(tf->functype == TFT_XMLTABLE ? "xmltable" : "json_table");
pstrdup(tf->functype == TFT_XMLTABLE ? "xmltable" : "json_table");
Alias *eref;
int numaliases;

4
src/backend/partitioning/partdesc.c
View File

@ -91,8 +91,8 @@ RelationGetPartitionDesc(Relation rel, bool omit_detached)
* cached descriptor too. We determine that based on the pg_inherits.xmin
* that was saved alongside that descriptor: if the xmin that was not in
* progress for that active snapshot is also not in progress for the
* current active snapshot, then we can use it. Otherwise build one
* from scratch.
* current active snapshot, then we can use it. Otherwise build one from
* scratch.
*/
if (omit_detached &&
rel->rd_partdesc_nodetached &&

15
src/backend/postmaster/autovacuum.c
View File

@ -984,7 +984,8 @@ rebuild_database_list(Oid newdb)
hctl.keysize = sizeof(Oid);
hctl.entrysize = sizeof(avl_dbase);
hctl.hcxt = tmpcxt;
dbhash = hash_create("autovacuum db hash", 20, &hctl, /* magic number here FIXME */
dbhash = hash_create("autovacuum db hash", 20, &hctl, /* magic number here
* FIXME */
HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
/* start by inserting the new database */
@ -1683,12 +1684,12 @@ AutoVacWorkerMain(int argc, char *argv[])
char dbname[NAMEDATALEN];
/*
* Report autovac startup to the cumulative stats system. We deliberately do
* this before InitPostgres, so that the last_autovac_time will get
* updated even if the connection attempt fails. This is to prevent
* autovac from getting "stuck" repeatedly selecting an unopenable
* database, rather than making any progress on stuff it can connect
* to.
* Report autovac startup to the cumulative stats system. We
* deliberately do this before InitPostgres, so that the
* last_autovac_time will get updated even if the connection attempt
* fails. This is to prevent autovac from getting "stuck" repeatedly
* selecting an unopenable database, rather than making any progress
* on stuff it can connect to.
*/
pgstat_report_autovac(dbid);

6
src/backend/postmaster/bgworker.c
View File

@ -826,9 +826,9 @@ StartBackgroundWorker(void)
/*
* Create a per-backend PGPROC struct in shared memory, except in the
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must
* do this before we can use LWLocks (and in the EXEC_BACKEND case we
* already had to do some stuff with LWLocks).
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
* this before we can use LWLocks (and in the EXEC_BACKEND case we already
* had to do some stuff with LWLocks).
*/
#ifndef EXEC_BACKEND
InitProcess();

44
src/backend/postmaster/pgarch.c
View File

@ -81,15 +81,14 @@ typedef struct PgArchData
int pgprocno; /* pgprocno of archiver process */
/*
* Forces a directory scan in pgarch_readyXlog(). Protected by
* arch_lck.
* Forces a directory scan in pgarch_readyXlog(). Protected by arch_lck.
*/
bool force_dir_scan;
slock_t arch_lck;
} PgArchData;
char *XLogArchiveLibrary = "";
char *XLogArchiveLibrary = "";
/* ----------
@ -143,7 +142,7 @@ static bool pgarch_readyXlog(char *xlog);
static void pgarch_archiveDone(char *xlog);
static void pgarch_die(int code, Datum arg);
static void HandlePgArchInterrupts(void);
static int ready_file_comparator(Datum a, Datum b, void *arg);
static int ready_file_comparator(Datum a, Datum b, void *arg);
static void LoadArchiveLibrary(void);
static void call_archive_module_shutdown_callback(int code, Datum arg);
@ -579,13 +578,13 @@ pgarch_readyXlog(char *xlog)
/*
* If we still have stored file names from the previous directory scan,
* try to return one of those. We check to make sure the status file
* is still present, as the archive_command for a previous file may
* have already marked it done.
* try to return one of those. We check to make sure the status file is
* still present, as the archive_command for a previous file may have
* already marked it done.
*/
while (arch_files->arch_files_size > 0)
{
struct stat st;
struct stat st;
char status_file[MAXPGPATH];
char *arch_file;
@ -655,8 +654,8 @@ pgarch_readyXlog(char *xlog)
CStringGetDatum(basename), NULL) > 0)
{
/*
* Remove the lowest priority file and add the current one to
* the heap.
* Remove the lowest priority file and add the current one to the
* heap.
*/
arch_file = DatumGetCString(binaryheap_remove_first(arch_files->arch_heap));
strcpy(arch_file, basename);
@ -677,8 +676,8 @@ pgarch_readyXlog(char *xlog)
binaryheap_build(arch_files->arch_heap);
/*
* Fill arch_files array with the files to archive in ascending order
* of priority.
* Fill arch_files array with the files to archive in ascending order of
* priority.
*/
arch_files->arch_files_size = arch_files->arch_heap->bh_size;
for (int i = 0; i < arch_files->arch_files_size; i++)
@ -702,10 +701,10 @@ pgarch_readyXlog(char *xlog)
static int
ready_file_comparator(Datum a, Datum b, void *arg)
{
char *a_str = DatumGetCString(a);
char *b_str = DatumGetCString(b);
bool a_history = IsTLHistoryFileName(a_str);
bool b_history = IsTLHistoryFileName(b_str);
char *a_str = DatumGetCString(a);
char *b_str = DatumGetCString(b);
bool a_history = IsTLHistoryFileName(a_str);
bool b_history = IsTLHistoryFileName(b_str);
/* Timeline history files always have the highest priority. */
if (a_history != b_history)
@ -793,8 +792,8 @@ HandlePgArchInterrupts(void)
if (archiveLibChanged)
{
/*
* Call the currently loaded archive module's shutdown callback, if
* one is defined.
* Call the currently loaded archive module's shutdown callback,
* if one is defined.
*/
call_archive_module_shutdown_callback(0, 0);
@ -803,8 +802,8 @@ HandlePgArchInterrupts(void)
* load the new one, but there is presently no mechanism for
* unloading a library (see the comment above
* internal_load_library()). To deal with this, we simply restart
* the archiver. The new archive module will be loaded when the new
* archiver process starts up.
* the archiver. The new archive module will be loaded when the
* new archiver process starts up.
*/
ereport(LOG,
(errmsg("restarting archiver process because value of "
@ -828,9 +827,8 @@ LoadArchiveLibrary(void)
memset(&ArchiveContext, 0, sizeof(ArchiveModuleCallbacks));
/*
* If shell archiving is enabled, use our special initialization
* function. Otherwise, load the library and call its
* _PG_archive_module_init().
* If shell archiving is enabled, use our special initialization function.
* Otherwise, load the library and call its _PG_archive_module_init().
*/
if (XLogArchiveLibrary[0] == '\0')
archive_init = shell_archive_init;

4
src/backend/postmaster/postmaster.c
View File

@ -2859,8 +2859,8 @@ pmdie(SIGNAL_ARGS)
/*
* If we reached normal running, we go straight to waiting for
* client backends to exit. If already in PM_STOP_BACKENDS or
* a later state, do not change it.
* client backends to exit. If already in PM_STOP_BACKENDS or a
* later state, do not change it.
*/
if (pmState == PM_RUN || pmState == PM_HOT_STANDBY)
connsAllowed = false;

2
src/backend/postmaster/startup.c
View File

@ -75,7 +75,7 @@ static volatile sig_atomic_t startup_progress_timer_expired = false;
/*
* Time between progress updates for long-running startup operations.
*/
int log_startup_progress_interval = 10000; /* 10 sec */
int log_startup_progress_interval = 10000; /* 10 sec */
/* Signal handlers */
static void StartupProcTriggerHandler(SIGNAL_ARGS);

6
src/backend/postmaster/walwriter.c
View File

@ -297,9 +297,9 @@ HandleWalWriterInterrupts(void)
/*
* Force reporting remaining WAL statistics at process exit.
*
* Since pgstat_report_wal is invoked with 'force' is false in main loop
* to avoid overloading the cumulative stats system, there may exist
* unreported stats counters for the WAL writer.
* Since pgstat_report_wal is invoked with 'force' is false in main
* loop to avoid overloading the cumulative stats system, there may
* exist unreported stats counters for the WAL writer.
*/
pgstat_report_wal(true);

10
src/backend/regex/regc_pg_locale.c
View File

@ -234,8 +234,8 @@ pg_set_regex_collation(Oid collation)
if (!OidIsValid(collation))
{
/*
* This typically means that the parser could not resolve a
* conflict of implicit collations, so report it that way.
* This typically means that the parser could not resolve a conflict
* of implicit collations, so report it that way.
*/
ereport(ERROR,
(errcode(ERRCODE_INDETERMINATE_COLLATION),
@ -253,9 +253,9 @@ pg_set_regex_collation(Oid collation)
else
{
/*
* NB: pg_newlocale_from_collation will fail if not HAVE_LOCALE_T;
* the case of pg_regex_locale != 0 but not HAVE_LOCALE_T does not
* have to be considered below.
* NB: pg_newlocale_from_collation will fail if not HAVE_LOCALE_T; the
* case of pg_regex_locale != 0 but not HAVE_LOCALE_T does not have to
* be considered below.
*/
pg_regex_locale = pg_newlocale_from_collation(collation);

2
src/backend/replication/backup_manifest.c
View File

@ -312,7 +312,7 @@ AddWALInfoToBackupManifest(backup_manifest_info *manifest, XLogRecPtr startptr,
* Finalize the backup manifest, and send it to the client.
*/
void
SendBackupManifest(backup_manifest_info *manifest, bbsink * sink)
SendBackupManifest(backup_manifest_info *manifest, bbsink *sink)
{
uint8 checksumbuf[PG_SHA256_DIGEST_LENGTH];
char checksumstringbuf[PG_SHA256_DIGEST_STRING_LENGTH];

12
src/backend/replication/basebackup_copy.c
View File

@ -124,18 +124,18 @@ bbsink_copystream_begin_backup(bbsink *sink)
{
bbsink_copystream *mysink = (bbsink_copystream *) sink;
bbsink_state *state = sink->bbs_state;
char *buf;
char *buf;
/*
* Initialize buffer. We ultimately want to send the archive and manifest
* data by means of CopyData messages where the payload portion of each
* message begins with a type byte. However, basebackup.c expects the
* buffer to be aligned, so we can't just allocate one extra byte for the
* type byte. Instead, allocate enough extra bytes that the portion of
* the buffer we reveal to our callers can be aligned, while leaving room
* to slip the type byte in just beforehand. That will allow us to ship
* the data with a single call to pq_putmessage and without needing any
* extra copying.
* type byte. Instead, allocate enough extra bytes that the portion of the
* buffer we reveal to our callers can be aligned, while leaving room to
* slip the type byte in just beforehand. That will allow us to ship the
* data with a single call to pq_putmessage and without needing any extra
* copying.
*/
buf = palloc(mysink->base.bbs_buffer_length + MAXIMUM_ALIGNOF);
mysink->msgbuffer = buf + (MAXIMUM_ALIGNOF - 1);

35
src/backend/replication/basebackup_gzip.c
View File

@ -68,7 +68,7 @@ bbsink_gzip_new(bbsink *next, pg_compress_specification *compress)
return NULL; /* keep compiler quiet */
#else
bbsink_gzip *sink;
int compresslevel;
int compresslevel;
Assert(next != NULL);
@ -118,8 +118,8 @@ static void
bbsink_gzip_begin_archive(bbsink *sink, const char *archive_name)
{
bbsink_gzip *mysink = (bbsink_gzip *) sink;
char *gz_archive_name;
z_stream *zs = &mysink->zstream;
char *gz_archive_name;
z_stream *zs = &mysink->zstream;
/* Initialize compressor object. */
memset(zs, 0, sizeof(z_stream));
@ -129,10 +129,10 @@ bbsink_gzip_begin_archive(bbsink *sink, const char *archive_name)
zs->avail_out = sink->bbs_next->bbs_buffer_length;
/*
* We need to use deflateInit2() rather than deflateInit() here so that
* we can request a gzip header rather than a zlib header. Otherwise, we
* want to supply the same values that would have been used by default
* if we had just called deflateInit().
* We need to use deflateInit2() rather than deflateInit() here so that we
* can request a gzip header rather than a zlib header. Otherwise, we want
* to supply the same values that would have been used by default if we
* had just called deflateInit().
*
* Per the documentation for deflateInit2, the third argument must be
* Z_DEFLATED; the fourth argument is the number of "window bits", by
@ -147,9 +147,8 @@ bbsink_gzip_begin_archive(bbsink *sink, const char *archive_name)
errmsg("could not initialize compression library"));
/*
* Add ".gz" to the archive name. Note that the pg_basebackup -z
* produces archives named ".tar.gz" rather than ".tgz", so we match
* that here.
* Add ".gz" to the archive name. Note that the pg_basebackup -z produces
* archives named ".tar.gz" rather than ".tgz", so we match that here.
*/
gz_archive_name = psprintf("%s.gz", archive_name);
Assert(sink->bbs_next != NULL);
@ -172,7 +171,7 @@ static void
bbsink_gzip_archive_contents(bbsink *sink, size_t len)
{
bbsink_gzip *mysink = (bbsink_gzip *) sink;
z_stream *zs = &mysink->zstream;
z_stream *zs = &mysink->zstream;
/* Compress data from input buffer. */
zs->next_in = (uint8 *) mysink->base.bbs_buffer;
@ -180,7 +179,7 @@ bbsink_gzip_archive_contents(bbsink *sink, size_t len)
while (zs->avail_in > 0)
{
int res;
int res;
/* Write output data into unused portion of output buffer. */
Assert(mysink->bytes_written < mysink->base.bbs_next->bbs_buffer_length);
@ -230,7 +229,7 @@ static void
bbsink_gzip_end_archive(bbsink *sink)
{
bbsink_gzip *mysink = (bbsink_gzip *) sink;
z_stream *zs = &mysink->zstream;
z_stream *zs = &mysink->zstream;
/* There is no more data available. */
zs->next_in = (uint8 *) mysink->base.bbs_buffer;
@ -238,7 +237,7 @@ bbsink_gzip_end_archive(bbsink *sink)
while (1)
{
int res;
int res;
/* Write output data into unused portion of output buffer. */
Assert(mysink->bytes_written < mysink->base.bbs_next->bbs_buffer_length);
@ -248,8 +247,8 @@ bbsink_gzip_end_archive(bbsink *sink)
mysink->base.bbs_next->bbs_buffer_length - mysink->bytes_written;
/*
* As bbsink_gzip_archive_contents, but pass Z_FINISH since there
* is no more input.
* As bbsink_gzip_archive_contents, but pass Z_FINISH since there is
* no more input.
*/
res = deflate(zs, Z_FINISH);
if (res == Z_STREAM_ERROR)
@ -260,8 +259,8 @@ bbsink_gzip_end_archive(bbsink *sink)
mysink->base.bbs_next->bbs_buffer_length - zs->avail_out;
/*
* Apparently we had no data in the output buffer and deflate()
* was not able to add any. We must be done.
* Apparently we had no data in the output buffer and deflate() was
* not able to add any. We must be done.
*/
if (mysink->bytes_written == 0)
break;

2
src/backend/replication/basebackup_lz4.c
View File

@ -68,7 +68,7 @@ bbsink_lz4_new(bbsink *next, pg_compress_specification *compress)
return NULL; /* keep compiler quiet */
#else
bbsink_lz4 *sink;
int compresslevel;
int compresslevel;
Assert(next != NULL);

18
src/backend/replication/basebackup_server.c
View File

@ -77,10 +77,11 @@ bbsink_server_new(bbsink *next, char *pathname)
/*
* It's not a good idea to store your backups in the same directory that
* you're backing up. If we allowed a relative path here, that could easily
* happen accidentally, so we don't. The user could still accomplish the
* same thing by including the absolute path to $PGDATA in the pathname,
* but that's likely an intentional bad decision rather than an accident.
* you're backing up. If we allowed a relative path here, that could
* easily happen accidentally, so we don't. The user could still
* accomplish the same thing by including the absolute path to $PGDATA in
* the pathname, but that's likely an intentional bad decision rather than
* an accident.
*/
if (!is_absolute_path(pathname))
ereport(ERROR,
@ -90,14 +91,15 @@ bbsink_server_new(bbsink *next, char *pathname)
switch (pg_check_dir(pathname))
{
case 0:
/*
* Does not exist, so create it using the same permissions we'd use
* for a new subdirectory of the data directory itself.
* Does not exist, so create it using the same permissions we'd
* use for a new subdirectory of the data directory itself.
*/
if (MakePGDirectory(pathname) < 0)
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not create directory \"%s\": %m", pathname)));
(errcode_for_file_access(),
errmsg("could not create directory \"%s\": %m", pathname)));
break;
case 1:

12
src/backend/replication/basebackup_target.c
View File

@ -80,9 +80,9 @@ BaseBackupAddTarget(char *name,
/*
* We found one, so update it.
*
* It is probably not a great idea to call BaseBackupAddTarget
* for the same name multiple times, but if it happens, this
* seems like the sanest behavior.
* It is probably not a great idea to call BaseBackupAddTarget for
* the same name multiple times, but if it happens, this seems
* like the sanest behavior.
*/
ttype->check_detail = check_detail;
ttype->get_sink = get_sink;
@ -91,9 +91,9 @@ BaseBackupAddTarget(char *name,
}
/*
* We use TopMemoryContext for allocations here to make sure that the
* data we need doesn't vanish under us; that's also why we copy the
* target name into a newly-allocated chunk of memory.
* We use TopMemoryContext for allocations here to make sure that the data
* we need doesn't vanish under us; that's also why we copy the target
* name into a newly-allocated chunk of memory.
*/
oldcontext = MemoryContextSwitchTo(TopMemoryContext);
ttype = palloc(sizeof(BaseBackupTargetType));

6
src/backend/replication/basebackup_zstd.c
View File

@ -108,9 +108,9 @@ bbsink_zstd_begin_backup(bbsink *sink)
if ((compress->options & PG_COMPRESSION_OPTION_WORKERS) != 0)
{
/*
* On older versions of libzstd, this option does not exist, and trying
* to set it will fail. Similarly for newer versions if they are
* compiled without threading support.
* On older versions of libzstd, this option does not exist, and
* trying to set it will fail. Similarly for newer versions if they
* are compiled without threading support.
*/
ret = ZSTD_CCtx_setParameter(mysink->cctx, ZSTD_c_nbWorkers,
compress->workers);

Some files were not shown because too many files have changed in this diff Show More