feat(dbconn): Map HDW 3.x versions to GPDB for compatibility

This change introduces a version mapping mechanism to address compatibility issues
between HashData Warehouse 3.x and Greenplum Database (GPDB).

Previously, features designed for specific GPDB versions (e.g., 6.x) could not be
enabled on compatible HDW instances (e.g., 3.x) because version checks would fail
due to the different versioning schemes.

The new `getComparableSemVer` function intelligently maps versions:
- When the target of a version comparison is GPDB 4.0.0 or greater, it translates
the HDW version to its GPDB equivalent (e.g., HDW 3.x is treated as GPDB 6.x).
- For comparisons against target versions less than 4.0.0, the native HDW version
is used, preserving HDW-specific logic.

This allows HDW 3.x to correctly pass compatibility checks for GPDB features while
maintaining its own version identity for other checks. The `IsGPDB()` check has also
been updated to treat HDW as part of the GPDB family.

Author: robertmu

internal/dbconn/version.go

@@ -2,6 +2,7 @@ package dbconn
 
 import (
 	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/greenplum-db/gp-common-go-libs/gplog"
@@ -173,19 +174,55 @@ func (dbversion GPDBVersion) StringToSemVerRange(versionStr string) semver.Range
 	return validRange
 }
 
+// getComparableSemVer returns a version object suitable for comparison.
+// It maps HDW versions to corresponding GPDB major versions for compatibility checks,
+// but only when comparing against a target version that appears to be a GPDB version (e.g., major version >= 4).
+// This allows for native version checks for HDW-specific features (e.g., AtLeast("3.1.0")).
+func (dbversion GPDBVersion) getComparableSemVer(targetVersion string) semver.Version {
+	v := dbversion.SemVer
+
+	if !dbversion.IsHDW() {
+		return v
+	}
+
+	// Heuristic to decide if we're comparing against a GPDB version.
+	// We only map HDW versions if the target comparison version is for GPDB 4 or greater.
+	targetMajorStr := strings.Split(targetVersion, ".")[0]
+	targetMajor, err := strconv.Atoi(targetMajorStr)
+	// If targetVersion is not a valid number string, we don't map.
+	if err != nil {
+		return v
+	}
+
+	// Based on product versioning, HDW has a max major version of 3,
+	// while GPDB has a min major version of 4. Therefore, any target
+	// version >= 4 is considered a check against GPDB features.
+	if targetMajor >= 4 {
+		switch v.Major {
+		// HDW 2.x is compatible with GPDB 5.x
+		case 2:
+			v.Major = 5
+		// HDW 3.x is compatible with GPDB 6.x
+		case 3:
+			v.Major = 6
+		}
+	}
+	return v
+}
+
 func (dbversion GPDBVersion) Before(targetVersion string) bool {
 	validRange := dbversion.StringToSemVerRange("<" + targetVersion)
-	return validRange(dbversion.SemVer)
+	return validRange(dbversion.getComparableSemVer(targetVersion))
 }
 
 func (dbversion GPDBVersion) AtLeast(targetVersion string) bool {
 	validRange := dbversion.StringToSemVerRange(">=" + targetVersion)
-	return validRange(dbversion.SemVer)
+	return validRange(dbversion.getComparableSemVer(targetVersion))
 }
 
 func (dbversion GPDBVersion) Is(targetVersion string) bool {
 	validRange := dbversion.StringToSemVerRange("==" + targetVersion)
-	return validRange(dbversion.SemVer)
+	return validRange(dbversion.getComparableSemVer(targetVersion))
 }
 
 func (dbversion GPDBVersion) IsCBDB() bool {
@@ -205,7 +242,8 @@ func (dbversion GPDBVersion) IsCBDBFamily() bool {
 }
 
 func (dbversion GPDBVersion) IsGPDB() bool {
-	return dbversion.Type == GPDB
+	// we treat HDW as GPDB for now
+	return dbversion.Type == GPDB || dbversion.Type == HDW
 }
 
 func (dbversion GPDBVersion) IsHDW() bool {

internal/dbconn/version_test.go

@@ -0,0 +1,114 @@
+package dbconn_test
+
+import (
+	"testing"
+
+	"github.com/blang/semver"
+	"github.com/cloudberrydb/cbcopy/internal/dbconn"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestVersion(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "DBConn Version HDW Mapping Suite")
+}
+
+var _ = Describe("internal/dbconn/version HDW Mapping", func() {
+
+	// --- Test Data Setup ---
+	// Represents an HDW 2.x database, which should be treated as GPDB 5.x for comparison.
+	hdw2_5_0 := dbconn.GPDBVersion{
+		VersionString: "PostgreSQL 9.4.26 (HashData Warehouse 2.5.0)",
+		SemVer:        semver.MustParse("2.5.0"),
+		Type:          dbconn.HDW,
+	}
+
+	// Represents an HDW 3.x database, which should be treated as GPDB 6.x for comparison.
+	hdw3_5_0 := dbconn.GPDBVersion{
+		VersionString: "PostgreSQL 9.4.26 (HashData Warehouse 3.5.0)",
+		SemVer:        semver.MustParse("3.5.0"),
+		Type:          dbconn.HDW,
+	}
+
+	// Represents a standard GPDB database to ensure its logic is not affected.
+	gpdb7_1_0 := dbconn.GPDBVersion{
+		VersionString: "PostgreSQL 12.12 (Greenplum Database 7.1.0)",
+		SemVer:        semver.MustParse("7.1.0"),
+		Type:          dbconn.GPDB,
+	}
+
+	Describe("AtLeast", func() {
+		Context("with an HDW 3.x version (maps to GPDB 6.x)", func() {
+			It("should pass native version checks (target < 4)", func() {
+				Expect(hdw3_5_0.AtLeast("3.1.0")).To(BeTrue())
+				Expect(hdw3_5_0.AtLeast("3.6.0")).To(BeFalse())
+			})
+			It("should pass mapped version checks (target >= 4)", func() {
+				Expect(hdw3_5_0.AtLeast("4.0.0")).To(BeTrue())
+				Expect(hdw3_5_0.AtLeast("6.0.0")).To(BeTrue())
+				Expect(hdw3_5_0.AtLeast("7.0.0")).To(BeFalse())
+			})
+		})
+
+		Context("with an HDW 2.x version (maps to GPDB 5.x)", func() {
+			It("should pass native version checks (target < 4)", func() {
+				Expect(hdw2_5_0.AtLeast("2.1.0")).To(BeTrue())
+			})
+			It("should pass mapped version checks (target >= 4)", func() {
+				Expect(hdw2_5_0.AtLeast("5.0.0")).To(BeTrue())
+				Expect(hdw2_5_0.AtLeast("6.0.0")).To(BeFalse())
+			})
+		})
+
+		Context("with a standard GPDB version (no mapping)", func() {
+			It("should behave normally", func() {
+				Expect(gpdb7_1_0.AtLeast("7.0.0")).To(BeTrue())
+				Expect(gpdb7_1_0.AtLeast("8.0.0")).To(BeFalse())
+			})
+		})
+	})
+
+	Describe("Is", func() {
+		Context("with an HDW 3.x version (maps to GPDB 6.x)", func() {
+			It("should be true for its native major version", func() {
+				Expect(hdw3_5_0.Is("3")).To(BeTrue())
+			})
+			It("should be true for its mapped major version", func() {
+				Expect(hdw3_5_0.Is("6")).To(BeTrue())
+			})
+			It("should be false for other major versions", func() {
+				Expect(hdw3_5_0.Is("5")).To(BeFalse())
+				Expect(hdw3_5_0.Is("7")).To(BeFalse())
+			})
+		})
+
+		Context("with a standard GPDB version (no mapping)", func() {
+			It("should behave normally", func() {
+				Expect(gpdb7_1_0.Is("7")).To(BeTrue())
+				Expect(gpdb7_1_0.Is("6")).To(BeFalse())
+			})
+		})
+	})
+
+	Describe("Before", func() {
+		Context("with an HDW 3.x version (maps to GPDB 6.x)", func() {
+			It("should pass native version checks (target < 4)", func() {
+				Expect(hdw3_5_0.Before("3.6.0")).To(BeTrue())
+				Expect(hdw3_5_0.Before("3.5.0")).To(BeFalse())
+			})
+			It("should pass mapped version checks (target >= 4)", func() {
+				Expect(hdw3_5_0.Before("7.0.0")).To(BeTrue())
+				Expect(hdw3_5_0.Before("6.0.0")).To(BeFalse())
+			})
+		})
+
+		Context("with a standard GPDB version (no mapping)", func() {
+			It("should behave normally", func() {
+				Expect(gpdb7_1_0.Before("8.0.0")).To(BeTrue())
+				Expect(gpdb7_1_0.Before("7.0.0")).To(BeFalse())
+			})
+		})
+	})
+})