implement the basic data branch.

cgo/lib.go

@@ -16,5 +16,6 @@ package cgo
 
 /*
 #cgo CFLAGS: -O3 -std=c99
+#cgo LDFLAGS: -lm
 */
 import "C"

pkg/bootstrap/versions/v4_0_0/cluster_upgrade_list.go

@@ -17,12 +17,14 @@ package v4_0_0
 import (
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
 	"github.com/matrixorigin/matrixone/pkg/catalog"
+	"github.com/matrixorigin/matrixone/pkg/frontend"
 	"github.com/matrixorigin/matrixone/pkg/predefine"
 	"github.com/matrixorigin/matrixone/pkg/util/executor"
 )
 
 var clusterUpgEntries = []versions.UpgradeEntry{
 	upg_mo_iscp_task,
+	upg_create_mo_branch_metadata,
 }
 
 var upg_mo_iscp_task = versions.UpgradeEntry{
@@ -35,3 +37,14 @@ var upg_mo_iscp_task = versions.UpgradeEntry{
 		return ok, err
 	},
 }
+
+var upg_create_mo_branch_metadata = versions.UpgradeEntry{
+	Schema:    catalog.MO_CATALOG,
+	TableName: catalog.MO_BRANCH_METADATA,
+	UpgType:   versions.CREATE_NEW_TABLE,
+	UpgSql:    frontend.MoCatalogBranchMetadataDDL,
+	CheckFunc: func(txn executor.TxnExecutor, accountId uint32) (bool, error) {
+		exist, err := versions.CheckTableDefinition(txn, accountId, catalog.MO_CATALOG, catalog.MO_BRANCH_METADATA)
+		return exist, err
+	},
+}

pkg/catalog/types.go

@@ -173,6 +173,8 @@ const (
 
 	MO_ISCP_LOG         = "mo_iscp_log"
 	MO_STORED_PROCEDURE = "mo_stored_procedure"
+
+	MO_BRANCH_METADATA = "mo_branch_metadata"
 )
 
 func IsSystemTable(id uint64) bool {

pkg/common/const.go

@@ -14,7 +14,9 @@
 
 package common
 
-import "fmt"
+import (
+	"fmt"
+)
 
 const (
 	KiB = 1024

pkg/container/types/encoding.go

@@ -366,6 +366,107 @@ func DecodeValue(val []byte, t T) any {
 	}
 }
 
+func CompareValues(left, right any, t T) int {
+	switch t {
+	case T_bool:
+		lVal := left.(bool)
+		rVal := right.(bool)
+
+		if lVal && !rVal {
+			return 1
+		} else if !lVal && rVal {
+			return -1
+		} else {
+			return 0
+		}
+	case T_int8:
+		lVal := left.(int8)
+		rVal := right.(int8)
+		return int(lVal - rVal)
+	case T_int16:
+		lVal := left.(int16)
+		rVal := right.(int16)
+		return int(lVal - rVal)
+	case T_int32:
+		lVal := left.(int32)
+		rVal := right.(int32)
+		return int(lVal - rVal)
+	case T_int64:
+		lVal := left.(int64)
+		rVal := right.(int64)
+		return int(lVal - rVal)
+	case T_uint8:
+		lVal := left.(uint8)
+		rVal := right.(uint8)
+		return int(lVal - rVal)
+	case T_uint16:
+		lVal := left.(uint16)
+		rVal := right.(uint16)
+		return int(lVal - rVal)
+	case T_uint32:
+		lVal := left.(uint32)
+		rVal := right.(uint32)
+		return int(lVal - rVal)
+	case T_uint64:
+		lVal := left.(uint64)
+		rVal := right.(uint64)
+		return int(lVal - rVal)
+	case T_float32:
+		lVal := left.(float32)
+		rVal := right.(float32)
+		return int(lVal - rVal)
+	case T_float64:
+		lVal := left.(float64)
+		rVal := right.(float64)
+		return int(lVal - rVal)
+	case T_decimal64:
+		lVal := left.(Decimal64)
+		rVal := right.(Decimal64)
+		return lVal.Compare(rVal)
+	case T_decimal128:
+		lVal := left.(Decimal128)
+		rVal := right.(Decimal128)
+		return lVal.Compare(rVal)
+	case T_date:
+		lVal := left.(Date)
+		rVal := right.(Date)
+		return int(lVal - rVal)
+	case T_time:
+		lVal := left.(Time)
+		rVal := right.(Time)
+		return int(lVal - rVal)
+	case T_timestamp:
+		lVal := left.(Timestamp)
+		rVal := right.(Timestamp)
+		return int(lVal - rVal)
+	case T_datetime:
+		lVal := left.(Datetime)
+		rVal := right.(Datetime)
+		return int(lVal - rVal)
+	case T_uuid:
+		lVal := left.(Uuid)
+		rVal := right.(Uuid)
+		return lVal.Compare(rVal)
+	case T_TS:
+		lVal := left.(TS)
+		rVal := right.(TS)
+		return lVal.Compare(&rVal)
+	case T_Rowid:
+		lVal := left.(Rowid)
+		rVal := right.(Rowid)
+		return lVal.Compare(&rVal)
+	case T_char, T_varchar, T_blob, T_json, T_text, T_binary, T_varbinary,
+		T_array_float32, T_array_float64, T_datalink:
+		return bytes.Compare(left.([]byte), right.([]byte))
+	case T_enum:
+		lVal := left.(Enum)
+		rVal := right.(Enum)
+		return int(lVal - rVal)
+	default:
+		panic(fmt.Sprintf("CompareValues unsupported type %v", t))
+	}
+}
+
 func EncodeValue(val any, t T) []byte {
 	switch t {
 	case T_bool: