enable parittion feature

etc/launch-dynamic-with-proxy/launch.toml

@@ -23,7 +23,7 @@ cn-template = "./etc/launch-dynamic-with-proxy/cn.toml.base"
 # how many cn service can be launched
 service-count = 2
 # how many cpu can used pr cn instance
-cpu-count = 2
+cpu-count = 8
 
 [dynamic.chaos]
 enable = false

pkg/bootstrap/service.go

@@ -31,6 +31,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/container/vector"
 	"github.com/matrixorigin/matrixone/pkg/frontend"
 	"github.com/matrixorigin/matrixone/pkg/logutil"
+	"github.com/matrixorigin/matrixone/pkg/partitionservice"
 	"github.com/matrixorigin/matrixone/pkg/pb/timestamp"
 	"github.com/matrixorigin/matrixone/pkg/predefine"
 	"github.com/matrixorigin/matrixone/pkg/shardservice"
@@ -102,6 +103,8 @@ func init() {
 	initSQLs = append(initSQLs, trace.InitSQLs...)
 
 	initSQLs = append(initSQLs, shardservice.InitSQLs...)
+
+	initSQLs = append(initSQLs, partitionservice.InitSQLs...)
 }
 
 type service struct {

pkg/bootstrap/upgrade.go

@@ -26,6 +26,7 @@ import (
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v2_1_0"
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v2_2_0"
 	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v3_0_0"
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions/v4_0_0"
 )
 
 // initUpgrade all versions need create a upgrade handle in pkg/bootstrap/versions
@@ -45,6 +46,7 @@ func (s *service) initUpgrade() {
 	s.handles = append(s.handles, v2_1_0.Handler)
 	s.handles = append(s.handles, v2_2_0.Handler)
 	s.handles = append(s.handles, v3_0_0.Handler)
+	s.handles = append(s.handles, v4_0_0.Handler)
 }
 
 func (s *service) getFinalVersionHandle() VersionHandle {

pkg/bootstrap/versions/v4_0_0/cluster_upgrade_list.go

@@ -0,0 +1,21 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+)
+
+var clusterUpgEntries = []versions.UpgradeEntry{}

pkg/bootstrap/versions/v4_0_0/log.go

@@ -0,0 +1,24 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/common/log"
+	"github.com/matrixorigin/matrixone/pkg/common/runtime"
+)
+
+func getLogger(sid string) *log.MOLogger {
+	return runtime.ServiceRuntime(sid).Logger()
+}

pkg/bootstrap/versions/v4_0_0/tenant_upgrade_list.go

@@ -0,0 +1,49 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/catalog"
+	"github.com/matrixorigin/matrixone/pkg/partitionservice"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+)
+
+var tenantUpgEntries = []versions.UpgradeEntry{
+	enablePartitionMetadata,
+	enablePartitionTables,
+}
+
+var enablePartitionMetadata = versions.UpgradeEntry{
+	Schema:    catalog.MO_CATALOG,
+	TableName: catalog.MOPartitionMetadata,
+	UpgType:   versions.CREATE_NEW_TABLE,
+	UpgSql:    partitionservice.PartitionTableMetadataSQL,
+	CheckFunc: func(txn executor.TxnExecutor, accountId uint32) (bool, error) {
+		exist, err := versions.CheckTableDefinition(txn, accountId, catalog.MO_CATALOG, partitionservice.PartitionTableMetadataSQL)
+		return exist, err
+	},
+}
+
+var enablePartitionTables = versions.UpgradeEntry{
+	Schema:    catalog.MO_CATALOG,
+	TableName: catalog.MOPartitionTables,
+	UpgType:   versions.CREATE_NEW_TABLE,
+	UpgSql:    partitionservice.PartitionTablesSQL,
+	CheckFunc: func(txn executor.TxnExecutor, accountId uint32) (bool, error) {
+		exist, err := versions.CheckTableDefinition(txn, accountId, catalog.MO_CATALOG, partitionservice.PartitionTablesSQL)
+		return exist, err
+	},
+}

pkg/bootstrap/versions/v4_0_0/upgrade.go

@@ -0,0 +1,126 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"context"
+	"time"
+
+	"github.com/matrixorigin/matrixone/pkg/logutil"
+
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/catalog"
+	"github.com/matrixorigin/matrixone/pkg/common/moerr"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+	"go.uber.org/zap"
+)
+
+var (
+	Handler = &versionHandle{
+		metadata: versions.Version{
+			Version:           "4.0.0",
+			MinUpgradeVersion: "3.0.0",
+			UpgradeCluster:    versions.Yes,
+			UpgradeTenant:     versions.Yes,
+			VersionOffset:     uint32(len(clusterUpgEntries) + len(tenantUpgEntries)),
+		},
+	}
+)
+
+type versionHandle struct {
+	metadata versions.Version
+}
+
+func (v *versionHandle) Metadata() versions.Version {
+	return v.metadata
+}
+
+func (v *versionHandle) Prepare(
+	ctx context.Context,
+	txn executor.TxnExecutor,
+	final bool) error {
+	txn.Use(catalog.MO_CATALOG)
+	return nil
+}
+
+func (v *versionHandle) HandleTenantUpgrade(
+	ctx context.Context,
+	tenantID int32,
+	txn executor.TxnExecutor,
+) error {
+
+	var (
+		err    error
+		goon   bool
+		logger func(msg string, fields ...zap.Field)
+	)
+
+	for _, upgEntry := range tenantUpgEntries {
+		goon = false
+		logger = logutil.Error
+
+		start := time.Now()
+		err = upgEntry.Upgrade(txn, uint32(tenantID))
+
+		duration := time.Since(start)
+
+		if err == nil {
+			logger = logutil.Info
+			goon = true
+		}
+
+		logger("tenant upgrade",
+			zap.String("cn", txn.Txn().TxnOptions().CN),
+			zap.String("entry", upgEntry.String()),
+			zap.Int32("tenantId", tenantID),
+			zap.String("version", v.metadata.Version),
+			zap.Duration("duration", duration),
+			zap.Error(err),
+		)
+
+		if goon {
+			continue
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (v *versionHandle) HandleClusterUpgrade(
+	ctx context.Context,
+	txn executor.TxnExecutor,
+) error {
+	for _, upgEntry := range clusterUpgEntries {
+		start := time.Now()
+
+		err := upgEntry.Upgrade(txn, catalog.System_Account)
+		if err != nil {
+			getLogger(txn.Txn().TxnOptions().CN).Error("cluster upgrade entry execute error", zap.Error(err), zap.String("version", v.Metadata().Version), zap.String("upgrade entry", upgEntry.String()))
+			return err
+		}
+
+		duration := time.Since(start)
+		getLogger(txn.Txn().TxnOptions().CN).Info("cluster upgrade entry complete",
+			zap.String("upgrade entry", upgEntry.String()),
+			zap.Int64("time cost(ms)", duration.Milliseconds()),
+			zap.String("toVersion", v.Metadata().Version))
+	}
+	return nil
+}
+
+func (v *versionHandle) HandleCreateFrameworkDeps(txn executor.TxnExecutor) error {
+	return moerr.NewInternalErrorNoCtxf("Only v1.2.0 can initialize upgrade framework, current version is:%s", Handler.metadata.Version)
+}

pkg/bootstrap/versions/v4_0_0/upgrade_test.go

@@ -0,0 +1,84 @@
+// Copyright 2025 Matrix Origin
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package v4_0_0
+
+import (
+	"context"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/matrixorigin/matrixone/pkg/bootstrap/versions"
+	"github.com/matrixorigin/matrixone/pkg/common/moerr"
+	"github.com/matrixorigin/matrixone/pkg/common/runtime"
+	mock_frontend "github.com/matrixorigin/matrixone/pkg/frontend/test"
+	"github.com/matrixorigin/matrixone/pkg/pb/txn"
+	"github.com/matrixorigin/matrixone/pkg/util/executor"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Upgrade(t *testing.T) {
+	sid := ""
+	runtime.RunTest(
+		sid,
+		func(rt runtime.Runtime) {
+			txnOperator := mock_frontend.NewMockTxnOperator(gomock.NewController(t))
+			txnOperator.EXPECT().TxnOptions().Return(txn.TxnOptions{CN: sid}).AnyTimes()
+
+			executor := executor.NewMemTxnExecutor(func(sql string) (executor.Result, error) {
+				return executor.Result{}, nil
+			}, txnOperator)
+
+			metadata := Handler.Metadata()
+			t.Logf("version metadata:%v", metadata)
+
+			if err := Handler.Prepare(context.Background(), executor, true); err != nil {
+				t.Errorf("Prepare() error = %v", err)
+			}
+
+			if err := Handler.HandleCreateFrameworkDeps(executor); err == nil {
+				t.Errorf("HandleCreateFrameworkDeps() should report err")
+			}
+
+			if err := Handler.HandleClusterUpgrade(context.Background(), executor); err != nil {
+				t.Errorf("HandleClusterUpgrade() error = %v", err)
+			}
+
+			if err := Handler.HandleTenantUpgrade(context.Background(), 0, executor); err != nil {
+				t.Errorf("HandleTenantUpgrade() error = %v", err)
+			}
+		},
+	)
+}
+
+func Test_versionHandle_HandleClusterUpgrade(t *testing.T) {
+	clusterUpgEntries = []versions.UpgradeEntry{}
+
+	v := &versionHandle{
+		metadata: versions.Version{
+			Version: "v4.0.0",
+		},
+	}
+	sid := ""
+	txnOperator := mock_frontend.NewMockTxnOperator(gomock.NewController(t))
+	txnOperator.EXPECT().TxnOptions().Return(txn.TxnOptions{CN: sid}).AnyTimes()
+	executor2 := executor.NewMemTxnExecutor(func(sql string) (executor.Result, error) {
+		return executor.Result{}, moerr.NewInvalidInputNoCtx("return error")
+	}, txnOperator)
+
+	err := v.HandleClusterUpgrade(context.Background(),
+		executor2,
+	)
+	assert.Nil(t, err)
+}

pkg/common/reuse/types.go

@@ -65,6 +65,7 @@ func init() {
 		switch strings.ToLower(enable) {
 		case "true":
 			enableChecker.Store(true)
+			enableVerbose.Store(true)
 		}
 	}
 

pkg/defines/type.go

@@ -169,6 +169,14 @@ type TenantIDKey struct{}
 type UserIDKey struct{}
 type RoleIDKey struct{}
 type NodeIDKey struct{}
+type InternalExecutorKey struct{}
+
+func IsInternalExecutor(ctx context.Context) bool {
+	if v := ctx.Value(InternalExecutorKey{}); v != nil {
+		return v.(bool)
+	}
+	return false
+}
 
 func GetAccountId(ctx context.Context) (uint32, error) {
 	if v := ctx.Value(TenantIDKey{}); v != nil {