#include "postgres_fe.h"
#include <limits.h>
#include <time.h>
#include "catalog/pg_am_d.h"
#include "catalog/pg_namespace_d.h"
#include "common/logging.h"
#include "common/username.h"
#include "fe_utils/cancel.h"
#include "fe_utils/option_utils.h"
#include "fe_utils/parallel_slot.h"
#include "fe_utils/query_utils.h"
#include "fe_utils/simple_list.h"
#include "fe_utils/string_utils.h"
#include "getopt_long.h"
#include "pgtime.h"
#include "storage/block.h"

Include dependency graph for pg_amcheck.c:

Data Structures
struct	PatternInfo

struct	PatternInfoArray

struct	AmcheckOptions

struct	DatabaseInfo

struct	RelationInfo

Macros
#define	log_no_match(...)

#define	FREE_AND_SET_NULL(x)

#define	VERBOSE_DATNAME_LENGTH 35

Typedefs
typedef struct PatternInfo	PatternInfo

typedef struct PatternInfoArray	PatternInfoArray

typedef struct AmcheckOptions	AmcheckOptions

typedef struct DatabaseInfo	DatabaseInfo

typedef struct RelationInfo	RelationInfo

Functions
static void	prepare_heap_command (PQExpBuffer sql, RelationInfo rel, PGconn conn)

static void	prepare_btree_command (PQExpBuffer sql, RelationInfo rel, PGconn conn)

static void	run_command (ParallelSlot slot, const char sql)

static bool	verify_heap_slot_handler (PGresult res, PGconn conn, void *context)

static bool	verify_btree_slot_handler (PGresult res, PGconn conn, void *context)

static void	help (const char *progname)

static void	progress_report (uint64 relations_total, uint64 relations_checked, uint64 relpages_total, uint64 relpages_checked, const char *datname, bool force, bool finished)

static void	append_database_pattern (PatternInfoArray pia, const char pattern, int encoding)

static void	append_schema_pattern (PatternInfoArray pia, const char pattern, int encoding)

static void	append_relation_pattern (PatternInfoArray pia, const char pattern, int encoding)

static void	append_heap_pattern (PatternInfoArray pia, const char pattern, int encoding)

static void	append_btree_pattern (PatternInfoArray pia, const char pattern, int encoding)

static void	compile_database_list (PGconn conn, SimplePtrList databases, const char *initial_dbname)

static void	compile_relation_list_one_db (PGconn conn, SimplePtrList relations, const DatabaseInfo dat, uint64 pagecount)

int	main (int argc, char *argv[])

static bool	should_processing_continue (PGresult *res)

static char *	indent_lines (const char *str)

static PatternInfo *	extend_pattern_info_array (PatternInfoArray *pia)

static void	append_relation_pattern_helper (PatternInfoArray pia, const char pattern, int encoding, bool heap_only, bool btree_only)

static bool	append_db_pattern_cte (PQExpBuffer buf, const PatternInfoArray pia, PGconn conn, bool inclusive)

static void	append_rel_pattern_raw_cte (PQExpBuffer buf, const PatternInfoArray pia, PGconn conn)

static void	append_rel_pattern_filtered_cte (PQExpBuffer buf, const char raw, const char filtered, PGconn *conn)

Variables
static AmcheckOptions	opts

static const char *	progname = NULL

static bool	all_checks_pass = true

static pg_time_t	last_progress_report = 0

static bool	progress_since_last_stderr = false

static const char *const	amcheck_sql

Macro Definition Documentation

◆ FREE_AND_SET_NULL

#define FREE_AND_SET_NULL ( x )

Value:

    do { \
    pg_free(x); \
    (x) = NULL; \
    } while (0)

Definition at line 213 of file pg_amcheck.c.

◆ log_no_match

#define log_no_match ( ... )

Value:

        do { \
        if (opts.strict_names) \
            pg_log_error(__VA_ARGS__); \
		else \
			pg_log_warning(__VA_ARGS__); \
    } while(0)

Definition at line 206 of file pg_amcheck.c.

◆ VERBOSE_DATNAME_LENGTH

#define VERBOSE_DATNAME_LENGTH 35

Typedef Documentation

◆ AmcheckOptions

typedef struct AmcheckOptions AmcheckOptions

◆ DatabaseInfo

typedef struct DatabaseInfo DatabaseInfo

◆ PatternInfo

typedef struct PatternInfo PatternInfo

◆ PatternInfoArray

typedef struct PatternInfoArray PatternInfoArray

◆ RelationInfo

typedef struct RelationInfo RelationInfo

Function Documentation

◆ append_btree_pattern()

static void append_btree_pattern	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding
	)

static

Definition at line 1509 of file pg_amcheck.c.

 {
     append_relation_pattern_helper(pia, pattern, encoding, false, true);
 }

References append_relation_pattern_helper(), and encoding.

Referenced by main().

◆ append_database_pattern()

static void append_database_pattern	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding
	)

static

Definition at line 1355 of file pg_amcheck.c.

 {
     PQExpBufferData buf;
     int         dotcnt;
     PatternInfo *info = extend_pattern_info_array(pia);
  
     initPQExpBuffer(&buf);
     patternToSQLRegex(encoding, NULL, NULL, &buf, pattern, false, false,
                       &dotcnt);
     if (dotcnt > 0)
     {
         pg_log_error("improper qualified name (too many dotted names): %s", pattern);
         exit(2);
     }
     info->pattern = pattern;
     info->db_regex = pstrdup(buf.data);
  
     termPQExpBuffer(&buf);
 }

References buf, PatternInfo::db_regex, encoding, exit(), extend_pattern_info_array(), initPQExpBuffer(), PatternInfo::pattern, patternToSQLRegex(), pg_log_error, pstrdup(), and termPQExpBuffer().

Referenced by main().

◆ append_db_pattern_cte()

static bool append_db_pattern_cte	(	PQExpBuffer	buf,
		const PatternInfoArray *	pia,
		PGconn *	conn,
		bool	inclusive
	)

static

Definition at line 1536 of file pg_amcheck.c.

 {
     int         pattern_id;
     const char *comma;
     bool        have_values;
  
     comma = "";
     have_values = false;
     for (pattern_id = 0; pattern_id < pia->len; pattern_id++)
     {
         PatternInfo *info = &pia->data[pattern_id];
  
         if (info->db_regex != NULL &&
             (inclusive || (info->nsp_regex == NULL && info->rel_regex == NULL)))
         {
             if (!have_values)
                 appendPQExpBufferStr(buf, "\nVALUES");
             have_values = true;
             appendPQExpBuffer(buf, "%s\n(%d, ", comma, pattern_id);
             appendStringLiteralConn(buf, info->db_regex, conn);
             appendPQExpBufferChar(buf, ')');
             comma = ",";
         }
     }
  
     if (!have_values)
         appendPQExpBufferStr(buf, "\nSELECT NULL, NULL, NULL WHERE false");
  
     return have_values;
 }

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralConn(), buf, comma, conn, PatternInfoArray::data, PatternInfo::db_regex, PatternInfoArray::len, PatternInfo::nsp_regex, and PatternInfo::rel_regex.

Referenced by compile_database_list().

◆ append_heap_pattern()

static void append_heap_pattern	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding
	)

static

Definition at line 1493 of file pg_amcheck.c.

 {
     append_relation_pattern_helper(pia, pattern, encoding, true, false);
 }

References append_relation_pattern_helper(), and encoding.

Referenced by main().

◆ append_rel_pattern_filtered_cte()

static void append_rel_pattern_filtered_cte	(	PQExpBuffer	buf,
		const char *	raw,
		const char *	filtered,
		PGconn *	conn
	)

static

Definition at line 1843 of file pg_amcheck.c.

 {
     appendPQExpBuffer(buf,
                       "\n%s (pattern_id, nsp_regex, rel_regex, heap_only, btree_only) AS ("
                       "\nSELECT pattern_id, nsp_regex, rel_regex, heap_only, btree_only "
                       "FROM %s r"
                       "\nWHERE (r.db_regex IS NULL "
                       "OR ",
                       filtered, raw);
     appendStringLiteralConn(buf, PQdb(conn), conn);
     appendPQExpBufferStr(buf, " ~ r.db_regex)");
     appendPQExpBufferStr(buf,
                          " AND (r.nsp_regex IS NOT NULL"
                          " OR r.rel_regex IS NOT NULL)"
                          "),");
 }

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralConn(), buf, conn, and PQdb().

Referenced by compile_relation_list_one_db().

◆ append_rel_pattern_raw_cte()

static void append_rel_pattern_raw_cte	(	PQExpBuffer	buf,
		const PatternInfoArray *	pia,
		PGconn *	conn
	)

static

Definition at line 1774 of file pg_amcheck.c.

 {
     int         pattern_id;
     const char *comma;
     bool        have_values;
  
     comma = "";
     have_values = false;
     for (pattern_id = 0; pattern_id < pia->len; pattern_id++)
     {
         PatternInfo *info = &pia->data[pattern_id];
  
         if (!have_values)
             appendPQExpBufferStr(buf, "\nVALUES");
         have_values = true;
         appendPQExpBuffer(buf, "%s\n(%d::INTEGER, ", comma, pattern_id);
         if (info->db_regex == NULL)
             appendPQExpBufferStr(buf, "NULL");
         else
             appendStringLiteralConn(buf, info->db_regex, conn);
         appendPQExpBufferStr(buf, "::TEXT, ");
         if (info->nsp_regex == NULL)
             appendPQExpBufferStr(buf, "NULL");
         else
             appendStringLiteralConn(buf, info->nsp_regex, conn);
         appendPQExpBufferStr(buf, "::TEXT, ");
         if (info->rel_regex == NULL)
             appendPQExpBufferStr(buf, "NULL");
         else
             appendStringLiteralConn(buf, info->rel_regex, conn);
         if (info->heap_only)
             appendPQExpBufferStr(buf, "::TEXT, true::BOOLEAN");
         else
             appendPQExpBufferStr(buf, "::TEXT, false::BOOLEAN");
         if (info->btree_only)
             appendPQExpBufferStr(buf, ", true::BOOLEAN");
         else
             appendPQExpBufferStr(buf, ", false::BOOLEAN");
         appendPQExpBufferChar(buf, ')');
         comma = ",";
     }
  
     if (!have_values)
         appendPQExpBufferStr(buf,
                              "\nSELECT NULL::INTEGER, NULL::TEXT, NULL::TEXT, "
                              "NULL::TEXT, NULL::BOOLEAN, NULL::BOOLEAN "
                              "WHERE false");
 }

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), appendStringLiteralConn(), PatternInfo::btree_only, buf, comma, conn, PatternInfoArray::data, PatternInfo::db_regex, PatternInfo::heap_only, PatternInfoArray::len, PatternInfo::nsp_regex, and PatternInfo::rel_regex.

Referenced by compile_relation_list_one_db().

◆ append_relation_pattern()

static void append_relation_pattern	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding
	)

static

Definition at line 1477 of file pg_amcheck.c.

 {
     append_relation_pattern_helper(pia, pattern, encoding, false, false);
 }

References append_relation_pattern_helper(), and encoding.

Referenced by main().

◆ append_relation_pattern_helper()

static void append_relation_pattern_helper	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding,
		bool	heap_only,
		bool	btree_only
	)

static

Definition at line 1427 of file pg_amcheck.c.

 {
     PQExpBufferData dbbuf;
     PQExpBufferData nspbuf;
     PQExpBufferData relbuf;
     int         dotcnt;
     PatternInfo *info = extend_pattern_info_array(pia);
  
     initPQExpBuffer(&dbbuf);
     initPQExpBuffer(&nspbuf);
     initPQExpBuffer(&relbuf);
  
     patternToSQLRegex(encoding, &dbbuf, &nspbuf, &relbuf, pattern, false,
                       false, &dotcnt);
     if (dotcnt > 2)
     {
         pg_log_error("improper relation name (too many dotted names): %s", pattern);
         exit(2);
     }
     info->pattern = pattern;
     if (dbbuf.data[0])
     {
         opts.dbpattern = true;
         info->db_regex = pstrdup(dbbuf.data);
     }
     if (nspbuf.data[0])
         info->nsp_regex = pstrdup(nspbuf.data);
     if (relbuf.data[0])
         info->rel_regex = pstrdup(relbuf.data);
  
     termPQExpBuffer(&dbbuf);
     termPQExpBuffer(&nspbuf);
     termPQExpBuffer(&relbuf);
  
     info->heap_only = heap_only;
     info->btree_only = btree_only;
 }

References PatternInfo::btree_only, PQExpBufferData::data, PatternInfo::db_regex, AmcheckOptions::dbpattern, encoding, exit(), extend_pattern_info_array(), PatternInfo::heap_only, initPQExpBuffer(), PatternInfo::nsp_regex, opts, PatternInfo::pattern, patternToSQLRegex(), pg_log_error, pstrdup(), PatternInfo::rel_regex, and termPQExpBuffer().

Referenced by append_btree_pattern(), append_heap_pattern(), and append_relation_pattern().

◆ append_schema_pattern()

static void append_schema_pattern	(	PatternInfoArray *	pia,
		const char *	pattern,
		int	encoding
	)

static

Definition at line 1385 of file pg_amcheck.c.

 {
     PQExpBufferData dbbuf;
     PQExpBufferData nspbuf;
     int         dotcnt;
     PatternInfo *info = extend_pattern_info_array(pia);
  
     initPQExpBuffer(&dbbuf);
     initPQExpBuffer(&nspbuf);
  
     patternToSQLRegex(encoding, NULL, &dbbuf, &nspbuf, pattern, false, false,
                       &dotcnt);
     if (dotcnt > 1)
     {
         pg_log_error("improper qualified name (too many dotted names): %s", pattern);
         exit(2);
     }
     info->pattern = pattern;
     if (dbbuf.data[0])
     {
         opts.dbpattern = true;
         info->db_regex = pstrdup(dbbuf.data);
     }
     if (nspbuf.data[0])
         info->nsp_regex = pstrdup(nspbuf.data);
  
     termPQExpBuffer(&dbbuf);
     termPQExpBuffer(&nspbuf);
 }

References PQExpBufferData::data, PatternInfo::db_regex, AmcheckOptions::dbpattern, encoding, exit(), extend_pattern_info_array(), initPQExpBuffer(), PatternInfo::nsp_regex, opts, PatternInfo::pattern, patternToSQLRegex(), pg_log_error, pstrdup(), and termPQExpBuffer().

Referenced by main().

◆ compile_database_list()

static void compile_database_list	(	PGconn *	conn,
		SimplePtrList *	databases,
		const char *	initial_dbname
	)

static

Definition at line 1582 of file pg_amcheck.c.

 {
     PGresult   *res;
     PQExpBufferData sql;
     int         ntups;
     int         i;
     bool        fatal;
  
     if (initial_dbname)
     {
         DatabaseInfo *dat = (DatabaseInfo *) pg_malloc0(sizeof(DatabaseInfo));
  
         /* This database is included.  Add to list */
         if (opts.verbose)
             pg_log_info("including database \"%s\"", initial_dbname);
  
         dat->datname = pstrdup(initial_dbname);
         simple_ptr_list_append(databases, dat);
     }
  
     initPQExpBuffer(&sql);
  
     /* Append the include patterns CTE. */
     appendPQExpBufferStr(&sql, "WITH include_raw (pattern_id, rgx) AS (");
     if (!append_db_pattern_cte(&sql, &opts.include, conn, true) &&
         !opts.alldb)
     {
         /*
          * None of the inclusion patterns (if any) contain database portions,
          * so there is no need to query the database to resolve database
          * patterns.
          *
          * Since we're also not operating under --all, we don't need to query
          * the exhaustive list of connectable databases, either.
          */
         termPQExpBuffer(&sql);
         return;
     }
  
     /* Append the exclude patterns CTE. */
     appendPQExpBufferStr(&sql, "),\nexclude_raw (pattern_id, rgx) AS (");
     append_db_pattern_cte(&sql, &opts.exclude, conn, false);
     appendPQExpBufferStr(&sql, "),");
  
     /*
      * Append the database CTE, which includes whether each database is
      * connectable and also joins against exclude_raw to determine whether
      * each database is excluded.
      */
     appendPQExpBufferStr(&sql,
                          "\ndatabase (datname) AS ("
                          "\nSELECT d.datname "
                          "FROM pg_catalog.pg_database d "
                          "LEFT OUTER JOIN exclude_raw e "
                          "ON d.datname ~ e.rgx "
                          "\nWHERE d.datallowconn AND datconnlimit != -2 "
                          "AND e.pattern_id IS NULL"
                          "),"
  
     /*
      * Append the include_pat CTE, which joins the include_raw CTE against the
      * databases CTE to determine if all the inclusion patterns had matches,
      * and whether each matched pattern had the misfortune of only matching
      * excluded or unconnectable databases.
      */
                          "\ninclude_pat (pattern_id, checkable) AS ("
                          "\nSELECT i.pattern_id, "
                          "COUNT(*) FILTER ("
                          "WHERE d IS NOT NULL"
                          ") AS checkable"
                          "\nFROM include_raw i "
                          "LEFT OUTER JOIN database d "
                          "ON d.datname ~ i.rgx"
                          "\nGROUP BY i.pattern_id"
                          "),"
  
     /*
      * Append the filtered_databases CTE, which selects from the database CTE
      * optionally joined against the include_raw CTE to only select databases
      * that match an inclusion pattern.  This appears to duplicate what the
      * include_pat CTE already did above, but here we want only databases, and
      * there we wanted patterns.
      */
                          "\nfiltered_databases (datname) AS ("
                          "\nSELECT DISTINCT d.datname "
                          "FROM database d");
     if (!opts.alldb)
         appendPQExpBufferStr(&sql,
                              " INNER JOIN include_raw i "
                              "ON d.datname ~ i.rgx");
     appendPQExpBufferStr(&sql,
                          ")"
  
     /*
      * Select the checkable databases and the unmatched inclusion patterns.
      */
                          "\nSELECT pattern_id, datname FROM ("
                          "\nSELECT pattern_id, NULL::TEXT AS datname "
                          "FROM include_pat "
                          "WHERE checkable = 0 "
                          "UNION ALL"
                          "\nSELECT NULL, datname "
                          "FROM filtered_databases"
                          ") AS combined_records"
                          "\nORDER BY pattern_id NULLS LAST, datname");
  
     res = executeQuery(conn, sql.data, opts.echo);
     if (PQresultStatus(res) != PGRES_TUPLES_OK)
     {
         pg_log_error("query failed: %s", PQerrorMessage(conn));
         pg_log_error_detail("Query was: %s", sql.data);
         disconnectDatabase(conn);
         exit(1);
     }
     termPQExpBuffer(&sql);
  
     ntups = PQntuples(res);
     for (fatal = false, i = 0; i < ntups; i++)
     {
         int         pattern_id = -1;
         const char *datname = NULL;
  
         if (!PQgetisnull(res, i, 0))
             pattern_id = atoi(PQgetvalue(res, i, 0));
         if (!PQgetisnull(res, i, 1))
             datname = PQgetvalue(res, i, 1);
  
         if (pattern_id >= 0)
         {
             /*
              * Current record pertains to an inclusion pattern that matched no
              * checkable databases.
              */
             fatal = opts.strict_names;
             if (pattern_id >= opts.include.len)
                 pg_fatal("internal error: received unexpected database pattern_id %d",
                          pattern_id);
             log_no_match("no connectable databases to check matching \"%s\"",
                          opts.include.data[pattern_id].pattern);
         }
         else
         {
             DatabaseInfo *dat;
  
             /* Current record pertains to a database */
             Assert(datname != NULL);
  
             /* Avoid entering a duplicate entry matching the initial_dbname */
             if (initial_dbname != NULL && strcmp(initial_dbname, datname) == 0)
                 continue;
  
             /* This database is included.  Add to list */
             if (opts.verbose)
                 pg_log_info("including database \"%s\"", datname);
  
             dat = (DatabaseInfo *) pg_malloc0(sizeof(DatabaseInfo));
             dat->datname = pstrdup(datname);
             simple_ptr_list_append(databases, dat);
         }
     }
     PQclear(res);
  
     if (fatal)
     {
         if (conn != NULL)
             disconnectDatabase(conn);
         exit(1);
     }
 }

References AmcheckOptions::alldb, append_db_pattern_cte(), appendPQExpBufferStr(), Assert(), conn, PatternInfoArray::data, PQExpBufferData::data, DatabaseInfo::datname, datname, disconnectDatabase(), AmcheckOptions::echo, AmcheckOptions::exclude, executeQuery(), exit(), i, AmcheckOptions::include, initPQExpBuffer(), PatternInfoArray::len, log_no_match, opts, PatternInfo::pattern, pg_fatal, pg_log_error, pg_log_error_detail, pg_log_info, pg_malloc0(), PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQgetisnull(), PQgetvalue(), PQntuples(), PQresultStatus(), pstrdup(), res, simple_ptr_list_append(), AmcheckOptions::strict_names, termPQExpBuffer(), and AmcheckOptions::verbose.

Referenced by main().

◆ compile_relation_list_one_db()

static void compile_relation_list_one_db	(	PGconn *	conn,
		SimplePtrList *	relations,
		const DatabaseInfo *	dat,
		uint64 *	pagecount
	)

static

Definition at line 1882 of file pg_amcheck.c.

 {
     PGresult   *res;
     PQExpBufferData sql;
     int         ntups;
     int         i;
  
     initPQExpBuffer(&sql);
     appendPQExpBufferStr(&sql, "WITH");
  
     /* Append CTEs for the relation inclusion patterns, if any */
     if (!opts.allrel)
     {
         appendPQExpBufferStr(&sql,
                              " include_raw (pattern_id, db_regex, nsp_regex, rel_regex, heap_only, btree_only) AS (");
         append_rel_pattern_raw_cte(&sql, &opts.include, conn);
         appendPQExpBufferStr(&sql, "\n),");
         append_rel_pattern_filtered_cte(&sql, "include_raw", "include_pat", conn);
     }
  
     /* Append CTEs for the relation exclusion patterns, if any */
     if (opts.excludetbl || opts.excludeidx || opts.excludensp)
     {
         appendPQExpBufferStr(&sql,
                              " exclude_raw (pattern_id, db_regex, nsp_regex, rel_regex, heap_only, btree_only) AS (");
         append_rel_pattern_raw_cte(&sql, &opts.exclude, conn);
         appendPQExpBufferStr(&sql, "\n),");
         append_rel_pattern_filtered_cte(&sql, "exclude_raw", "exclude_pat", conn);
     }
  
     /* Append the relation CTE. */
     appendPQExpBufferStr(&sql,
                          " relation (pattern_id, oid, nspname, relname, reltoastrelid, relpages, is_heap, is_btree) AS ("
                          "\nSELECT DISTINCT ON (c.oid");
     if (!opts.allrel)
         appendPQExpBufferStr(&sql, ", ip.pattern_id) ip.pattern_id,");
     else
         appendPQExpBufferStr(&sql, ") NULL::INTEGER AS pattern_id,");
     appendPQExpBuffer(&sql,
                       "\nc.oid, n.nspname, c.relname, c.reltoastrelid, c.relpages, "
                       "c.relam = %u AS is_heap, "
                       "c.relam = %u AS is_btree"
                       "\nFROM pg_catalog.pg_class c "
                       "INNER JOIN pg_catalog.pg_namespace n "
                       "ON c.relnamespace = n.oid",
                       HEAP_TABLE_AM_OID, BTREE_AM_OID);
     if (!opts.allrel)
         appendPQExpBuffer(&sql,
                           "\nINNER JOIN include_pat ip"
                           "\nON (n.nspname ~ ip.nsp_regex OR ip.nsp_regex IS NULL)"
                           "\nAND (c.relname ~ ip.rel_regex OR ip.rel_regex IS NULL)"
                           "\nAND (c.relam = %u OR NOT ip.heap_only)"
                           "\nAND (c.relam = %u OR NOT ip.btree_only)",
                           HEAP_TABLE_AM_OID, BTREE_AM_OID);
     if (opts.excludetbl || opts.excludeidx || opts.excludensp)
         appendPQExpBuffer(&sql,
                           "\nLEFT OUTER JOIN exclude_pat ep"
                           "\nON (n.nspname ~ ep.nsp_regex OR ep.nsp_regex IS NULL)"
                           "\nAND (c.relname ~ ep.rel_regex OR ep.rel_regex IS NULL)"
                           "\nAND (c.relam = %u OR NOT ep.heap_only OR ep.rel_regex IS NULL)"
                           "\nAND (c.relam = %u OR NOT ep.btree_only OR ep.rel_regex IS NULL)",
                           HEAP_TABLE_AM_OID, BTREE_AM_OID);
  
     /*
      * Exclude temporary tables and indexes, which must necessarily belong to
      * other sessions.  (We don't create any ourselves.)  We must ultimately
      * exclude indexes marked invalid or not ready, but we delay that decision
      * until firing off the amcheck command, as the state of an index may
      * change by then.
      */
     appendPQExpBufferStr(&sql, "\nWHERE c.relpersistence != 't'");
     if (opts.excludetbl || opts.excludeidx || opts.excludensp)
         appendPQExpBufferStr(&sql, "\nAND ep.pattern_id IS NULL");
  
     /*
      * We need to be careful not to break the --no-dependent-toast and
      * --no-dependent-indexes options.  By default, the btree indexes, toast
      * tables, and toast table btree indexes associated with primary heap
      * tables are included, using their own CTEs below.  We implement the
      * --exclude-* options by not creating those CTEs, but that's no use if
      * we've already selected the toast and indexes here.  On the other hand,
      * we want inclusion patterns that match indexes or toast tables to be
      * honored.  So, if inclusion patterns were given, we want to select all
      * tables, toast tables, or indexes that match the patterns.  But if no
      * inclusion patterns were given, and we're simply matching all relations,
      * then we only want to match the primary tables here.
      */
     if (opts.allrel)
         appendPQExpBuffer(&sql,
                           " AND c.relam = %u "
                           "AND c.relkind IN ('r', 'S', 'm', 't') "
                           "AND c.relnamespace != %u",
                           HEAP_TABLE_AM_OID, PG_TOAST_NAMESPACE);
     else
         appendPQExpBuffer(&sql,
                           " AND c.relam IN (%u, %u)"
                           "AND c.relkind IN ('r', 'S', 'm', 't', 'i') "
                           "AND ((c.relam = %u AND c.relkind IN ('r', 'S', 'm', 't')) OR "
                           "(c.relam = %u AND c.relkind = 'i'))",
                           HEAP_TABLE_AM_OID, BTREE_AM_OID,
                           HEAP_TABLE_AM_OID, BTREE_AM_OID);
  
     appendPQExpBufferStr(&sql,
                          "\nORDER BY c.oid)");
  
     if (!opts.no_toast_expansion)
     {
         /*
          * Include a CTE for toast tables associated with primary heap tables
          * selected above, filtering by exclusion patterns (if any) that match
          * toast table names.
          */
         appendPQExpBufferStr(&sql,
                              ", toast (oid, nspname, relname, relpages) AS ("
                              "\nSELECT t.oid, 'pg_toast', t.relname, t.relpages"
                              "\nFROM pg_catalog.pg_class t "
                              "INNER JOIN relation r "
                              "ON r.reltoastrelid = t.oid");
         if (opts.excludetbl || opts.excludensp)
             appendPQExpBufferStr(&sql,
                                  "\nLEFT OUTER JOIN exclude_pat ep"
                                  "\nON ('pg_toast' ~ ep.nsp_regex OR ep.nsp_regex IS NULL)"
                                  "\nAND (t.relname ~ ep.rel_regex OR ep.rel_regex IS NULL)"
                                  "\nAND ep.heap_only"
                                  "\nWHERE ep.pattern_id IS NULL"
                                  "\nAND t.relpersistence != 't'");
         appendPQExpBufferStr(&sql,
                              "\n)");
     }
     if (!opts.no_btree_expansion)
     {
         /*
          * Include a CTE for btree indexes associated with primary heap tables
          * selected above, filtering by exclusion patterns (if any) that match
          * btree index names.
          */
         appendPQExpBufferStr(&sql,
                              ", index (oid, nspname, relname, relpages) AS ("
                              "\nSELECT c.oid, r.nspname, c.relname, c.relpages "
                              "FROM relation r"
                              "\nINNER JOIN pg_catalog.pg_index i "
                              "ON r.oid = i.indrelid "
                              "INNER JOIN pg_catalog.pg_class c "
                              "ON i.indexrelid = c.oid "
                              "AND c.relpersistence != 't'");
         if (opts.excludeidx || opts.excludensp)
             appendPQExpBufferStr(&sql,
                                  "\nINNER JOIN pg_catalog.pg_namespace n "
                                  "ON c.relnamespace = n.oid"
                                  "\nLEFT OUTER JOIN exclude_pat ep "
                                  "ON (n.nspname ~ ep.nsp_regex OR ep.nsp_regex IS NULL) "
                                  "AND (c.relname ~ ep.rel_regex OR ep.rel_regex IS NULL) "
                                  "AND ep.btree_only"
                                  "\nWHERE ep.pattern_id IS NULL");
         else
             appendPQExpBufferStr(&sql,
                                  "\nWHERE true");
         appendPQExpBuffer(&sql,
                           " AND c.relam = %u "
                           "AND c.relkind = 'i'",
                           BTREE_AM_OID);
         if (opts.no_toast_expansion)
             appendPQExpBuffer(&sql,
                               " AND c.relnamespace != %u",
                               PG_TOAST_NAMESPACE);
         appendPQExpBufferStr(&sql, "\n)");
     }
  
     if (!opts.no_toast_expansion && !opts.no_btree_expansion)
     {
         /*
          * Include a CTE for btree indexes associated with toast tables of
          * primary heap tables selected above, filtering by exclusion patterns
          * (if any) that match the toast index names.
          */
         appendPQExpBufferStr(&sql,
                              ", toast_index (oid, nspname, relname, relpages) AS ("
                              "\nSELECT c.oid, 'pg_toast', c.relname, c.relpages "
                              "FROM toast t "
                              "INNER JOIN pg_catalog.pg_index i "
                              "ON t.oid = i.indrelid"
                              "\nINNER JOIN pg_catalog.pg_class c "
                              "ON i.indexrelid = c.oid "
                              "AND c.relpersistence != 't'");
         if (opts.excludeidx)
             appendPQExpBufferStr(&sql,
                                  "\nLEFT OUTER JOIN exclude_pat ep "
                                  "ON ('pg_toast' ~ ep.nsp_regex OR ep.nsp_regex IS NULL) "
                                  "AND (c.relname ~ ep.rel_regex OR ep.rel_regex IS NULL) "
                                  "AND ep.btree_only "
                                  "WHERE ep.pattern_id IS NULL");
         else
             appendPQExpBufferStr(&sql,
                                  "\nWHERE true");
         appendPQExpBuffer(&sql,
                           " AND c.relam = %u"
                           " AND c.relkind = 'i')",
                           BTREE_AM_OID);
     }
  
     /*
      * Roll-up distinct rows from CTEs.
      *
      * Relations that match more than one pattern may occur more than once in
      * the list, and indexes and toast for primary relations may also have
      * matched in their own right, so we rely on UNION to deduplicate the
      * list.
      */
     appendPQExpBufferStr(&sql,
                          "\nSELECT pattern_id, is_heap, is_btree, oid, nspname, relname, relpages "
                          "FROM (");
     appendPQExpBufferStr(&sql,
     /* Inclusion patterns that failed to match */
                          "\nSELECT pattern_id, is_heap, is_btree, "
                          "NULL::OID AS oid, "
                          "NULL::TEXT AS nspname, "
                          "NULL::TEXT AS relname, "
                          "NULL::INTEGER AS relpages"
                          "\nFROM relation "
                          "WHERE pattern_id IS NOT NULL "
                          "UNION"
     /* Primary relations */
                          "\nSELECT NULL::INTEGER AS pattern_id, "
                          "is_heap, is_btree, oid, nspname, relname, relpages "
                          "FROM relation");
     if (!opts.no_toast_expansion)
         appendPQExpBufferStr(&sql,
                              " UNION"
         /* Toast tables for primary relations */
                              "\nSELECT NULL::INTEGER AS pattern_id, TRUE AS is_heap, "
                              "FALSE AS is_btree, oid, nspname, relname, relpages "
                              "FROM toast");
     if (!opts.no_btree_expansion)
         appendPQExpBufferStr(&sql,
                              " UNION"
         /* Indexes for primary relations */
                              "\nSELECT NULL::INTEGER AS pattern_id, FALSE AS is_heap, "
                              "TRUE AS is_btree, oid, nspname, relname, relpages "
                              "FROM index");
     if (!opts.no_toast_expansion && !opts.no_btree_expansion)
         appendPQExpBufferStr(&sql,
                              " UNION"
         /* Indexes for toast relations */
                              "\nSELECT NULL::INTEGER AS pattern_id, FALSE AS is_heap, "
                              "TRUE AS is_btree, oid, nspname, relname, relpages "
                              "FROM toast_index");
     appendPQExpBufferStr(&sql,
                          "\n) AS combined_records "
                          "ORDER BY relpages DESC NULLS FIRST, oid");
  
     res = executeQuery(conn, sql.data, opts.echo);
     if (PQresultStatus(res) != PGRES_TUPLES_OK)
     {
         pg_log_error("query failed: %s", PQerrorMessage(conn));
         pg_log_error_detail("Query was: %s", sql.data);
         disconnectDatabase(conn);
         exit(1);
     }
     termPQExpBuffer(&sql);
  
     ntups = PQntuples(res);
     for (i = 0; i < ntups; i++)
     {
         int         pattern_id = -1;
         bool        is_heap = false;
         bool        is_btree PG_USED_FOR_ASSERTS_ONLY = false;
         Oid         oid = InvalidOid;
         const char *nspname = NULL;
         const char *relname = NULL;
         int         relpages = 0;
  
         if (!PQgetisnull(res, i, 0))
             pattern_id = atoi(PQgetvalue(res, i, 0));
         if (!PQgetisnull(res, i, 1))
             is_heap = (PQgetvalue(res, i, 1)[0] == 't');
         if (!PQgetisnull(res, i, 2))
             is_btree = (PQgetvalue(res, i, 2)[0] == 't');
         if (!PQgetisnull(res, i, 3))
             oid = atooid(PQgetvalue(res, i, 3));
         if (!PQgetisnull(res, i, 4))
             nspname = PQgetvalue(res, i, 4);
         if (!PQgetisnull(res, i, 5))
             relname = PQgetvalue(res, i, 5);
         if (!PQgetisnull(res, i, 6))
             relpages = atoi(PQgetvalue(res, i, 6));
  
         if (pattern_id >= 0)
         {
             /*
              * Current record pertains to an inclusion pattern.  Record that
              * it matched.
              */
  
             if (pattern_id >= opts.include.len)
                 pg_fatal("internal error: received unexpected relation pattern_id %d",
                          pattern_id);
  
             opts.include.data[pattern_id].matched = true;
         }
         else
         {
             /* Current record pertains to a relation */
  
             RelationInfo *rel = (RelationInfo *) pg_malloc0(sizeof(RelationInfo));
  
             Assert(OidIsValid(oid));
             Assert((is_heap && !is_btree) || (is_btree && !is_heap));
  
             rel->datinfo = dat;
             rel->reloid = oid;
             rel->is_heap = is_heap;
             rel->nspname = pstrdup(nspname);
             rel->relname = pstrdup(relname);
             rel->relpages = relpages;
             rel->blocks_to_check = relpages;
             if (is_heap && (opts.startblock >= 0 || opts.endblock >= 0))
             {
                 /*
                  * We apply --startblock and --endblock to heap tables, but
                  * not btree indexes, and for progress purposes we need to
                  * track how many blocks we expect to check.
                  */
                 if (opts.endblock >= 0 && rel->blocks_to_check > opts.endblock)
                     rel->blocks_to_check = opts.endblock + 1;
                 if (opts.startblock >= 0)
                 {
                     if (rel->blocks_to_check > opts.startblock)
                         rel->blocks_to_check -= opts.startblock;
                     else
                         rel->blocks_to_check = 0;
                 }
             }
             *pagecount += rel->blocks_to_check;
  
             simple_ptr_list_append(relations, rel);
         }
     }
     PQclear(res);
 }

References AmcheckOptions::allrel, append_rel_pattern_filtered_cte(), append_rel_pattern_raw_cte(), appendPQExpBuffer(), appendPQExpBufferStr(), Assert(), atooid, RelationInfo::blocks_to_check, conn, PatternInfoArray::data, PQExpBufferData::data, RelationInfo::datinfo, disconnectDatabase(), AmcheckOptions::echo, AmcheckOptions::endblock, AmcheckOptions::exclude, AmcheckOptions::excludeidx, AmcheckOptions::excludensp, AmcheckOptions::excludetbl, executeQuery(), exit(), i, AmcheckOptions::include, initPQExpBuffer(), InvalidOid, RelationInfo::is_heap, PatternInfoArray::len, PatternInfo::matched, AmcheckOptions::no_btree_expansion, AmcheckOptions::no_toast_expansion, RelationInfo::nspname, OidIsValid, opts, pg_fatal, pg_log_error, pg_log_error_detail, pg_malloc0(), PG_USED_FOR_ASSERTS_ONLY, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQgetisnull(), PQgetvalue(), PQntuples(), PQresultStatus(), pstrdup(), RelationInfo::relname, relname, RelationInfo::reloid, RelationInfo::relpages, res, simple_ptr_list_append(), AmcheckOptions::startblock, and termPQExpBuffer().

Referenced by main().

◆ extend_pattern_info_array()

static PatternInfo* extend_pattern_info_array ( PatternInfoArray * pia )

static

Definition at line 1333 of file pg_amcheck.c.

 {
     PatternInfo *result;
  
     pia->len++;
     pia->data = (PatternInfo *) pg_realloc(pia->data, pia->len * sizeof(PatternInfo));
     result = &pia->data[pia->len - 1];
     memset(result, 0, sizeof(*result));
  
     return result;
 }

References PatternInfoArray::data, PatternInfoArray::len, and pg_realloc().

Referenced by append_database_pattern(), append_relation_pattern_helper(), and append_schema_pattern().

◆ help()

static void help ( const char * progname )

static

Definition at line 1180 of file pg_amcheck.c.

 {
     printf(_("%s checks objects in a PostgreSQL database for corruption.\n\n"), progname);
     printf(_("Usage:\n"));
     printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
     printf(_("\nTarget options:\n"));
     printf(_("  -a, --all                       check all databases\n"));
     printf(_("  -d, --database=PATTERN          check matching database(s)\n"));
     printf(_("  -D, --exclude-database=PATTERN  do NOT check matching database(s)\n"));
     printf(_("  -i, --index=PATTERN             check matching index(es)\n"));
     printf(_("  -I, --exclude-index=PATTERN     do NOT check matching index(es)\n"));
     printf(_("  -r, --relation=PATTERN          check matching relation(s)\n"));
     printf(_("  -R, --exclude-relation=PATTERN  do NOT check matching relation(s)\n"));
     printf(_("  -s, --schema=PATTERN            check matching schema(s)\n"));
     printf(_("  -S, --exclude-schema=PATTERN    do NOT check matching schema(s)\n"));
     printf(_("  -t, --table=PATTERN             check matching table(s)\n"));
     printf(_("  -T, --exclude-table=PATTERN     do NOT check matching table(s)\n"));
     printf(_("      --no-dependent-indexes      do NOT expand list of relations to include indexes\n"));
     printf(_("      --no-dependent-toast        do NOT expand list of relations to include TOAST tables\n"));
     printf(_("      --no-strict-names           do NOT require patterns to match objects\n"));
     printf(_("\nTable checking options:\n"));
     printf(_("      --exclude-toast-pointers    do NOT follow relation TOAST pointers\n"));
     printf(_("      --on-error-stop             stop checking at end of first corrupt page\n"));
     printf(_("      --skip=OPTION               do NOT check \"all-frozen\" or \"all-visible\" blocks\n"));
     printf(_("      --startblock=BLOCK          begin checking table(s) at the given block number\n"));
     printf(_("      --endblock=BLOCK            check table(s) only up to the given block number\n"));
     printf(_("\nB-tree index checking options:\n"));
     printf(_("      --heapallindexed            check that all heap tuples are found within indexes\n"));
     printf(_("      --parent-check              check index parent/child relationships\n"));
     printf(_("      --rootdescend               search from root page to refind tuples\n"));
     printf(_("      --checkunique               check unique constraint if index is unique\n"));
     printf(_("\nConnection options:\n"));
     printf(_("  -h, --host=HOSTNAME             database server host or socket directory\n"));
     printf(_("  -p, --port=PORT                 database server port\n"));
     printf(_("  -U, --username=USERNAME         user name to connect as\n"));
     printf(_("  -w, --no-password               never prompt for password\n"));
     printf(_("  -W, --password                  force password prompt\n"));
     printf(_("      --maintenance-db=DBNAME     alternate maintenance database\n"));
     printf(_("\nOther options:\n"));
     printf(_("  -e, --echo                      show the commands being sent to the server\n"));
     printf(_("  -j, --jobs=NUM                  use this many concurrent connections to the server\n"));
     printf(_("  -P, --progress                  show progress information\n"));
     printf(_("  -v, --verbose                   write a lot of output\n"));
     printf(_("  -V, --version                   output version information, then exit\n"));
     printf(_("      --install-missing           install missing extensions\n"));
     printf(_("  -?, --help                      show this help, then exit\n"));
  
     printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
 }

References _, printf, and progname.

Referenced by main().

◆ indent_lines()

static char* indent_lines ( const char * str )

static

Definition at line 1005 of file pg_amcheck.c.

 {
     PQExpBufferData buf;
     const char *c;
     char       *result;
  
     initPQExpBuffer(&buf);
     appendPQExpBufferStr(&buf, "    ");
     for (c = str; *c; c++)
     {
         appendPQExpBufferChar(&buf, *c);
         if (c[0] == '\n' && c[1] != '\0')
             appendPQExpBufferStr(&buf, "    ");
     }
     result = pstrdup(buf.data);
     termPQExpBuffer(&buf);
  
     return result;
 }

References appendPQExpBufferChar(), appendPQExpBufferStr(), buf, initPQExpBuffer(), pstrdup(), generate_unaccent_rules::str, and termPQExpBuffer().

Referenced by verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 219 of file pg_amcheck.c.

 {
     PGconn     *conn = NULL;
     SimplePtrListCell *cell;
     SimplePtrList databases = {NULL, NULL};
     SimplePtrList relations = {NULL, NULL};
     bool        failed = false;
     const char *latest_datname;
     int         parallel_workers;
     ParallelSlotArray *sa;
     PQExpBufferData sql;
     uint64      reltotal = 0;
     uint64      pageschecked = 0;
     uint64      pagestotal = 0;
     uint64      relprogress = 0;
     int         pattern_id;
  
     static struct option long_options[] = {
         /* Connection options */
         {"host", required_argument, NULL, 'h'},
         {"port", required_argument, NULL, 'p'},
         {"username", required_argument, NULL, 'U'},
         {"no-password", no_argument, NULL, 'w'},
         {"password", no_argument, NULL, 'W'},
         {"maintenance-db", required_argument, NULL, 1},
  
         /* check options */
         {"all", no_argument, NULL, 'a'},
         {"database", required_argument, NULL, 'd'},
         {"exclude-database", required_argument, NULL, 'D'},
         {"echo", no_argument, NULL, 'e'},
         {"index", required_argument, NULL, 'i'},
         {"exclude-index", required_argument, NULL, 'I'},
         {"jobs", required_argument, NULL, 'j'},
         {"progress", no_argument, NULL, 'P'},
         {"relation", required_argument, NULL, 'r'},
         {"exclude-relation", required_argument, NULL, 'R'},
         {"schema", required_argument, NULL, 's'},
         {"exclude-schema", required_argument, NULL, 'S'},
         {"table", required_argument, NULL, 't'},
         {"exclude-table", required_argument, NULL, 'T'},
         {"verbose", no_argument, NULL, 'v'},
         {"no-dependent-indexes", no_argument, NULL, 2},
         {"no-dependent-toast", no_argument, NULL, 3},
         {"exclude-toast-pointers", no_argument, NULL, 4},
         {"on-error-stop", no_argument, NULL, 5},
         {"skip", required_argument, NULL, 6},
         {"startblock", required_argument, NULL, 7},
         {"endblock", required_argument, NULL, 8},
         {"rootdescend", no_argument, NULL, 9},
         {"no-strict-names", no_argument, NULL, 10},
         {"heapallindexed", no_argument, NULL, 11},
         {"parent-check", no_argument, NULL, 12},
         {"install-missing", optional_argument, NULL, 13},
         {"checkunique", no_argument, NULL, 14},
  
         {NULL, 0, NULL, 0}
     };
  
     int         optindex;
     int         c;
  
     const char *db = NULL;
     const char *maintenance_db = NULL;
  
     const char *host = NULL;
     const char *port = NULL;
     const char *username = NULL;
     enum trivalue prompt_password = TRI_DEFAULT;
     int         encoding = pg_get_encoding_from_locale(NULL, false);
     ConnParams  cparams;
  
     pg_logging_init(argv[0]);
     progname = get_progname(argv[0]);
     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_amcheck"));
  
     handle_help_version_opts(argc, argv, progname, help);
  
     /* process command-line options */
     while ((c = getopt_long(argc, argv, "ad:D:eh:Hi:I:j:p:Pr:R:s:S:t:T:U:vwW",
                             long_options, &optindex)) != -1)
     {
         char       *endptr;
         unsigned long optval;
  
         switch (c)
         {
             case 'a':
                 opts.alldb = true;
                 break;
             case 'd':
                 opts.dbpattern = true;
                 append_database_pattern(&opts.include, optarg, encoding);
                 break;
             case 'D':
                 opts.dbpattern = true;
                 append_database_pattern(&opts.exclude, optarg, encoding);
                 break;
             case 'e':
                 opts.echo = true;
                 break;
             case 'h':
                 host = pg_strdup(optarg);
                 break;
             case 'i':
                 opts.allrel = false;
                 append_btree_pattern(&opts.include, optarg, encoding);
                 break;
             case 'I':
                 opts.excludeidx = true;
                 append_btree_pattern(&opts.exclude, optarg, encoding);
                 break;
             case 'j':
                 if (!option_parse_int(optarg, "-j/--jobs", 1, INT_MAX,
                                       &opts.jobs))
                     exit(1);
                 break;
             case 'p':
                 port = pg_strdup(optarg);
                 break;
             case 'P':
                 opts.show_progress = true;
                 break;
             case 'r':
                 opts.allrel = false;
                 append_relation_pattern(&opts.include, optarg, encoding);
                 break;
             case 'R':
                 opts.excludeidx = true;
                 opts.excludetbl = true;
                 append_relation_pattern(&opts.exclude, optarg, encoding);
                 break;
             case 's':
                 opts.allrel = false;
                 append_schema_pattern(&opts.include, optarg, encoding);
                 break;
             case 'S':
                 opts.excludensp = true;
                 append_schema_pattern(&opts.exclude, optarg, encoding);
                 break;
             case 't':
                 opts.allrel = false;
                 append_heap_pattern(&opts.include, optarg, encoding);
                 break;
             case 'T':
                 opts.excludetbl = true;
                 append_heap_pattern(&opts.exclude, optarg, encoding);
                 break;
             case 'U':
                 username = pg_strdup(optarg);
                 break;
             case 'v':
                 opts.verbose = true;
                 pg_logging_increase_verbosity();
                 break;
             case 'w':
                 prompt_password = TRI_NO;
                 break;
             case 'W':
                 prompt_password = TRI_YES;
                 break;
             case 1:
                 maintenance_db = pg_strdup(optarg);
                 break;
             case 2:
                 opts.no_btree_expansion = true;
                 break;
             case 3:
                 opts.no_toast_expansion = true;
                 break;
             case 4:
                 opts.reconcile_toast = false;
                 break;
             case 5:
                 opts.on_error_stop = true;
                 break;
             case 6:
                 if (pg_strcasecmp(optarg, "all-visible") == 0)
                     opts.skip = "all-visible";
                 else if (pg_strcasecmp(optarg, "all-frozen") == 0)
                     opts.skip = "all-frozen";
                 else if (pg_strcasecmp(optarg, "none") == 0)
                     opts.skip = "none";
                 else
                     pg_fatal("invalid argument for option %s", "--skip");
                 break;
             case 7:
                 errno = 0;
                 optval = strtoul(optarg, &endptr, 10);
                 if (endptr == optarg || *endptr != '\0' || errno != 0)
                     pg_fatal("invalid start block");
                 if (optval > MaxBlockNumber)
                     pg_fatal("start block out of bounds");
                 opts.startblock = optval;
                 break;
             case 8:
                 errno = 0;
                 optval = strtoul(optarg, &endptr, 10);
                 if (endptr == optarg || *endptr != '\0' || errno != 0)
                     pg_fatal("invalid end block");
                 if (optval > MaxBlockNumber)
                     pg_fatal("end block out of bounds");
                 opts.endblock = optval;
                 break;
             case 9:
                 opts.rootdescend = true;
                 opts.parent_check = true;
                 break;
             case 10:
                 opts.strict_names = false;
                 break;
             case 11:
                 opts.heapallindexed = true;
                 break;
             case 12:
                 opts.parent_check = true;
                 break;
             case 13:
                 opts.install_missing = true;
                 if (optarg)
                     opts.install_schema = pg_strdup(optarg);
                 break;
             case 14:
                 opts.checkunique = true;
                 break;
             default:
                 /* getopt_long already emitted a complaint */
                 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
                 exit(1);
         }
     }
  
     if (opts.endblock >= 0 && opts.endblock < opts.startblock)
         pg_fatal("end block precedes start block");
  
     /*
      * A single non-option arguments specifies a database name or connection
      * string.
      */
     if (optind < argc)
     {
         db = argv[optind];
         optind++;
     }
  
     if (optind < argc)
     {
         pg_log_error("too many command-line arguments (first is \"%s\")",
                      argv[optind]);
         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
         exit(1);
     }
  
     /* fill cparams except for dbname, which is set below */
     cparams.pghost = host;
     cparams.pgport = port;
     cparams.pguser = username;
     cparams.prompt_password = prompt_password;
     cparams.dbname = NULL;
     cparams.override_dbname = NULL;
  
     setup_cancel_handler(NULL);
  
     /* choose the database for our initial connection */
     if (opts.alldb)
     {
         if (db != NULL)
             pg_fatal("cannot specify a database name with --all");
         cparams.dbname = maintenance_db;
     }
     else if (db != NULL)
     {
         if (opts.dbpattern)
             pg_fatal("cannot specify both a database name and database patterns");
         cparams.dbname = db;
     }
  
     if (opts.alldb || opts.dbpattern)
     {
         conn = connectMaintenanceDatabase(&cparams, progname, opts.echo);
         compile_database_list(conn, &databases, NULL);
     }
     else
     {
         if (cparams.dbname == NULL)
         {
             if (getenv("PGDATABASE"))
                 cparams.dbname = getenv("PGDATABASE");
             else if (getenv("PGUSER"))
                 cparams.dbname = getenv("PGUSER");
             else
                 cparams.dbname = get_user_name_or_exit(progname);
         }
         conn = connectDatabase(&cparams, progname, opts.echo, false, true);
         compile_database_list(conn, &databases, PQdb(conn));
     }
  
     if (databases.head == NULL)
     {
         if (conn != NULL)
             disconnectDatabase(conn);
         pg_log_warning("no databases to check");
         exit(0);
     }
  
     /*
      * Compile a list of all relations spanning all databases to be checked.
      */
     for (cell = databases.head; cell; cell = cell->next)
     {
         PGresult   *result;
         int         ntups;
         const char *amcheck_schema = NULL;
         DatabaseInfo *dat = (DatabaseInfo *) cell->ptr;
  
         cparams.override_dbname = dat->datname;
         if (conn == NULL || strcmp(PQdb(conn), dat->datname) != 0)
         {
             if (conn != NULL)
                 disconnectDatabase(conn);
             conn = connectDatabase(&cparams, progname, opts.echo, false, true);
         }
  
         /*
          * Optionally install amcheck if not already installed in this
          * database.
          */
         if (opts.install_missing)
         {
             char       *schema;
             char       *install_sql;
  
             /*
              * Must re-escape the schema name for each database, as the
              * escaping rules may change.
              */
             schema = PQescapeIdentifier(conn, opts.install_schema,
                                         strlen(opts.install_schema));
             install_sql = psprintf("CREATE EXTENSION IF NOT EXISTS amcheck WITH SCHEMA %s",
                                    schema);
  
             executeCommand(conn, install_sql, opts.echo);
             pfree(install_sql);
             pfree(schema);
         }
  
         /*
          * Verify that amcheck is installed for this next database.  User
          * error could result in a database not having amcheck that should
          * have it, but we also could be iterating over multiple databases
          * where not all of them have amcheck installed (for example,
          * 'template1').
          */
         result = executeQuery(conn, amcheck_sql, opts.echo);
         if (PQresultStatus(result) != PGRES_TUPLES_OK)
         {
             /* Querying the catalog failed. */
             pg_log_error("database \"%s\": %s",
                          PQdb(conn), PQerrorMessage(conn));
             pg_log_error_detail("Query was: %s", amcheck_sql);
             PQclear(result);
             disconnectDatabase(conn);
             exit(1);
         }
         ntups = PQntuples(result);
         if (ntups == 0)
         {
             /* Querying the catalog succeeded, but amcheck is missing. */
             pg_log_warning("skipping database \"%s\": amcheck is not installed",
                            PQdb(conn));
             disconnectDatabase(conn);
             conn = NULL;
             continue;
         }
         amcheck_schema = PQgetvalue(result, 0, 0);
         if (opts.verbose)
             pg_log_info("in database \"%s\": using amcheck version \"%s\" in schema \"%s\"",
                         PQdb(conn), PQgetvalue(result, 0, 1), amcheck_schema);
         dat->amcheck_schema = PQescapeIdentifier(conn, amcheck_schema,
                                                  strlen(amcheck_schema));
  
         /*
          * Check the version of amcheck extension. Skip requested unique
          * constraint check with warning if it is not yet supported by
          * amcheck.
          */
         if (opts.checkunique == true)
         {
             /*
              * Now amcheck has only major and minor versions in the string but
              * we also support revision just in case. Now it is expected to be
              * zero.
              */
             int         vmaj = 0,
                         vmin = 0,
                         vrev = 0;
             const char *amcheck_version = PQgetvalue(result, 0, 1);
  
             sscanf(amcheck_version, "%d.%d.%d", &vmaj, &vmin, &vrev);
  
             /*
              * checkunique option is supported in amcheck since version 1.4
              */
             if ((vmaj == 1 && vmin < 4) || vmaj == 0)
             {
                 pg_log_warning("--checkunique option is not supported by amcheck "
                                "version \"%s\"", amcheck_version);
                 dat->is_checkunique = false;
             }
             else
                 dat->is_checkunique = true;
         }
  
         PQclear(result);
  
         compile_relation_list_one_db(conn, &relations, dat, &pagestotal);
     }
  
     /*
      * Check that all inclusion patterns matched at least one schema or
      * relation that we can check.
      */
     for (pattern_id = 0; pattern_id < opts.include.len; pattern_id++)
     {
         PatternInfo *pat = &opts.include.data[pattern_id];
  
         if (!pat->matched && (pat->nsp_regex != NULL || pat->rel_regex != NULL))
         {
             failed = opts.strict_names;
  
             if (pat->heap_only)
                 log_no_match("no heap tables to check matching \"%s\"",
                              pat->pattern);
             else if (pat->btree_only)
                 log_no_match("no btree indexes to check matching \"%s\"",
                              pat->pattern);
             else if (pat->rel_regex == NULL)
                 log_no_match("no relations to check in schemas matching \"%s\"",
                              pat->pattern);
             else
                 log_no_match("no relations to check matching \"%s\"",
                              pat->pattern);
         }
     }
  
     if (failed)
     {
         if (conn != NULL)
             disconnectDatabase(conn);
         exit(1);
     }
  
     /*
      * Set parallel_workers to the lesser of opts.jobs and the number of
      * relations.
      */
     parallel_workers = 0;
     for (cell = relations.head; cell; cell = cell->next)
     {
         reltotal++;
         if (parallel_workers < opts.jobs)
             parallel_workers++;
     }
  
     if (reltotal == 0)
     {
         if (conn != NULL)
             disconnectDatabase(conn);
         pg_fatal("no relations to check");
     }
     progress_report(reltotal, relprogress, pagestotal, pageschecked,
                     NULL, true, false);
  
     /*
      * Main event loop.
      *
      * We use server-side parallelism to check up to parallel_workers
      * relations in parallel.  The list of relations was computed in database
      * order, which minimizes the number of connects and disconnects as we
      * process the list.
      */
     latest_datname = NULL;
     sa = ParallelSlotsSetup(parallel_workers, &cparams, progname, opts.echo,
                             NULL);
     if (conn != NULL)
     {
         ParallelSlotsAdoptConn(sa, conn);
         conn = NULL;
     }
  
     initPQExpBuffer(&sql);
     for (relprogress = 0, cell = relations.head; cell; cell = cell->next)
     {
         ParallelSlot *free_slot;
         RelationInfo *rel;
  
         rel = (RelationInfo *) cell->ptr;
  
         if (CancelRequested)
         {
             failed = true;
             break;
         }
  
         /*
          * The list of relations is in database sorted order.  If this next
          * relation is in a different database than the last one seen, we are
          * about to start checking this database.  Note that other slots may
          * still be working on relations from prior databases.
          */
         latest_datname = rel->datinfo->datname;
  
         progress_report(reltotal, relprogress, pagestotal, pageschecked,
                         latest_datname, false, false);
  
         relprogress++;
         pageschecked += rel->blocks_to_check;
  
         /*
          * Get a parallel slot for the next amcheck command, blocking if
          * necessary until one is available, or until a previously issued slot
          * command fails, indicating that we should abort checking the
          * remaining objects.
          */
         free_slot = ParallelSlotsGetIdle(sa, rel->datinfo->datname);
         if (!free_slot)
         {
             /*
              * Something failed.  We don't need to know what it was, because
              * the handler should already have emitted the necessary error
              * messages.
              */
             failed = true;
             break;
         }
  
         if (opts.verbose)
             PQsetErrorVerbosity(free_slot->connection, PQERRORS_VERBOSE);
  
         /*
          * Execute the appropriate amcheck command for this relation using our
          * slot's database connection.  We do not wait for the command to
          * complete, nor do we perform any error checking, as that is done by
          * the parallel slots and our handler callback functions.
          */
         if (rel->is_heap)
         {
             if (opts.verbose)
             {
                 if (opts.show_progress && progress_since_last_stderr)
                     fprintf(stderr, "\n");
                 pg_log_info("checking heap table \"%s.%s.%s\"",
                             rel->datinfo->datname, rel->nspname, rel->relname);
                 progress_since_last_stderr = false;
             }
             prepare_heap_command(&sql, rel, free_slot->connection);
             rel->sql = pstrdup(sql.data);   /* pg_free'd after command */
             ParallelSlotSetHandler(free_slot, verify_heap_slot_handler, rel);
             run_command(free_slot, rel->sql);
         }
         else
         {
             if (opts.verbose)
             {
                 if (opts.show_progress && progress_since_last_stderr)
                     fprintf(stderr, "\n");
  
                 pg_log_info("checking btree index \"%s.%s.%s\"",
                             rel->datinfo->datname, rel->nspname, rel->relname);
                 progress_since_last_stderr = false;
             }
             prepare_btree_command(&sql, rel, free_slot->connection);
             rel->sql = pstrdup(sql.data);   /* pg_free'd after command */
             ParallelSlotSetHandler(free_slot, verify_btree_slot_handler, rel);
             run_command(free_slot, rel->sql);
         }
     }
     termPQExpBuffer(&sql);
  
     if (!failed)
     {
  
         /*
          * Wait for all slots to complete, or for one to indicate that an
          * error occurred.  Like above, we rely on the handler emitting the
          * necessary error messages.
          */
         if (sa && !ParallelSlotsWaitCompletion(sa))
             failed = true;
  
         progress_report(reltotal, relprogress, pagestotal, pageschecked, NULL, true, true);
     }
  
     if (sa)
     {
         ParallelSlotsTerminate(sa);
         FREE_AND_SET_NULL(sa);
     }
  
     if (failed)
         exit(1);
  
     if (!all_checks_pass)
         exit(2);
 }

References all_checks_pass, AmcheckOptions::alldb, AmcheckOptions::allrel, DatabaseInfo::amcheck_schema, amcheck_sql, append_btree_pattern(), append_database_pattern(), append_heap_pattern(), append_relation_pattern(), append_schema_pattern(), RelationInfo::blocks_to_check, PatternInfo::btree_only, CancelRequested, AmcheckOptions::checkunique, compile_database_list(), compile_relation_list_one_db(), conn, connectDatabase(), ParallelSlot::connection, connectMaintenanceDatabase(), PatternInfoArray::data, PQExpBufferData::data, RelationInfo::datinfo, DatabaseInfo::datname, _connParams::dbname, AmcheckOptions::dbpattern, disconnectDatabase(), AmcheckOptions::echo, encoding, AmcheckOptions::endblock, AmcheckOptions::exclude, AmcheckOptions::excludeidx, AmcheckOptions::excludensp, AmcheckOptions::excludetbl, executeCommand(), executeQuery(), exit(), fprintf, FREE_AND_SET_NULL, get_progname(), get_user_name_or_exit(), getopt_long(), handle_help_version_opts(), SimplePtrList::head, PatternInfo::heap_only, AmcheckOptions::heapallindexed, help(), if(), AmcheckOptions::include, initPQExpBuffer(), AmcheckOptions::install_missing, AmcheckOptions::install_schema, DatabaseInfo::is_checkunique, RelationInfo::is_heap, AmcheckOptions::jobs, PatternInfoArray::len, log_no_match, PatternInfo::matched, MaxBlockNumber, SimplePtrListCell::next, no_argument, AmcheckOptions::no_btree_expansion, AmcheckOptions::no_toast_expansion, PatternInfo::nsp_regex, RelationInfo::nspname, AmcheckOptions::on_error_stop, optarg, optind, option_parse_int(), optional_argument, opts, _connParams::override_dbname, ParallelSlotsAdoptConn(), ParallelSlotSetHandler(), ParallelSlotsGetIdle(), ParallelSlotsSetup(), ParallelSlotsTerminate(), ParallelSlotsWaitCompletion(), AmcheckOptions::parent_check, PatternInfo::pattern, pfree(), pg_fatal, pg_get_encoding_from_locale(), pg_log_error, pg_log_error_detail, pg_log_error_hint, pg_log_info, pg_log_warning, pg_logging_increase_verbosity(), pg_logging_init(), pg_strcasecmp(), pg_strdup(), PG_TEXTDOMAIN, _connParams::pghost, _connParams::pgport, PGRES_TUPLES_OK, _connParams::pguser, port, PQclear(), PQdb(), PQerrorMessage(), PQERRORS_VERBOSE, PQescapeIdentifier(), PQgetvalue(), PQntuples(), PQresultStatus(), PQsetErrorVerbosity(), prepare_btree_command(), prepare_heap_command(), progname, progress_report(), progress_since_last_stderr, _connParams::prompt_password, psprintf(), pstrdup(), SimplePtrListCell::ptr, AmcheckOptions::reconcile_toast, PatternInfo::rel_regex, RelationInfo::relname, required_argument, AmcheckOptions::rootdescend, run_command(), set_pglocale_pgservice(), setup_cancel_handler(), AmcheckOptions::show_progress, AmcheckOptions::skip, RelationInfo::sql, AmcheckOptions::startblock, AmcheckOptions::strict_names, termPQExpBuffer(), TRI_DEFAULT, TRI_NO, TRI_YES, username, AmcheckOptions::verbose, verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ prepare_btree_command()

static void prepare_btree_command	(	PQExpBuffer	sql,
		RelationInfo *	rel,
		PGconn *	conn
	)

static

Definition at line 881 of file pg_amcheck.c.

 {
     resetPQExpBuffer(sql);
  
     if (opts.parent_check)
         appendPQExpBuffer(sql,
                           "SELECT %s.bt_index_parent_check("
                           "index := c.oid, heapallindexed := %s, rootdescend := %s "
                           "%s)"
                           "\nFROM pg_catalog.pg_class c, pg_catalog.pg_index i "
                           "WHERE c.oid = %u "
                           "AND c.oid = i.indexrelid "
                           "AND c.relpersistence != 't' "
                           "AND i.indisready AND i.indisvalid AND i.indislive",
                           rel->datinfo->amcheck_schema,
                           (opts.heapallindexed ? "true" : "false"),
                           (opts.rootdescend ? "true" : "false"),
                           (rel->datinfo->is_checkunique ? ", checkunique := true" : ""),
                           rel->reloid);
     else
         appendPQExpBuffer(sql,
                           "SELECT %s.bt_index_check("
                           "index := c.oid, heapallindexed := %s "
                           "%s)"
                           "\nFROM pg_catalog.pg_class c, pg_catalog.pg_index i "
                           "WHERE c.oid = %u "
                           "AND c.oid = i.indexrelid "
                           "AND c.relpersistence != 't' "
                           "AND i.indisready AND i.indisvalid AND i.indislive",
                           rel->datinfo->amcheck_schema,
                           (opts.heapallindexed ? "true" : "false"),
                           (rel->datinfo->is_checkunique ? ", checkunique := true" : ""),
                           rel->reloid);
 }

References DatabaseInfo::amcheck_schema, appendPQExpBuffer(), RelationInfo::datinfo, AmcheckOptions::heapallindexed, DatabaseInfo::is_checkunique, opts, AmcheckOptions::parent_check, RelationInfo::reloid, resetPQExpBuffer(), and AmcheckOptions::rootdescend.

Referenced by main().

◆ prepare_heap_command()

static void prepare_heap_command	(	PQExpBuffer	sql,
		RelationInfo *	rel,
		PGconn *	conn
	)

static

Definition at line 841 of file pg_amcheck.c.

 {
     resetPQExpBuffer(sql);
     appendPQExpBuffer(sql,
                       "SELECT v.blkno, v.offnum, v.attnum, v.msg "
                       "FROM pg_catalog.pg_class c, %s.verify_heapam("
                       "\nrelation := c.oid, on_error_stop := %s, check_toast := %s, skip := '%s'",
                       rel->datinfo->amcheck_schema,
                       opts.on_error_stop ? "true" : "false",
                       opts.reconcile_toast ? "true" : "false",
                       opts.skip);
  
     if (opts.startblock >= 0)
         appendPQExpBuffer(sql, ", startblock := " INT64_FORMAT, opts.startblock);
     if (opts.endblock >= 0)
         appendPQExpBuffer(sql, ", endblock := " INT64_FORMAT, opts.endblock);
  
     appendPQExpBuffer(sql,
                       "\n) v WHERE c.oid = %u "
                       "AND c.relpersistence != 't'",
                       rel->reloid);
 }

References DatabaseInfo::amcheck_schema, appendPQExpBuffer(), RelationInfo::datinfo, AmcheckOptions::endblock, INT64_FORMAT, AmcheckOptions::on_error_stop, opts, AmcheckOptions::reconcile_toast, RelationInfo::reloid, resetPQExpBuffer(), AmcheckOptions::skip, and AmcheckOptions::startblock.

Referenced by main().

◆ progress_report()

static void progress_report	(	uint64	relations_total,
		uint64	relations_checked,
		uint64	relpages_total,
		uint64	relpages_checked,
		const char *	datname,
		bool	force,
		bool	finished
	)

static

Definition at line 1241 of file pg_amcheck.c.

 {
     int         percent_rel = 0;
     int         percent_pages = 0;
     char        checked_rel[32];
     char        total_rel[32];
     char        checked_pages[32];
     char        total_pages[32];
     pg_time_t   now;
  
     if (!opts.show_progress)
         return;
  
     now = time(NULL);
     if (now == last_progress_report && !force && !finished)
         return;                 /* Max once per second */
  
     last_progress_report = now;
     if (relations_total)
         percent_rel = (int) (relations_checked * 100 / relations_total);
     if (relpages_total)
         percent_pages = (int) (relpages_checked * 100 / relpages_total);
  
     snprintf(checked_rel, sizeof(checked_rel), UINT64_FORMAT, relations_checked);
     snprintf(total_rel, sizeof(total_rel), UINT64_FORMAT, relations_total);
     snprintf(checked_pages, sizeof(checked_pages), UINT64_FORMAT, relpages_checked);
     snprintf(total_pages, sizeof(total_pages), UINT64_FORMAT, relpages_total);
  
 #define VERBOSE_DATNAME_LENGTH 35
     if (opts.verbose)
     {
         if (!datname)
  
             /*
              * No datname given, so clear the status line (used for first and
              * last call)
              */
             fprintf(stderr,
                     _("%*s/%s relations (%d%%), %*s/%s pages (%d%%) %*s"),
                     (int) strlen(total_rel),
                     checked_rel, total_rel, percent_rel,
                     (int) strlen(total_pages),
                     checked_pages, total_pages, percent_pages,
                     VERBOSE_DATNAME_LENGTH + 2, "");
         else
         {
             bool        truncate = (strlen(datname) > VERBOSE_DATNAME_LENGTH);
  
             fprintf(stderr,
                     _("%*s/%s relations (%d%%), %*s/%s pages (%d%%) (%s%-*.*s)"),
                     (int) strlen(total_rel),
                     checked_rel, total_rel, percent_rel,
                     (int) strlen(total_pages),
                     checked_pages, total_pages, percent_pages,
             /* Prefix with "..." if we do leading truncation */
                     truncate ? "..." : "",
                     truncate ? VERBOSE_DATNAME_LENGTH - 3 : VERBOSE_DATNAME_LENGTH,
                     truncate ? VERBOSE_DATNAME_LENGTH - 3 : VERBOSE_DATNAME_LENGTH,
             /* Truncate datname at beginning if it's too long */
                     truncate ? datname + strlen(datname) - VERBOSE_DATNAME_LENGTH + 3 : datname);
         }
     }
     else
         fprintf(stderr,
                 _("%*s/%s relations (%d%%), %*s/%s pages (%d%%)"),
                 (int) strlen(total_rel),
                 checked_rel, total_rel, percent_rel,
                 (int) strlen(total_pages),
                 checked_pages, total_pages, percent_pages);
  
     /*
      * Stay on the same line if reporting to a terminal and we're not done
      * yet.
      */
     if (!finished && isatty(fileno(stderr)))
     {
         fputc('\r', stderr);
         progress_since_last_stderr = true;
     }
     else
         fputc('\n', stderr);
 }

References _, datname, fprintf, last_progress_report, now(), opts, progress_since_last_stderr, AmcheckOptions::show_progress, snprintf, UINT64_FORMAT, AmcheckOptions::verbose, and VERBOSE_DATNAME_LENGTH.

Referenced by main(), and write_target_range().

◆ run_command()

static void run_command	(	ParallelSlot *	slot,
		const char *	sql
	)

static

Definition at line 930 of file pg_amcheck.c.

 {
     if (opts.echo)
         printf("%s\n", sql);
  
     if (PQsendQuery(slot->connection, sql) == 0)
     {
         pg_log_error("error sending command to database \"%s\": %s",
                      PQdb(slot->connection),
                      PQerrorMessage(slot->connection));
         pg_log_error_detail("Command was: %s", sql);
         exit(1);
     }
 }

References ParallelSlot::connection, AmcheckOptions::echo, exit(), opts, pg_log_error, pg_log_error_detail, PQdb(), PQerrorMessage(), PQsendQuery(), and printf.

Referenced by main().

◆ should_processing_continue()

static bool should_processing_continue ( PGresult * res )

static

Definition at line 962 of file pg_amcheck.c.

 {
     const char *severity;
  
     switch (PQresultStatus(res))
     {
             /* These are expected and ok */
         case PGRES_COMMAND_OK:
         case PGRES_TUPLES_OK:
         case PGRES_NONFATAL_ERROR:
             break;
  
             /* This is expected but requires closer scrutiny */
         case PGRES_FATAL_ERROR:
             severity = PQresultErrorField(res, PG_DIAG_SEVERITY_NONLOCALIZED);
             if (severity == NULL)
                 return false;   /* libpq failure, probably lost connection */
             if (strcmp(severity, "FATAL") == 0)
                 return false;
             if (strcmp(severity, "PANIC") == 0)
                 return false;
             break;
  
             /* These are unexpected */
         case PGRES_BAD_RESPONSE:
         case PGRES_EMPTY_QUERY:
         case PGRES_COPY_OUT:
         case PGRES_COPY_IN:
         case PGRES_COPY_BOTH:
         case PGRES_SINGLE_TUPLE:
         case PGRES_PIPELINE_SYNC:
         case PGRES_PIPELINE_ABORTED:
             return false;
     }
     return true;
 }

References PG_DIAG_SEVERITY_NONLOCALIZED, PGRES_BAD_RESPONSE, PGRES_COMMAND_OK, PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PGRES_NONFATAL_ERROR, PGRES_PIPELINE_ABORTED, PGRES_PIPELINE_SYNC, PGRES_SINGLE_TUPLE, PGRES_TUPLES_OK, PQresultErrorField(), PQresultStatus(), and res.

Referenced by verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ verify_btree_slot_handler()

static bool verify_btree_slot_handler	(	PGresult *	res,
		PGconn *	conn,
		void *	context
	)

static

Definition at line 1117 of file pg_amcheck.c.

 {
     RelationInfo *rel = (RelationInfo *) context;
  
     if (PQresultStatus(res) == PGRES_TUPLES_OK)
     {
         int         ntups = PQntuples(res);
  
         if (ntups > 1)
         {
             /*
              * We expect the btree checking functions to return one void row
              * each, or zero rows if the check was skipped due to the object
              * being in the wrong state to be checked, so we should output
              * some sort of warning if we get anything more, not because it
              * indicates corruption, but because it suggests a mismatch
              * between amcheck and pg_amcheck versions.
              *
              * In conjunction with --progress, anything written to stderr at
              * this time would present strangely to the user without an extra
              * newline, so we print one.  If we were multithreaded, we'd have
              * to avoid splitting this across multiple calls, but we're in an
              * event loop, so it doesn't matter.
              */
             if (opts.show_progress && progress_since_last_stderr)
                 fprintf(stderr, "\n");
             pg_log_warning("btree index \"%s.%s.%s\": btree checking function returned unexpected number of rows: %d",
                            rel->datinfo->datname, rel->nspname, rel->relname, ntups);
             if (opts.verbose)
                 pg_log_warning_detail("Query was: %s", rel->sql);
             pg_log_warning_hint("Are %s's and amcheck's versions compatible?",
                                 progname);
             progress_since_last_stderr = false;
         }
     }
     else
     {
         char       *msg = indent_lines(PQerrorMessage(conn));
  
         all_checks_pass = false;
         printf(_("btree index \"%s.%s.%s\":\n"),
                rel->datinfo->datname, rel->nspname, rel->relname);
         printf("%s", msg);
         if (opts.verbose)
             printf(_("query was: %s\n"), rel->sql);
         FREE_AND_SET_NULL(msg);
     }
  
     FREE_AND_SET_NULL(rel->sql);
     FREE_AND_SET_NULL(rel->nspname);
     FREE_AND_SET_NULL(rel->relname);
  
     return should_processing_continue(res);
 }

References _, all_checks_pass, conn, RelationInfo::datinfo, DatabaseInfo::datname, fprintf, FREE_AND_SET_NULL, indent_lines(), RelationInfo::nspname, opts, pg_log_warning, pg_log_warning_detail, pg_log_warning_hint, PGRES_TUPLES_OK, PQerrorMessage(), PQntuples(), PQresultStatus(), printf, progname, progress_since_last_stderr, RelationInfo::relname, res, should_processing_continue(), AmcheckOptions::show_progress, RelationInfo::sql, and AmcheckOptions::verbose.

Referenced by main().

◆ verify_heap_slot_handler()

static bool verify_heap_slot_handler	(	PGresult *	res,
		PGconn *	conn,
		void *	context
	)

static

Definition at line 1036 of file pg_amcheck.c.

 {
     RelationInfo *rel = (RelationInfo *) context;
  
     if (PQresultStatus(res) == PGRES_TUPLES_OK)
     {
         int         i;
         int         ntups = PQntuples(res);
  
         if (ntups > 0)
             all_checks_pass = false;
  
         for (i = 0; i < ntups; i++)
         {
             const char *msg;
  
             /* The message string should never be null, but check */
             if (PQgetisnull(res, i, 3))
                 msg = "NO MESSAGE";
             else
                 msg = PQgetvalue(res, i, 3);
  
             if (!PQgetisnull(res, i, 2))
                 printf(_("heap table \"%s.%s.%s\", block %s, offset %s, attribute %s:\n"),
                        rel->datinfo->datname, rel->nspname, rel->relname,
                        PQgetvalue(res, i, 0),   /* blkno */
                        PQgetvalue(res, i, 1),   /* offnum */
                        PQgetvalue(res, i, 2));  /* attnum */
  
             else if (!PQgetisnull(res, i, 1))
                 printf(_("heap table \"%s.%s.%s\", block %s, offset %s:\n"),
                        rel->datinfo->datname, rel->nspname, rel->relname,
                        PQgetvalue(res, i, 0),   /* blkno */
                        PQgetvalue(res, i, 1));  /* offnum */
  
             else if (!PQgetisnull(res, i, 0))
                 printf(_("heap table \"%s.%s.%s\", block %s:\n"),
                        rel->datinfo->datname, rel->nspname, rel->relname,
                        PQgetvalue(res, i, 0));  /* blkno */
  
             else
                 printf(_("heap table \"%s.%s.%s\":\n"),
                        rel->datinfo->datname, rel->nspname, rel->relname);
  
             printf("    %s\n", msg);
         }
     }
     else if (PQresultStatus(res) != PGRES_TUPLES_OK)
     {
         char       *msg = indent_lines(PQerrorMessage(conn));
  
         all_checks_pass = false;
         printf(_("heap table \"%s.%s.%s\":\n"),
                rel->datinfo->datname, rel->nspname, rel->relname);
         printf("%s", msg);
         if (opts.verbose)
             printf(_("query was: %s\n"), rel->sql);
         FREE_AND_SET_NULL(msg);
     }
  
     FREE_AND_SET_NULL(rel->sql);
     FREE_AND_SET_NULL(rel->nspname);
     FREE_AND_SET_NULL(rel->relname);
  
     return should_processing_continue(res);
 }

References _, all_checks_pass, conn, RelationInfo::datinfo, DatabaseInfo::datname, FREE_AND_SET_NULL, i, indent_lines(), RelationInfo::nspname, opts, PGRES_TUPLES_OK, PQerrorMessage(), PQgetisnull(), PQgetvalue(), PQntuples(), PQresultStatus(), printf, RelationInfo::relname, res, should_processing_continue(), RelationInfo::sql, and AmcheckOptions::verbose.

Referenced by main().

Variable Documentation

◆ all_checks_pass

bool all_checks_pass = true

static

Definition at line 143 of file pg_amcheck.c.

Referenced by main(), verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ amcheck_sql

const char* const amcheck_sql

static

Initial value:

=
"SELECT n.nspname, x.extversion FROM pg_catalog.pg_extension x"
"\nJOIN pg_catalog.pg_namespace n ON x.extnamespace = n.oid"
"\nWHERE x.extname = 'amcheck'"

Definition at line 172 of file pg_amcheck.c.

Referenced by main().

◆ last_progress_report

pg_time_t last_progress_report = 0

static

Definition at line 146 of file pg_amcheck.c.

Referenced by progress_report().

◆ opts

AmcheckOptions opts

static

Initial value:

= {
    .dbpattern = false,
    .alldb = false,
    .echo = false,
    .verbose = false,
    .strict_names = true,
    .show_progress = false,
    .jobs = 1,
    .install_missing = false,
    .install_schema = "pg_catalog",
    .include = {NULL, 0},
    .exclude = {NULL, 0},
    .excludetbl = false,
    .excludeidx = false,
    .excludensp = false,
    .allrel = true,
    .no_toast_expansion = false,
    .reconcile_toast = true,
    .on_error_stop = false,
    .startblock = -1,
    .endblock = -1,
    .skip = "none",
    .parent_check = false,
    .rootdescend = false,
    .heapallindexed = false,
    .checkunique = false,
    .no_btree_expansion = false
}

Definition at line 111 of file pg_amcheck.c.

Referenced by AlterSubscription(), append_relation_pattern_helper(), append_schema_pattern(), ArchiveEntry(), BloomFillMetapage(), brin_bloom_add_value(), brin_bloom_get_ndistinct(), brin_minmax_multi_add_value(), brin_minmax_multi_get_values(), build_local_reloptions(), compile_database_list(), compile_relation_list_one_db(), CopyIndexAttOptions(), CreateSubscription(), get_attribute_options(), get_tablespace(), getFormattedTypeName(), initBloomState(), InitDumpOptions(), libpqrcv_check_conninfo(), main(), makeDefaultBloomOptions(), NewDumpOptions(), NewRestoreOptions(), parse_re_flags(), parse_subscription_options(), parse_test_flags(), prepare_btree_command(), prepare_heap_command(), progress_report(), read_restore_filters(), RelationGetIndexAttOptions(), run_command(), sql_exec_dumpalldbs(), sql_exec_dumpalltables(), sql_exec_dumpalltbspc(), sql_exec_searchtables(), verify_btree_slot_handler(), and verify_heap_slot_handler().

◆ progname

const char* progname = NULL

static

Definition at line 140 of file pg_amcheck.c.

Referenced by help(), main(), and verify_btree_slot_handler().

◆ progress_since_last_stderr

bool progress_since_last_stderr = false

static

Definition at line 147 of file pg_amcheck.c.

Referenced by main(), progress_report(), and verify_btree_slot_handler().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ FREE_AND_SET_NULL

◆ log_no_match

◆ VERBOSE_DATNAME_LENGTH

Typedef Documentation

◆ AmcheckOptions

◆ DatabaseInfo

◆ PatternInfo

◆ PatternInfoArray

◆ RelationInfo

Function Documentation

◆ append_btree_pattern()

◆ append_database_pattern()

◆ append_db_pattern_cte()

◆ append_heap_pattern()

◆ append_rel_pattern_filtered_cte()

◆ append_rel_pattern_raw_cte()

◆ append_relation_pattern()

◆ append_relation_pattern_helper()

◆ append_schema_pattern()

◆ compile_database_list()

◆ compile_relation_list_one_db()

◆ extend_pattern_info_array()

◆ help()

◆ indent_lines()

◆ main()

◆ prepare_btree_command()

◆ prepare_heap_command()

◆ progress_report()

◆ run_command()

◆ should_processing_continue()

◆ verify_btree_slot_handler()

◆ verify_heap_slot_handler()

Variable Documentation

◆ all_checks_pass

◆ amcheck_sql

◆ last_progress_report

◆ opts

◆ progname

◆ progress_since_last_stderr