PostgreSQL_Review_Full_Check_Script.sql

/*
    ====================================================================================
    PostgreSQL Review - Template Header

    Purpose: Collect PostgreSQL system introduction information.

    This header collects:
        - PostgreSQL server and cluster identity
        - PostgreSQL version and build information
        - PostgreSQL distribution/flavor best-effort detection
        - Execution context
        - Basic host information visible from PostgreSQL
        - Important PostgreSQL configuration values
        - Databases list
        - Tablespaces list
        - Installed extensions
        - Current database statistics snapshot
        - Current activity summary
        - Replication / recovery high-level state
        - PostgreSQL licensing note
        - Header collection errors, if any

    Important:
        This file should be included at the beginning of the generated script: PostgreSQL_Review_Full_Check_Script.sql

    Expected flow:
        Template_Header.sql
        SQLChecks\*.sql
        Template_Footer.sql

    Output:
        This header does not return the final Review output.
        Final JSON output is generated by Template_Footer.sql.

    Important PostgreSQL limitation:
        PostgreSQL does not expose full operating system and hardware inventory through standard SQL.

        The following information is usually not available from SQL alone:
            - Number of sockets
            - Cores per socket
            - Total physical memory
            - NUMA layout
            - Virtualization type
            - Detailed operating system version

        These values should be collected from the OS, cloud provider, VM platform,
        monitoring platform, or customer documentation when required.

    PostgreSQL documentation:
        https://www.postgresql.org/docs/current/

    System information functions:
        https://www.postgresql.org/docs/current/functions-info.html

    Monitoring statistics:
        https://www.postgresql.org/docs/current/monitoring-stats.html

    Server configuration:
        https://www.postgresql.org/docs/current/runtime-config.html

    System catalogs:
        https://www.postgresql.org/docs/current/catalogs.html
    ====================================================================================
*/


/*
    ====================================================================================
    Header section 1 - Cleanup previous temporary objects
    Purpose: Drop temporary tables from a previous execution in the same session.
             Allows this script to be re-run in the same session, for example from pgAdmin.
    ====================================================================================
*/

    DROP TABLE IF EXISTS pg_review_header_server_identity;
    DROP TABLE IF EXISTS pg_review_header_host_visibility;
    DROP TABLE IF EXISTS pg_review_header_execution_context;
    DROP TABLE IF EXISTS pg_review_header_distribution_detection;
    DROP TABLE IF EXISTS pg_review_header_important_settings;
    DROP TABLE IF EXISTS pg_review_header_licensing;
    DROP TABLE IF EXISTS pg_review_header_databases;
    DROP TABLE IF EXISTS pg_review_header_current_database_session;
    DROP TABLE IF EXISTS pg_review_header_tablespaces;
    DROP TABLE IF EXISTS pg_review_header_extensions;
    DROP TABLE IF EXISTS pg_review_header_database_statistics;
    DROP TABLE IF EXISTS pg_review_header_activity_summary;
    DROP TABLE IF EXISTS pg_review_header_replication_state;
    DROP TABLE IF EXISTS pg_review_header_capabilities;
    DROP TABLE IF EXISTS pg_review_header_errors;
    DROP TABLE IF EXISTS pg_review_results;
    DROP TABLE IF EXISTS pg_review_errors;

/*
    ====================================================================================
    Header section 2 - Create output tables
    Purpose: Create all output tables before collecting data.
    Why: If a specific collection section fails, the relevant table still exists and the final SELECT statements will not fail.
    ====================================================================================
*/

    -- Temp table for Header collection errors
    CREATE TEMP TABLE pg_review_header_errors
    (
        SectionName      text,
        ErrorMessage     text,
        ErrorTime        timestamptz DEFAULT now()
    );

    -- Temp table for PostgreSQL server and cluster identity information
    CREATE TEMP TABLE pg_review_header_server_identity
    (
        PostgreSQLClusterName       text,
        CurrentDatabaseName         text,
        PostgreSQLVersion           text,
        PostgreSQLVersionNum        text,
        PostgreSQLFullVersionString text,
        ServerIPAddress             text,
        ServerPort                  integer,
        PostgreSQLStartTime         timestamptz,
        PostgreSQLUptime            interval,
        IsInRecovery                boolean,
        TransactionReadOnly         text,
        DataDirectory               text,
        ConfigFile                  text,
        HbaFile                     text,
        IdentFile                   text
    );

    -- Temp table for host and operating system information visible from PostgreSQL
    CREATE TEMP TABLE pg_review_header_host_visibility
    (
        ServerIPAddress                 text,
        ServerPort                      integer,
        ClientIPAddress                 text,
        ClientPort                      integer,
        PostgreSQLBuildAndHostString    text,
        OperatingSystemName             text,
        OperatingSystemRelease          text,
        OperatingSystemArchitecture     text,
        VirtualizationType              text,
        NumOfSockets                    integer,
        CoresPerSocket                  integer,
        HostNumOfCores                  integer,
        NumOfNUMAs                      integer,
        PhysicalMemory_GB               numeric,
        HostResourceCollectionNote      text
    );

    -- Temp table for the Review execution context and current user permissions
    CREATE TEMP TABLE pg_review_header_execution_context
    (
        CurrentUser                     text,
        SessionUser                     text,
        CurrentDatabaseName             text,
        CanLogin                        boolean,
        IsSuperuser                     boolean,
        CanCreateDatabase               boolean,
        CanCreateRole                   boolean,
        HasReplicationPrivilege         boolean,
        CanBypassRowLevelSecurity       boolean,
        HasPgMonitor                    boolean,
        HasPgReadAllStats               boolean,
        HasPgReadAllSettings            boolean,
        HasPgStatScanTables             boolean
    );

    -- Temp table for PostgreSQL distribution and managed-service detection
    CREATE TEMP TABLE pg_review_header_distribution_detection
    (
        PostgreSQLDistributionFlavor        text,
        DetectionConfidence                 text,
        PostgreSQLVersion                   text,
        PostgreSQLVersionNum                text,
        HasRdsAdminRole                     boolean,
        HasRdsAdminDatabase                 boolean,
        RdsExtensionsSettingExists          boolean,
        HasRdsToolsExtension                boolean,
        HasAwsCommonsExtension              boolean,
        HasAwsS3Extension                   boolean,
        HasAzurePgAdminRole                 boolean,
        AzureExtensionsSettingExists        boolean,
        HasAzureStorageExtension            boolean,
        HasCloudSqlSuperuserRole            boolean,
        CloudSqlPglogicalSettingExists      boolean,
        HasGoogleMlIntegrationExtension     boolean,
        EdbRedwoodDateSettingExists         boolean,
        HasPgStatStatementsExtension        boolean,
        DetectionNote                       text
    );

    -- Temp table for important PostgreSQL configuration settings
    CREATE TEMP TABLE pg_review_header_important_settings
    (
        SettingName         text,
        SettingValue        text,
        Unit                text,
        Category            text,
        Description         text,
        Context             text,
        ValueType           text,
        BootValue           text,
        ResetValue          text,
        Source              text,
        PendingRestart      boolean
    );

    -- Temp table for PostgreSQL licensing information
    CREATE TEMP TABLE pg_review_header_licensing
    (
        LicensingCategory       text,
        LicensingInformation    text,
        LicensingNote           text
    );

    -- Temp table for the PostgreSQL databases list
    CREATE TEMP TABLE pg_review_header_databases
    (
        DatabaseName        text,
        OwnerName           text,
        AllowConnections    boolean,
        IsTemplate          boolean,
        ConnectionLimit     integer,
        DatabaseEncoding    text,
        DatabaseCollation   text,
        DatabaseCType       text,
        DatabaseSize        text,
        DatabaseSizeBytes   bigint
    );

    -- Temp table for current database session settings
    CREATE TEMP TABLE pg_review_header_current_database_session
    (
        DatabaseName                        text,
        ClientEncoding                      text,
        ServerEncoding                      text,
        DateStyle                           text,
        TimeZone                            text,
        IntervalStyle                       text,
        StandardConformingStrings           text,
        DefaultTransactionIsolation         text,
        CurrentTransactionIsolation         text,
        TransactionReadOnly                 text,
        StatementTimeout                    text,
        LockTimeout                         text,
        IdleInTransactionSessionTimeout     text,
        SearchPath                          text
    );

    -- Temp table for PostgreSQL tablespaces information
    CREATE TEMP TABLE pg_review_header_tablespaces
    (
        TablespaceName          text,
        OwnerName               text,
        TablespaceLocation      text,
        TablespaceOptions       text[]
    );

    -- Temp table for installed extensions in the current database
    CREATE TEMP TABLE pg_review_header_extensions
    (
        ExtensionName       text,
        ExtensionVersion    text,
        SchemaName          text,
        IsRelocatable       boolean
    );

    -- Temp table for current database statistics snapshot
    CREATE TEMP TABLE pg_review_header_database_statistics
    (
        DatabaseName                text,
        CurrentBackends             integer,
        TransactionsCommitted       bigint,
        TransactionsRolledBack      bigint,
        BlocksReadFromDisk          bigint,
        BlocksHitInCache            bigint,
        CacheHitPercent             numeric,
        TuplesReturned              bigint,
        TuplesFetched               bigint,
        TuplesInserted              bigint,
        TuplesUpdated               bigint,
        TuplesDeleted               bigint,
        Conflicts                   bigint,
        TempFiles                   bigint,
        TempBytes                   text,
        TempBytesRaw                bigint,
        Deadlocks                   bigint,
        BlockReadTimeMs             double precision,
        BlockWriteTimeMs            double precision,
        StatisticsResetTime         timestamptz
    );

    -- Temp table for current PostgreSQL activity summary
    CREATE TEMP TABLE pg_review_header_activity_summary
    (
        TotalConnections                    bigint,
        ActiveConnections                   bigint,
        IdleConnections                     bigint,
        IdleInTransactionConnections        bigint,
        SessionsWaitingOnLocks              bigint,
        DistinctUsers                       bigint,
        DistinctApplications                bigint,
        DistinctClientAddresses             bigint,
        OldestBackendStart                  timestamptz,
        OldestTransactionStart              timestamptz,
        OldestQueryStart                    timestamptz
    );

    -- Temp table for replication and recovery state summary
    CREATE TEMP TABLE pg_review_header_replication_state
    (
        IsInRecovery                    boolean,
        WalLevel                        text,
        ArchiveMode                     text,
        MaxWalSenders                   text,
        MaxReplicationSlots             text,
        WalKeepSize                     text,
        ConnectedStandbyCount           bigint,
        ReplicationSlotCount            bigint,
        ActiveReplicationSlotCount      bigint
    );

    -- Temp table for optional PostgreSQL capabilities and feature availability
    CREATE TEMP TABLE pg_review_header_capabilities
    (
        CapabilityName      text,
        IsAvailable         boolean
    );

    -- Temp table for PostgreSQL Review check results
    CREATE TEMP TABLE pg_review_results
    (
        CheckId                 integer PRIMARY KEY,
        Title                   text NOT NULL,
        Category                text NOT NULL,
        Scope                   text NOT NULL,
        RequiresAttention       boolean NOT NULL,
        WorstCaseImpact         integer NOT NULL,
        CurrentStateImpact      integer NOT NULL,
        RecommendationEffort    integer NOT NULL,
        RecommendationRisk      integer NOT NULL,
        Recommendation          text NOT NULL,
        AdditionalInfo          jsonb NOT NULL DEFAULT '{}'::jsonb,
        ResponsibleDbaTeam      text NOT NULL DEFAULT 'Production/Development'
    );

    -- Temp table for PostgreSQL Review check execution errors.
    CREATE TEMP TABLE pg_review_errors
    (
        CheckId             integer,
        Title               text,
        ErrorSqlState       text,
        ErrorMessage        text,
        ErrorDetail         text,
        ErrorHint           text,
        ErrorContext        text,
        IsDeadlockRetry     boolean DEFAULT false,
        ErrorTime           timestamptz DEFAULT now()
    );

/*
    ====================================================================================
    Header section 3 - PostgreSQL Server / Cluster Identity
    Purpose: Basic PostgreSQL identity information.
    Notes: PostgreSQL cluster can contain multiple databases.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_server_identity
    SELECT
        COALESCE(NULLIF(current_setting('cluster_name', true), ''), 'Not provided') AS PostgreSQLClusterName,
        current_database() AS CurrentDatabaseName,
        current_setting('server_version', true) AS PostgreSQLVersion,
        current_setting('server_version_num', true) AS PostgreSQLVersionNum,
        version() AS PostgreSQLFullVersionString,
        inet_server_addr()::text AS ServerIPAddress,
        inet_server_port() AS ServerPort,
        pg_postmaster_start_time() AS PostgreSQLStartTime,
        now() - pg_postmaster_start_time() AS PostgreSQLUptime,
        pg_is_in_recovery() AS IsInRecovery,
        current_setting('transaction_read_only', true) AS TransactionReadOnly,
        current_setting('data_directory', true) AS DataDirectory,
        current_setting('config_file', true) AS ConfigFile,
        current_setting('hba_file', true) AS HbaFile,
        current_setting('ident_file', true) AS IdentFile;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('PostgreSQL Server / Cluster Identity', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 4 - Host / Operating System Visibility from PostgreSQL
    Purpose: Provide host-related information that is visible from PostgreSQL.
    Important: PostgreSQL does not expose full OS/hardware inventory through standard SQL.
               CPU count, sockets, cores per socket, NUMA, physical memory, and virtualization
               type should be collected from OS/cloud/monitoring tools when needed.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_host_visibility
    SELECT
        inet_server_addr()::text AS ServerIPAddress,
        inet_server_port() AS ServerPort,
        inet_client_addr()::text AS ClientIPAddress,
        inet_client_port() AS ClientPort,
        version() AS PostgreSQLBuildAndHostString,
        'Not available from standard PostgreSQL SQL'::text AS OperatingSystemName,
        'Not available from standard PostgreSQL SQL'::text AS OperatingSystemRelease,
        'Not available from standard PostgreSQL SQL'::text AS OperatingSystemArchitecture,
        'Not available from standard PostgreSQL SQL'::text AS VirtualizationType,
        NULL::integer AS NumOfSockets,
        NULL::integer AS CoresPerSocket,
        NULL::integer AS HostNumOfCores,
        NULL::integer AS NumOfNUMAs,
        NULL::numeric AS PhysicalMemory_GB,
        'Collect OS and hardware details from operating system, cloud provider, VM platform, container platform, or monitoring tool.'::text AS HostResourceCollectionNote;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Host / Operating System Visibility from PostgreSQL', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 5 - Execution Context
    Purpose: Identify who executed the Review and what privileges are visible.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_execution_context
    SELECT
        current_user AS CurrentUser,
        session_user AS SessionUser,
        current_database() AS CurrentDatabaseName,
        r.rolcanlogin AS CanLogin,
        r.rolsuper AS IsSuperuser,
        r.rolcreatedb AS CanCreateDatabase,
        r.rolcreaterole AS CanCreateRole,
        r.rolreplication AS HasReplicationPrivilege,
        r.rolbypassrls AS CanBypassRowLevelSecurity,
        pg_has_role(current_user, 'pg_monitor', 'member') AS HasPgMonitor,
        pg_has_role(current_user, 'pg_read_all_stats', 'member') AS HasPgReadAllStats,
        pg_has_role(current_user, 'pg_read_all_settings', 'member') AS HasPgReadAllSettings,
        pg_has_role(current_user, 'pg_stat_scan_tables', 'member') AS HasPgStatScanTables
    FROM pg_roles r
    WHERE r.rolname = current_user;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Execution Context', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 6 - PostgreSQL Distribution / Flavor Detection
    Purpose: Best-effort detection of PostgreSQL distribution/flavor.
    Detects signals for:
                    - Community PostgreSQL or unknown
                    - Amazon RDS for PostgreSQL / Amazon Aurora PostgreSQL
                    - Azure Database for PostgreSQL
                    - Google Cloud SQL for PostgreSQL
                    - EDB Postgres Advanced Server
    Important:
                This is best-effort detection from SQL only.
                Managed services may hide internal details.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_distribution_detection
    WITH settings AS
    (
        SELECT
            current_setting('server_version', true) AS server_version,
            current_setting('server_version_num', true) AS server_version_num,
            current_setting('rds.extensions', true) AS rds_extensions,
            current_setting('azure.extensions', true) AS azure_extensions,
            current_setting('cloudsql.enable_pglogical', true) AS cloudsql_enable_pglogical,
            current_setting('edb_redwood_date', true) AS edb_redwood_date
    ),
    extensions AS
    (
        SELECT
            bool_or(extname = 'rds_tools') AS has_rds_tools,
            bool_or(extname = 'aws_commons') AS has_aws_commons,
            bool_or(extname = 'aws_s3') AS has_aws_s3,
            bool_or(extname = 'azure_storage') AS has_azure_storage,
            bool_or(extname = 'google_ml_integration') AS has_google_ml_integration,
            bool_or(extname = 'pg_stat_statements') AS has_pg_stat_statements
        FROM pg_extension
    ),
    roles AS
    (
        SELECT
            bool_or(rolname = 'rdsadmin') AS has_rdsadmin_role,
            bool_or(rolname = 'azure_pg_admin') AS has_azure_pg_admin_role,
            bool_or(rolname = 'cloudsqlsuperuser') AS has_cloudsqlsuperuser_role
        FROM pg_roles
    ),
    databases AS
    (
        SELECT
            bool_or(datname = 'rdsadmin') AS has_rdsadmin_database
        FROM pg_database
    )
    SELECT
        CASE
            WHEN settings.server_version ILIKE '%EnterpriseDB%'
              OR settings.server_version ILIKE '%EDB%'
              OR settings.edb_redwood_date IS NOT NULL
            THEN 'EDB Postgres Advanced Server'

            WHEN roles.has_rdsadmin_role
              OR databases.has_rdsadmin_database
              OR settings.rds_extensions IS NOT NULL
              OR extensions.has_rds_tools
              OR extensions.has_aws_commons
              OR extensions.has_aws_s3
            THEN
                CASE
                    WHEN settings.server_version ILIKE '%aurora%'
                    THEN 'Amazon Aurora PostgreSQL'
                    ELSE 'Amazon RDS for PostgreSQL or Amazon Aurora PostgreSQL'
                END

            WHEN roles.has_azure_pg_admin_role
              OR settings.azure_extensions IS NOT NULL
              OR extensions.has_azure_storage
            THEN 'Azure Database for PostgreSQL'

            WHEN roles.has_cloudsqlsuperuser_role
              OR settings.cloudsql_enable_pglogical IS NOT NULL
              OR extensions.has_google_ml_integration
            THEN 'Google Cloud SQL for PostgreSQL'

            ELSE 'PostgreSQL Community or unknown distribution'
        END AS PostgreSQLDistributionFlavor,

        CASE
            WHEN settings.server_version ILIKE '%EnterpriseDB%'
              OR settings.server_version ILIKE '%EDB%'
              OR settings.edb_redwood_date IS NOT NULL
              OR roles.has_rdsadmin_role
              OR databases.has_rdsadmin_database
              OR roles.has_azure_pg_admin_role
              OR roles.has_cloudsqlsuperuser_role
            THEN 'High'

            WHEN settings.rds_extensions IS NOT NULL
              OR settings.azure_extensions IS NOT NULL
              OR settings.cloudsql_enable_pglogical IS NOT NULL
              OR extensions.has_rds_tools
              OR extensions.has_aws_commons
              OR extensions.has_aws_s3
              OR extensions.has_azure_storage
              OR extensions.has_google_ml_integration
            THEN 'Medium'

            ELSE 'Best-effort detection'
        END AS DetectionConfidence,

        settings.server_version AS PostgreSQLVersion,
        settings.server_version_num AS PostgreSQLVersionNum,

        COALESCE(roles.has_rdsadmin_role, false) AS HasRdsAdminRole,
        COALESCE(databases.has_rdsadmin_database, false) AS HasRdsAdminDatabase,
        settings.rds_extensions IS NOT NULL AS RdsExtensionsSettingExists,
        COALESCE(extensions.has_rds_tools, false) AS HasRdsToolsExtension,
        COALESCE(extensions.has_aws_commons, false) AS HasAwsCommonsExtension,
        COALESCE(extensions.has_aws_s3, false) AS HasAwsS3Extension,

        COALESCE(roles.has_azure_pg_admin_role, false) AS HasAzurePgAdminRole,
        settings.azure_extensions IS NOT NULL AS AzureExtensionsSettingExists,
        COALESCE(extensions.has_azure_storage, false) AS HasAzureStorageExtension,

        COALESCE(roles.has_cloudsqlsuperuser_role, false) AS HasCloudSqlSuperuserRole,
        settings.cloudsql_enable_pglogical IS NOT NULL AS CloudSqlPglogicalSettingExists,
        COALESCE(extensions.has_google_ml_integration, false) AS HasGoogleMlIntegrationExtension,

        settings.edb_redwood_date IS NOT NULL AS EdbRedwoodDateSettingExists,
        COALESCE(extensions.has_pg_stat_statements, false) AS HasPgStatStatementsExtension,

        'Best-effort detection from SQL only. Validate with customer/provider documentation when required.'::text AS DetectionNote
    FROM settings
    CROSS JOIN extensions
    CROSS JOIN roles
    CROSS JOIN databases;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('PostgreSQL Distribution / Flavor Detection', SQLERRM);
END $$;


/*  
    ====================================================================================
    Header section 7 - Important PostgreSQL Configuration Values
    Purpose: Collect important PostgreSQL settings for system introduction.
             Values are shown for context only.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_important_settings
    SELECT
        name AS SettingName,
        setting AS SettingValue,
        unit AS Unit,
        category AS Category,
        short_desc AS Description,
        context AS Context,
        vartype AS ValueType,
        boot_val AS BootValue,
        reset_val AS ResetValue,
        source AS Source,
        pending_restart AS PendingRestart
    FROM pg_settings
    WHERE name IN
    (
        'max_connections',
        'superuser_reserved_connections',
        'reserved_connections',

        'shared_buffers',
        'effective_cache_size',
        'work_mem',
        'maintenance_work_mem',
        'autovacuum_work_mem',

        'autovacuum',
        'autovacuum_max_workers',
        'autovacuum_naptime',
        'autovacuum_vacuum_threshold',
        'autovacuum_vacuum_scale_factor',
        'autovacuum_analyze_threshold',
        'autovacuum_analyze_scale_factor',
        'autovacuum_freeze_max_age',

        'checkpoint_timeout',
        'checkpoint_completion_target',
        'max_wal_size',
        'min_wal_size',
        'wal_level',
        'wal_compression',
        'archive_mode',
        'archive_command',
        'archive_library',
        'max_wal_senders',
        'max_replication_slots',
        'wal_keep_size',

        'shared_preload_libraries',
        'track_activities',
        'track_counts',
        'track_io_timing',
        'track_wal_io_timing',

        'log_min_duration_statement',
        'log_temp_files',
        'log_autovacuum_min_duration',
        'log_checkpoints',
        'log_lock_waits',
        'deadlock_timeout',

        'max_worker_processes',
        'max_parallel_workers',
        'max_parallel_workers_per_gather',

        'statement_timeout',
        'lock_timeout',
        'idle_in_transaction_session_timeout',
        'temp_file_limit',

        'default_statistics_target',
        'random_page_cost',
        'seq_page_cost',
        'effective_io_concurrency'
    )
    ORDER BY category, name;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Important PostgreSQL Configuration Values', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 8 - PostgreSQL Licensing Information
    Purpose: Provide licensing context.
    Notes: PostgreSQL Community Edition is open-source and does not have per-core licensing limits.
           Managed services and commercial distributions may have provider-specific pricing or subscription models.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_licensing
    SELECT
        'PostgreSQL License'::text AS LicensingCategory,
        'PostgreSQL is released under the PostgreSQL License, a liberal open-source license.'::text AS LicensingInformation,
        'PostgreSQL Community does not use socket/core licensing. Managed services and commercial distributions may have provider-specific pricing or subscriptions.'::text AS LicensingNote;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('PostgreSQL Licensing Information', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 9 - Databases List
    Purpose: List databases in the PostgreSQL cluster.
    Notes: PostgreSQL has multiple databases inside a cluster.
           Object-level checks usually apply only to the database where the script runs.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_databases
    SELECT
        d.datname::text AS DatabaseName,
        pg_get_userbyid(d.datdba)::text AS OwnerName,
        d.datallowconn AS AllowConnections,
        d.datistemplate AS IsTemplate,
        d.datconnlimit AS ConnectionLimit,
        pg_encoding_to_char(d.encoding)::text AS DatabaseEncoding,
        d.datcollate::text AS DatabaseCollation,
        d.datctype::text AS DatabaseCType,
        CASE
            WHEN d.datallowconn THEN pg_size_pretty(pg_database_size(d.datname))
            ELSE NULL
        END AS DatabaseSize,
        CASE
            WHEN d.datallowconn THEN pg_database_size(d.datname)
            ELSE NULL
        END AS DatabaseSizeBytes
    FROM pg_database d
    ORDER BY d.datistemplate, d.datname;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Databases List', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 10 - Current Database Session Defaults
    Purpose: Show session/default values relevant to the current database connection.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_current_database_session
    SELECT
        current_database() AS DatabaseName,
        current_setting('client_encoding', true) AS ClientEncoding,
        current_setting('server_encoding', true) AS ServerEncoding,
        current_setting('DateStyle', true) AS DateStyle,
        current_setting('TimeZone', true) AS TimeZone,
        current_setting('IntervalStyle', true) AS IntervalStyle,
        current_setting('standard_conforming_strings', true) AS StandardConformingStrings,
        current_setting('default_transaction_isolation', true) AS DefaultTransactionIsolation,
        current_setting('transaction_isolation', true) AS CurrentTransactionIsolation,
        current_setting('transaction_read_only', true) AS TransactionReadOnly,
        current_setting('statement_timeout', true) AS StatementTimeout,
        current_setting('lock_timeout', true) AS LockTimeout,
        current_setting('idle_in_transaction_session_timeout', true) AS IdleInTransactionSessionTimeout,
        current_setting('search_path', true) AS SearchPath;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Current Database Session Defaults', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 11 - Tablespaces
    Purpose: List PostgreSQL tablespaces.
    Notes: PostgreSQL tablespaces represent locations in the filesystem.
           Filesystem free space is not available through standard SQL.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_tablespaces
    SELECT
        t.spcname::text AS TablespaceName,
        pg_get_userbyid(t.spcowner)::text AS OwnerName,
        pg_tablespace_location(t.oid)::text AS TablespaceLocation,
        t.spcoptions AS TablespaceOptions
    FROM pg_tablespace t
    ORDER BY t.spcname;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Tablespaces', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 12 - Installed Extensions in Current Database
    Purpose: List extensions installed in the current database.
    Notes: Extensions are database-level in PostgreSQL.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_extensions
    SELECT
        e.extname::text AS ExtensionName,
        e.extversion::text AS ExtensionVersion,
        n.nspname::text AS SchemaName,
        e.extrelocatable AS IsRelocatable
    FROM pg_extension e
    JOIN pg_namespace n
        ON n.oid = e.extnamespace
    ORDER BY e.extname;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Installed Extensions in Current Database', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 13 - Current Database Statistics Snapshot
    Purpose: Show high-level statistics for the current database.
    Notes: These counters are cumulative since statistics reset.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_database_statistics
    SELECT
        datname::text AS DatabaseName,
        numbackends AS CurrentBackends,
        xact_commit AS TransactionsCommitted,
        xact_rollback AS TransactionsRolledBack,
        blks_read AS BlocksReadFromDisk,
        blks_hit AS BlocksHitInCache,
        CASE
            WHEN blks_hit + blks_read > 0
            THEN round((blks_hit::numeric / (blks_hit + blks_read)) * 100, 2)
            ELSE NULL
        END AS CacheHitPercent,
        tup_returned AS TuplesReturned,
        tup_fetched AS TuplesFetched,
        tup_inserted AS TuplesInserted,
        tup_updated AS TuplesUpdated,
        tup_deleted AS TuplesDeleted,
        conflicts AS Conflicts,
        temp_files AS TempFiles,
        pg_size_pretty(temp_bytes) AS TempBytes,
        temp_bytes AS TempBytesRaw,
        deadlocks AS Deadlocks,
        blk_read_time AS BlockReadTimeMs,
        blk_write_time AS BlockWriteTimeMs,
        stats_reset AS StatisticsResetTime
    FROM pg_stat_database
    WHERE datname = current_database();

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Current Database Statistics Snapshot', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 14 - Activity Summary
    Purpose: Provide high-level current connection/session summary.
    Notes: This is a runtime snapshot.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_activity_summary
    SELECT
        count(*) AS TotalConnections,
        count(*) FILTER (WHERE state = 'active') AS ActiveConnections,
        count(*) FILTER (WHERE state = 'idle') AS IdleConnections,
        count(*) FILTER (WHERE state = 'idle in transaction') AS IdleInTransactionConnections,
        count(*) FILTER (WHERE wait_event_type = 'Lock') AS SessionsWaitingOnLocks,
        count(DISTINCT usename) AS DistinctUsers,
        count(DISTINCT application_name) AS DistinctApplications,
        count(DISTINCT client_addr) AS DistinctClientAddresses,
        min(backend_start) AS OldestBackendStart,
        min(xact_start) FILTER (WHERE xact_start IS NOT NULL) AS OldestTransactionStart,
        min(query_start) FILTER (WHERE query_start IS NOT NULL) AS OldestQueryStart
    FROM pg_stat_activity;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Activity Summary', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 15 - Replication and Recovery State
    Purpose: Provide high-level replication/recovery information.
    Notes: This is not a replication health check.
           It is only system introduction information.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_replication_state
    SELECT
        pg_is_in_recovery() AS IsInRecovery,
        current_setting('wal_level', true) AS WalLevel,
        current_setting('archive_mode', true) AS ArchiveMode,
        current_setting('max_wal_senders', true) AS MaxWalSenders,
        current_setting('max_replication_slots', true) AS MaxReplicationSlots,
        current_setting('wal_keep_size', true) AS WalKeepSize,
        (
            SELECT count(*)
            FROM pg_stat_replication
        ) AS ConnectedStandbyCount,
        (
            SELECT count(*)
            FROM pg_replication_slots
        ) AS ReplicationSlotCount,
        (
            SELECT count(*)
            FROM pg_replication_slots
            WHERE active
        ) AS ActiveReplicationSlotCount;

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Replication and Recovery State', SQLERRM);
END $$;


/*
    ====================================================================================
    Header section 16 - Capability Summary
    Purpose: Show which optional PostgreSQL capabilities/views/extensions are available.
             This is useful for understanding what later checks can use.
    ====================================================================================
*/

DO $$
BEGIN
    INSERT INTO pg_review_header_capabilities
    SELECT
        'pg_stat_statements extension installed in current database' AS CapabilityName,
        EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_stat_statements') AS IsAvailable
    UNION ALL
    SELECT
        'pg_stat_statements view visible',
        to_regclass('public.pg_stat_statements') IS NOT NULL
        OR to_regclass('pg_catalog.pg_stat_statements') IS NOT NULL
    UNION ALL
    SELECT
        'pg_stat_checkpointer view available',
        to_regclass('pg_catalog.pg_stat_checkpointer') IS NOT NULL
    UNION ALL
    SELECT
        'pg_stat_io view available',
        to_regclass('pg_catalog.pg_stat_io') IS NOT NULL
    UNION ALL
    SELECT
        'pg_stat_wal view available',
        to_regclass('pg_catalog.pg_stat_wal') IS NOT NULL
    UNION ALL
    SELECT
        'Current user has pg_monitor',
        pg_has_role(current_user, 'pg_monitor', 'member')
    UNION ALL
    SELECT
        'Current user has pg_read_all_stats',
        pg_has_role(current_user, 'pg_read_all_stats', 'member')
    UNION ALL
    SELECT
        'Current user has pg_read_all_settings',
        pg_has_role(current_user, 'pg_read_all_settings', 'member')
    UNION ALL
    SELECT
        'Current database TEMP privilege',
        has_database_privilege(current_user, current_database(), 'TEMP');

EXCEPTION WHEN OTHERS THEN
    INSERT INTO pg_review_header_errors(SectionName, ErrorMessage)
    VALUES ('Capability Summary', SQLERRM);
END $$;




/*
    ====================================================================================
    Check #1: pg_stat_statements is Missing or Not Fully Enabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 1;
    v_CheckTitle          text    := $check_title$pg_stat_statements is Missing or Not Fully Enabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/*
    DESCRIPTION:

    What This Means: pg_stat_statements is missing or not fully enabled.
        Without it, workload-level query analysis is limited.

    Recommendations:
        Enable pg_stat_statements using the appropriate PostgreSQL or managed-service configuration.
        This may require shared_preload_libraries, a restart, and CREATE EXTENSION in relevant databases.

    Scope : cluster-level
    Category : Monitor

    More info:
        https://www.postgresql.org/docs/current/pgstatstatements.html
        https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-SHARED-PRELOAD-LIBRARIES
*/

v_AdditionalInfo :=
(
    WITH pgss_status AS
    (
        SELECT
            EXISTS
            (
                SELECT 1
                FROM pg_extension
                WHERE extname = 'pg_stat_statements'
            ) AS ExtensionInstalledInCurrentDatabase,

            COALESCE(current_setting('shared_preload_libraries', true), '') ILIKE '%pg_stat_statements%' AS LoadedInSharedPreloadLibraries,

            to_regclass('public.pg_stat_statements') IS NOT NULL
            OR to_regclass('pg_catalog.pg_stat_statements') IS NOT NULL AS PgStatStatementsViewVisible,

            current_setting('shared_preload_libraries', true) AS SharedPreloadLibraries
    )
    SELECT
        CASE
            WHEN ExtensionInstalledInCurrentDatabase
             AND LoadedInSharedPreloadLibraries
             AND PgStatStatementsViewVisible
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'CurrentDatabase', current_database(),
                    'ExtensionInstalledInCurrentDatabase', ExtensionInstalledInCurrentDatabase,
                    'LoadedInSharedPreloadLibraries', LoadedInSharedPreloadLibraries,
                    'PgStatStatementsViewVisible', PgStatStatementsViewVisible,
                    'SharedPreloadLibraries', SharedPreloadLibraries,
                    'FindingReason',
                        CASE
                            WHEN NOT LoadedInSharedPreloadLibraries
                                THEN 'pg_stat_statements is not listed in shared_preload_libraries.'
                            WHEN NOT ExtensionInstalledInCurrentDatabase
                                THEN 'pg_stat_statements extension is not installed in the current database.'
                            WHEN NOT PgStatStatementsViewVisible
                                THEN 'pg_stat_statements view is not visible to the current user or is not available.'
                            ELSE
                                'pg_stat_statements is not fully available.'
                        END,
                    'Note', 'pg_stat_statements requires both cluster-level preload configuration and database-level extension creation.'
                )
        END
    FROM pgss_status
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster/database-level',
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN false
        ELSE
            true
    END,
    3,      -- High
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 0  -- None
        ELSE
            3  -- High
    END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 0  -- None
        ELSE
            2  -- Medium
    END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 0  -- None
        ELSE
            1  -- Low
    END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'pg_stat_statements is installed, loaded, and visible in the current database.'
        ELSE
            'Enable pg_stat_statements in a controlled way to support workload-level query analysis. This may require shared_preload_libraries configuration and a PostgreSQL restart depending on the environment. The extension must also be created in each relevant database where query statistics are required.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #2: Autovacuum is Disabled Globally
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 2;
    v_CheckTitle          text    := $check_title$Autovacuum is Disabled Globally$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: autovacuum is disabled globally.
        This can cause bloat, stale statistics, and wraparound risk.

    Recommendations:
        Enable autovacuum unless a documented manual maintenance process exists.
        Review autovacuum settings before changing cluster-wide configuration.

    Scope : cluster-level
    Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
        https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN current_setting('autovacuum', true) = 'on'
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Autovacuum', current_setting('autovacuum', true),
                    'TrackCounts', current_setting('track_counts', true),
                    'FindingReason', 'autovacuum is disabled at the PostgreSQL cluster level.'
                )
        END
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,      -- High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Autovacuum is enabled globally.'
        ELSE
            'Enable autovacuum globally unless there is a documented and reliable manual maintenance process.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #3: Tables with Autovacuum Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 3;
    v_CheckTitle          text    := $check_title$Tables with Autovacuum Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: one or more user tables have autovacuum disabled.
        This can cause dead tuple accumulation, bloat, and stale statistics.

    Recommendations:
        Review tables with autovacuum_enabled=false and enable autovacuum where possible.
        Keep autovacuum disabled only when a reliable manual process exists.

    Scope : database-level
    Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
        https://www.postgresql.org/docs/current/sql-createtable.html
*/

v_AdditionalInfo :=
(
    WITH tables_with_disabled_autovacuum AS
    (
        SELECT
            n.nspname AS SchemaName,
            c.relname AS TableName,
            c.reloptions AS RelOptions
        FROM pg_class c
        JOIN pg_namespace n
            ON n.oid = c.relnamespace
        WHERE c.relkind IN ('r', 'p')
          AND n.nspname NOT IN ('pg_catalog', 'information_schema')
          AND c.reloptions::text ILIKE '%autovacuum_enabled=false%'
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'RelOptions', RelOptions
                        )
                        ORDER BY SchemaName, TableName
                    )
                )
        END
    FROM tables_with_disabled_autovacuum
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,      -- High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No user tables with autovacuum disabled were detected.'
        ELSE
            'Review tables where autovacuum is disabled. Enable autovacuum unless a documented manual maintenance process exists.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production/Development';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #4: Tables with High Dead Tuple Ratio
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 4;
    v_CheckTitle          text    := $check_title$Tables with High Dead Tuple Ratio$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: tables have a high dead tuple ratio.
        This may indicate autovacuum is not keeping up or long transactions exist.

    Recommendations:
        Investigate autovacuum behavior, table churn, and long-running transactions.
        Do not use VACUUM FULL as the default remediation.

     Scope : Database-level
     Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo :=
(
    WITH candidate_tables AS
    (
        SELECT
            schemaname AS SchemaName,
            relname AS TableName,
            n_live_tup AS LiveTuples,
            n_dead_tup AS DeadTuples,
            round((n_dead_tup::numeric / NULLIF(n_live_tup + n_dead_tup, 0)) * 100, 2) AS DeadTuplePercent,
            last_autovacuum AS LastAutovacuum,
            last_autoanalyze AS LastAutoanalyze
        FROM pg_stat_user_tables
        WHERE n_live_tup > 10000
          AND n_dead_tup::numeric / NULLIF(n_live_tup + n_dead_tup, 0) > 0.20
        ORDER BY n_dead_tup DESC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumLiveTuples', 10000,
                        'DeadTupleRatioPercent', 20
                    ),
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'LiveTuples', LiveTuples,
                            'DeadTuples', DeadTuples,
                            'DeadTuplePercent', DeadTuplePercent,
                            'LastAutovacuum', LastAutovacuum,
                            'LastAutoanalyze', LastAutoanalyze
                        )
                        ORDER BY DeadTuples DESC
                    )
                )
        END
    FROM candidate_tables
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,      -- High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No tables with high dead tuple ratio were detected.'
        ELSE
            'Investigate autovacuum behavior and table churn. Consider regular VACUUM, autovacuum tuning, REINDEX CONCURRENTLY, pg_repack, or planned maintenance options.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #5: Large Tables Without Recent Autovacuum or Autoanalyze
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 5;
    v_CheckTitle          text    := $check_title$Large Tables Without Recent Autovacuum or Autoanalyze$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: large tables do not show recent autovacuum or autoanalyze activity.
        Missing maintenance activity can lead to stale statistics and poor query plans.

    Recommendations:
        Review autovacuum configuration and table-level storage parameters.
        Confirm whether manual maintenance or recent statistics reset explains the result.

    Scope : Database-level
    Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/planner-stats.html
*/

v_AdditionalInfo :=
(
    WITH candidate_tables AS
    (
        SELECT
            schemaname AS SchemaName,
            relname AS TableName,
            n_live_tup AS LiveTuples,
            last_autovacuum AS LastAutovacuum,
            last_autoanalyze AS LastAutoanalyze,
            autovacuum_count AS AutovacuumCount,
            autoanalyze_count AS AutoanalyzeCount
        FROM pg_stat_user_tables
        WHERE n_live_tup > 100000
          AND
          (
              last_autovacuum IS NULL
              OR last_autoanalyze IS NULL
          )
        ORDER BY n_live_tup DESC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumLiveTuples', 100000
                    ),
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'LiveTuples', LiveTuples,
                            'LastAutovacuum', LastAutovacuum,
                            'LastAutoanalyze', LastAutoanalyze,
                            'AutovacuumCount', AutovacuumCount,
                            'AutoanalyzeCount', AutoanalyzeCount
                        )
                        ORDER BY LiveTuples DESC
                    )
                )
        END
    FROM candidate_tables
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,      -- High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No large tables without recent autovacuum or autoanalyze activity were detected.'
        ELSE
            'Review autovacuum and autoanalyze activity for large tables. Missing or stale statistics can lead to poor execution plans.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #6: Long Running Active Queries
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 6;
    v_CheckTitle          text    := $check_title$Long Running Active Queries$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: active queries are running longer than the configured threshold.
        Long-running queries may consume resources and delay other workload.

    Recommendations:
        Review query purpose, execution plan, wait events, and application behavior.
        Do not terminate sessions automatically without business validation.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
*/

v_AdditionalInfo :=
(
    WITH long_running_queries AS
    (
        SELECT
            pid AS ProcessId,
            usename AS UserName,
            datname AS DatabaseName,
            application_name AS ApplicationName,
            client_addr::text AS ClientAddress,
            state AS SessionState,
            wait_event_type AS WaitEventType,
            wait_event AS WaitEvent,
            query_start AS QueryStartTime,
            now() - query_start AS QueryDuration,
            left(query, 500) AS QuerySample
        FROM pg_stat_activity
        WHERE pid <> pg_backend_pid()
          AND backend_type = 'client backend'
          AND state = 'active'
          AND query_start IS NOT NULL
          AND now() - query_start > interval '30 minutes'
        ORDER BY query_start ASC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Threshold', '30 minutes',
                    'Sessions',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'ProcessId', ProcessId,
                            'UserName', UserName,
                            'DatabaseName', DatabaseName,
                            'ApplicationName', ApplicationName,
                            'ClientAddress', ClientAddress,
                            'SessionState', SessionState,
                            'WaitEventType', WaitEventType,
                            'WaitEvent', WaitEvent,
                            'QueryStartTime', QueryStartTime,
                            'QueryDuration', QueryDuration,
                            'QuerySample', QuerySample
                        )
                        ORDER BY QueryStartTime ASC
                    )
                )
        END
    FROM long_running_queries
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Concurrency',
    'Cluster/session-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No long-running active queries above the threshold were detected.'
        ELSE
            'Review long-running active queries, their wait events, execution plans, and application context. Terminate sessions only after business validation.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production/Development';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #7: Sessions Idle in Transaction
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 7;
    v_CheckTitle          text    := $check_title$Sessions Idle in Transaction$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: sessions are idle while holding an open transaction.
        This can block vacuum cleanup, hold locks, and increase bloat risk.

    Recommendations:
        Review the application/session behavior and close transactions promptly.
        Consider idle_in_transaction_session_timeout after validating application impact.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/runtime-config-client.html
*/

v_AdditionalInfo :=
(
    WITH idle_transactions AS
    (
        SELECT
            pid AS ProcessId,
            usename AS UserName,
            datname AS DatabaseName,
            application_name AS ApplicationName,
            client_addr::text AS ClientAddress,
            state AS SessionState,
            xact_start AS TransactionStartTime,
            now() - xact_start AS TransactionDuration,
            wait_event_type AS WaitEventType,
            wait_event AS WaitEvent,
            left(query, 500) AS QuerySample
        FROM pg_stat_activity
        WHERE pid <> pg_backend_pid()
          AND backend_type = 'client backend'
          AND state = 'idle in transaction'
          AND xact_start IS NOT NULL
          AND now() - xact_start > interval '5 minutes'
        ORDER BY xact_start ASC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Threshold', '5 minutes',
                    'Sessions',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'ProcessId', ProcessId,
                            'UserName', UserName,
                            'DatabaseName', DatabaseName,
                            'ApplicationName', ApplicationName,
                            'ClientAddress', ClientAddress,
                            'SessionState', SessionState,
                            'TransactionStartTime', TransactionStartTime,
                            'TransactionDuration', TransactionDuration,
                            'WaitEventType', WaitEventType,
                            'WaitEvent', WaitEvent,
                            'QuerySample', QuerySample
                        )
                        ORDER BY TransactionStartTime ASC
                    )
                )
        END
    FROM idle_transactions
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Concurrency',
    'Cluster/session-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No idle-in-transaction sessions above the threshold were detected.'
        ELSE
            'Investigate sessions that remain idle inside open transactions. Consider application fixes and a controlled idle_in_transaction_session_timeout configuration if appropriate.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production/Development';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #8: User Tables Without Any Index
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 8;
    v_CheckTitle          text    := $check_title$User Tables Without Any Index$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: user tables were found without any indexes.
        This may cause full table scans and poor performance as data grows.

    Recommendations:
        Review access patterns before adding indexes.
        For large active tables, prefer CREATE INDEX CONCURRENTLY where appropriate.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/indexes.html
        https://www.postgresql.org/docs/current/sql-createindex.html
*/

v_AdditionalInfo :=
(
    WITH tables_without_indexes AS
    (
        SELECT
            n.nspname AS SchemaName,
            c.relname AS TableName,
            c.reltuples::bigint AS EstimatedRows,
            pg_total_relation_size(c.oid) AS TotalSizeBytes,
            pg_size_pretty(pg_total_relation_size(c.oid)) AS TotalSize
        FROM pg_class c
        JOIN pg_namespace n
            ON n.oid = c.relnamespace
        WHERE c.relkind = 'r'
          AND c.relpersistence = 'p'
          AND n.nspname NOT IN ('pg_catalog', 'information_schema')
          AND n.nspname NOT LIKE 'pg_toast%'
          AND NOT EXISTS
          (
              SELECT 1
              FROM pg_index i
              WHERE i.indrelid = c.oid
          )
          AND
          (
              c.reltuples > 1000
              OR pg_total_relation_size(c.oid) > 10485760
          )
        ORDER BY pg_total_relation_size(c.oid) DESC, n.nspname, c.relname
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumEstimatedRows', 1000,
                        'MinimumTotalSizeBytes', 10485760
                    ),
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'EstimatedRows', EstimatedRows,
                            'TotalSize', TotalSize,
                            'TotalSizeBytes', TotalSizeBytes
                        )
                        ORDER BY TotalSizeBytes DESC
                    )
                )
        END
    FROM tables_without_indexes
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Indexing',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No relevant user tables without indexes were detected.'
        ELSE
            'Review table access patterns before adding indexes. For large active tables, use CONCURRENTLY-aware rollout planning and validate resource impact.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production/Development';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #9: Tables with Stale or Missing Statistics
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 9;
    v_CheckTitle          text    := $check_title$Tables with Stale or Missing Statistics$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: tables have stale or missing planner statistics.
        Stale statistics can lead to poor query plans and unstable performance.

    Recommendations:
        Review autovacuum/analyze behavior and recent table changes.
        Run ANALYZE where appropriate and tune autovacuum if this repeats.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/planner-stats.html
        https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo :=
(
    WITH stale_statistics AS
    (
        SELECT
            schemaname AS SchemaName,
            relname AS TableName,
            n_live_tup AS EstimatedLiveRows,
            n_mod_since_analyze AS RowsModifiedSinceAnalyze,
            last_analyze AS LastAnalyze,
            last_autoanalyze AS LastAutoAnalyze,
            COALESCE(last_analyze, last_autoanalyze) AS LastStatisticsUpdate
        FROM pg_stat_user_tables
        WHERE n_live_tup > 1000
          AND
          (
              COALESCE(last_analyze, last_autoanalyze) < now() - interval '7 days'
              OR
              (
                  last_analyze IS NULL
                  AND last_autoanalyze IS NULL
                  AND n_mod_since_analyze > 0
              )
          )
        ORDER BY
            LastStatisticsUpdate NULLS FIRST,
            n_mod_since_analyze DESC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumEstimatedLiveRows', 1000,
                        'StatisticsAgeThreshold', '7 days'
                    ),
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'EstimatedLiveRows', EstimatedLiveRows,
                            'RowsModifiedSinceAnalyze', RowsModifiedSinceAnalyze,
                            'LastAnalyze', LastAnalyze,
                            'LastAutoAnalyze', LastAutoAnalyze,
                            'LastStatisticsUpdate', LastStatisticsUpdate
                        )
                        ORDER BY LastStatisticsUpdate NULLS FIRST
                    )
                )
        END
    FROM stale_statistics
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Statistics',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No relevant tables with stale or missing statistics were detected.'
        ELSE
            'Review stale or missing table statistics. Run ANALYZE where appropriate and investigate whether autovacuum/autoanalyze is keeping up with table changes.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #10: Approximate Table Bloat Indicators
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 10;
    v_CheckTitle          text    := $check_title$Approximate Table Bloat Indicators$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: large tables show possible bloat indicators.
        This is an approximate signal based on PostgreSQL statistics, not exact bloat measurement.

    Recommendations:
        Investigate autovacuum behavior, table churn, and long transactions.
        Consider VACUUM, REINDEX CONCURRENTLY, pg_repack, or planned maintenance options.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo :=
(
    WITH candidate_tables AS
    (
        SELECT
            s.schemaname AS SchemaName,
            s.relname AS TableName,
            s.n_live_tup AS EstimatedLiveTuples,
            s.n_dead_tup AS EstimatedDeadTuples,
            round
            (
                s.n_dead_tup::numeric
                / NULLIF(s.n_live_tup + s.n_dead_tup, 0)
                * 100,
                2
            ) AS EstimatedDeadTuplePercent,
            pg_total_relation_size(c.oid) AS TotalSizeBytes,
            pg_size_pretty(pg_total_relation_size(c.oid)) AS TotalSize,
            s.last_vacuum AS LastVacuum,
            s.last_autovacuum AS LastAutovacuum,
            s.last_analyze AS LastAnalyze,
            s.last_autoanalyze AS LastAutoAnalyze,
            s.vacuum_count AS VacuumCount,
            s.autovacuum_count AS AutovacuumCount
        FROM pg_stat_user_tables s
        JOIN pg_class c
            ON c.oid = s.relid
        WHERE pg_total_relation_size(c.oid) > 1073741824
          AND s.n_live_tup > 10000
          AND s.n_dead_tup::numeric / NULLIF(s.n_live_tup + s.n_dead_tup, 0) > 0.10
        ORDER BY
            pg_total_relation_size(c.oid) DESC,
            s.n_dead_tup DESC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'ImportantNote', 'This is an approximate bloat indicator based on PostgreSQL statistics, not exact bloat measurement.',
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumTableSizeBytes', 1073741824,
                        'MinimumTableSize', '1 GB',
                        'MinimumEstimatedLiveTuples', 10000,
                        'EstimatedDeadTuplePercentThreshold', 10
                    ),
                    'Tables',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'TotalSize', TotalSize,
                            'TotalSizeBytes', TotalSizeBytes,
                            'EstimatedLiveTuples', EstimatedLiveTuples,
                            'EstimatedDeadTuples', EstimatedDeadTuples,
                            'EstimatedDeadTuplePercent', EstimatedDeadTuplePercent,
                            'LastVacuum', LastVacuum,
                            'LastAutovacuum', LastAutovacuum,
                            'LastAnalyze', LastAnalyze,
                            'LastAutoAnalyze', LastAutoAnalyze,
                            'VacuumCount', VacuumCount,
                            'AutovacuumCount', AutovacuumCount
                        )
                        ORDER BY TotalSizeBytes DESC
                    )
                )
        END
    FROM candidate_tables
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No large tables with approximate bloat indicators were detected.'
        ELSE
            'Investigate possible table bloat indicators. Review autovacuum behavior, table churn, and long-running transactions. Do not use VACUUM FULL as the default remediation.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #11: Large Indexes with Zero Scans
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 11;
    v_CheckTitle          text    := $check_title$Large Indexes with Zero Scans$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        Indexing: large indexes have zero recorded scans.
        This may indicate unused indexes, but counters must be validated before action.

    Recommendations:
        Validate over a full business cycle before dropping indexes.
        Check constraints, rare reports, maintenance jobs, and statistics reset time.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/indexes.html
*/

v_AdditionalInfo :=
(
    WITH large_zero_scan_indexes AS
    (
        SELECT
            s.schemaname AS SchemaName,
            s.relname AS TableName,
            s.indexrelname AS IndexName,
            s.idx_scan AS IndexScans,
            pg_relation_size(s.indexrelid) AS IndexSizeBytes,
            pg_size_pretty(pg_relation_size(s.indexrelid)) AS IndexSize,
            i.indisunique AS IsUnique,
            i.indisprimary AS IsPrimaryKey,
            i.indisexclusion AS IsExclusionConstraint,
            d.stats_reset AS DatabaseStatisticsResetTime
        FROM pg_stat_user_indexes s
        JOIN pg_index i
            ON i.indexrelid = s.indexrelid
        LEFT JOIN pg_stat_database d
            ON d.datname = current_database()
        WHERE s.idx_scan = 0
          AND pg_relation_size(s.indexrelid) > 104857600
        ORDER BY pg_relation_size(s.indexrelid) DESC
        LIMIT 50
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0
                THEN NULL::jsonb
            ELSE
                jsonb_build_object
                (
                    'ImportantNote', 'Zero scans alone is not enough evidence to drop an index.',
                    'Thresholds',
                    jsonb_build_object
                    (
                        'MinimumIndexSizeBytes', 104857600,
                        'MinimumIndexSize', '100 MB',
                        'IndexScans', 0
                    ),
                    'ValidationRequired',
                    jsonb_build_array
                    (
                        'Validate usage over a full business cycle.',
                        'Check whether the index supports constraints or unique enforcement.',
                        'Check rare reports, batch jobs, maintenance jobs, and application releases.',
                        'Check the database statistics reset time before making a decision.'
                    ),
                    'Indexes',
                    jsonb_agg
                    (
                        jsonb_build_object
                        (
                            'SchemaName', SchemaName,
                            'TableName', TableName,
                            'IndexName', IndexName,
                            'IndexSize', IndexSize,
                            'IndexSizeBytes', IndexSizeBytes,
                            'IndexScans', IndexScans,
                            'IsUnique', IsUnique,
                            'IsPrimaryKey', IsPrimaryKey,
                            'IsExclusionConstraint', IsExclusionConstraint,
                            'DatabaseStatisticsResetTime', DatabaseStatisticsResetTime
                        )
                        ORDER BY IndexSizeBytes DESC
                    )
                )
        END
    FROM large_zero_scan_indexes
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Indexing',
    'Object-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No large indexes with zero scans were detected.'
        ELSE
            'Review large indexes with zero scans. Do not drop indexes based only on zero scans; validate over a full business cycle and check constraints, rare reports, maintenance jobs, and statistics reset time.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production/Development';


            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #12: Connection Usage is High
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 12;
    v_CheckTitle          text    := $check_title$Connection Usage is High$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: PostgreSQL connection usage is high (active connections are
        approaching max_connections). As usage nears the limit, the cluster risks
        rejecting new connections with "FATAL: too many connections", including
        the connections reserved for superuser/administrative tasks.

    Recommendations:
        Review application connection behavior, idle-in-transaction sessions, and
        long-lived idle connections. Introduce or tune a connection pooler
        (e.g. PgBouncer) so many client connections share a small pool of backend
        connections, rather than raising max_connections indiscriminately.
        Raising max_connections increases per-backend memory (work_mem, shared
        memory overhead) and should only be done after benchmarking and with
        adequate RAM headroom. Always keep superuser_reserved_connections
        available for administrative access.

    Scope : cluster-level
    Category : Connections

    More info:
        https://www.postgresql.org/docs/current/runtime-config-connection.html#GUC-MAX-CONNECTIONS
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW
        https://www.pgbouncer.org/config.html
*/

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN connection_usage_percent < 80 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'MaxConnections', max_connections,
                'ActiveConnections', active_connections,
                'ConnectionUsagePercent', connection_usage_percent,
                'ReservedSuperuserConnections', reserved_superuser_connections,
                'FindingReason', 'PostgreSQL connection usage is high.'
            )
        END
    FROM
    (
        SELECT
            current_setting('max_connections')::int AS max_connections,
            current_setting('superuser_reserved_connections')::int AS reserved_superuser_connections,
            COUNT(*)::int AS active_connections,
            ROUND
            (
                COUNT(*)::numeric
                / NULLIF(current_setting('max_connections')::numeric, 0) * 100,
                2
            ) AS connection_usage_percent
        FROM pg_stat_activity
    ) s
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Connections',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Connection usage is within the expected range.'
        ELSE
            'Review application connection behavior, connection pooling, idle sessions, and max_connections configuration.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';

            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #13: Lock Waits and Blocking Chains Detected
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 13;
    v_CheckTitle          text    := $check_title$Lock Waits and Blocking Chains Detected$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: One or more sessions are currently waiting to acquire locks
        because other sessions (blockers) are holding conflicting locks. When a
        blocker holds a lock for a long time, waiters queue up behind it, and a
        single slow query, an idle-in-transaction session, or a DDL statement
        (e.g. ALTER TABLE requiring AccessExclusiveLock) can cascade into a chain
        that stalls many otherwise-fast queries and causes application timeouts.

    Recommendations:
        Identify the root blocker at the head of the chain (the session others are
        ultimately waiting on) and decide on corrective action based on the
        application: cancel the offending statement with pg_cancel_backend(pid) or,
        if necessary, terminate it with pg_terminate_backend(pid). Look for
        idle-in-transaction sessions and long-running transactions that hold locks
        longer than needed. To prevent recurrence, set a session-level lock_timeout
        so statements give up rather than block others indefinitely, keep
        transactions short, avoid long-lived DDL during peak hours, and add or fix
        indexes that reduce lock duration. Enabling log_lock_waits (with a suitable
        deadlock_timeout) records slow lock acquisition in the server log for later
        analysis.

    Scope : database-level
    Category : Concurrency

    More info:
        https://www.postgresql.org/docs/current/view-pg-locks.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW
        https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-LOCK-TIMEOUT
        https://wiki.postgresql.org/wiki/Lock_Monitoring
*/

v_AdditionalInfo :=
(
    WITH blocked_sessions AS
    (
        SELECT
            blocked.pid AS blocked_pid,
            blocked.usename AS blocked_user,
            blocked.datname AS blocked_database,
            blocked.application_name AS blocked_application,
            blocked.client_addr AS blocked_client_addr,
            blocked.state AS blocked_state,
            blocked.wait_event_type,
            blocked.wait_event,
            now() - blocked.query_start AS blocked_query_age,
            left(blocked.query, 500) AS blocked_query,
            blocker.pid AS blocker_pid,
            blocker.usename AS blocker_user,
            blocker.datname AS blocker_database,
            blocker.application_name AS blocker_application,
            blocker.client_addr AS blocker_client_addr,
            blocker.state AS blocker_state,
            now() - blocker.query_start AS blocker_query_age,
            now() - blocker.xact_start AS blocker_transaction_age,
            left(blocker.query, 500) AS blocker_query
        FROM pg_stat_activity blocked
        JOIN LATERAL unnest(pg_blocking_pids(blocked.pid)) AS blocking_pid ON true
        JOIN pg_stat_activity blocker ON blocker.pid = blocking_pid
        WHERE blocked.wait_event_type = 'Lock'
    )
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more sessions are waiting on locks and have blocking sessions.',
                'BlockedSessionCount', COUNT(*),
                'BlockingChains',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'BlockedPid', blocked_pid,
                        'BlockedUser', blocked_user,
                        'BlockedDatabase', blocked_database,
                        'BlockedApplication', blocked_application,
                        'BlockedClientAddress', blocked_client_addr,
                        'BlockedState', blocked_state,
                        'WaitEventType', wait_event_type,
                        'WaitEvent', wait_event,
                        'BlockedQueryAge', blocked_query_age,
                        'BlockedQuery', blocked_query,
                        'BlockerPid', blocker_pid,
                        'BlockerUser', blocker_user,
                        'BlockerDatabase', blocker_database,
                        'BlockerApplication', blocker_application,
                        'BlockerClientAddress', blocker_client_addr,
                        'BlockerState', blocker_state,
                        'BlockerQueryAge', blocker_query_age,
                        'BlockerTransactionAge', blocker_transaction_age,
                        'BlockerQuery', blocker_query
                    )
                    ORDER BY blocked_query_age DESC
                )
            )
        END
    FROM blocked_sessions
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Concurrency',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No current lock waits or blocking chains were detected.'
        ELSE
            'Investigate blocking sessions, long transactions, application locking behavior, and missing indexes that may increase lock duration.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #14: Long Running Transactions
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 14;
    v_CheckTitle          text    := $check_title$Long Running Transactions$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: One or more transactions have been open for a long time
        (over the 30-minute threshold). A transaction that stays open — whether
        actively running or sitting "idle in transaction" — holds its snapshot
        and any acquired locks for its entire lifetime. Because of MVCC, this
        prevents VACUUM/autovacuum from cleaning up dead tuples newer than the
        transaction's xmin, which drives table and index bloat, degrades query
        performance, consumes disk space, and holds back the cluster's oldest
        transaction ID. Left unchecked, this raises the risk of transaction ID
        (XID) wraparound, which can eventually force PostgreSQL to stop accepting
        new write commands.

    Recommendations:
        Identify the offending sessions and determine whether they are stuck,
        idle-in-transaction, or legitimately long-running. Work with application
        owners to commit or roll back these transactions; if necessary, cancel the
        statement with pg_cancel_backend(pid) or terminate the backend with
        pg_terminate_backend(pid). To prevent recurrence, set
        idle_in_transaction_session_timeout to bound idle-in-transaction sessions
        and statement_timeout to bound individual statement duration, keep
        transactions short, and avoid holding transactions open across
        application-side waits. Monitor age(backend_xmin) in pg_stat_activity to
        catch old snapshots before they threaten vacuum progress and wraparound
        safety.

    Scope : database-level
    Category : Transactions

    More info:
        https://www.postgresql.org/docs/current/routine-vacuuming.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW
        https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-IDLE-IN-TRANSACTION-SESSION-TIMEOUT
*/

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more transactions have been running for a long time.',
                'LongRunningTransactionThreshold', '30 minutes',
                'TransactionCount', COUNT(*),
                'Transactions',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'Pid', pid,
                        'UserName', usename,
                        'DatabaseName', datname,
                        'ApplicationName', application_name,
                        'ClientAddress', client_addr,
                        'State', state,
                        'TransactionStart', xact_start,
                        'TransactionAge', now() - xact_start,
                        'QueryStart', query_start,
                        'QueryAge', now() - query_start,
                        'WaitEventType', wait_event_type,
                        'WaitEvent', wait_event,
                        'Query', left(query, 500)
                    )
                    ORDER BY xact_start
                )
            )
        END
    FROM pg_stat_activity
    WHERE xact_start IS NOT NULL
      AND now() - xact_start > interval '30 minutes'
      AND pid <> pg_backend_pid()
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Transactions',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No long running transactions were detected.'
        ELSE
            'Review long running transactions. They can hold locks, prevent vacuum cleanup, increase bloat, and affect transaction ID wraparound safety.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #15: Oldest Transaction Age is High
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 15;
    v_CheckTitle          text    := $check_title$Oldest Transaction Age is High$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: The single oldest open transaction in the cluster has been
        running longer than the 1-hour threshold. This check focuses on the age of
        the very oldest transaction because, under MVCC, it is the oldest open
        transaction's snapshot (its xmin) that sets the floor for what VACUUM and
        autovacuum are allowed to clean up. As long as one old transaction stays
        open — actively running or "idle in transaction" — dead tuples newer than
        its snapshot cannot be reclaimed anywhere it applies, which causes table
        and index bloat, wasted disk space, degraded query performance, retained
        locks, and a held-back cluster-wide oldest transaction ID that increases
        transaction ID (XID) wraparound risk.

    Recommendations:
        Investigate the oldest open transaction identified here and determine
        whether it is stuck, idle-in-transaction, or a legitimately long workload.
        Coordinate with the application owner to commit or roll it back; if needed,
        cancel the statement with pg_cancel_backend(pid) or terminate the backend
        with pg_terminate_backend(pid). To prevent recurrence, set
        idle_in_transaction_session_timeout and statement_timeout to bound session
        and statement duration, keep transactions short, and avoid holding a
        transaction open across application-side waits. Track age(backend_xmin) in
        pg_stat_activity so old snapshots are caught before they threaten vacuum
        progress and wraparound safety.

    Scope : database-level
    Category : Transactions

    More info:
        https://www.postgresql.org/docs/current/routine-vacuuming.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ACTIVITY-VIEW
        https://www.postgresql.org/docs/current/runtime-config-client.html#GUC-IDLE-IN-TRANSACTION-SESSION-TIMEOUT
*/

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN max_transaction_age < interval '1 hour' THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'The oldest open transaction age is high.',
                'Threshold', '1 hour',
                'OldestTransactionAge', max_transaction_age,
                'OldestTransactionStart', oldest_transaction_start,
                'Pid', pid,
                'UserName', usename,
                'DatabaseName', datname,
                'ApplicationName', application_name,
                'ClientAddress', client_addr,
                'State', state,
                'WaitEventType', wait_event_type,
                'WaitEvent', wait_event,
                'Query', left(query, 500)
            )
        END
    FROM
    (
        SELECT
            pid,
            usename,
            datname,
            application_name,
            client_addr,
            state,
            wait_event_type,
            wait_event,
            query,
            xact_start AS oldest_transaction_start,
            now() - xact_start AS max_transaction_age
        FROM pg_stat_activity
        WHERE xact_start IS NOT NULL
          AND pid <> pg_backend_pid()
        ORDER BY xact_start ASC
        LIMIT 1
    ) s
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Transactions',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Oldest open transaction age is within the expected range.'
        ELSE
            'Investigate the oldest open transaction. Long transactions can delay vacuum cleanup, increase bloat, hold locks, and increase transaction ID wraparound risk.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';

            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #16: High Temporary File Usage
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 16;
    v_CheckTitle          text    := $check_title$High Temporary File Usage$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: One or more databases have written a large volume of temporary
        files (more than 1 GB since the last statistics reset). PostgreSQL writes
        temporary files to disk when an operation cannot complete within work_mem
        and has to spill. This commonly happens with large sorts (ORDER BY,
        DISTINCT, merge joins), hash joins, and hash-based aggregation. Disk spills
        are far slower than in-memory processing, so heavy temporary file usage
        signals queries that are degrading performance and consuming disk I/O and
        space in the temporary tablespace ($PGDATA/base/pgsql_tmp by default).
        Note that temp_bytes in pg_stat_database is cumulative since stats_reset,
        so a high value can reflect long uptime rather than a current spike.

    Recommendations:
        Enable log_temp_files (e.g. a low threshold in KB) to capture which queries
        are spilling and how large the temporary files are, then use
        EXPLAIN (ANALYZE, BUFFERS) to confirm external merge sorts or batched hash
        joins. Address the heaviest offenders by adding or improving indexes to
        avoid large sorts, rewriting expensive queries, and limiting result sets.
        Tune work_mem carefully — it is allocated per operation per query, so a
        complex query with several sorts/hashes and many concurrent sessions can
        multiply memory use quickly; prefer raising it per-session or per-query for
        known heavy workloads rather than globally. Consider setting a
        temp_file_limit to protect against runaway queries filling the disk, and
        optionally a dedicated temp_tablespaces location to isolate temporary file
        I/O from data files. pg_stat_statements (temp_blks_written) helps rank the
        queries responsible.

    Scope : database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-WORK-MEM
        https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-TEMP-FILES
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW
*/


v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more databases have high temporary file usage.',
                'ThresholdTempBytes', 1073741824,
                'ThresholdDescription', 'More than 1 GB temporary file usage since statistics reset.',
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'TempFiles', temp_files,
                        'TempBytes', temp_bytes,
                        'TempGB', ROUND(temp_bytes::numeric / 1024 / 1024 / 1024, 2),
                        'StatsReset', stats_reset
                    )
                    ORDER BY temp_bytes DESC
                )
            )
        END
    FROM pg_stat_database
    WHERE temp_bytes > 1073741824
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Temporary file usage is within the expected range.'
        ELSE
            'Review queries that spill to disk. Consider tuning work_mem carefully, improving indexes, rewriting expensive sorts/hash joins, and reviewing temporary file logging.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #17: Replication Slots Retaining Significant WAL
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 17;
    v_CheckTitle          text    := $check_title$Replication Slots Retaining Significant WAL$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: One or more replication slots are holding on to a large volume
        of WAL (more than 10 GB, measured as the distance between the slot's
        restart_lsn and the current WAL position). A replication slot guarantees
        WAL retention for its consumer: the primary will not recycle WAL segments
        the slot still needs, regardless of wal_keep_size or checkpoint settings.
        This is exactly what makes slots dangerous — if a consumer is inactive,
        lagging, or abandoned (a decommissioned subscriber, a disconnected CDC
        connector such as Debezium, or a leftover pg_upgrade slot), the pg_wal
        directory grows without bound and can fill the disk, which stops the server
        from processing new transactions. For logical slots on an otherwise idle
        database, WAL can also accumulate simply because the slot never receives
        changes to advance past.

    Recommendations:
        Identify the consumer behind each slot and whether it is active
        (the "active" flag) and making progress. For a lagging but needed consumer,
        fix or restart it so the slot advances. For a genuinely abandoned slot,
        drop it with pg_drop_replication_slot(slot_name) after validating it is not
        required — note the downstream consumer will then need a full re-sync. As a
        safety valve, set max_slot_wal_keep_size (PG13+) so a runaway slot is
        invalidated at checkpoint rather than filling the disk, and on PG18+ use
        idle_replication_slot_timeout to auto-invalidate long-idle slots. Monitor
        pg_replication_slots (retained WAL, wal_status, safe_wal_size) and alert
        before WAL volume approaches disk capacity.

    Scope : cluster-level
    Category : Replication

    More info:
        https://www.postgresql.org/docs/current/view-pg-replication-slots.html
        https://www.postgresql.org/docs/current/runtime-config-replication.html#GUC-MAX-SLOT-WAL-KEEP-SIZE
        https://www.postgresql.org/docs/current/functions-admin.html#FUNCTIONS-REPLICATION
*/


v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more replication slots are retaining significant WAL.',
                'ThresholdBytes', 10737418240,
                'ThresholdDescription', 'More than 10 GB WAL retained by a replication slot.',
                'ReplicationSlots',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'SlotName', slot_name,
                        'SlotType', slot_type,
                        'Database', database,
                        'Active', active,
                        'RestartLsn', restart_lsn,
                        'ConfirmedFlushLsn', confirmed_flush_lsn,
                        'WalRetainedBytes', wal_retained_bytes,
                        'WalRetainedGB', ROUND(wal_retained_bytes::numeric / 1024 / 1024 / 1024, 2)
                    )
                    ORDER BY wal_retained_bytes DESC
                )
            )
        END
    FROM
    (
        SELECT
            slot_name,
            slot_type,
            database,
            active,
            restart_lsn,
            confirmed_flush_lsn,
            pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) AS wal_retained_bytes
        FROM pg_replication_slots
        WHERE restart_lsn IS NOT NULL
    ) s
    WHERE wal_retained_bytes > 10737418240
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Replication',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No replication slots retaining significant WAL were detected.'
        ELSE
            'Review replication slot consumers. Confirm whether lagging or inactive slots are required, fix the consumer, or drop unused slots carefully after validation.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #18: Tables Approaching Transaction ID Wraparound
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 18;
    v_CheckTitle          text    := $check_title$Tables Approaching Transaction ID Wraparound$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: One or more tables have a transaction ID (XID) age above the
        1 billion threshold, meaning their oldest unfrozen XID (relfrozenxid) has
        aged far past the point where routine autovacuum should have frozen it.
        PostgreSQL uses 32-bit transaction IDs, which can only span about 2 billion
        transactions before they "wrap around". To prevent that, VACUUM freezes old
        rows so their XIDs no longer count toward age. If freezing fails to keep up,
        the age keeps climbing silently — there is no performance symptom — until
        PostgreSQL begins emitting mandatory-vacuum warnings, then forces the
        database into read-only mode and ultimately refuses new write transactions
        to avoid data corruption. A single lagging table (often a rarely-used or
        autovacuum-disabled table) sets the age for the whole database, so even one
        entry here is a genuine cluster-wide risk.

    Recommendations:
        Freeze the affected tables to advance relfrozenxid: run VACUUM (or VACUUM
        FREEZE) on them, prioritizing the oldest first, or let the anti-wraparound
        ("to prevent wraparound") autovacuum complete rather than cancelling it.
        Investigate why freezing fell behind — the usual culprits are long-running
        or idle-in-transaction sessions and stale replication slots that hold back
        the oldest xmin and block freezing, or autovacuum being disabled/too slow on
        specific tables; identify and clear these first, since VACUUM cannot freeze
        past them. Confirm autovacuum is enabled on all tables (including
        abandoned/test tables), review autovacuum_freeze_max_age and per-table
        autovacuum settings, and consider making autovacuum more aggressive
        (workers, cost delay) on high-write tables. Monitor age(relfrozenxid) and
        age(datfrozenxid) trends over time so intervention happens early rather
        than as an emergency.

    Scope : database-level
    Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/routine-vacuuming.html#VACUUM-FOR-WRAPAROUND
        https://www.postgresql.org/docs/current/runtime-config-autovacuum.html#GUC-AUTOVACUUM-FREEZE-MAX-AGE
        https://www.postgresql.org/docs/current/sql-vacuum.html
*/

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more tables have a high transaction ID age and may be approaching wraparound risk.',
                'ThresholdXidAge', 1000000000,
                'AutovacuumFreezeMaxAge',
                    current_setting('autovacuum_freeze_max_age', true),
                'Tables',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'SchemaName', n.nspname,
                        'TableName', c.relname,
                        'RelationKind', c.relkind,
                        'XidAge', age(c.relfrozenxid),
                        'RelFrozenXid', c.relfrozenxid,
                        'TableSize', pg_size_pretty(pg_total_relation_size(c.oid)),
                        'LastVacuum', s.last_vacuum,
                        'LastAutovacuum', s.last_autovacuum,
                        'VacuumCount', s.vacuum_count,
                        'AutovacuumCount', s.autovacuum_count
                    )
                    ORDER BY age(c.relfrozenxid) DESC
                )
            )
        END
    FROM pg_class c
    JOIN pg_namespace n
        ON n.oid = c.relnamespace
    LEFT JOIN pg_stat_user_tables s
        ON s.relid = c.oid
    WHERE c.relkind IN ('r', 'm', 't')
      AND n.nspname NOT IN ('pg_catalog', 'information_schema')
      AND age(c.relfrozenxid) > 1000000000
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No tables approaching transaction ID wraparound risk were detected.'
        ELSE
            'Run VACUUM FREEZE or allow aggressive autovacuum to complete on the affected tables. Review autovacuum freeze settings and investigate why freezing is not keeping up.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #19: Databases Approaching Transaction ID Wraparound
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 19;
    v_CheckTitle          text    := $check_title$Databases Approaching Transaction ID Wraparound$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/*
    DESCRIPTION:
        What This Means: One or more databases have a high transaction ID age
        and may be approaching transaction ID wraparound.

        PostgreSQL uses transaction IDs (XIDs) that are limited in size.
        If freezing does not occur regularly through VACUUM or autovacuum,
        old XIDs can eventually approach wraparound, which may force
        emergency maintenance and can ultimately prevent writes.

    Recommendations:
        Identify tables with high relfrozenxid age in the affected databases.
        Ensure autovacuum is functioning correctly and not being blocked by
        long-running transactions.
        Consider running VACUUM (FREEZE) on affected tables during a maintenance window.

    Scope : Database-level
    Category : Maintenance

    More info:
        https://www.postgresql.org/docs/current/routine-vacuuming.html
        https://www.postgresql.org/docs/current/routine-vacuuming.html#VACUUM-FOR-WRAPAROUND
        https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
*/

/* ============================================================
   CHECK: Databases Approaching Transaction ID Wraparound
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more databases have a high transaction ID age and may be approaching wraparound risk.',
                'ThresholdXidAge', 1000000000,
                'AutovacuumFreezeMaxAge',
                    current_setting('autovacuum_freeze_max_age', true),
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'XidAge', age(datfrozenxid),
                        'DatFrozenXid', datfrozenxid,
                        'AllowConnections', datallowconn,
                        'IsTemplate', datistemplate
                    )
                    ORDER BY age(datfrozenxid) DESC
                )
            )
        END
    FROM pg_database
    WHERE datallowconn = true
      AND age(datfrozenxid) > 1000000000
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No databases approaching transaction ID wraparound risk were detected.'
        ELSE
            'Identify the oldest tables in the affected databases and run VACUUM FREEZE or allow aggressive autovacuum to complete. Review autovacuum freeze settings and long-running transactions that may prevent cleanup.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #20: Prepared Transactions Exist
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 20;
    v_CheckTitle          text    := $check_title$Prepared Transactions Exist$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: Prepared transactions exist in the PostgreSQL cluster.

        Prepared transactions are created by two-phase commit using PREPARE TRANSACTION.
        If they remain open for a long time, they can hold locks, retain transaction IDs,
        prevent vacuum cleanup, increase bloat, and create operational risk.

    Recommendations:
        Review each prepared transaction and confirm whether it is still required.
        Commit or roll back old prepared transactions after validating with the
        owning application or transaction coordinator.
        If two-phase commit is not required, consider setting max_prepared_transactions
        to 0 after confirming application requirements.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/sql-prepare-transaction.html
        https://www.postgresql.org/docs/current/view-pg-prepared-xacts.html
        https://www.postgresql.org/docs/current/runtime-config-resource.html
*/

/* ============================================================
   CHECK: Prepared Transactions Exist
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more prepared transactions exist in the PostgreSQL cluster.',
                'PreparedTransactionCount', COUNT(*),
                'MaxPreparedTransactions', current_setting('max_prepared_transactions', true),
                'PreparedTransactions',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'TransactionId', transaction,
                        'GlobalTransactionId', gid,
                        'PreparedAt', prepared,
                        'PreparedAge', now() - prepared,
                        'Owner', owner,
                        'DatabaseName', database
                    )
                    ORDER BY prepared ASC
                )
            )
        END
    FROM pg_prepared_xacts
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Transactions',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No prepared transactions were found.'
        ELSE
            'Review prepared transactions and commit or roll them back if they are no longer required. Validate with the application or transaction coordinator before taking action.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #21: Database Statistics Reset Time is Recent
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 21;
    v_CheckTitle          text    := $check_title$Database Statistics Reset Time is Recent$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/*
    DESCRIPTION:
        What This Means: Database statistics reset time is recent.

        PostgreSQL cumulative statistics in pg_stat_database can be reset manually
        using pg_stat_reset() or by certain operational actions. A recent reset can
        make performance, activity, temporary file usage, transaction, block I/O,
        and cache hit ratio metrics incomplete or misleading.

    Recommendations:
        Confirm whether the statistics reset was expected.
        If the reset was planned, treat current cumulative statistics as partial
        since the reset time.
        If the reset was unexpected, investigate who or what reset the statistics
        and review monitoring or maintenance automation.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW
*/

/* ============================================================
   CHECK: Database Statistics Reset Time is Recent
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more databases have had statistics reset recently.',
                'Threshold', '24 hours',
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'StatsReset', stats_reset,
                        'StatsAge', now() - stats_reset,
                        'NumBackends', numbackends,
                        'XactCommit', xact_commit,
                        'XactRollback', xact_rollback,
                        'TempFiles', temp_files,
                        'TempBytes', temp_bytes,
                        'Deadlocks', deadlocks
                    )
                    ORDER BY stats_reset DESC
                )
            )
        END
    FROM pg_stat_database
    WHERE stats_reset IS NOT NULL
      AND stats_reset > now() - interval '24 hours'
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Database statistics reset time is not recent.'
        ELSE
            'Confirm whether the statistics reset was expected. Treat cumulative pg_stat_database metrics as partial since the reset time.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #22: Deadlocks Detected
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 22;
    v_CheckTitle          text    := $check_title$Deadlocks Detected$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/*
    DESCRIPTION:
        What This Means: Deadlocks were detected in one or more databases.

        A deadlock occurs when two or more sessions wait on each other in a cycle,
        and PostgreSQL resolves it by canceling one of the transactions. Deadlocks
        can indicate problematic transaction ordering, long-held locks, missing
        indexes, or application concurrency issues.

    Recommendations:
        Review PostgreSQL logs around the deadlock times for the full deadlock
        details and involved SQL statements.
        Investigate application transaction order, lock acquisition order, and
        queries that hold locks for a long time.
        Consider adding indexes or reducing transaction scope where appropriate.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/explicit-locking.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW
*/

/* ============================================================
   CHECK: Deadlocks Detected
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more databases report deadlocks in pg_stat_database.',
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'Deadlocks', deadlocks,
                        'StatsReset', stats_reset
                    )
                    ORDER BY deadlocks DESC
                )
            )
        END
    FROM pg_stat_database
    WHERE deadlocks > 0
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Concurrency',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No deadlocks were reported in pg_stat_database.'
        ELSE
            'Review PostgreSQL logs for deadlock details and investigate transaction ordering, long-held locks, and application concurrency patterns.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #23: High Rollback Ratio
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 23;
    v_CheckTitle          text    := $check_title$High Rollback Ratio$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: High rollback ratio detected in this database.

        A high rollback ratio means a significant percentage of transactions are
        being rolled back instead of committed. This can indicate application
        errors, failed transactions, deadlocks, lock timeouts, constraint violations,
        retry behavior, or inefficient transaction handling.

    Recommendations:
        Review application logs and PostgreSQL logs for transaction errors.
        Investigate deadlocks, lock timeouts, statement timeouts, constraint
        violations, and application retry patterns.
        If the rollback volume is expected, document the reason and validate that
        it does not create unnecessary load.

    Scope : Database-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW
*/

/* ============================================================
   CHECK: High Rollback Ratio
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'This database has a high rollback ratio.',
                'ThresholdRollbackPercent', 10,
                'MinimumTransactionCount', 1000,
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'Commits', xact_commit,
                        'Rollbacks', xact_rollback,
                        'TotalTransactions', xact_commit + xact_rollback,
                        'RollbackPercent',
                            ROUND
                            (
                                xact_rollback::numeric
                                / NULLIF(xact_commit + xact_rollback, 0) * 100,
                                2
                            ),
                        'StatsReset', stats_reset
                    )
                    ORDER BY
                        ROUND
                        (
                            xact_rollback::numeric
                            / NULLIF(xact_commit + xact_rollback, 0) * 100,
                            2
                        ) DESC
                )
            )
        END
    FROM pg_stat_database
    WHERE datname = current_database()
      AND xact_commit + xact_rollback >= 1000
      AND
      (
          xact_rollback::numeric
          / NULLIF(xact_commit + xact_rollback, 0) * 100
      ) > 10
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Transactions',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Rollback ratio is within the expected range.'
        ELSE
            'Investigate application errors, failed transactions, deadlocks, timeouts, constraint violations, and retry behavior causing frequent rollbacks.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #24: High Cache Miss Ratio
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 24;
    v_CheckTitle          text    := $check_title$High Cache Miss Ratio$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:
        What This Means: High cache miss ratio detected in one or more databases.

        PostgreSQL reports block reads from disk and block hits from shared buffers
        in pg_stat_database. A high cache miss ratio means a larger percentage of
        reads are coming from disk instead of memory, which may indicate memory
        pressure, inefficient queries, missing indexes, large scans, or a workload
        that does not fit well in shared buffers and OS cache.

    Recommendations:
        Review query patterns, indexes, table scans, and memory pressure.
        Investigate databases with high disk reads using pg_stat_statements if
        available.
        Consider tuning shared_buffers carefully, improving indexes, reducing
        unnecessary full scans, and validating whether the working set fits in memory.

        Scope : Cluster-level
        Category : Performance

    More info:
        https://www.postgresql.org/docs/current/monitoring-stats.html
        https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-DATABASE-VIEW
*/

/* ============================================================
   CHECK: High Cache Miss Ratio
   ============================================================ */

v_AdditionalInfo :=
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'One or more databases have a high cache miss ratio.',
                'ThresholdCacheMissPercent', 5,
                'MinimumBlockAccesses', 100000,
                'Databases',
                jsonb_agg
                (
                    jsonb_build_object
                    (
                        'DatabaseName', datname,
                        'BlockHits', blks_hit,
                        'BlockReads', blks_read,
                        'TotalBlockAccesses', blks_hit + blks_read,
                        'CacheHitPercent',
                            ROUND
                            (
                                blks_hit::numeric
                                / NULLIF(blks_hit + blks_read, 0) * 100,
                                2
                            ),
                        'CacheMissPercent',
                            ROUND
                            (
                                blks_read::numeric
                                / NULLIF(blks_hit + blks_read, 0) * 100,
                                2
                            ),
                        'StatsReset', stats_reset
                    )
                    ORDER BY
                        ROUND
                        (
                            blks_read::numeric
                            / NULLIF(blks_hit + blks_read, 0) * 100,
                            2
                        ) DESC
                )
            )
        END
    FROM pg_stat_database
    WHERE blks_hit + blks_read >= 100000
      AND
      (
          blks_read::numeric
          / NULLIF(blks_hit + blks_read, 0) * 100
      ) > 5
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Cache miss ratio is within the expected range.'
        ELSE
            'Investigate disk reads, inefficient queries, missing indexes, large scans, and memory pressure. Use pg_stat_statements if available to identify the main read-heavy queries.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #25: work_mem Configuration Risk
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 25;
    v_CheckTitle          text    := $check_title$work_mem Configuration Risk$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/*
    DESCRIPTION:
        What This Means: work_mem configuration may create memory pressure risk.

        work_mem controls the memory available to each sort, hash join, materialize,
        and similar operation before PostgreSQL writes temporary files to disk.
        This setting is applied per operation, not per session, so total memory usage
        can become much higher than work_mem multiplied by active connections.

        A high work_mem value combined with many allowed connections can increase
        the risk of memory pressure, swapping, out-of-memory events, or degraded
        database performance.

    Recommendations:
        Review work_mem together with max_connections, active workload concurrency,
        query patterns, and temporary file usage.
        Avoid setting work_mem too high globally.
        Prefer targeted tuning per role, per database, or per session for known
        reporting or maintenance workloads.
        Consider connection pooling to reduce concurrent memory risk.

    Scope : Cluster-level
    Category : Performance

    More info:
        https://www.postgresql.org/docs/current/runtime-config-resource.html
        https://www.postgresql.org/docs/current/runtime-config-resource.html#GUC-WORK-MEM
*/

/* ============================================================
   CHECK: work_mem Configuration Risk
   ============================================================ */


v_AdditionalInfo :=
(
    WITH settings AS
    (
        SELECT
            pg_size_bytes(current_setting('work_mem')) AS work_mem_bytes,
            current_setting('work_mem') AS work_mem,
            current_setting('max_connections')::int AS max_connections,
            current_setting('superuser_reserved_connections')::int AS superuser_reserved_connections
    ),
    calculated AS
    (
        SELECT
            work_mem,
            work_mem_bytes,
            max_connections,
            superuser_reserved_connections,
            GREATEST(max_connections - superuser_reserved_connections, 0) AS usable_connections,
            work_mem_bytes * GREATEST(max_connections - superuser_reserved_connections, 0) AS theoretical_single_operation_memory_bytes,
            ROUND
            (
                (
                    work_mem_bytes * GREATEST(max_connections - superuser_reserved_connections, 0)
                )::numeric / 1024 / 1024 / 1024,
                2
            ) AS theoretical_single_operation_memory_gb
        FROM settings
    )
    SELECT
        CASE
            WHEN theoretical_single_operation_memory_bytes < 8589934592
                 AND work_mem_bytes < 67108864
                THEN NULL::jsonb
            ELSE jsonb_build_object
            (
                'FindingReason', 'Global work_mem may create memory pressure risk when combined with allowed connection count.',
                'WorkMem', work_mem,
                'WorkMemBytes', work_mem_bytes,
                'MaxConnections', max_connections,
                'SuperuserReservedConnections', superuser_reserved_connections,
                'UsableConnections', usable_connections,
                'TheoreticalSingleOperationMemoryBytes', theoretical_single_operation_memory_bytes,
                'TheoreticalSingleOperationMemoryGB', theoretical_single_operation_memory_gb,
                'RiskNote', 'work_mem is applied per sort/hash operation, not per session. A single query can use work_mem multiple times.'
            )
        END
    FROM calculated
);

INSERT INTO pg_review_results
(
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'work_mem configuration does not indicate elevated global memory risk.'
        ELSE
            'Review global work_mem and max_connections together. Prefer targeted work_mem increases for specific roles, sessions, or workloads instead of a high cluster-wide default.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #26: Foreign Keys Without Supporting Indexes
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 26;
    v_CheckTitle          text    := $check_title$Foreign Keys Without Supporting Indexes$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: foreign keys exist without supporting indexes on the referencing
   columns. This can slow down DELETE and UPDATE operations on the parent table
   because PostgreSQL must check referencing rows in the child table.

   WHY THIS MATTERS:
   PostgreSQL does not automatically create indexes for foreign key columns.
   Missing indexes can cause long-running statements, excessive locking, and
   poor performance during parent-table updates or deletes.

   Recommendations:
   Create indexes on foreign key referencing columns where appropriate,
   especially for active OLTP tables and large child tables.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/ddl-constraints.html
   https://www.postgresql.org/docs/current/indexes.html
*/

v_AdditionalInfo := (
    WITH fk_columns AS (
        SELECT
            con.oid AS constraint_oid,
            con.conname AS constraint_name,
            con.conrelid AS child_table_oid,
            con.confrelid AS parent_table_oid,
            nsp.nspname AS child_schema,
            cls.relname AS child_table,
            pnsp.nspname AS parent_schema,
            pcls.relname AS parent_table,
            con.conkey AS fk_attnums
        FROM pg_constraint con
        JOIN pg_class cls
            ON cls.oid = con.conrelid
        JOIN pg_namespace nsp
            ON nsp.oid = cls.relnamespace
        JOIN pg_class pcls
            ON pcls.oid = con.confrelid
        JOIN pg_namespace pnsp
            ON pnsp.oid = pcls.relnamespace
        WHERE con.contype = 'f'
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
    ),
    fk_with_columns AS (
        SELECT
            fk.*,
            array_agg(att.attname ORDER BY ord.ordinality) AS fk_columns
        FROM fk_columns fk
        JOIN unnest(fk.fk_attnums) WITH ORDINALITY AS ord(attnum, ordinality)
            ON true
        JOIN pg_attribute att
            ON att.attrelid = fk.child_table_oid
           AND att.attnum = ord.attnum
        GROUP BY
            fk.constraint_oid,
            fk.constraint_name,
            fk.child_table_oid,
            fk.parent_table_oid,
            fk.child_schema,
            fk.child_table,
            fk.parent_schema,
            fk.parent_table,
            fk.fk_attnums
    ),
    fk_without_index AS (
        SELECT
            fk.constraint_name,
            fk.child_schema,
            fk.child_table,
            fk.parent_schema,
            fk.parent_table,
            fk.fk_columns,
            pg_total_relation_size(fk.child_table_oid) AS child_table_size_bytes
        FROM fk_with_columns fk
        WHERE NOT EXISTS (
            SELECT 1
            FROM pg_index idx
            WHERE idx.indrelid = fk.child_table_oid
              AND idx.indisvalid
              AND idx.indisready
              AND idx.indpred IS NULL
              AND (
                  string_to_array(idx.indkey::text, ' ')::smallint[]
              )[1:array_length(fk.fk_attnums, 1)] = fk.fk_attnums
        )
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM fk_without_index)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'ForeignKeysWithoutSupportingIndexes',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'ConstraintName', constraint_name,
                        'ChildSchema', child_schema,
                        'ChildTable', child_table,
                        'ChildColumns', fk_columns,
                        'ParentSchema', parent_schema,
                        'ParentTable', parent_table,
                        'ChildTableSizeBytes', child_table_size_bytes
                    )
                    ORDER BY child_table_size_bytes DESC
                )
                FROM fk_without_index
            ),
            'FindingReason',
            'One or more foreign keys do not have a supporting index on the referencing columns.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'All foreign keys appear to have supporting indexes.'
        ELSE
            'Create supporting indexes on the referencing columns of foreign keys, prioritizing large and frequently modified child tables.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #27: Invalid Indexes
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 27;
    v_CheckTitle          text    := $check_title$Invalid Indexes$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: invalid indexes exist in the database. Invalid indexes may be
   left behind by failed CREATE INDEX CONCURRENTLY, REINDEX CONCURRENTLY, or
   interrupted index maintenance operations.

   WHY THIS MATTERS:
   Invalid indexes are not usable by the query planner for normal query
   execution, but they can still consume disk space and create operational
   confusion. They may also indicate a failed or incomplete maintenance task.

   Recommendations:
   Review each invalid index. If the index is still required, rebuild it using
   REINDEX INDEX CONCURRENTLY or recreate it. If it is not required, drop it.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/catalog-pg-index.html
   https://www.postgresql.org/docs/current/sql-reindex.html
   https://www.postgresql.org/docs/current/sql-createindex.html
*/

v_AdditionalInfo := (
    WITH invalid_indexes AS (
        SELECT
            nsp.nspname AS schema_name,
            tbl.relname AS table_name,
            idx.relname AS index_name,
            pg_get_indexdef(idx.oid) AS index_definition,
            pg_relation_size(idx.oid) AS index_size_bytes,
            ix.indisvalid AS is_valid,
            ix.indisready AS is_ready,
            ix.indislive AS is_live
        FROM pg_index ix
        JOIN pg_class idx
            ON idx.oid = ix.indexrelid
        JOIN pg_class tbl
            ON tbl.oid = ix.indrelid
        JOIN pg_namespace nsp
            ON nsp.oid = tbl.relnamespace
        WHERE ix.indisvalid = false
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM invalid_indexes)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'InvalidIndexes',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'IndexName', index_name,
                        'IndexDefinition', index_definition,
                        'IndexSizeBytes', index_size_bytes,
                        'IsValid', is_valid,
                        'IsReady', is_ready,
                        'IsLive', is_live
                    )
                    ORDER BY index_size_bytes DESC
                )
                FROM invalid_indexes
            ),
            'FindingReason',
            'One or more invalid indexes exist in the database.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No invalid indexes were found.'
        ELSE
            'Review invalid indexes. Rebuild required indexes using REINDEX INDEX CONCURRENTLY where supported, or drop indexes that are no longer needed.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #28: Duplicate Index Candidates
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 28;
    v_CheckTitle          text    := $check_title$Duplicate Index Candidates$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: duplicate index candidates exist in the database. These are
   indexes on the same table with the same indexed columns, expressions,
   predicates, access method, and uniqueness behavior.

   WHY THIS MATTERS:
   Duplicate indexes waste disk space and increase write overhead because
   INSERT, UPDATE, DELETE, VACUUM, and autovacuum operations must maintain
   unnecessary index structures.

   Recommendations:
   Review each duplicate index group. Keep the index that is required by a
   constraint or actively used by queries, and drop redundant indexes only after
   validating usage and dependency requirements.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/indexes.html
   https://www.postgresql.org/docs/current/catalog-pg-index.html
   https://www.postgresql.org/docs/current/sql-dropindex.html
*/

v_AdditionalInfo := (
    WITH user_indexes AS (
        SELECT
            nsp.nspname AS schema_name,
            tbl.relname AS table_name,
            idx.relname AS index_name,
            idx.oid AS index_oid,
            tbl.oid AS table_oid,
            am.amname AS access_method,
            ix.indisunique AS is_unique,
            ix.indisprimary AS is_primary,
            ix.indisexclusion AS is_exclusion,
            ix.indisvalid AS is_valid,
            ix.indkey::text AS index_keys,
            pg_get_expr(ix.indexprs, ix.indrelid) AS index_expressions,
            pg_get_expr(ix.indpred, ix.indrelid) AS index_predicate,
            pg_get_indexdef(idx.oid) AS index_definition,
            pg_relation_size(idx.oid) AS index_size_bytes
        FROM pg_index ix
        JOIN pg_class idx
            ON idx.oid = ix.indexrelid
        JOIN pg_class tbl
            ON tbl.oid = ix.indrelid
        JOIN pg_namespace nsp
            ON nsp.oid = tbl.relnamespace
        JOIN pg_am am
            ON am.oid = idx.relam
        WHERE nsp.nspname NOT IN ('pg_catalog', 'information_schema')
          AND idx.relkind = 'i'
          AND ix.indisvalid = true
    ),
    duplicate_groups AS (
        SELECT
            schema_name,
            table_name,
            access_method,
            is_unique,
            index_keys,
            COALESCE(index_expressions, '') AS index_expressions,
            COALESCE(index_predicate, '') AS index_predicate,
            COUNT(*) AS duplicate_count,
            SUM(index_size_bytes) AS total_index_size_bytes,
            jsonb_agg(
                jsonb_build_object(
                    'IndexName', index_name,
                    'IndexDefinition', index_definition,
                    'IndexSizeBytes', index_size_bytes,
                    'IsPrimary', is_primary,
                    'IsExclusion', is_exclusion
                )
                ORDER BY index_size_bytes DESC
            ) AS indexes
        FROM user_indexes
        WHERE is_primary = false
          AND is_exclusion = false
        GROUP BY
            schema_name,
            table_name,
            access_method,
            is_unique,
            index_keys,
            COALESCE(index_expressions, ''),
            COALESCE(index_predicate, '')
        HAVING COUNT(*) > 1
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM duplicate_groups)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'DuplicateIndexCandidates',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'AccessMethod', access_method,
                        'IsUnique', is_unique,
                        'DuplicateCount', duplicate_count,
                        'TotalIndexSizeBytes', total_index_size_bytes,
                        'IndexKeys', index_keys,
                        'IndexExpressions', index_expressions,
                        'IndexPredicate', index_predicate,
                        'Indexes', indexes
                    )
                    ORDER BY total_index_size_bytes DESC
                )
                FROM duplicate_groups
            ),
            'FindingReason',
            'One or more groups of duplicate index candidates were found.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No duplicate index candidates were found.'
        ELSE
            'Review duplicate index candidates carefully. Drop only indexes proven to be redundant and not required by constraints, query patterns, or operational procedures.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #29: Overlapping Index Candidates
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 29;
    v_CheckTitle          text    := $check_title$Overlapping Index Candidates$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: overlapping index candidates exist in the database. These are
   indexes where one index starts with the same leading columns as another
   index on the same table.

   WHY THIS MATTERS:
   A wider index may sometimes make a narrower index redundant when the narrower
   index is a left-prefix of the wider index. Redundant overlapping indexes
   waste disk space and increase write overhead for INSERT, UPDATE, DELETE,
   VACUUM, and autovacuum operations.

   Recommendations:
   Review each overlapping index pair. Do not automatically drop indexes.
   Validate query usage, uniqueness, constraints, predicates, sort order,
   included columns, and index-only scan behavior before removing any index.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/indexes.html
   https://www.postgresql.org/docs/current/indexes-multicolumn.html
   https://www.postgresql.org/docs/current/catalog-pg-index.html
   https://www.postgresql.org/docs/current/sql-dropindex.html
*/

v_AdditionalInfo := (
    WITH user_indexes AS (
        SELECT
            nsp.nspname AS schema_name,
            tbl.relname AS table_name,
            tbl.oid AS table_oid,
            idx.relname AS index_name,
            idx.oid AS index_oid,
            am.amname AS access_method,
            ix.indisunique AS is_unique,
            ix.indisprimary AS is_primary,
            ix.indisexclusion AS is_exclusion,
            ix.indisvalid AS is_valid,
            ix.indkey::int[] AS index_keys,
            ix.indnkeyatts AS key_column_count,
            ix.indnatts AS total_column_count,
            pg_get_expr(ix.indexprs, ix.indrelid) AS index_expressions,
            pg_get_expr(ix.indpred, ix.indrelid) AS index_predicate,
            pg_get_indexdef(idx.oid) AS index_definition,
            pg_relation_size(idx.oid) AS index_size_bytes
        FROM pg_index ix
        JOIN pg_class idx
            ON idx.oid = ix.indexrelid
        JOIN pg_class tbl
            ON tbl.oid = ix.indrelid
        JOIN pg_namespace nsp
            ON nsp.oid = tbl.relnamespace
        JOIN pg_am am
            ON am.oid = idx.relam
        WHERE nsp.nspname NOT IN ('pg_catalog', 'information_schema')
          AND idx.relkind = 'i'
          AND ix.indisvalid = true
          AND ix.indisready = true
          AND ix.indisprimary = false
          AND ix.indisexclusion = false
    ),
    overlapping_indexes AS (
        SELECT
            narrow.schema_name,
            narrow.table_name,
            narrow.index_name AS narrower_index_name,
            wide.index_name AS wider_index_name,
            narrow.index_definition AS narrower_index_definition,
            wide.index_definition AS wider_index_definition,
            narrow.index_size_bytes AS narrower_index_size_bytes,
            wide.index_size_bytes AS wider_index_size_bytes,
            narrow.access_method,
            narrow.is_unique AS narrower_is_unique,
            wide.is_unique AS wider_is_unique,
            narrow.index_predicate AS narrower_predicate,
            wide.index_predicate AS wider_predicate,
            narrow.index_expressions AS narrower_expressions,
            wide.index_expressions AS wider_expressions,
            narrow.key_column_count AS narrower_key_column_count,
            wide.key_column_count AS wider_key_column_count
        FROM user_indexes narrow
        JOIN user_indexes wide
            ON wide.table_oid = narrow.table_oid
           AND wide.index_oid <> narrow.index_oid
           AND wide.access_method = narrow.access_method
           AND COALESCE(wide.index_predicate, '') = COALESCE(narrow.index_predicate, '')
           AND COALESCE(wide.index_expressions, '') = COALESCE(narrow.index_expressions, '')
           AND wide.key_column_count > narrow.key_column_count
           AND wide.index_keys[1:narrow.key_column_count]
               = narrow.index_keys[1:narrow.key_column_count]
        WHERE narrow.is_unique = false
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM overlapping_indexes)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'OverlappingIndexCandidates',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'NarrowerIndexName', narrower_index_name,
                        'WiderIndexName', wider_index_name,
                        'AccessMethod', access_method,
                        'NarrowerIndexDefinition', narrower_index_definition,
                        'WiderIndexDefinition', wider_index_definition,
                        'NarrowerIndexSizeBytes', narrower_index_size_bytes,
                        'WiderIndexSizeBytes', wider_index_size_bytes,
                        'NarrowerIsUnique', narrower_is_unique,
                        'WiderIsUnique', wider_is_unique,
                        'NarrowerPredicate', narrower_predicate,
                        'WiderPredicate', wider_predicate,
                        'NarrowerExpressions', narrower_expressions,
                        'WiderExpressions', wider_expressions
                    )
                    ORDER BY narrower_index_size_bytes DESC
                )
                FROM overlapping_indexes
            ),
            'FindingReason',
            'One or more overlapping index candidates were found where a narrower index is a left-prefix of a wider index.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No overlapping index candidates were found.'
        ELSE
            'Review overlapping index candidates carefully. Drop only indexes proven to be redundant after validating workload usage, constraints, predicates, ordering, and index-only scan requirements.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #30: User Tables Without Primary Key
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 30;
    v_CheckTitle          text    := $check_title$User Tables Without Primary Key$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: user tables exist without a primary key.

   WHY THIS MATTERS:
   Tables without a primary key can allow duplicate or hard-to-identify rows,
   complicate application logic, replication, change tracking, data cleanup,
   and foreign key relationships. Primary keys also provide a clear row identity
   for operational and maintenance tasks.

   Recommendations:
   Review each table and define an appropriate primary key. If a natural key is
   not available, consider adding a surrogate key such as bigint identity or UUID,
   depending on application requirements.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/ddl-constraints.html
   https://www.postgresql.org/docs/current/ddl-identity-columns.html
*/

v_AdditionalInfo := (
    WITH user_tables_without_pk AS (
        SELECT
            nsp.nspname AS schema_name,
            cls.relname AS table_name,
            cls.relkind AS relation_kind,
            pg_total_relation_size(cls.oid) AS table_size_bytes,
            COALESCE(st.n_live_tup, 0) AS estimated_live_rows
        FROM pg_class cls
        JOIN pg_namespace nsp
            ON nsp.oid = cls.relnamespace
        LEFT JOIN pg_stat_user_tables st
            ON st.relid = cls.oid
        WHERE cls.relkind IN ('r', 'p')
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
          AND NOT EXISTS (
              SELECT 1
              FROM pg_constraint con
              WHERE con.conrelid = cls.oid
                AND con.contype = 'p'
          )
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM user_tables_without_pk)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'UserTablesWithoutPrimaryKey',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'RelationKind', relation_kind,
                        'EstimatedLiveRows', estimated_live_rows,
                        'TableSizeBytes', table_size_bytes
                    )
                    ORDER BY table_size_bytes DESC
                )
                FROM user_tables_without_pk
            ),
            'FindingReason',
            'One or more user tables do not have a primary key.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Data Modeling',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'All user tables have primary keys.'
        ELSE
            'Review user tables without primary keys and add an appropriate primary key where application design allows.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #31: max_connections Configuration Risk
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 31;
    v_CheckTitle          text    := $check_title$max_connections Configuration Risk$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: max_connections is configured with a potentially risky value.
   A high max_connections setting can increase memory pressure because each
   backend process consumes memory, and query operations may allocate additional
   memory such as work_mem.

   WHY THIS MATTERS:
   PostgreSQL uses one backend process per connection. Setting max_connections
   too high can reduce stability, increase context switching, and amplify memory
   usage during concurrent workloads.

   Recommendations:
   Review max_connections together with active connection usage, application
   concurrency, available RAM, work_mem, maintenance_work_mem, and connection
   pooling strategy. Consider using PgBouncer or another connection pooler
   instead of allowing excessive direct database connections.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-connection.html
   https://www.postgresql.org/docs/current/runtime-config-resource.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('max_connections')::int <= 500
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'MaxConnections', current_setting('max_connections')::int,
            'WorkMem', current_setting('work_mem', true),
            'WorkMemBytes', pg_size_bytes(current_setting('work_mem')),
            'EstimatedWorkMemExposureBytes',
                current_setting('max_connections')::bigint
                * pg_size_bytes(current_setting('work_mem')),
            'SharedBuffers', current_setting('shared_buffers', true),
            'FindingReason',
                'max_connections is configured above 500, which may create memory pressure and connection-management overhead.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'max_connections is within the expected global range.'
        ELSE
            'Review max_connections and consider reducing direct database connections by using connection pooling.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #32: shared_buffers Appears Very Small
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 32;
    v_CheckTitle          text    := $check_title$shared_buffers Appears Very Small$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: shared_buffers appears to be very small. This may indicate
   that PostgreSQL has not been tuned for the server workload or available
   memory.

   WHY THIS MATTERS:
   shared_buffers is PostgreSQL's main shared memory area for caching table and
   index pages. If it is too small, PostgreSQL may rely more heavily on the
   operating system cache and perform more physical I/O than necessary.

   Recommendations:
   Review shared_buffers together with total server RAM, workload type,
   effective_cache_size, checkpoint behavior, and operating system memory usage.
   For dedicated PostgreSQL servers, shared_buffers is commonly sized as a
   meaningful portion of RAM, but should be tested before changing in production.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-resource.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('shared_buffers')) >= 134217728 -- 128 MB
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'SharedBuffers', current_setting('shared_buffers', true),
            'SharedBuffersBytes', pg_size_bytes(current_setting('shared_buffers')),
            'EffectiveCacheSize', current_setting('effective_cache_size', true),
            'BlockSize', current_setting('block_size', true),
            'FindingReason',
                'shared_buffers is configured below 128 MB, which appears very small for many production PostgreSQL servers.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'shared_buffers does not appear to be very small.'
        ELSE
            'Review shared_buffers sizing and tune it according to server RAM, workload characteristics, and production testing.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #33: effective_cache_size Appears Very Small
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 33;
    v_CheckTitle          text    := $check_title$effective_cache_size Appears Very Small$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: effective_cache_size appears to be very small. This may cause
   the PostgreSQL planner to underestimate the amount of data likely to be
   cached by PostgreSQL and the operating system.

   WHY THIS MATTERS:
   effective_cache_size is a planner cost estimate, not a memory allocation.
   If it is too low, PostgreSQL may avoid index scans even when they would be
   beneficial, potentially leading to inefficient query plans.

   Recommendations:
   Review effective_cache_size together with total server RAM, shared_buffers,
   operating system cache, workload type, and concurrent services on the server.
   For dedicated PostgreSQL servers, configure it to reflect the estimated memory
   available for caching data.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-query.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('effective_cache_size')) >= 536870912 -- 512 MB
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'EffectiveCacheSize', current_setting('effective_cache_size', true),
            'EffectiveCacheSizeBytes', pg_size_bytes(current_setting('effective_cache_size')),
            'SharedBuffers', current_setting('shared_buffers', true),
            'SharedBuffersBytes', pg_size_bytes(current_setting('shared_buffers')),
            'FindingReason',
                'effective_cache_size is configured below 512 MB, which appears very small for many production PostgreSQL servers.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'effective_cache_size does not appear to be very small.'
        ELSE
            'Review effective_cache_size and tune it to reflect the estimated memory available for PostgreSQL and operating system caching.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #34: maintenance_work_mem Appears Too Low
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 34;
    v_CheckTitle          text    := $check_title$maintenance_work_mem Appears Too Low$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: maintenance_work_mem appears to be too low. This can make
   maintenance operations such as VACUUM, CREATE INDEX, ALTER TABLE ADD FOREIGN
   KEY, and other index-related operations slower than necessary.

   WHY THIS MATTERS:
   maintenance_work_mem controls the maximum memory used by maintenance
   operations. If it is too small, PostgreSQL may need more passes or more
   temporary disk work during maintenance tasks, increasing runtime and I/O.

   Recommendations:
   Review maintenance_work_mem together with server RAM, maintenance workload,
   autovacuum settings, and concurrent maintenance operations. Consider
   increasing it for production systems, especially before large index builds or
   maintenance windows.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-resource.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('maintenance_work_mem')) >= 67108864 -- 64 MB
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'MaintenanceWorkMem', current_setting('maintenance_work_mem', true),
            'MaintenanceWorkMemBytes', pg_size_bytes(current_setting('maintenance_work_mem')),
            'AutovacuumWorkMem', current_setting('autovacuum_work_mem', true),
            'MaxParallelMaintenanceWorkers', current_setting('max_parallel_maintenance_workers', true),
            'FindingReason',
                'maintenance_work_mem is configured below 64 MB, which may slow maintenance operations.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'maintenance_work_mem does not appear to be too low.'
        ELSE
            'Review maintenance_work_mem and consider increasing it to improve maintenance operation performance, while accounting for available RAM and concurrency.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #35: idle_in_transaction_session_timeout is Not Configured
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 35;
    v_CheckTitle          text    := $check_title$idle_in_transaction_session_timeout is Not Configured$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: idle_in_transaction_session_timeout is not configured. This
   allows sessions that are idle while holding an open transaction to remain
   open indefinitely.

   WHY THIS MATTERS:
   Idle transactions can hold locks, prevent vacuum cleanup, retain old row
   versions, increase table and index bloat, and contribute to transaction ID
   wraparound risk. They can also block DDL and other application activity.

   Recommendations:
   Configure idle_in_transaction_session_timeout to a reasonable value based on
   application behavior. Common starting values are several minutes for OLTP
   systems, but the value should be tested to avoid interrupting legitimate
   long-running workflows.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-client.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('idle_in_transaction_session_timeout')) > 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'IdleInTransactionSessionTimeout',
                current_setting('idle_in_transaction_session_timeout', true),
            'FindingReason',
                'idle_in_transaction_session_timeout is set to 0, meaning idle transactions are allowed to remain open indefinitely.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'idle_in_transaction_session_timeout is configured.'
        ELSE
            'Configure idle_in_transaction_session_timeout to prevent idle transactions from remaining open indefinitely.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #36: statement_timeout is Not Configured
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 36;
    v_CheckTitle          text    := $check_title$statement_timeout is Not Configured$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: statement_timeout is not configured. This allows queries to
   run indefinitely unless they are cancelled manually or terminated by another
   mechanism.

   WHY THIS MATTERS:
   Runaway queries, inefficient execution plans, application bugs, or accidental
   full-table operations can consume CPU, memory, I/O, and locks for extended
   periods. A statement timeout provides a safety mechanism that helps prevent
   individual queries from impacting overall database availability.

   Recommendations:
   Configure statement_timeout to a value appropriate for the workload.
   Consider applying different timeout values at the role, database, or
   application level rather than a single global setting. Validate application
   behavior before enabling timeouts in production.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-client.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('statement_timeout')) > 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'StatementTimeout',
                current_setting('statement_timeout', true),
            'FindingReason',
                'statement_timeout is set to 0, allowing queries to run without a timeout.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'statement_timeout is configured.'
        ELSE
            'Consider configuring statement_timeout to prevent runaway queries from consuming resources indefinitely.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #37: lock_timeout is Not Configured
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 37;
    v_CheckTitle          text    := $check_title$lock_timeout is Not Configured$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: lock_timeout is not configured. This allows sessions to wait
   indefinitely when attempting to acquire locks held by other transactions.

   WHY THIS MATTERS:
   Long lock waits can lead to application slowdowns, blocked sessions, reduced
   throughput, and operational incidents. A lock timeout helps prevent sessions
   from waiting forever on lock contention and allows applications to handle
   blocking situations more predictably.

   Recommendations:
   Consider configuring lock_timeout to a value appropriate for the workload.
   Evaluate application retry logic and transaction patterns before enabling
   lock timeouts in production. Different values may be appropriate at the
   role, database, or application level.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-client.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('lock_timeout')) > 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LockTimeout',
                current_setting('lock_timeout', true),
            'FindingReason',
                'lock_timeout is set to 0, allowing sessions to wait indefinitely for locks.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'lock_timeout is configured.'
        ELSE
            'Consider configuring lock_timeout to prevent sessions from waiting indefinitely on lock contention.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #38: track_io_timing is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 38;
    v_CheckTitle          text    := $check_title$track_io_timing is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: track_io_timing is disabled. This prevents PostgreSQL from
   collecting block read and write timing information for query and database
   activity.

   WHY THIS MATTERS:
   Without I/O timing data, it is harder to distinguish CPU-bound workloads from
   I/O-bound workloads and to diagnose slow queries, storage latency, cache
   efficiency, and read/write bottlenecks.

   Recommendations:
   Consider enabling track_io_timing, especially for production systems where
   query performance troubleshooting is important. Test overhead in the target
   environment before enabling globally.

   Scope : Cluster-level
   Category : Monitoring

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-statistics.html
   https://www.postgresql.org/docs/current/monitoring-stats.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('track_io_timing', true) = 'on'
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'TrackIOTiming',
                current_setting('track_io_timing', true),
            'FindingReason',
                'track_io_timing is disabled, so PostgreSQL is not collecting I/O timing statistics.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'track_io_timing is enabled.'
        ELSE
            'Consider enabling track_io_timing to improve visibility into PostgreSQL I/O latency and performance bottlenecks.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #39: log_temp_files is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 39;
    v_CheckTitle          text    := $check_title$log_temp_files is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: log_temp_files is disabled. This prevents PostgreSQL from
   logging temporary file usage generated by queries that spill to disk.

   WHY THIS MATTERS:
   Temporary file creation often indicates insufficient work_mem, inefficient
   query plans, large sorts, hash operations, or reporting workloads. Without
   logging, it can be difficult to identify queries that generate excessive
   temporary I/O and negatively impact performance.

   Recommendations:
   Consider configuring log_temp_files to capture temporary file activity.
   A common starting value is 0 (log all temporary files) or a threshold such
   as 10 MB to reduce logging volume while still identifying significant spills.

   Scope : Cluster-level
   Category : Monitoring

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-logging.html
   https://www.postgresql.org/docs/current/runtime-config-resource.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('log_temp_files', true)::integer >= 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LogTempFiles',
                current_setting('log_temp_files', true),
            'FindingReason',
                'log_temp_files is disabled (-1), so temporary file creation is not being logged.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'log_temp_files is configured.'
        ELSE
            'Consider enabling log_temp_files to help identify queries that spill to disk and generate excessive temporary I/O.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #40: Slow Statement Logging is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 40;
    v_CheckTitle          text    := $check_title$Slow Statement Logging is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: slow statement logging is disabled. PostgreSQL is not
   configured to log long-running statements.

   WHY THIS MATTERS:
   Slow query logging is one of the most effective methods for identifying
   inefficient SQL statements, missing indexes, plan regressions, application
   bottlenecks, and workload changes. Without it, performance troubleshooting
   often requires reactive investigation after issues occur.

   Recommendations:
   Configure log_min_duration_statement to an appropriate threshold for the
   workload. Common starting values range from 500 ms to several seconds,
   depending on application requirements and logging volume considerations.
   
   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-logging.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('log_min_duration_statement', true)::integer >= 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LogMinDurationStatement',
                current_setting('log_min_duration_statement', true),
            'FindingReason',
                'log_min_duration_statement is disabled (-1), so slow statements are not being logged.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Slow statement logging is configured.'
        ELSE
            'Consider configuring log_min_duration_statement to capture long-running queries and improve performance troubleshooting capabilities.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #41: log_lock_waits is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 41;
    v_CheckTitle          text    := $check_title$log_lock_waits is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: log_lock_waits is disabled. PostgreSQL is not configured to
   log sessions that wait longer than deadlock_timeout while trying to acquire
   a lock.

   WHY THIS MATTERS:
   Lock waits can cause application slowdowns, blocked sessions, transaction
   pileups, and operational incidents. Without lock-wait logging, it is harder
   to identify blocking patterns, problematic transactions, migration issues,
   and queries that hold locks for too long.

   Recommendations:
   Enable log_lock_waits to improve visibility into lock contention. Review
   deadlock_timeout as well, because it controls how long PostgreSQL waits
   before logging lock waits when log_lock_waits is enabled.

   Scope : Cluster-level
   Category : Monitoring

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-logging.html
   https://www.postgresql.org/docs/current/runtime-config-locks.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('log_lock_waits', true) = 'on'
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LogLockWaits',
                current_setting('log_lock_waits', true),
            'DeadlockTimeout',
                current_setting('deadlock_timeout', true),
            'FindingReason',
                'log_lock_waits is disabled, so PostgreSQL is not logging long lock waits.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'log_lock_waits is enabled.'
        ELSE
            'Enable log_lock_waits to improve visibility into lock contention and long lock waits.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #42: log_checkpoints is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 42;
    v_CheckTitle          text    := $check_title$log_checkpoints is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: log_checkpoints is disabled. PostgreSQL is not configured to
   log checkpoint activity.

   WHY THIS MATTERS:
   Checkpoint logging helps identify checkpoint frequency, write pressure,
   sync time, and potential I/O spikes. Without it, it is harder to diagnose
   performance issues related to checkpoint tuning, WAL volume, storage latency,
   or sudden bursts of disk writes.

   Recommendations:
   Enable log_checkpoints to improve visibility into checkpoint behavior.
   Review checkpoint_timeout, max_wal_size, checkpoint_completion_target, and
   storage performance when checkpoint activity appears excessive.

   Scope : Cluster-level
   Category : Monitoring

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-logging.html
   https://www.postgresql.org/docs/current/wal-configuration.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('log_checkpoints', true) = 'on'
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LogCheckpoints',
                current_setting('log_checkpoints', true),
            'CheckpointTimeout',
                current_setting('checkpoint_timeout', true),
            'MaxWalSize',
                current_setting('max_wal_size', true),
            'CheckpointCompletionTarget',
                current_setting('checkpoint_completion_target', true),
            'FindingReason',
                'log_checkpoints is disabled, so PostgreSQL is not logging checkpoint activity.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'log_checkpoints is enabled.'
        ELSE
            'Enable log_checkpoints to improve visibility into checkpoint frequency, checkpoint duration, and storage write pressure.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #43: log_autovacuum_min_duration is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 43;
    v_CheckTitle          text    := $check_title$log_autovacuum_min_duration is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: log_autovacuum_min_duration is disabled. PostgreSQL is not
   configured to log autovacuum activity.

   WHY THIS MATTERS:
   Autovacuum logging helps identify tables with heavy churn, slow vacuum
   activity, frequent analyze operations, dead tuple accumulation, wraparound
   prevention activity, and maintenance pressure. Without it, it is harder to
   troubleshoot table bloat, stale statistics, and autovacuum performance issues.

   Recommendations:
   Configure log_autovacuum_min_duration to an appropriate threshold. A common
   starting value is several seconds, such as 5000 ms or 10000 ms, to capture
   expensive autovacuum activity without excessive logging. Use 0 temporarily
   when deeper autovacuum diagnostics are required.

   Scope : Cluster-level
   Category : Monitoring

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-logging.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('log_autovacuum_min_duration', true)::integer >= 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LogAutovacuumMinDuration',
                current_setting('log_autovacuum_min_duration', true),
            'Autovacuum',
                current_setting('autovacuum', true),
            'AutovacuumNaptime',
                current_setting('autovacuum_naptime', true),
            'FindingReason',
                'log_autovacuum_min_duration is disabled (-1), so autovacuum activity is not being logged.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Observability',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'log_autovacuum_min_duration is configured.'
        ELSE
            'Configure log_autovacuum_min_duration to improve visibility into autovacuum activity and table maintenance behavior.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #44: Autovacuum Worker Capacity Review
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 44;
    v_CheckTitle          text    := $check_title$Autovacuum Worker Capacity Review$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: autovacuum worker capacity may be too low for the workload.
   A low autovacuum_max_workers setting can limit how many tables PostgreSQL can
   vacuum or analyze concurrently.

   WHY THIS MATTERS:
   If autovacuum cannot keep up with table churn, dead tuples may accumulate,
   statistics may become stale, tables and indexes may bloat, and transaction ID
   wraparound risk may increase. This is especially important on databases with
   many large or frequently updated tables.

   Recommendations:
   Review autovacuum_max_workers together with autovacuum_naptime,
   autovacuum_vacuum_cost_limit, autovacuum_vacuum_cost_delay, table churn,
   dead tuple counts, and server resources. Consider increasing worker capacity
   when many tables regularly require vacuum or analyze work.

   Scope : Cluster-level
   Category : Maintenance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
   https://www.postgresql.org/docs/current/monitoring-stats.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('autovacuum', true) = 'on'
         AND current_setting('autovacuum_max_workers', true)::integer >= 3
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'Autovacuum',
                current_setting('autovacuum', true),
            'AutovacuumMaxWorkers',
                current_setting('autovacuum_max_workers', true),
            'AutovacuumNaptime',
                current_setting('autovacuum_naptime', true),
            'AutovacuumVacuumCostLimit',
                current_setting('autovacuum_vacuum_cost_limit', true),
            'AutovacuumVacuumCostDelay',
                current_setting('autovacuum_vacuum_cost_delay', true),
            'FindingReason',
                CASE
                    WHEN current_setting('autovacuum', true) <> 'on'
                        THEN 'autovacuum is disabled, so worker capacity is not available.'
                    ELSE
                        'autovacuum_max_workers is below 3, which may limit autovacuum capacity on active systems.'
                END
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Autovacuum worker capacity appears to be within the expected baseline.'
        ELSE
            'Review autovacuum worker capacity and consider increasing autovacuum_max_workers if autovacuum is not keeping up with table churn.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #45: Autovacuum Naptime Review
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 45;
    v_CheckTitle          text    := $check_title$Autovacuum Naptime Review$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: autovacuum_naptime may not be appropriate for the workload.
   A large autovacuum_naptime increases the time between autovacuum launcher
   cycles, potentially delaying vacuum and analyze activity.

   WHY THIS MATTERS:
   If autovacuum checks tables too infrequently, dead tuples and stale
   statistics can accumulate before maintenance is triggered. This can lead
   to table bloat, index bloat, suboptimal query plans, and increased
   maintenance pressure on busy systems.

   Recommendations:
   Review autovacuum_naptime together with table churn, autovacuum worker
   capacity, dead tuple growth, and maintenance activity. Consider reducing
   autovacuum_naptime if vacuum and analyze operations are not keeping pace
   with workload changes.

   Scope : Cluster-level
   Category : Maintenance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('autovacuum_naptime')) <= 300000 -- 5 minutes
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'AutovacuumNaptime',
                current_setting('autovacuum_naptime', true),
            'AutovacuumMaxWorkers',
                current_setting('autovacuum_max_workers', true),
            'AutovacuumVacuumCostLimit',
                current_setting('autovacuum_vacuum_cost_limit', true),
            'AutovacuumVacuumCostDelay',
                current_setting('autovacuum_vacuum_cost_delay', true),
            'FindingReason',
                'autovacuum_naptime is configured above 5 minutes, which may delay autovacuum responsiveness on busy systems.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'autovacuum_naptime appears to be within the expected range.'
        ELSE
            'Review autovacuum_naptime and consider reducing it if autovacuum is not reacting quickly enough to workload changes.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #46: Autovacuum Scale Factor Review for Large Tables
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 46;
    v_CheckTitle          text    := $check_title$Autovacuum Scale Factor Review for Large Tables$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: autovacuum scale factor settings may be too high for large
   tables. Large tables can require a very large number of row changes before
   autovacuum is triggered when scale-factor-based thresholds are used.

   WHY THIS MATTERS:
   On large tables, high autovacuum_vacuum_scale_factor or
   autovacuum_analyze_scale_factor values can delay vacuum and analyze activity.
   This may allow dead tuples to accumulate, increase table and index bloat,
   delay statistics refreshes, and contribute to poor query plans or wraparound
   pressure.

   Recommendations:
   Review large tables and consider table-level autovacuum settings using lower
   scale factors and/or fixed thresholds. Prioritize frequently updated large
   tables with high dead tuple counts or stale statistics.

   Scope : Cluster-level
   Category : Maintenance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
   https://www.postgresql.org/docs/current/sql-altertable.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
*/

v_AdditionalInfo := (
    WITH table_autovacuum_settings AS (
        SELECT
            nsp.nspname AS schema_name,
            cls.relname AS table_name,
            cls.oid AS table_oid,
            pg_total_relation_size(cls.oid) AS table_size_bytes,
            COALESCE(st.n_live_tup, 0) AS estimated_live_rows,
            COALESCE(st.n_dead_tup, 0) AS estimated_dead_rows,
            st.last_autovacuum,
            st.last_autoanalyze,
            current_setting('autovacuum_vacuum_scale_factor')::numeric
                AS global_vacuum_scale_factor,
            current_setting('autovacuum_vacuum_threshold')::integer
                AS global_vacuum_threshold,
            current_setting('autovacuum_analyze_scale_factor')::numeric
                AS global_analyze_scale_factor,
            current_setting('autovacuum_analyze_threshold')::integer
                AS global_analyze_threshold,
            (
                SELECT option_value::numeric
                FROM pg_options_to_table(cls.reloptions)
                WHERE option_name = 'autovacuum_vacuum_scale_factor'
            ) AS table_vacuum_scale_factor,
            (
                SELECT option_value::integer
                FROM pg_options_to_table(cls.reloptions)
                WHERE option_name = 'autovacuum_vacuum_threshold'
            ) AS table_vacuum_threshold,
            (
                SELECT option_value::numeric
                FROM pg_options_to_table(cls.reloptions)
                WHERE option_name = 'autovacuum_analyze_scale_factor'
            ) AS table_analyze_scale_factor,
            (
                SELECT option_value::integer
                FROM pg_options_to_table(cls.reloptions)
                WHERE option_name = 'autovacuum_analyze_threshold'
            ) AS table_analyze_threshold
        FROM pg_class cls
        JOIN pg_namespace nsp
            ON nsp.oid = cls.relnamespace
        LEFT JOIN pg_stat_user_tables st
            ON st.relid = cls.oid
        WHERE cls.relkind IN ('r', 'p')
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
    ),
    calculated_thresholds AS (
        SELECT
            *,
            COALESCE(table_vacuum_scale_factor, global_vacuum_scale_factor)
                AS effective_vacuum_scale_factor,
            COALESCE(table_vacuum_threshold, global_vacuum_threshold)
                AS effective_vacuum_threshold,
            COALESCE(table_analyze_scale_factor, global_analyze_scale_factor)
                AS effective_analyze_scale_factor,
            COALESCE(table_analyze_threshold, global_analyze_threshold)
                AS effective_analyze_threshold
        FROM table_autovacuum_settings
    ),
    large_table_risks AS (
        SELECT
            *,
            (
                effective_vacuum_threshold
                + floor(effective_vacuum_scale_factor * estimated_live_rows)
            )::bigint AS estimated_vacuum_trigger_rows,
            (
                effective_analyze_threshold
                + floor(effective_analyze_scale_factor * estimated_live_rows)
            )::bigint AS estimated_analyze_trigger_rows
        FROM calculated_thresholds
        WHERE table_size_bytes >= 1073741824 -- 1 GB
          AND estimated_live_rows >= 1000000
          AND (
                effective_vacuum_scale_factor >= 0.10
             OR effective_analyze_scale_factor >= 0.05
          )
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM large_table_risks)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LargeTablesWithHighAutovacuumScaleFactors',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'TableSizeBytes', table_size_bytes,
                        'EstimatedLiveRows', estimated_live_rows,
                        'EstimatedDeadRows', estimated_dead_rows,
                        'EffectiveVacuumScaleFactor', effective_vacuum_scale_factor,
                        'EffectiveVacuumThreshold', effective_vacuum_threshold,
                        'EstimatedVacuumTriggerRows', estimated_vacuum_trigger_rows,
                        'EffectiveAnalyzeScaleFactor', effective_analyze_scale_factor,
                        'EffectiveAnalyzeThreshold', effective_analyze_threshold,
                        'EstimatedAnalyzeTriggerRows', estimated_analyze_trigger_rows,
                        'LastAutovacuum', last_autovacuum,
                        'LastAutoanalyze', last_autoanalyze
                    )
                    ORDER BY table_size_bytes DESC
                )
                FROM large_table_risks
            ),
            'FindingReason',
            'One or more large tables have autovacuum or autoanalyze scale factors that may delay maintenance activity.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Large table autovacuum scale factors appear to be within the expected review range.'
        ELSE
            'Review large-table autovacuum settings and consider lower table-level scale factors or fixed thresholds for high-churn tables.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #47: Large Tables with No Recent Analyze
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 47;
    v_CheckTitle          text    := $check_title$Large Tables with No Recent Analyze$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: large tables have not been analyzed recently. This may indicate
   stale planner statistics on important tables.

   WHY THIS MATTERS:
   PostgreSQL relies on table statistics to choose efficient query plans. If
   large tables are not analyzed regularly, the planner may make poor estimates,
   choose inefficient joins or scans, and cause query performance regressions.

   Recommendations:
   Review large tables with no recent analyze activity. Confirm that autovacuum
   and autoanalyze are enabled and keeping up. Consider running ANALYZE manually
   for affected tables and tuning table-level autovacuum analyze thresholds for
   high-change or large tables.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/sql-analyze.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
   https://www.postgresql.org/docs/current/monitoring-stats.html
*/

v_AdditionalInfo := (
    WITH large_tables AS (
        SELECT
            nsp.nspname AS schema_name,
            cls.relname AS table_name,
            cls.oid AS table_oid,
            pg_total_relation_size(cls.oid) AS table_size_bytes,
            COALESCE(st.n_live_tup, 0) AS estimated_live_rows,
            COALESCE(st.n_mod_since_analyze, 0) AS rows_modified_since_analyze,
            st.last_analyze,
            st.last_autoanalyze,
            GREATEST(st.last_analyze, st.last_autoanalyze) AS last_analyze_activity
        FROM pg_class cls
        JOIN pg_namespace nsp
            ON nsp.oid = cls.relnamespace
        LEFT JOIN pg_stat_user_tables st
            ON st.relid = cls.oid
        WHERE cls.relkind IN ('r', 'p')
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
          AND pg_total_relation_size(cls.oid) >= 1073741824 -- 1 GB
    ),
    large_tables_without_recent_analyze AS (
        SELECT
            *
        FROM large_tables
        WHERE last_analyze_activity IS NULL
           OR last_analyze_activity < now() - interval '30 days'
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM large_tables_without_recent_analyze)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LargeTablesWithNoRecentAnalyze',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'TableSizeBytes', table_size_bytes,
                        'EstimatedLiveRows', estimated_live_rows,
                        'RowsModifiedSinceAnalyze', rows_modified_since_analyze,
                        'LastAnalyze', last_analyze,
                        'LastAutoAnalyze', last_autoanalyze,
                        'LastAnalyzeActivity', last_analyze_activity
                    )
                    ORDER BY table_size_bytes DESC
                )
                FROM large_tables_without_recent_analyze
            ),
            'FindingReason',
            'One or more large tables have not been analyzed in the last 30 days or have no recorded analyze activity.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Large tables appear to have recent analyze activity.'
        ELSE
            'Review large tables without recent analyze activity. Run ANALYZE where needed and tune autoanalyze thresholds for important large tables.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #48: Large Tables with No Recent Vacuum
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 48;
    v_CheckTitle          text    := $check_title$Large Tables with No Recent Vacuum$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: large tables have not been vacuumed recently. This may indicate
   that dead tuples are not being cleaned up regularly on important tables.

   WHY THIS MATTERS:
   PostgreSQL relies on VACUUM and autovacuum to reclaim dead tuples, reduce
   table and index bloat, maintain visibility map information, and reduce
   transaction ID wraparound risk. If large tables are not vacuumed regularly,
   performance and storage usage may degrade over time.

   Recommendations:
   Review large tables with no recent vacuum activity. Confirm that autovacuum
   is enabled and keeping up with table churn. Consider running VACUUM manually
   for affected tables and tuning table-level autovacuum thresholds for large
   or frequently updated tables.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/sql-vacuum.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
   https://www.postgresql.org/docs/current/monitoring-stats.html
*/

v_AdditionalInfo := (
    WITH large_tables AS (
        SELECT
            nsp.nspname AS schema_name,
            cls.relname AS table_name,
            cls.oid AS table_oid,
            pg_total_relation_size(cls.oid) AS table_size_bytes,
            COALESCE(st.n_live_tup, 0) AS estimated_live_rows,
            COALESCE(st.n_dead_tup, 0) AS estimated_dead_rows,
            st.last_vacuum,
            st.last_autovacuum,
            GREATEST(st.last_vacuum, st.last_autovacuum) AS last_vacuum_activity
        FROM pg_class cls
        JOIN pg_namespace nsp
            ON nsp.oid = cls.relnamespace
        LEFT JOIN pg_stat_user_tables st
            ON st.relid = cls.oid
        WHERE cls.relkind IN ('r', 'p')
          AND nsp.nspname NOT IN ('pg_catalog', 'information_schema')
          AND pg_total_relation_size(cls.oid) >= 1073741824 -- 1 GB
    ),
    large_tables_without_recent_vacuum AS (
        SELECT *
        FROM large_tables
        WHERE last_vacuum_activity IS NULL
           OR last_vacuum_activity < now() - interval '30 days'
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM large_tables_without_recent_vacuum)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'LargeTablesWithNoRecentVacuum',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'TableSizeBytes', table_size_bytes,
                        'EstimatedLiveRows', estimated_live_rows,
                        'EstimatedDeadRows', estimated_dead_rows,
                        'LastVacuum', last_vacuum,
                        'LastAutovacuum', last_autovacuum,
                        'LastVacuumActivity', last_vacuum_activity
                    )
                    ORDER BY table_size_bytes DESC
                )
                FROM large_tables_without_recent_vacuum
            ),
            'FindingReason',
            'One or more large tables have not been vacuumed in the last 30 days or have no recorded vacuum activity.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Large tables appear to have recent vacuum activity.'
        ELSE
            'Review large tables without recent vacuum activity. Run VACUUM where needed and tune autovacuum thresholds for important large or high-churn tables.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #49: Tables with High Insert Update Delete Activity
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 49;
    v_CheckTitle          text    := $check_title$Tables with High Insert Update Delete Activity$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: tables with high INSERT, UPDATE, and DELETE activity were found.
   These tables experience significant write activity and may require closer
   maintenance, indexing, autovacuum, and bloat review.

   WHY THIS MATTERS:
   High write activity can generate dead tuples, increase WAL volume, create
   index maintenance overhead, trigger frequent autovacuum work, and contribute
   to table or index bloat. These tables are often the most important candidates
   for autovacuum tuning, index review, and performance monitoring.

   Recommendations:
   Review high-activity tables together with dead tuple counts, autovacuum
   history, table size, index count, query patterns, and application workload.
   Consider tuning table-level autovacuum settings, removing redundant indexes,
   and validating that write-heavy tables have appropriate maintenance capacity.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/routine-vacuuming.html
   https://www.postgresql.org/docs/current/runtime-config-autovacuum.html
*/

v_AdditionalInfo := (
    WITH database_stats AS (
        SELECT
            datname,
            stats_reset
        FROM pg_stat_database
        WHERE datname = current_database()
    ),
    table_activity AS (
        SELECT
            schemaname AS schema_name,
            relname AS table_name,
            relid AS table_oid,
            pg_total_relation_size(relid) AS table_size_bytes,
            COALESCE(n_live_tup, 0) AS estimated_live_rows,
            COALESCE(n_dead_tup, 0) AS estimated_dead_rows,
            COALESCE(n_tup_ins, 0) AS rows_inserted,
            COALESCE(n_tup_upd, 0) AS rows_updated,
            COALESCE(n_tup_del, 0) AS rows_deleted,
            COALESCE(n_tup_hot_upd, 0) AS hot_rows_updated,
            (
                COALESCE(n_tup_ins, 0)
                + COALESCE(n_tup_upd, 0)
                + COALESCE(n_tup_del, 0)
            ) AS total_write_activity,
            last_vacuum,
            last_autovacuum,
            last_analyze,
            last_autoanalyze
        FROM pg_stat_user_tables
    ),
    high_activity_tables AS (
        SELECT
            ta.*,
            ds.stats_reset,
            CASE
                WHEN ta.estimated_live_rows > 0
                    THEN round(
                        (
                            ta.total_write_activity::numeric
                            / ta.estimated_live_rows::numeric
                        ),
                        2
                    )
                ELSE NULL
            END AS write_activity_to_live_rows_ratio
        FROM table_activity ta
        CROSS JOIN database_stats ds
        WHERE ta.total_write_activity >= 1000000
           OR (
                ta.estimated_live_rows >= 100000
            AND ta.total_write_activity >= ta.estimated_live_rows
           )
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM high_activity_tables)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'TablesWithHighInsertUpdateDeleteActivity',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'TableSizeBytes', table_size_bytes,
                        'EstimatedLiveRows', estimated_live_rows,
                        'EstimatedDeadRows', estimated_dead_rows,
                        'RowsInserted', rows_inserted,
                        'RowsUpdated', rows_updated,
                        'RowsDeleted', rows_deleted,
                        'HotRowsUpdated', hot_rows_updated,
                        'TotalWriteActivity', total_write_activity,
                        'WriteActivityToLiveRowsRatio', write_activity_to_live_rows_ratio,
                        'LastVacuum', last_vacuum,
                        'LastAutovacuum', last_autovacuum,
                        'LastAnalyze', last_analyze,
                        'LastAutoAnalyze', last_autoanalyze,
                        'StatsReset', stats_reset
                    )
                    ORDER BY total_write_activity DESC
                )
                FROM high_activity_tables
            ),
            'FindingReason',
            'One or more tables have high cumulative INSERT, UPDATE, and DELETE activity according to pg_stat_user_tables.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Maintenance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No tables exceeded the high INSERT, UPDATE, and DELETE activity review thresholds.'
        ELSE
            'Review high-write-activity tables for autovacuum tuning, bloat risk, redundant indexes, and maintenance capacity.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #50: Tables with High Sequential Scan Activity
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 50;
    v_CheckTitle          text    := $check_title$Tables with High Sequential Scan Activity$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: tables with high sequential scan activity were found. These
   tables are being scanned sequentially frequently, which may indicate missing
   indexes, inefficient query predicates, reporting workloads, or normal access
   patterns for small tables.

   WHY THIS MATTERS:
   Frequent sequential scans on large or frequently accessed tables can increase
   I/O, CPU usage, buffer churn, and query latency. High sequential scan activity
   should be reviewed together with table size, rows read, index usage, and query
   patterns before deciding whether indexing or query tuning is required.

   Recommendations:
   Review tables with high sequential scan activity. Use pg_stat_statements,
   execution plans, and application query patterns to identify whether indexes,
   query rewrites, partitioning, or statistics improvements are needed. Do not
   add indexes automatically, especially for small tables or intentional
   reporting scans.

   Scope : Database-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/indexes.html
   https://www.postgresql.org/docs/current/using-explain.html
*/

v_AdditionalInfo := (
    WITH table_scan_activity AS (
        SELECT
            schemaname AS schema_name,
            relname AS table_name,
            relid AS table_oid,
            pg_total_relation_size(relid) AS table_size_bytes,
            COALESCE(n_live_tup, 0) AS estimated_live_rows,
            COALESCE(seq_scan, 0) AS sequential_scans,
            COALESCE(seq_tup_read, 0) AS sequential_rows_read,
            COALESCE(idx_scan, 0) AS index_scans,
            CASE
                WHEN (COALESCE(seq_scan, 0) + COALESCE(idx_scan, 0)) > 0
                    THEN round(
                        COALESCE(seq_scan, 0)::numeric
                        / (COALESCE(seq_scan, 0) + COALESCE(idx_scan, 0))::numeric,
                        4
                    )
                ELSE NULL
            END AS sequential_scan_ratio
        FROM pg_stat_user_tables
    ),
    high_seq_scan_tables AS (
        SELECT *
        FROM table_scan_activity
        WHERE table_size_bytes >= 104857600 -- 100 MB
          AND (
                sequential_scans >= 1000
             OR sequential_rows_read >= 10000000
             OR (
                    sequential_scan_ratio >= 0.80
                AND sequential_scans >= 100
                )
          )
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM high_seq_scan_tables)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'TablesWithHighSequentialScanActivity',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'TableName', table_name,
                        'TableSizeBytes', table_size_bytes,
                        'EstimatedLiveRows', estimated_live_rows,
                        'SequentialScans', sequential_scans,
                        'SequentialRowsRead', sequential_rows_read,
                        'IndexScans', index_scans,
                        'SequentialScanRatio', sequential_scan_ratio
                    )
                    ORDER BY sequential_rows_read DESC
                )
                FROM high_seq_scan_tables
            ),
            'FindingReason',
            'One or more user tables have high sequential scan activity according to pg_stat_user_tables.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Performance',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No large user tables exceeded the sequential scan activity review thresholds.'
        ELSE
            'Review high sequential scan tables using pg_stat_statements and execution plans before adding or changing indexes.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #51: WAL Archiving is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 51;
    v_CheckTitle          text    := $check_title$WAL Archiving is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: WAL archiving is disabled. This means PostgreSQL is not
   configured to archive completed WAL segments for point-in-time recovery.

   WHY THIS MATTERS:
   Without WAL archiving, backup strategy may be limited to restoring only from
   base backups or platform snapshots. Point-in-time recovery may not be
   available, and recovery options after data corruption, accidental changes, or
   operational mistakes may be reduced.

   Recommendations:
   Enable archive_mode and configure a reliable archive_command or archive
   library according to the backup architecture. Validate that archived WAL files
   are being stored safely and that restore testing is performed regularly.

   Scope : Cluster-level
   Category : backup

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-wal.html
   https://www.postgresql.org/docs/current/continuous-archiving.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('archive_mode', true) IN ('on', 'always')
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'ArchiveMode',
                current_setting('archive_mode', true),
            'ArchiveCommand',
                current_setting('archive_command', true),
            'WalLevel',
                current_setting('wal_level', true),
            'FindingReason',
                'archive_mode is disabled, so PostgreSQL is not archiving WAL segments for point-in-time recovery.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Backup and Recovery',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'WAL archiving is enabled.'
        ELSE
            'Enable WAL archiving if point-in-time recovery is required for this PostgreSQL server.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #52: WAL Archiving Failures
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 52;
    v_CheckTitle          text    := $check_title$WAL Archiving Failures$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: WAL archiving failures were detected. PostgreSQL has
   attempted to archive completed WAL segments, but one or more archive attempts
   have failed.

   WHY THIS MATTERS:
   WAL archiving failures can break point-in-time recovery continuity. If WAL
   segments are not archived successfully, backups may be unable to restore to
   the desired recovery point, and the server may accumulate WAL files until
   disk space is exhausted.

   Recommendations:
   Review pg_stat_archiver, PostgreSQL logs, archive_command or archive library
   configuration, archive destination availability, permissions, storage
   capacity, and backup tooling. Resolve archive failures immediately and
   confirm that new WAL segments are archiving successfully.

   Scope : Cluster-level
   Category : Backup

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/continuous-archiving.html
   https://www.postgresql.org/docs/current/runtime-config-wal.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN COALESCE(failed_count, 0) = 0
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'ArchivedCount',
                archived_count,
            'LastArchivedWal',
                last_archived_wal,
            'LastArchivedTime',
                last_archived_time,
            'FailedCount',
                failed_count,
            'LastFailedWal',
                last_failed_wal,
            'LastFailedTime',
                last_failed_time,
            'StatsReset',
                stats_reset,
            'ArchiveMode',
                current_setting('archive_mode', true),
            'ArchiveCommand',
                current_setting('archive_command', true),
            'FindingReason',
                'pg_stat_archiver reports one or more failed WAL archive attempts since statistics were last reset.'
        )
    END
    FROM pg_stat_archiver
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Backup and Recovery',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No WAL archiving failures were reported by pg_stat_archiver.'
        ELSE
            'Investigate WAL archiving failures and confirm that archive_command or archive library is successfully archiving new WAL segments.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #53: Inactive Replication Slots
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 53;
    v_CheckTitle          text    := $check_title$Inactive Replication Slots$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: inactive replication slots exist. These slots are not currently
   connected to an active replication client but may still retain WAL.

   WHY THIS MATTERS:
   Inactive replication slots can prevent PostgreSQL from recycling old WAL
   files. If the slot is unused or abandoned, retained WAL can grow until disk
   space is exhausted. This can cause database outages and interrupt backup or
   replication operations.

   Recommendations:
   Review each inactive replication slot and confirm whether it is still needed.
   Drop abandoned slots only after validating with the application, backup,
   replication, or CDC owner. For PostgreSQL versions that support it, consider
   max_slot_wal_keep_size to limit WAL retention risk.

   Scope : Cluster-level
   Category : Replication

   REFERENCES:
   https://www.postgresql.org/docs/current/view-pg-replication-slots.html
   https://www.postgresql.org/docs/current/warm-standby.html#STREAMING-REPLICATION-SLOTS
   https://www.postgresql.org/docs/current/runtime-config-replication.html
*/

v_AdditionalInfo := (
    WITH inactive_slots AS (
        SELECT
            slot_name,
            plugin,
            slot_type,
            datoid,
            database,
            temporary,
            active,
            active_pid,
            restart_lsn,
            confirmed_flush_lsn,
            wal_status,
            safe_wal_size,
            two_phase,
            xmin,
            catalog_xmin,
            pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) AS retained_wal_bytes
        FROM pg_replication_slots
        WHERE active = false
          AND temporary = false
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM inactive_slots)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'InactiveReplicationSlots',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SlotName', slot_name,
                        'Plugin', plugin,
                        'SlotType', slot_type,
                        'Database', database,
                        'Active', active,
                        'RestartLsn', restart_lsn,
                        'ConfirmedFlushLsn', confirmed_flush_lsn,
                        'WalStatus', wal_status,
                        'SafeWalSize', safe_wal_size,
                        'TwoPhase', two_phase,
                        'Xmin', xmin,
                        'CatalogXmin', catalog_xmin,
                        'RetainedWalBytes', retained_wal_bytes
                    )
                    ORDER BY retained_wal_bytes DESC NULLS LAST
                )
                FROM inactive_slots
            ),
            'FindingReason',
            'One or more persistent replication slots are inactive and may retain WAL.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Replication',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No inactive persistent replication slots were found.'
        ELSE
            'Review inactive replication slots and drop abandoned slots only after confirming they are no longer required.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #54: Replication Lag Detected
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 54;
    v_CheckTitle          text    := $check_title$Replication Lag Detected$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: replication lag was detected. One or more connected replicas
   appear to be behind the primary based on WAL write, flush, replay, or byte
   lag information.

   WHY THIS MATTERS:
   Replication lag can increase recovery point exposure, delay read replica
   visibility, affect failover readiness, and cause stale reads for applications
   using replicas. Large or growing lag may indicate network issues, slow
   storage, replica resource pressure, long-running queries, or WAL apply
   bottlenecks.

   Recommendations:
   Review replication lag together with replica health, network latency,
   storage performance, WAL generation rate, long-running queries on replicas,
   replication slots, and PostgreSQL logs. Investigate replicas with high or
   increasing lag and confirm whether they are suitable for failover or reads.

   Scope : Cluster-level
   Category : Replication

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/warm-standby.html
   https://www.postgresql.org/docs/current/view-pg-stat-replication.html
*/

v_AdditionalInfo := (
    WITH replication_lag AS (
        SELECT
            pid,
            usename AS user_name,
            application_name,
            client_addr::text AS client_address,
            state,
            sync_state,
            sent_lsn,
            write_lsn,
            flush_lsn,
            replay_lsn,
            write_lag,
            flush_lag,
            replay_lag,
            pg_wal_lsn_diff(sent_lsn, write_lsn) AS write_lag_bytes,
            pg_wal_lsn_diff(sent_lsn, flush_lsn) AS flush_lag_bytes,
            pg_wal_lsn_diff(sent_lsn, replay_lsn) AS replay_lag_bytes
        FROM pg_stat_replication
        WHERE state IS DISTINCT FROM 'streaming'
           OR COALESCE(pg_wal_lsn_diff(sent_lsn, write_lsn), 0) > 104857600
           OR COALESCE(pg_wal_lsn_diff(sent_lsn, flush_lsn), 0) > 104857600
           OR COALESCE(pg_wal_lsn_diff(sent_lsn, replay_lsn), 0) > 104857600
           OR write_lag > interval '5 minutes'
           OR flush_lag > interval '5 minutes'
           OR replay_lag > interval '5 minutes'
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM replication_lag)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'ReplicationLagDetected',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'Pid', pid,
                        'UserName', user_name,
                        'ApplicationName', application_name,
                        'ClientAddress', client_address,
                        'State', state,
                        'SyncState', sync_state,
                        'SentLsn', sent_lsn,
                        'WriteLsn', write_lsn,
                        'FlushLsn', flush_lsn,
                        'ReplayLsn', replay_lsn,
                        'WriteLag', write_lag,
                        'FlushLag', flush_lag,
                        'ReplayLag', replay_lag,
                        'WriteLagBytes', write_lag_bytes,
                        'FlushLagBytes', flush_lag_bytes,
                        'ReplayLagBytes', replay_lag_bytes
                    )
                    ORDER BY replay_lag_bytes DESC NULLS LAST
                )
                FROM replication_lag
            ),
            'FindingReason',
            'One or more replicas are not streaming normally or exceed the replication lag review threshold.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Replication',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No replication lag exceeded the review threshold for connected replicas.'
        ELSE
            'Investigate replicas with lag or non-streaming state and confirm whether they are suitable for read traffic, recovery, or failover.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #55: Synchronous Replication Configuration Review
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 55;
    v_CheckTitle          text    := $check_title$Synchronous Replication Configuration Review$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: synchronous replication configuration should be reviewed.
   synchronous_commit or synchronous_standby_names may indicate that synchronous
   replication is disabled, partially configured, or configured in a way that
   may affect durability, latency, or failover expectations.

   WHY THIS MATTERS:
   Synchronous replication can reduce data loss risk by waiting for WAL
   confirmation from standby servers, but it can also increase transaction
   latency or block commits if required synchronous standbys are unavailable.
   If synchronous replication is expected but not configured correctly, recovery
   point objectives may not be met.

   Recommendations:
   Review synchronous_commit, synchronous_standby_names, connected standby
   servers, sync_state in pg_stat_replication, and business RPO/RTO
   requirements. Configure synchronous replication only where required, and
   validate failover behavior, quorum settings, and application latency impact.

   Scope : Cluster-level
   Category : Replication

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-replication.html
   https://www.postgresql.org/docs/current/warm-standby.html#SYNCHRONOUS-REPLICATION
   https://www.postgresql.org/docs/current/view-pg-stat-replication.html
*/

v_AdditionalInfo := (
    WITH sync_config AS (
        SELECT
            current_setting('synchronous_commit', true) AS synchronous_commit,
            current_setting('synchronous_standby_names', true) AS synchronous_standby_names
    ),
    replication_state AS (
        SELECT
            application_name,
            client_addr::text AS client_address,
            state,
            sync_state,
            sent_lsn,
            write_lsn,
            flush_lsn,
            replay_lsn,
            write_lag,
            flush_lag,
            replay_lag
        FROM pg_stat_replication
    ),
    review_needed AS (
        SELECT
            sc.*,
            EXISTS (
                SELECT 1
                FROM replication_state rs
                WHERE rs.sync_state IN ('sync', 'quorum')
            ) AS has_synchronous_standby,
            EXISTS (
                SELECT 1
                FROM replication_state
            ) AS has_connected_standby
        FROM sync_config sc
    )
    SELECT CASE
        WHEN synchronous_commit IN ('on', 'remote_write', 'remote_apply')
         AND COALESCE(NULLIF(synchronous_standby_names, ''), '') <> ''
         AND has_synchronous_standby
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'SynchronousCommit',
                synchronous_commit,
            'SynchronousStandbyNames',
                synchronous_standby_names,
            'HasConnectedStandby',
                has_connected_standby,
            'HasSynchronousStandby',
                has_synchronous_standby,
            'ReplicationState',
                COALESCE(
                    (
                        SELECT jsonb_agg(
                            jsonb_build_object(
                                'ApplicationName', application_name,
                                'ClientAddress', client_address,
                                'State', state,
                                'SyncState', sync_state,
                                'SentLsn', sent_lsn,
                                'WriteLsn', write_lsn,
                                'FlushLsn', flush_lsn,
                                'ReplayLsn', replay_lsn,
                                'WriteLag', write_lag,
                                'FlushLag', flush_lag,
                                'ReplayLag', replay_lag
                            )
                            ORDER BY application_name
                        )
                        FROM replication_state
                    ),
                    '[]'::jsonb
                ),
            'FindingReason',
                CASE
                    WHEN synchronous_commit = 'off'
                        THEN 'synchronous_commit is off, so commits do not wait for WAL flush confirmation.'
                    WHEN COALESCE(NULLIF(synchronous_standby_names, ''), '') = ''
                        THEN 'synchronous_standby_names is empty, so no synchronous standby requirement is configured.'
                    WHEN NOT has_connected_standby
                        THEN 'synchronous replication is configured, but no standby is currently connected.'
                    WHEN NOT has_synchronous_standby
                        THEN 'standbys are connected, but none are currently reported as synchronous or quorum.'
                    ELSE
                        'synchronous replication configuration should be reviewed against durability and latency requirements.'
                END
        )
    END
    FROM review_needed
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Replication',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Synchronous replication appears to be configured with at least one synchronous standby.'
        ELSE
            'Review synchronous replication configuration against business RPO/RTO requirements and confirm whether synchronous standby behavior is expected.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #56: wal_level Configuration Review
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 56;
    v_CheckTitle          text    := $check_title$wal_level Configuration Review$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: wal_level configuration should be reviewed.
   wal_level controls how much information PostgreSQL writes to WAL for crash
   recovery, replication, logical decoding, and point-in-time recovery support.

   WHY THIS MATTERS:
   If wal_level is set too low for the required architecture, streaming
   replication, logical replication, CDC tooling, or backup and recovery
   workflows may not work as expected. Higher wal_level settings can also
   increase WAL volume, so the setting should match the actual business and
   platform requirements.

   Recommendations:
   Review wal_level together with replication usage, logical decoding or CDC
   requirements, backup tooling, archive_mode, max_wal_senders, and replication
   slots. Use replica for physical replication and PITR requirements, and use
   logical only when logical replication or decoding is required.

   Scope : Cluster-level
   Category : Backup

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-wal.html
   https://www.postgresql.org/docs/current/wal-configuration.html
   https://www.postgresql.org/docs/current/logicaldecoding-explanation.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('wal_level', true) IN ('replica', 'logical')
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'WalLevel',
                current_setting('wal_level', true),
            'ArchiveMode',
                current_setting('archive_mode', true),
            'MaxWalSenders',
                current_setting('max_wal_senders', true),
            'MaxReplicationSlots',
                current_setting('max_replication_slots', true),
            'FindingReason',
                'wal_level is not configured as replica or logical, which may limit replication, PITR, or logical decoding capabilities.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Replication',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'wal_level is configured for replication, recovery, or logical decoding use cases.'
        ELSE
            'Review wal_level and configure it according to replication, backup, PITR, and logical decoding requirements.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #57: max_wal_size Appears Too Small
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 57;
    v_CheckTitle          text    := $check_title$max_wal_size Appears Too Small$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: max_wal_size appears to be too small. A low max_wal_size
   can cause PostgreSQL to perform checkpoints too frequently.

   WHY THIS MATTERS:
   Frequent checkpoints can increase I/O pressure, reduce write performance,
   create latency spikes, and increase WAL recycling overhead. On busy systems,
   a small max_wal_size may prevent PostgreSQL from spreading checkpoint writes
   smoothly over time.

   Recommendations:
   Review max_wal_size together with checkpoint frequency, checkpoint_timeout,
   checkpoint_completion_target, WAL generation rate, storage performance, and
   available disk capacity. Consider increasing max_wal_size if checkpoints are
   occurring too frequently or are caused by WAL volume rather than timeout.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-wal.html
   https://www.postgresql.org/docs/current/wal-configuration.html
   https://www.postgresql.org/docs/current/runtime-config-logging.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN pg_size_bytes(current_setting('max_wal_size')) >= 1073741824 -- 1 GB
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'MaxWalSize',
                current_setting('max_wal_size', true),
            'MaxWalSizeBytes',
                pg_size_bytes(current_setting('max_wal_size')),
            'MinWalSize',
                current_setting('min_wal_size', true),
            'CheckpointTimeout',
                current_setting('checkpoint_timeout', true),
            'CheckpointCompletionTarget',
                current_setting('checkpoint_completion_target', true),
            'LogCheckpoints',
                current_setting('log_checkpoints', true),
            'FindingReason',
                'max_wal_size is configured below 1 GB, which may cause frequent checkpoints on write-active PostgreSQL systems.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'WAL and Checkpoints',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'max_wal_size does not appear to be too small.'
        ELSE
            'Review max_wal_size and consider increasing it if checkpoint activity is too frequent for the workload.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #58: Checkpoint Pressure Detected
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 58;
    v_CheckTitle          text    := $check_title$Checkpoint Pressure Detected$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: checkpoint pressure was detected. PostgreSQL statistics
   show that checkpoints are occurring because WAL volume reaches max_wal_size,
   not only because checkpoint_timeout is reached.

   WHY THIS MATTERS:
   Frequent requested checkpoints can create write spikes, increase I/O
   pressure, reduce throughput, and cause latency instability. This often
   indicates that max_wal_size is too small for the WAL generation rate, or that
   checkpoint tuning and storage performance should be reviewed.

   Recommendations:
   Review pg_stat_bgwriter checkpoint activity together with max_wal_size,
   checkpoint_timeout, checkpoint_completion_target, log_checkpoints, WAL
   generation rate, and storage latency. Consider increasing max_wal_size if
   checkpoints are frequently requested before checkpoint_timeout is reached.

   Scope : Cluster-level
   Category : Backup

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/runtime-config-wal.html
   https://www.postgresql.org/docs/current/wal-configuration.html
*/

v_AdditionalInfo := (
    WITH checkpoint_stats AS (
        SELECT
            checkpoints_timed,
            checkpoints_req,
            checkpoint_write_time,
            checkpoint_sync_time,
            buffers_checkpoint,
            buffers_clean,
            maxwritten_clean,
            buffers_backend,
            buffers_backend_fsync,
            buffers_alloc,
            stats_reset,
            CASE
                WHEN (checkpoints_timed + checkpoints_req) > 0
                    THEN round(
                        checkpoints_req::numeric
                        / (checkpoints_timed + checkpoints_req)::numeric,
                        4
                    )
                ELSE 0
            END AS requested_checkpoint_ratio
        FROM pg_stat_bgwriter
    )
    SELECT CASE
        WHEN checkpoints_req < 10
          OR requested_checkpoint_ratio < 0.25
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'CheckpointsTimed',
                checkpoints_timed,
            'CheckpointsRequested',
                checkpoints_req,
            'RequestedCheckpointRatio',
                requested_checkpoint_ratio,
            'CheckpointWriteTimeMs',
                checkpoint_write_time,
            'CheckpointSyncTimeMs',
                checkpoint_sync_time,
            'BuffersCheckpoint',
                buffers_checkpoint,
            'BuffersClean',
                buffers_clean,
            'MaxwrittenClean',
                maxwritten_clean,
            'BuffersBackend',
                buffers_backend,
            'BuffersBackendFsync',
                buffers_backend_fsync,
            'BuffersAlloc',
                buffers_alloc,
            'StatsReset',
                stats_reset,
            'MaxWalSize',
                current_setting('max_wal_size', true),
            'CheckpointTimeout',
                current_setting('checkpoint_timeout', true),
            'CheckpointCompletionTarget',
                current_setting('checkpoint_completion_target', true),
            'LogCheckpoints',
                current_setting('log_checkpoints', true),
            'FindingReason',
                'A significant portion of checkpoints are requested checkpoints, which may indicate checkpoint pressure from WAL volume.'
        )
    END
    FROM checkpoint_stats
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'WAL and Checkpoints',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Checkpoint pressure was not detected based on pg_stat_bgwriter requested checkpoint activity.'
        ELSE
            'Review checkpoint pressure and consider increasing max_wal_size or tuning checkpoint behavior if requested checkpoints are frequent.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #59: High Requested Checkpoint Ratio
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 59;
    v_CheckTitle          text    := $check_title$High Requested Checkpoint Ratio$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: a high requested checkpoint ratio was detected.
   PostgreSQL statistics show that a significant portion of checkpoints were
   requested checkpoints rather than timed checkpoints.

   WHY THIS MATTERS:
   Requested checkpoints usually occur when WAL volume reaches max_wal_size
   before checkpoint_timeout is reached. A high requested checkpoint ratio can
   indicate that max_wal_size is too small for the workload, WAL generation is
   high, or checkpoint tuning should be reviewed. This can lead to write I/O
   spikes and latency instability.

   Recommendations:
   Review max_wal_size, checkpoint_timeout, checkpoint_completion_target,
   WAL generation rate, log_checkpoints output, and storage latency. Consider
   increasing max_wal_size if requested checkpoints are frequent and caused by
   normal WAL volume rather than unusual workload spikes.

   Scope : Cluster-level
   Category : Backup

   REFERENCES:
   https://www.postgresql.org/docs/current/monitoring-stats.html
   https://www.postgresql.org/docs/current/wal-configuration.html
   https://www.postgresql.org/docs/current/runtime-config-wal.html
*/

v_AdditionalInfo := (
    WITH checkpoint_stats AS (
        SELECT
            checkpoints_timed,
            checkpoints_req,
            checkpoint_write_time,
            checkpoint_sync_time,
            buffers_checkpoint,
            buffers_backend,
            buffers_backend_fsync,
            buffers_alloc,
            stats_reset,
            CASE
                WHEN (checkpoints_timed + checkpoints_req) > 0
                    THEN round(
                        checkpoints_req::numeric
                        / (checkpoints_timed + checkpoints_req)::numeric,
                        4
                    )
                ELSE 0
            END AS requested_checkpoint_ratio
        FROM pg_stat_bgwriter
    )
    SELECT CASE
        WHEN checkpoints_req < 10
          OR requested_checkpoint_ratio < 0.50
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'CheckpointsTimed',
                checkpoints_timed,
            'CheckpointsRequested',
                checkpoints_req,
            'RequestedCheckpointRatio',
                requested_checkpoint_ratio,
            'CheckpointWriteTimeMs',
                checkpoint_write_time,
            'CheckpointSyncTimeMs',
                checkpoint_sync_time,
            'BuffersCheckpoint',
                buffers_checkpoint,
            'BuffersBackend',
                buffers_backend,
            'BuffersBackendFsync',
                buffers_backend_fsync,
            'BuffersAlloc',
                buffers_alloc,
            'StatsReset',
                stats_reset,
            'MaxWalSize',
                current_setting('max_wal_size', true),
            'MinWalSize',
                current_setting('min_wal_size', true),
            'CheckpointTimeout',
                current_setting('checkpoint_timeout', true),
            'CheckpointCompletionTarget',
                current_setting('checkpoint_completion_target', true),
            'FindingReason',
                'More than 50% of checkpoints are requested checkpoints, indicating that checkpoints are often triggered by WAL volume before checkpoint_timeout.'
        )
    END
    FROM checkpoint_stats
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'WAL and Checkpoints',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'Requested checkpoint ratio is within the expected review threshold.'
        ELSE
            'Review requested checkpoint frequency and consider increasing max_wal_size or tuning checkpoint behavior if requested checkpoints are frequent.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #60: WAL Compression is Disabled
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 60;
    v_CheckTitle          text    := $check_title$WAL Compression is Disabled$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: WAL compression is disabled. PostgreSQL is not configured
   to compress full-page images written to WAL.

   WHY THIS MATTERS:
   When full-page writes occur, especially after checkpoints, PostgreSQL may
   generate a significant amount of WAL. Without WAL compression, write-heavy
   workloads can produce more WAL traffic, increase disk usage, increase
   replication bandwidth, and increase WAL archiving volume.

   Recommendations:
   Review wal_compression together with WAL generation rate, CPU capacity,
   replication bandwidth, archive storage usage, and checkpoint behavior.
   Consider enabling WAL compression if WAL volume is high and the server has
   enough CPU capacity to absorb the compression overhead.

   Scope : Cluster-level
   Category : Performance

   REFERENCES:
   https://www.postgresql.org/docs/current/runtime-config-wal.html
   https://www.postgresql.org/docs/current/wal-configuration.html
*/

v_AdditionalInfo := (
    SELECT CASE
        WHEN current_setting('wal_compression', true) NOT IN ('off', 'false', '0')
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'WalCompression',
                current_setting('wal_compression', true),
            'FullPageWrites',
                current_setting('full_page_writes', true),
            'WalLevel',
                current_setting('wal_level', true),
            'MaxWalSize',
                current_setting('max_wal_size', true),
            'ArchiveMode',
                current_setting('archive_mode', true),
            'FindingReason',
                'wal_compression is disabled, so full-page images written to WAL are not compressed.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'WAL and Checkpoints',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'WAL compression is enabled.'
        ELSE
            'Review WAL volume and consider enabling wal_compression if full-page-image WAL volume, archive storage, or replication bandwidth is significant.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #61: Pending Restart Settings
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 61;
    v_CheckTitle          text    := $check_title$Pending Restart Settings$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN

/* DESCRIPTION:
   What This Means: pending restart settings were detected. One or more
   PostgreSQL configuration parameters have been changed but require a server
   restart before the new values take effect.

   WHY THIS MATTERS:
   Pending restart settings can create a mismatch between expected and active
   configuration. Administrators may believe a change is already applied when
   PostgreSQL is still running with the previous value. This can affect memory,
   WAL, replication, logging, and other important server behavior.

   Recommendations:
   Review all settings where pending_restart is true. Confirm whether the
   pending values are intentional, schedule a controlled restart if needed, and
   validate the active configuration after restart.

   Scope : Cluster-level
   Category : Configurations

   REFERENCES:
   https://www.postgresql.org/docs/current/view-pg-settings.html
   https://www.postgresql.org/docs/current/config-setting.html
*/

v_AdditionalInfo := (
    WITH pending_restart_settings AS (
        SELECT
            name,
            setting,
            unit,
            boot_val,
            reset_val,
            source,
            sourcefile,
            sourceline,
            pending_restart,
            short_desc
        FROM pg_settings
        WHERE pending_restart = true
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM pending_restart_settings)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'PendingRestartSettings',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'Name', name,
                        'CurrentSetting', setting,
                        'Unit', unit,
                        'BootValue', boot_val,
                        'ResetValue', reset_val,
                        'Source', source,
                        'SourceFile', sourcefile,
                        'SourceLine', sourceline,
                        'PendingRestart', pending_restart,
                        'Description', short_desc
                    )
                    ORDER BY name
                )
                FROM pending_restart_settings
            ),
            'FindingReason',
            'One or more PostgreSQL settings have pending_restart = true and require a server restart to take effect.'
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Configuration',
    'Cluster-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    2,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No pending restart settings were found.'
        ELSE
            'Review pending restart settings and schedule a controlled PostgreSQL restart if the pending configuration should take effect.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;


/*
    ====================================================================================
    Check #62: Schemas Granting CREATE Privilege to PUBLIC
    ====================================================================================
*/

DO $pg_review_check$
DECLARE
    v_CheckId             integer := 62;
    v_CheckTitle          text    := $check_title$Schemas Granting CREATE Privilege to PUBLIC$check_title$;
    v_DeadlockRetry       boolean := false;

    v_ErrorSqlState       text;
    v_ErrorMessage        text;
    v_ErrorDetail         text;
    v_ErrorHint           text;
    v_ErrorContext        text;

    v_AdditionalInfo      jsonb;
BEGIN
    LOOP
        BEGIN
/*
    DESCRIPTION:

    What This Means: one or more schemas grant the CREATE privilege to PUBLIC,
        meaning every authenticated role in the database can create objects
        (tables, views, functions, etc.) inside that schema. This is the classic
        PostgreSQL "public schema" exposure: an untrusted or low-privilege user
        can create an object that shadows one the application relies on (a
        schema search_path attack), or plant a function/view that later runs
        with another user's privileges. Most documented PostgreSQL privilege
        escalation techniques rely on being able to create an object in a
        schema an unintended role can reach. PostgreSQL 15 changed the built-in
        "public" schema's default specifically to close this exposure, but
        instances upgraded from an earlier version, or any schema where CREATE
        was explicitly (re-)granted to PUBLIC, remain open.

    Recommendations:
        Revoke CREATE from PUBLIC on the affected schema(s): REVOKE CREATE ON
        SCHEMA <schema> FROM PUBLIC. Grant CREATE only to the specific roles or
        application accounts that need to create objects there. If applications
        currently rely on writing into a shared schema, move them to a
        dedicated, owned schema instead of leaving it open to every role.
        Validate with the application owners before revoking, in case a
        workflow depends on the broad create access.

    Scope : Database-level
    Category : Security

    More info:
        https://www.postgresql.org/docs/current/ddl-schemas.html#DDL-SCHEMAS-PATTERNS
        https://www.percona.com/blog/public-schema-security-upgrade-in-postgresql-15/
        https://www.cybertec-postgresql.com/en/postgresql-security-things-to-avoid-in-real-life/
*/

v_AdditionalInfo := (
    WITH public_create_schemas AS (
        SELECT
            n.nspname AS schema_name,
            pg_get_userbyid(n.nspowner) AS schema_owner
        FROM pg_namespace n
        CROSS JOIN LATERAL aclexplode(n.nspacl) AS acl
        WHERE acl.grantee = 0
          AND acl.privilege_type = 'CREATE'
          AND n.nspname NOT IN ('pg_catalog', 'information_schema')
    )
    SELECT CASE
        WHEN NOT EXISTS (SELECT 1 FROM public_create_schemas)
            THEN NULL::jsonb
        ELSE jsonb_build_object(
            'FindingReason',
                'One or more schemas grant the CREATE privilege to PUBLIC, allowing any authenticated role to create objects in the schema.',
            'Schemas',
            (
                SELECT jsonb_agg(
                    jsonb_build_object(
                        'SchemaName', schema_name,
                        'SchemaOwner', schema_owner
                    )
                    ORDER BY schema_name
                )
                FROM public_create_schemas
            )
        )
    END
);

INSERT INTO pg_review_results (
    CheckId,
    Title,
    Category,
    Scope,
    RequiresAttention,
    WorstCaseImpact,
    CurrentStateImpact,
    RecommendationEffort,
    RecommendationRisk,
    Recommendation,
    AdditionalInfo,
    ResponsibleDbaTeam
)
SELECT
    v_CheckId,
    v_CheckTitle,
    'Security',
    'Database-level',
    CASE WHEN v_AdditionalInfo IS NULL THEN false ELSE true END,
    3,                                                          -- High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 3 END,       -- None / High
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 1 END,       -- None / Low
    CASE WHEN v_AdditionalInfo IS NULL THEN 0 ELSE 2 END,       -- None / Medium
    CASE
        WHEN v_AdditionalInfo IS NULL
            THEN 'No schemas grant the CREATE privilege to PUBLIC.'
        ELSE
            'Revoke CREATE from PUBLIC on the listed schema(s) (REVOKE CREATE ON SCHEMA <schema> FROM PUBLIC) and grant it only to the specific roles/applications that need to create objects there. Validate with application owners before revoking.'
    END,
    COALESCE(v_AdditionalInfo, '{}'::jsonb),
    'Production';
            EXIT;

        EXCEPTION
            WHEN deadlock_detected THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    v_DeadlockRetry
                );

                IF v_DeadlockRetry = false THEN
                    v_DeadlockRetry := true;
                ELSE
                    EXIT;
                END IF;

            WHEN OTHERS THEN

                GET STACKED DIAGNOSTICS
                    v_ErrorSqlState = RETURNED_SQLSTATE,
                    v_ErrorMessage  = MESSAGE_TEXT,
                    v_ErrorDetail   = PG_EXCEPTION_DETAIL,
                    v_ErrorHint     = PG_EXCEPTION_HINT,
                    v_ErrorContext  = PG_EXCEPTION_CONTEXT;

                INSERT INTO pg_review_errors
                (
                    CheckId,
                    Title,
                    ErrorSqlState,
                    ErrorMessage,
                    ErrorDetail,
                    ErrorHint,
                    ErrorContext,
                    IsDeadlockRetry
                )
                VALUES
                (
                    v_CheckId,
                    v_CheckTitle,
                    v_ErrorSqlState,
                    v_ErrorMessage,
                    v_ErrorDetail,
                    v_ErrorHint,
                    v_ErrorContext,
                    false
                );

                EXIT;

        END;
    END LOOP;
END
$pg_review_check$;

/*
    ====================================================================================
    PostgreSQL Review - Template Footer

    Purpose: Generate the final PostgreSQL Review output as a single JSON document.

    This footer collects:
        - System introduction data collected by Template_Header.sql
        - Review score
        - Summary counters
        - Failed checks that require attention
        - Passed checks that do not require attention
        - Check execution errors
        - Header collection errors

    Important:
        This file should be included at the end of the generated script: PostgreSQL_Review_Full_Check_Script.sql

    Expected flow:
        Template_Header.sql
        SQLChecks\*.sql
        Template_Footer.sql

    Notes:
        - This footer should be the only section that returns the final result.
        - Header and individual check scripts should not return final output directly.
        - This makes pgAdmin and psql execution easier.
    ====================================================================================
*/

/*
    ====================================================================================
    Footer section - Final JSON output
    ====================================================================================
*/

WITH
score AS
(
    SELECT
        CASE
            WHEN COUNT(*) = 0 THEN NULL
            WHEN SUM(WorstCaseImpact) IS NULL OR SUM(WorstCaseImpact) = 0 THEN NULL
            ELSE
                GREATEST
                (
                    0,
                    LEAST
                    (
                        100,
                        ROUND
                        (
                            100
                            -
                            (
                                COALESCE(SUM(CurrentStateImpact), 0)::numeric
                                / NULLIF(SUM(WorstCaseImpact), 0)::numeric
                            ) * 100
                        )::integer
                    )
                )
        END AS ClusterScore
    FROM pg_review_results
),
summary AS
(
    SELECT
        COUNT(*) AS TotalChecks,
        COUNT(*) FILTER (WHERE RequiresAttention = true) AS FailedChecksCount,
        COUNT(*) FILTER (WHERE RequiresAttention = false) AS PassedChecksCount,
        COUNT(*) FILTER (WHERE RequiresAttention = true AND CurrentStateImpact = 3) AS HighImpactFindings,
        COUNT(*) FILTER (WHERE RequiresAttention = true AND CurrentStateImpact = 2) AS MediumImpactFindings,
        COUNT(*) FILTER (WHERE RequiresAttention = true AND CurrentStateImpact = 1) AS LowImpactFindings,
        COUNT(*) FILTER (WHERE RequiresAttention = true AND RecommendationEffort = 3) AS HighEffortRecommendations,
        COUNT(*) FILTER (WHERE RequiresAttention = true AND RecommendationRisk = 3) AS HighRiskRecommendations,
        (SELECT COUNT(*) FROM pg_review_errors) AS CheckErrorsCount
    FROM pg_review_results
),
score_note AS
(
    SELECT
        CASE
            WHEN (SELECT COUNT(*) FROM pg_review_results) = 0
                THEN 'No checks were executed. Score is NULL.'
            WHEN (SELECT COUNT(*) FROM pg_review_errors) > 0
                THEN 'Some checks failed to execute and are reported in CheckErrors. Failed checks are not included in the score calculation.'
            ELSE
                'Score is calculated from checks that executed successfully.'
        END AS ScoreNote
),
system_introduction AS
(
    SELECT jsonb_build_object
    (
        'HostVisibility',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_host_visibility t LIMIT 1),
                '{}'::jsonb
            ),

        'ServerIdentity',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_server_identity t LIMIT 1),
                '{}'::jsonb
            ),

        'DistributionDetection',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_distribution_detection t LIMIT 1),
                '{}'::jsonb
            ),

        'ExecutionContext',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_execution_context t LIMIT 1),
                '{}'::jsonb
            ),

        'Licensing',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_licensing t LIMIT 1),
                '{}'::jsonb
            ),

        'Databases',
            COALESCE
            (
                (SELECT jsonb_agg(to_jsonb(t) ORDER BY t.DatabaseName) FROM pg_review_header_databases t),
                '[]'::jsonb
            ),

        'CurrentDatabaseSession',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_current_database_session t LIMIT 1),
                '{}'::jsonb
            ),

        'ImportantSettings',
            COALESCE
            (
                (SELECT jsonb_agg(to_jsonb(t) ORDER BY t.SettingName) FROM pg_review_header_important_settings t),
                '[]'::jsonb
            ),

        'Tablespaces',
            COALESCE
            (
                (SELECT jsonb_agg(to_jsonb(t) ORDER BY t.TablespaceName) FROM pg_review_header_tablespaces t),
                '[]'::jsonb
            ),

        'Extensions',
            COALESCE
            (
                (SELECT jsonb_agg(to_jsonb(t) ORDER BY t.ExtensionName) FROM pg_review_header_extensions t),
                '[]'::jsonb
            ),

        'DatabaseStatistics',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_database_statistics t LIMIT 1),
                '{}'::jsonb
            ),

        'ActivitySummary',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_activity_summary t LIMIT 1),
                '{}'::jsonb
            ),

        'ReplicationState',
            COALESCE
            (
                (SELECT to_jsonb(t) FROM pg_review_header_replication_state t LIMIT 1),
                '{}'::jsonb
            ),

        'Capabilities',
            COALESCE
            (
                (SELECT jsonb_agg(to_jsonb(t) ORDER BY t.CapabilityName) FROM pg_review_header_capabilities t),
                '[]'::jsonb
            )
    ) AS SystemIntroduction
),
failed_checks AS
(
    SELECT
        COALESCE
        (
            jsonb_agg
            (
                jsonb_build_object
                (
                    'CheckId', CheckId,
                    'Title', Title,
                    'Category', Category,
                    'Scope', Scope,
                    'Impact', CurrentStateImpact,
                    'WorstCaseImpact', WorstCaseImpact,
                    'RecommendationEffort', RecommendationEffort,
                    'RecommendationRisk', RecommendationRisk,
                    'Recommendation', Recommendation,
                    'AdditionalInfo', AdditionalInfo,
                    'ResponsibleDbaTeam', ResponsibleDbaTeam
                )
                ORDER BY
                    CurrentStateImpact DESC,
                    RecommendationRisk DESC,
                    RecommendationEffort DESC,
                    CheckId ASC
            ),
            '[]'::jsonb
        ) AS FailedChecks
    FROM pg_review_results
    WHERE RequiresAttention = true
),
passed_checks AS
(
    SELECT
        COALESCE
        (
            jsonb_agg
            (
                jsonb_build_object
                (
                    'CheckId', CheckId,
                    'Title', Title,
                    'Category', Category,
                    'Scope', Scope,
                    'AdditionalInfo', AdditionalInfo
                )
                ORDER BY CheckId ASC
            ),
            '[]'::jsonb
        ) AS PassedChecks
    FROM pg_review_results
    WHERE RequiresAttention = false
),
check_errors AS
(
    SELECT
        COALESCE
        (
            jsonb_agg
            (
                jsonb_build_object
                (
                    'CheckId', CheckId,
                    'Title', Title,
                    'ErrorSqlState', ErrorSqlState,
                    'ErrorMessage', ErrorMessage,
                    'ErrorDetail', ErrorDetail,
                    'ErrorHint', ErrorHint,
                    'ErrorContext', ErrorContext,
                    'IsDeadlockRetry', IsDeadlockRetry,
                    'ErrorTime', ErrorTime
                )
                ORDER BY ErrorTime ASC, CheckId ASC
            ),
            '[]'::jsonb
        ) AS CheckErrors
    FROM pg_review_errors
),
header_errors AS
(
    SELECT
        COALESCE
        (
            jsonb_agg
            (
                jsonb_build_object
                (
                    'SectionName', SectionName,
                    'ErrorMessage', ErrorMessage,
                    'ErrorTime', ErrorTime
                )
                ORDER BY ErrorTime ASC, SectionName ASC
            ),
            '[]'::jsonb
        ) AS HeaderErrors
    FROM pg_review_header_errors
),
review_warnings AS
(
    SELECT jsonb_build_array
    (
        'PostgreSQL distribution/flavor detection is best-effort and may not be fully accurate in managed services.',
        'Some checks are cluster-level, while table, index, schema, pg_stat_statements, and database statistics checks apply to the current database.',
        'Session, lock, connection, and transaction findings are snapshot-based and should be correlated with monitoring data.',
        'Some findings are based on cumulative PostgreSQL statistics since the last statistics reset.',
        'Checks that fail to execute are reported in CheckErrors and are not included in the score calculation.',
        'PostgreSQL does not expose full operating system and hardware inventory through standard SQL.'
    ) AS ReviewWarnings
)
SELECT
    jsonb_pretty
    (
        jsonb_build_object
        (
            'AssessmentType', 'PostgreSQL Review',
            'ReviewGeneratedAt', now(),
            'ReviewScriptName', 'PostgreSQL_Review_Full_Check_Script.sql',

            'PostgreSQLClusterName',
                COALESCE
                (
                    (
                        SELECT PostgreSQLClusterName
                        FROM pg_review_header_server_identity
                        LIMIT 1
                    ),
                    'Not provided'
                ),

            'CurrentDatabase',
                current_database(),

            'ExecutedBy',
                current_user,

            'ClusterScore',
                score.ClusterScore,

            'ScoreNote',
                score_note.ScoreNote,

            'Summary',
                jsonb_build_object
                (
                    'TotalChecks', summary.TotalChecks,
                    'FailedChecksCount', summary.FailedChecksCount,
                    'PassedChecksCount', summary.PassedChecksCount,
                    'HighImpactFindings', summary.HighImpactFindings,
                    'MediumImpactFindings', summary.MediumImpactFindings,
                    'LowImpactFindings', summary.LowImpactFindings,
                    'HighEffortRecommendations', summary.HighEffortRecommendations,
                    'HighRiskRecommendations', summary.HighRiskRecommendations,
                    'CheckErrorsCount', summary.CheckErrorsCount
                ),

            'SystemIntroduction',
                system_introduction.SystemIntroduction,

            'ReviewWarnings',
                review_warnings.ReviewWarnings,

            'FailedChecksThatRequireAttention',
                failed_checks.FailedChecks,

            'PassedChecksThatDoNotRequireAttention',
                passed_checks.PassedChecks,

            'CheckErrors',
                check_errors.CheckErrors,

            'HeaderErrors',
                header_errors.HeaderErrors
        )
    ) AS postgresql_review_json
FROM score
CROSS JOIN summary
CROSS JOIN score_note
CROSS JOIN system_introduction
CROSS JOIN review_warnings
CROSS JOIN failed_checks
CROSS JOIN passed_checks
CROSS JOIN check_errors
CROSS JOIN header_errors;