github.com/matrixorigin/matrixone@v0.7.0/pkg/vm/engine/tae/tables/updates/chain_test.go (about)

     1  // Copyright 2021 Matrix Origin
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package updates
    16  
    17  import (
    18  	"bytes"
    19  	"testing"
    20  
    21  	"github.com/matrixorigin/matrixone/pkg/container/types"
    22  
    23  	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/catalog"
    24  	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/common"
    25  	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/iface/handle"
    26  	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/testutils"
    27  	"github.com/matrixorigin/matrixone/pkg/vm/engine/tae/txn/txnbase"
    28  	"github.com/stretchr/testify/assert"
    29  )
    30  
    31  const (
    32  	ModuleName = "TAEUPDATES"
    33  )
    34  
    35  func mockTxn() *txnbase.Txn {
    36  	txn := new(txnbase.Txn)
    37  	txn.TxnCtx = txnbase.NewTxnCtx(common.NewTxnIDAllocator().Alloc(), types.NextGlobalTsForTest(), nil)
    38  	return txn
    39  }
    40  
    41  func commitTxn(txn *txnbase.Txn) {
    42  	txn.CommitTS = types.NextGlobalTsForTest()
    43  }
    44  
    45  func TestDeleteChain1(t *testing.T) {
    46  	defer testutils.AfterTest(t)()
    47  	testutils.EnsureNoLeak(t)
    48  	schema := catalog.MockSchema(1, 0)
    49  	c := catalog.MockCatalog(nil)
    50  	defer c.Close()
    51  
    52  	db, _ := c.CreateDBEntry("db", "", nil)
    53  	table, _ := db.CreateTableEntry(schema, nil, nil)
    54  	seg, _ := table.CreateSegment(nil, catalog.ES_Appendable, nil)
    55  	blk, _ := seg.CreateBlock(nil, catalog.ES_Appendable, nil)
    56  
    57  	controller := NewMVCCHandle(blk)
    58  	chain := NewDeleteChain(nil, controller)
    59  	txn1 := new(txnbase.Txn)
    60  	txn1.TxnCtx = txnbase.NewTxnCtx(common.NewTxnIDAllocator().Alloc(), types.NextGlobalTsForTest(), nil)
    61  	n1 := chain.AddNodeLocked(txn1, handle.DeleteType(handle.DT_Normal)).(*DeleteNode)
    62  	assert.Equal(t, 1, chain.Depth())
    63  
    64  	// 1. Txn1 delete from 1 to 10 -- PASS
    65  	err := chain.PrepareRangeDelete(1, 10, txn1.GetStartTS())
    66  	assert.Nil(t, err)
    67  	n1.RangeDeleteLocked(1, 10)
    68  	assert.Equal(t, uint32(10), n1.GetCardinalityLocked())
    69  	t.Log(n1.mask.String())
    70  
    71  	// 2. Txn1 delete 10 -- FAIL
    72  	err = chain.PrepareRangeDelete(10, 10, txn1.GetStartTS())
    73  	assert.NotNil(t, err)
    74  
    75  	txn2 := mockTxn()
    76  	// 3. Txn2 delete 2 -- FAIL
    77  	err = chain.PrepareRangeDelete(2, 2, txn2.GetStartTS())
    78  	assert.NotNil(t, err)
    79  
    80  	// 4. Txn2 delete from 21 to 30 -- PASS
    81  	err = chain.PrepareRangeDelete(20, 30, txn2.GetStartTS())
    82  	assert.Nil(t, err)
    83  	n2 := chain.AddNodeLocked(txn2, handle.DeleteType(handle.DT_Normal)).(*DeleteNode)
    84  	n2.RangeDeleteLocked(20, 30)
    85  	assert.Equal(t, uint32(11), n2.GetCardinalityLocked())
    86  	t.Log(n2.mask.String())
    87  
    88  	merged := chain.AddMergeNode().(*DeleteNode)
    89  	assert.Nil(t, merged)
    90  	assert.Equal(t, 2, chain.Depth())
    91  
    92  	collected, err := chain.CollectDeletesLocked(txn1.GetStartTS(), false, nil)
    93  	assert.NoError(t, err)
    94  	assert.Equal(t, uint32(10), collected.GetCardinalityLocked())
    95  	collected, err = chain.CollectDeletesLocked(txn2.GetStartTS(), false, nil)
    96  	assert.NoError(t, err)
    97  	assert.Equal(t, uint32(11), collected.GetCardinalityLocked())
    98  
    99  	var startTs1 types.TS
   100  	collected, err = chain.CollectDeletesLocked(startTs1, false, nil)
   101  	assert.NoError(t, err)
   102  	assert.Nil(t, collected)
   103  	collected, err = chain.CollectDeletesLocked(types.NextGlobalTsForTest(), false, nil)
   104  	assert.NoError(t, err)
   105  	assert.Nil(t, collected)
   106  
   107  	commitTxn(txn1)
   108  	assert.Nil(t, n1.PrepareCommit())
   109  	assert.Nil(t, n1.ApplyCommit(nil))
   110  	t.Log(chain.StringLocked())
   111  
   112  	var startTs2 types.TS
   113  	collected, err = chain.CollectDeletesLocked(startTs2, false, nil)
   114  	assert.NoError(t, err)
   115  	assert.Nil(t, collected)
   116  	collected, err = chain.CollectDeletesLocked(types.NextGlobalTsForTest(), false, nil)
   117  	assert.NoError(t, err)
   118  	assert.Equal(t, uint32(10), collected.GetCardinalityLocked())
   119  	collected, err = chain.CollectDeletesLocked(txn2.GetStartTS(), false, nil)
   120  	assert.NoError(t, err)
   121  	assert.Equal(t, uint32(11), collected.GetCardinalityLocked())
   122  
   123  	txn3 := mockTxn()
   124  	err = chain.PrepareRangeDelete(5, 5, txn3.GetStartTS())
   125  	assert.NotNil(t, err)
   126  	err = chain.PrepareRangeDelete(31, 33, txn3.GetStartTS())
   127  	assert.Nil(t, err)
   128  	n3 := chain.AddNodeLocked(txn3, handle.DeleteType(handle.DT_Normal))
   129  	n3.RangeDeleteLocked(31, 33)
   130  
   131  	collected, err = chain.CollectDeletesLocked(txn3.GetStartTS(), false, nil)
   132  	assert.NoError(t, err)
   133  	assert.Equal(t, uint32(13), collected.GetCardinalityLocked())
   134  	t.Log(chain.StringLocked())
   135  
   136  	merged = chain.AddMergeNode().(*DeleteNode)
   137  	assert.NotNil(t, merged)
   138  	t.Log(chain.StringLocked())
   139  	assert.Equal(t, 4, chain.DepthLocked())
   140  
   141  	cmd, err := merged.MakeCommand(1)
   142  	assert.Nil(t, err)
   143  	assert.NotNil(t, cmd)
   144  
   145  	var w bytes.Buffer
   146  	_, err = cmd.WriteTo(&w)
   147  	assert.Nil(t, err)
   148  
   149  	buf := w.Bytes()
   150  	r := bytes.NewBuffer(buf)
   151  
   152  	cmd2, _, err := txnbase.BuildCommandFrom(r)
   153  	assert.Nil(t, err)
   154  	assert.Equal(t, txnbase.CmdDelete, cmd2.GetType())
   155  	assert.Equal(t, txnbase.CmdDelete, cmd2.(*UpdateCmd).cmdType)
   156  	assert.True(t, cmd2.(*UpdateCmd).delete.mask.Equals(merged.mask))
   157  }
   158  
   159  func TestDeleteChain2(t *testing.T) {
   160  	defer testutils.AfterTest(t)()
   161  	testutils.EnsureNoLeak(t)
   162  	controller := NewMVCCHandle(catalog.NewStandaloneBlock(nil, 0, types.TS{}))
   163  	chain := NewDeleteChain(nil, controller)
   164  
   165  	txn1 := mockTxn()
   166  	n1 := chain.AddNodeLocked(txn1, handle.DeleteType(handle.DT_Normal)).(*DeleteNode)
   167  	err := chain.PrepareRangeDelete(1, 4, txn1.GetStartTS())
   168  	assert.Nil(t, err)
   169  	n1.RangeDeleteLocked(1, 4)
   170  	commitTxn(txn1)
   171  	err = n1.PrepareCommit()
   172  	assert.Nil(t, err)
   173  	err = n1.ApplyCommit(nil)
   174  	assert.Nil(t, err)
   175  	t.Log(chain.StringLocked())
   176  
   177  	txn2 := mockTxn()
   178  	n2 := chain.AddNodeLocked(txn2, handle.DeleteType(handle.DT_Normal)).(*DeleteNode)
   179  	err = chain.PrepareRangeDelete(5, 8, txn2.GetStartTS())
   180  	assert.Nil(t, err)
   181  	n2.RangeDeleteLocked(5, 8)
   182  	t.Log(chain.StringLocked())
   183  
   184  	txn3 := mockTxn()
   185  	n3 := chain.AddNodeLocked(txn3, handle.DeleteType(handle.DT_Normal)).(*DeleteNode)
   186  	err = chain.PrepareRangeDelete(9, 12, txn3.GetStartTS())
   187  	assert.Nil(t, err)
   188  	n3.RangeDeleteLocked(9, 12)
   189  	commitTxn(txn3)
   190  	err = n3.PrepareCommit()
   191  	assert.Nil(t, err)
   192  	err = n3.ApplyCommit(nil)
   193  	assert.Nil(t, err)
   194  	t.Log(chain.StringLocked())
   195  
   196  	m, err := chain.CollectDeletesLocked(types.NextGlobalTsForTest(), false, nil)
   197  	assert.NoError(t, err)
   198  	mask := m.(*DeleteNode).mask
   199  	assert.Equal(t, uint64(8), mask.GetCardinality())
   200  	m, err = chain.CollectDeletesLocked(txn3.GetCommitTS(), false, nil)
   201  	assert.NoError(t, err)
   202  	mask = m.(*DeleteNode).mask
   203  	assert.Equal(t, uint64(8), mask.GetCardinality())
   204  	m, err = chain.CollectDeletesLocked(txn1.GetCommitTS(), false, nil)
   205  	assert.NoError(t, err)
   206  	mask = m.(*DeleteNode).mask
   207  	assert.Equal(t, uint64(4), mask.GetCardinality())
   208  	m, err = chain.CollectDeletesLocked(txn1.GetCommitTS().Prev(), false, nil)
   209  	assert.NoError(t, err)
   210  	assert.Nil(t, m)
   211  
   212  	var startTs1 types.TS
   213  	mask, _, err = chain.CollectDeletesInRange(startTs1, txn3.GetCommitTS(), nil)
   214  	assert.NoError(t, err)
   215  	t.Log(mask.String())
   216  	assert.Equal(t, uint64(8), mask.GetCardinality())
   217  
   218  	var startTs2 types.TS
   219  	mask, _, err = chain.CollectDeletesInRange(startTs2, txn3.GetCommitTS().Next(), nil)
   220  	assert.NoError(t, err)
   221  	t.Log(mask.String())
   222  	assert.Equal(t, uint64(8), mask.GetCardinality())
   223  
   224  	mask, _, err = chain.CollectDeletesInRange(txn1.GetCommitTS(), txn3.GetCommitTS().Next(), nil)
   225  	assert.NoError(t, err)
   226  	t.Log(mask.String())
   227  	assert.Equal(t, uint64(4), mask.GetCardinality())
   228  }