Refactoring

Author: artemgavrilov

collector/pg_stat_bgwriter.go

@@ -216,31 +216,21 @@ const statBGWriterQueryPost17 = `SELECT
 		,stats_reset
 	FROM pg_stat_bgwriter;`
 
-const statCheckpointerQueryPre18 = `SELECT
+const statCheckpointerQuery = `SELECT
 		num_timed
 		,num_requested
-		,NULL::bigint as num_done
+		CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN COALESCE(num_done, 0)
+			 ELSE 0 END as num_done,
 		,restartpoints_timed
 		,restartpoints_req
 		,restartpoints_done
 		,write_time
 		,sync_time
 		,buffers_written
-		,NULL::bigint as slru_written
-		,stats_reset
-	FROM pg_stat_checkpointer;`
-
-const statCheckpointerQuery18Plus = `SELECT
-		num_timed
-		,num_requested
-		,num_done
-		,restartpoints_timed
-		,restartpoints_req
-		,restartpoints_done
-		,write_time
-		,sync_time
-		,buffers_written
-		,slru_written
+		,CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN COALESCE(slru_written, 0)
+			 ELSE 0 END as slru_written,
 		,stats_reset
 	FROM pg_stat_checkpointer;`
 
@@ -263,13 +253,7 @@ func (p PGStatBGWriterCollector) Update(ctx context.Context, instance *instance,
 		var rpt, rpr, rpd sql.NullInt64
 		var csr sql.NullTime
 
-		// Use version-specific checkpointer query for PostgreSQL 18+
-		checkpointerQuery := statCheckpointerQueryPre18
-		if after18 {
-			checkpointerQuery = statCheckpointerQuery18Plus
-		}
-
-		row = db.QueryRowContext(ctx, checkpointerQuery)
+		row = db.QueryRowContext(ctx, statCheckpointerQuery)
 		err = row.Scan(&cpt, &cpr, &cpd, &rpt, &rpr, &rpd, &cpwt, &cpst, &bcp, &slruw, &csr)
 		if err != nil {
 			return err

collector/pg_stat_database.go

@@ -226,7 +226,7 @@ var (
 		prometheus.Labels{},
 	)
 
-	statDatabaseQueryPrePG18 = `
+	statDatabaseQuery = `
 		SELECT
 			datid
 			,datname
@@ -247,34 +247,12 @@ var (
 			,blk_read_time
 			,blk_write_time
 			,stats_reset
-			,NULL::bigint as parallel_workers_to_launch
-			,NULL::bigint as parallel_workers_launched
-		FROM pg_stat_database;
-	`
-
-	statDatabaseQueryPG18 = `
-		SELECT
-			datid
-			,datname
-			,numbackends
-			,xact_commit
-			,xact_rollback
-			,blks_read
-			,blks_hit
-			,tup_returned
-			,tup_fetched
-			,tup_inserted
-			,tup_updated
-			,tup_deleted
-			,conflicts
-			,temp_files
-			,temp_bytes
-			,deadlocks
-			,blk_read_time
-			,blk_write_time
-			,stats_reset
-			,parallel_workers_to_launch
-			,parallel_workers_launched
+			CASE WHEN current_setting('server_version_num')::int >= 180000
+				THEN parallel_workers_to_launch
+				ELSE NULL END as parallel_workers_to_launch
+			CASE WHEN current_setting('server_version_num')::int >= 180000
+				THEN parallel_workers_launched
+				ELSE NULL END as parallel_workers_launched
 		FROM pg_stat_database;
 	`
 )
@@ -283,13 +261,8 @@ func (c *PGStatDatabaseCollector) Update(ctx context.Context, instance *instance
 	db := instance.getDB()
 
 	after18 := instance.version.GTE(semver.Version{Major: 18})
-	// Use version-specific query for PostgreSQL 18+
-	query := statDatabaseQueryPrePG18
-	if after18 {
-		query = statDatabaseQueryPG18
-	}
 
-	rows, err := db.QueryContext(ctx, query)
+	rows, err := db.QueryContext(ctx, statDatabaseQuery)
 	if err != nil {
 		return err
 	}
@@ -410,7 +383,7 @@ func (c *PGStatDatabaseCollector) Update(ctx context.Context, instance *instance
 		}
 
 		if after18 {
-			if !parallelWorkersToLaunch.Valid && after18 {
+			if !parallelWorkersToLaunch.Valid {
 				level.Debug(c.log).Log("msg", "Skipping collecting metric because it has no parallel_workers_to_launch")
 				continue
 			}

collector/pg_stat_database_test.go

@@ -90,7 +90,7 @@ func TestPGStatDatabaseCollector(t *testing.T) {
 			2,
 		)
 
-	mock.ExpectQuery(sanitizeQuery(statDatabaseQueryPG18)).WillReturnRows(rows)
+	mock.ExpectQuery(sanitizeQuery(statDatabaseQuery)).WillReturnRows(rows)
 
 	ch := make(chan prometheus.Metric)
 	go func() {
@@ -221,7 +221,7 @@ func TestPGStatDatabaseCollectorNullValues(t *testing.T) {
 			3,
 			2,
 		)
-	mock.ExpectQuery(sanitizeQuery(statDatabaseQueryPG18)).WillReturnRows(rows)
+	mock.ExpectQuery(sanitizeQuery(statDatabaseQuery)).WillReturnRows(rows)
 
 	ch := make(chan prometheus.Metric)
 	go func() {
@@ -375,7 +375,7 @@ func TestPGStatDatabaseCollectorRowLeakTest(t *testing.T) {
 			3,
 			2,
 		)
-	mock.ExpectQuery(sanitizeQuery(statDatabaseQueryPG18)).WillReturnRows(rows)
+	mock.ExpectQuery(sanitizeQuery(statDatabaseQuery)).WillReturnRows(rows)
 
 	ch := make(chan prometheus.Metric)
 	go func() {
@@ -499,7 +499,7 @@ func TestPGStatDatabaseCollectorTestNilStatReset(t *testing.T) {
 			2,
 		)
 
-	mock.ExpectQuery(sanitizeQuery(statDatabaseQueryPG18)).WillReturnRows(rows)
+	mock.ExpectQuery(sanitizeQuery(statDatabaseQuery)).WillReturnRows(rows)
 
 	ch := make(chan prometheus.Metric)
 	go func() {

collector/pg_stat_io.go

@@ -134,22 +134,27 @@ var (
 		prometheus.Labels{},
 	)
 
-	// PostgreSQL 18+ query with byte statistics and WAL I/O
-	StatIOQuery18Plus = `
+	statIOQuery = `
 		SELECT
 			backend_type,
 			io_object,
 			io_context,
 			reads,
-			read_bytes,
+			CASE WHEN current_setting('server_version_num')::int >= 180000
+				THEN read_bytes
+				ELSE NULL END as read_bytes,
 			read_time,
 			writes,
-			write_bytes,
+			CASE WHEN current_setting('server_version_num')::int >= 180000
+				THEN write_bytes
+				ELSE NULL END as write_bytes,
 			write_time,
 			writebacks,
 			writeback_time,
 			extends,
-			extend_bytes,
+			CASE WHEN current_setting('server_version_num')::int >= 180000
+				THEN extend_bytes
+				ELSE NULL END as extend_bytes,
 			extend_time,
 			hits,
 			evictions,
@@ -158,31 +163,6 @@ var (
 			fsync_time,
 		FROM pg_stat_io
 	`
-
-	// Pre-PostgreSQL 18 query without byte statistics
-	StatIOQueryPre18 = `
-		SELECT
-			backend_type,
-			io_object,
-			io_context,
-			reads,
-			NULL::bigint as read_bytes,
-			read_time,
-			writes,
-			NULL::bigint as write_bytes,
-			write_time,
-			writebacks,
-			writeback_time,
-			extends,
-			NULL::numeric as extend_bytes,
-			extend_time,
-			hits,
-			NULL::bigint as evictions,
-			reueses,
-			fsyncs
-			fsync_time
-		FROM pg_stat_io
-	`
 )
 
 func (c *PGStatIOCollector) Update(ctx context.Context, instance *instance, ch chan<- prometheus.Metric) error {
@@ -194,13 +174,8 @@ func (c *PGStatIOCollector) Update(ctx context.Context, instance *instance, ch c
 	db := instance.getDB()
 
 	after18 := instance.version.GTE(semver.Version{Major: 18})
-	// Use version-specific query for PostgreSQL 18+
-	query := StatIOQueryPre18
-	if after18 {
-		query = StatIOQuery18Plus
-	}
 
-	rows, err := db.QueryContext(ctx, query)
+	rows, err := db.QueryContext(ctx, statIOQuery)
 	if err != nil {
 		return err
 	}

collector/pg_stat_user_tables.go

@@ -182,7 +182,7 @@ var (
 		prometheus.Labels{},
 	)
 
-	statUserTablesQueryPrePG18 = `SELECT
+	statUserTablesQuery = `SELECT
 		current_database() datname,
 		schemaname,
 		relname,
@@ -206,41 +206,18 @@ var (
 		analyze_count,
 		autoanalyze_count,
 		pg_total_relation_size(relid) as total_size,
-		NULL::double precision as total_vacuum_time,
-		NULL::double precision as total_autovacuum_time,
-		NULL::double precision as total_analyze_time,
-		NULL::double precision as total_autoanalyze_time
-	FROM
-		pg_stat_user_tables`
-
-	statUserTablesQueryPG18 = `SELECT
-		current_database() datname,
-		schemaname,
-		relname,
-		seq_scan,
-		seq_tup_read,
-		idx_scan,
-		idx_tup_fetch,
-		n_tup_ins,
-		n_tup_upd,
-		n_tup_del,
-		n_tup_hot_upd,
-		n_live_tup,
-		n_dead_tup,
-		n_mod_since_analyze,
-		COALESCE(last_vacuum, '1970-01-01Z') as last_vacuum,
-		COALESCE(last_autovacuum, '1970-01-01Z') as last_autovacuum,
-		COALESCE(last_analyze, '1970-01-01Z') as last_analyze,
-		COALESCE(last_autoanalyze, '1970-01-01Z') as last_autoanalyze,
-		vacuum_count,
-		autovacuum_count,
-		analyze_count,
-		autoanalyze_count,
-		pg_total_relation_size(relid) as total_size,
-		total_vacuum_time,
-		total_autovacuum_time,
-		total_analyze_time,
-		total_autoanalyze_time
+		CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN total_vacuum_time
+			 ELSE NULL precision END as total_vacuum_time,
+		CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN total_autovacuum_time
+			 ELSE NULL precision END as total_autovacuum_time,
+		CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN total_analyze_time
+			 ELSE NULL precision END as total_analyze_time,
+		CASE WHEN current_setting('server_version_num')::int >= 180000
+			 THEN total_autoanalyze_time
+			 ELSE NULL precision END as total_autoanalyze_time
 	FROM
 		pg_stat_user_tables`
 )
@@ -249,13 +226,8 @@ func (c *PGStatUserTablesCollector) Update(ctx context.Context, instance *instan
 	db := instance.getDB()
 
 	after18 := instance.version.GTE(semver.Version{Major: 18})
-	// Use version-specific query for PostgreSQL 18+
-	query := statUserTablesQueryPrePG18
-	if after18 {
-		query = statUserTablesQueryPG18
-	}
 
-	rows, err := db.QueryContext(ctx, query)
+	rows, err := db.QueryContext(ctx, statUserTablesQuery)
 
 	if err != nil {
 		return err
@@ -508,33 +480,38 @@ func (c *PGStatUserTablesCollector) Update(ctx context.Context, instance *instan
 
 		if after18 {
 			// PostgreSQL 18+ vacuum/analyze timing metrics
-			ch <- prometheus.MustNewConstMetric(
-				statUserTablesTotalVacuumTime,
-				prometheus.CounterValue,
-				totalVacuumTime.Float64,
-				datnameLabel, schemanameLabel, relnameLabel,
-			)
-
-			ch <- prometheus.MustNewConstMetric(
-				statUserTablesTotalAutovacuumTime,
-				prometheus.CounterValue,
-				totalAutovacuumTime.Float64,
-				datnameLabel, schemanameLabel, relnameLabel,
-			)
-
-			ch <- prometheus.MustNewConstMetric(
-				statUserTablesTotalAnalyzeTime,
-				prometheus.CounterValue,
-				totalAnalyzeTime.Float64,
-				datnameLabel, schemanameLabel, relnameLabel,
-			)
-
-			ch <- prometheus.MustNewConstMetric(
-				statUserTablesTotalAutoanalyzeTime,
-				prometheus.CounterValue,
-				totalAutoanalyzeTime.Float64,
-				datnameLabel, schemanameLabel, relnameLabel,
-			)
+			if totalVacuumTime.Valid {
+				ch <- prometheus.MustNewConstMetric(
+					statUserTablesTotalVacuumTime,
+					prometheus.CounterValue,
+					totalVacuumTime.Float64,
+					datnameLabel, schemanameLabel, relnameLabel,
+				)
+			}
+			if totalAutovacuumTime.Valid {
+				ch <- prometheus.MustNewConstMetric(
+					statUserTablesTotalAutovacuumTime,
+					prometheus.CounterValue,
+					totalAutovacuumTime.Float64,
+					datnameLabel, schemanameLabel, relnameLabel,
+				)
+			}
+			if totalAnalyzeTime.Valid {
+				ch <- prometheus.MustNewConstMetric(
+					statUserTablesTotalAnalyzeTime,
+					prometheus.CounterValue,
+					totalAnalyzeTime.Float64,
+					datnameLabel, schemanameLabel, relnameLabel,
+				)
+			}
+			if totalAutoanalyzeTime.Valid {
+				ch <- prometheus.MustNewConstMetric(
+					statUserTablesTotalAutoanalyzeTime,
+					prometheus.CounterValue,
+					totalAutoanalyzeTime.Float64,
+					datnameLabel, schemanameLabel, relnameLabel,
+				)
+			}
 		}
 	}