github.com/whtcorpsinc/MilevaDB-Prod@v0.0.0-20211104133533-f57f4be3b597/dbs/table_test.go (about) 1 // Copyright 2020 WHTCORPS INC, Inc. 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 // See the License for the specific language governing permissions and 12 // limitations under the License. 13 14 package dbs 15 16 import ( 17 "bytes" 18 "context" 19 "fmt" 20 21 "github.com/whtcorpsinc/BerolinaSQL/allegrosql" 22 "github.com/whtcorpsinc/BerolinaSQL/auth" 23 "github.com/whtcorpsinc/BerolinaSQL/perceptron" 24 . "github.com/whtcorpsinc/check" 25 "github.com/whtcorpsinc/errors" 26 "github.com/whtcorpsinc/milevadb/causet" 27 "github.com/whtcorpsinc/milevadb/ekv" 28 "github.com/whtcorpsinc/milevadb/spacetime" 29 "github.com/whtcorpsinc/milevadb/spacetime/autoid" 30 "github.com/whtcorpsinc/milevadb/stochastikctx" 31 "github.com/whtcorpsinc/milevadb/types" 32 ) 33 34 var _ = Suite(&testTableSuite{}) 35 36 type testTableSuite struct { 37 causetstore ekv.CausetStorage 38 dbInfo *perceptron.DBInfo 39 40 d *dbs 41 } 42 43 func testTableInfoWith2IndexOnFirstDeferredCauset(c *C, d *dbs, name string, num int) *perceptron.TableInfo { 44 normalInfo := testTableInfo(c, d, name, num) 45 idxs := make([]*perceptron.IndexInfo, 0, 2) 46 for i := range idxs { 47 idx := &perceptron.IndexInfo{ 48 Name: perceptron.NewCIStr(fmt.Sprintf("i%d", i+1)), 49 State: perceptron.StatePublic, 50 DeferredCausets: []*perceptron.IndexDeferredCauset{{Name: perceptron.NewCIStr("c1")}}, 51 } 52 idxs = append(idxs, idx) 53 } 54 normalInfo.Indices = idxs 55 normalInfo.DeferredCausets[0].FieldType.Flen = 11 56 return normalInfo 57 } 58 59 // testTableInfo creates a test causet with num int columns and with no index. 60 func testTableInfo(c *C, d *dbs, name string, num int) *perceptron.TableInfo { 61 tblInfo := &perceptron.TableInfo{ 62 Name: perceptron.NewCIStr(name), 63 } 64 genIDs, err := d.genGlobalIDs(1) 65 c.Assert(err, IsNil) 66 tblInfo.ID = genIDs[0] 67 68 defcaus := make([]*perceptron.DeferredCausetInfo, num) 69 for i := range defcaus { 70 col := &perceptron.DeferredCausetInfo{ 71 Name: perceptron.NewCIStr(fmt.Sprintf("c%d", i+1)), 72 Offset: i, 73 DefaultValue: i + 1, 74 State: perceptron.StatePublic, 75 } 76 77 col.FieldType = *types.NewFieldType(allegrosql.TypeLong) 78 col.ID = allocateDeferredCausetID(tblInfo) 79 defcaus[i] = col 80 } 81 tblInfo.DeferredCausets = defcaus 82 tblInfo.Charset = "utf8" 83 tblInfo.DefCauslate = "utf8_bin" 84 return tblInfo 85 } 86 87 // testTableInfoWithPartition creates a test causet with num int columns and with no index. 88 func testTableInfoWithPartition(c *C, d *dbs, name string, num int) *perceptron.TableInfo { 89 tblInfo := testTableInfo(c, d, name, num) 90 genIDs, err := d.genGlobalIDs(1) 91 c.Assert(err, IsNil) 92 pid := genIDs[0] 93 tblInfo.Partition = &perceptron.PartitionInfo{ 94 Type: perceptron.PartitionTypeRange, 95 Expr: tblInfo.DeferredCausets[0].Name.L, 96 Enable: true, 97 Definitions: []perceptron.PartitionDefinition{{ 98 ID: pid, 99 Name: perceptron.NewCIStr("p0"), 100 LessThan: []string{"maxvalue"}, 101 }}, 102 } 103 104 return tblInfo 105 } 106 107 // testTableInfoWithPartitionLessThan creates a test causet with num int columns and one partition specified with lessthan. 108 func testTableInfoWithPartitionLessThan(c *C, d *dbs, name string, num int, lessthan string) *perceptron.TableInfo { 109 tblInfo := testTableInfoWithPartition(c, d, name, num) 110 tblInfo.Partition.Definitions[0].LessThan = []string{lessthan} 111 return tblInfo 112 } 113 114 func testAddedNewTablePartitionInfo(c *C, d *dbs, tblInfo *perceptron.TableInfo, partName, lessthan string) *perceptron.PartitionInfo { 115 genIDs, err := d.genGlobalIDs(1) 116 c.Assert(err, IsNil) 117 pid := genIDs[0] 118 // the new added partition should change the partition state to state none at the beginning. 119 return &perceptron.PartitionInfo{ 120 Type: perceptron.PartitionTypeRange, 121 Expr: tblInfo.DeferredCausets[0].Name.L, 122 Enable: true, 123 Definitions: []perceptron.PartitionDefinition{{ 124 ID: pid, 125 Name: perceptron.NewCIStr(partName), 126 LessThan: []string{lessthan}, 127 }}, 128 } 129 } 130 131 // testViewInfo creates a test view with num int columns. 132 func testViewInfo(c *C, d *dbs, name string, num int) *perceptron.TableInfo { 133 tblInfo := &perceptron.TableInfo{ 134 Name: perceptron.NewCIStr(name), 135 } 136 genIDs, err := d.genGlobalIDs(1) 137 c.Assert(err, IsNil) 138 tblInfo.ID = genIDs[0] 139 140 defcaus := make([]*perceptron.DeferredCausetInfo, num) 141 viewDefCauss := make([]perceptron.CIStr, num) 142 143 var stmtBuffer bytes.Buffer 144 stmtBuffer.WriteString("SELECT ") 145 for i := range defcaus { 146 col := &perceptron.DeferredCausetInfo{ 147 Name: perceptron.NewCIStr(fmt.Sprintf("c%d", i+1)), 148 Offset: i, 149 State: perceptron.StatePublic, 150 } 151 152 col.ID = allocateDeferredCausetID(tblInfo) 153 defcaus[i] = col 154 viewDefCauss[i] = col.Name 155 stmtBuffer.WriteString(defcaus[i].Name.L + ",") 156 } 157 stmtBuffer.WriteString("1 FROM t") 158 159 view := perceptron.ViewInfo{DefCauss: viewDefCauss, Security: perceptron.SecurityDefiner, Algorithm: perceptron.AlgorithmMerge, 160 SelectStmt: stmtBuffer.String(), CheckOption: perceptron.CheckOptionCascaded, Definer: &auth.UserIdentity{CurrentUser: true}} 161 162 tblInfo.View = &view 163 tblInfo.DeferredCausets = defcaus 164 165 return tblInfo 166 } 167 168 func testCreateTable(c *C, ctx stochastikctx.Context, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo) *perceptron.Job { 169 job := &perceptron.Job{ 170 SchemaID: dbInfo.ID, 171 TableID: tblInfo.ID, 172 Type: perceptron.CausetActionCreateTable, 173 BinlogInfo: &perceptron.HistoryInfo{}, 174 Args: []interface{}{tblInfo}, 175 } 176 err := d.doDBSJob(ctx, job) 177 c.Assert(err, IsNil) 178 179 v := getSchemaVer(c, ctx) 180 tblInfo.State = perceptron.StatePublic 181 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) 182 tblInfo.State = perceptron.StateNone 183 return job 184 } 185 186 func testCreateView(c *C, ctx stochastikctx.Context, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo) *perceptron.Job { 187 job := &perceptron.Job{ 188 SchemaID: dbInfo.ID, 189 TableID: tblInfo.ID, 190 Type: perceptron.CausetActionCreateView, 191 BinlogInfo: &perceptron.HistoryInfo{}, 192 Args: []interface{}{tblInfo, false, 0}, 193 } 194 195 c.Assert(tblInfo.IsView(), IsTrue) 196 err := d.doDBSJob(ctx, job) 197 c.Assert(err, IsNil) 198 199 v := getSchemaVer(c, ctx) 200 tblInfo.State = perceptron.StatePublic 201 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) 202 tblInfo.State = perceptron.StateNone 203 return job 204 } 205 206 func testRenameTable(c *C, ctx stochastikctx.Context, d *dbs, newSchemaID, oldSchemaID int64, tblInfo *perceptron.TableInfo) *perceptron.Job { 207 job := &perceptron.Job{ 208 SchemaID: newSchemaID, 209 TableID: tblInfo.ID, 210 Type: perceptron.CausetActionRenameTable, 211 BinlogInfo: &perceptron.HistoryInfo{}, 212 Args: []interface{}{oldSchemaID, tblInfo.Name}, 213 } 214 err := d.doDBSJob(ctx, job) 215 c.Assert(err, IsNil) 216 217 v := getSchemaVer(c, ctx) 218 tblInfo.State = perceptron.StatePublic 219 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) 220 tblInfo.State = perceptron.StateNone 221 return job 222 } 223 224 func testLockTable(c *C, ctx stochastikctx.Context, d *dbs, newSchemaID int64, tblInfo *perceptron.TableInfo, lockTp perceptron.TableLockType) *perceptron.Job { 225 arg := &lockTablesArg{ 226 LockTables: []perceptron.TableLockTpInfo{{SchemaID: newSchemaID, TableID: tblInfo.ID, Tp: lockTp}}, 227 StochastikInfo: perceptron.StochastikInfo{ 228 ServerID: d.GetID(), 229 StochastikID: ctx.GetStochastikVars().ConnectionID, 230 }, 231 } 232 job := &perceptron.Job{ 233 SchemaID: newSchemaID, 234 TableID: tblInfo.ID, 235 Type: perceptron.CausetActionLockTable, 236 BinlogInfo: &perceptron.HistoryInfo{}, 237 Args: []interface{}{arg}, 238 } 239 err := d.doDBSJob(ctx, job) 240 c.Assert(err, IsNil) 241 242 v := getSchemaVer(c, ctx) 243 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v}) 244 return job 245 } 246 247 func checkTableLockedTest(c *C, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo, serverID string, stochastikID uint64, lockTp perceptron.TableLockType) { 248 err := ekv.RunInNewTxn(d.causetstore, false, func(txn ekv.Transaction) error { 249 t := spacetime.NewMeta(txn) 250 info, err := t.GetTable(dbInfo.ID, tblInfo.ID) 251 c.Assert(err, IsNil) 252 253 c.Assert(info, NotNil) 254 c.Assert(info.Lock, NotNil) 255 c.Assert(len(info.Lock.Stochastiks) == 1, IsTrue) 256 c.Assert(info.Lock.Stochastiks[0].ServerID, Equals, serverID) 257 c.Assert(info.Lock.Stochastiks[0].StochastikID, Equals, stochastikID) 258 c.Assert(info.Lock.Tp, Equals, lockTp) 259 c.Assert(info.Lock.State, Equals, perceptron.TableLockStatePublic) 260 return nil 261 }) 262 c.Assert(err, IsNil) 263 } 264 265 func testDropTable(c *C, ctx stochastikctx.Context, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo) *perceptron.Job { 266 job := &perceptron.Job{ 267 SchemaID: dbInfo.ID, 268 TableID: tblInfo.ID, 269 Type: perceptron.CausetActionDropTable, 270 BinlogInfo: &perceptron.HistoryInfo{}, 271 } 272 err := d.doDBSJob(ctx, job) 273 c.Assert(err, IsNil) 274 275 v := getSchemaVer(c, ctx) 276 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) 277 return job 278 } 279 280 func testTruncateTable(c *C, ctx stochastikctx.Context, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo) *perceptron.Job { 281 genIDs, err := d.genGlobalIDs(1) 282 c.Assert(err, IsNil) 283 newTableID := genIDs[0] 284 job := &perceptron.Job{ 285 SchemaID: dbInfo.ID, 286 TableID: tblInfo.ID, 287 Type: perceptron.CausetActionTruncateTable, 288 BinlogInfo: &perceptron.HistoryInfo{}, 289 Args: []interface{}{newTableID}, 290 } 291 err = d.doDBSJob(ctx, job) 292 c.Assert(err, IsNil) 293 294 v := getSchemaVer(c, ctx) 295 tblInfo.ID = newTableID 296 checkHistoryJobArgs(c, ctx, job.ID, &historyJobArgs{ver: v, tbl: tblInfo}) 297 return job 298 } 299 300 func testCheckTableState(c *C, d *dbs, dbInfo *perceptron.DBInfo, tblInfo *perceptron.TableInfo, state perceptron.SchemaState) { 301 err := ekv.RunInNewTxn(d.causetstore, false, func(txn ekv.Transaction) error { 302 t := spacetime.NewMeta(txn) 303 info, err := t.GetTable(dbInfo.ID, tblInfo.ID) 304 c.Assert(err, IsNil) 305 306 if state == perceptron.StateNone { 307 c.Assert(info, IsNil) 308 return nil 309 } 310 311 c.Assert(info.Name, DeepEquals, tblInfo.Name) 312 c.Assert(info.State, Equals, state) 313 return nil 314 }) 315 c.Assert(err, IsNil) 316 } 317 318 func testGetTable(c *C, d *dbs, schemaID int64, blockID int64) causet.Block { 319 tbl, err := testGetTableWithError(d, schemaID, blockID) 320 c.Assert(err, IsNil) 321 return tbl 322 } 323 324 func testGetTableWithError(d *dbs, schemaID, blockID int64) (causet.Block, error) { 325 var tblInfo *perceptron.TableInfo 326 err := ekv.RunInNewTxn(d.causetstore, false, func(txn ekv.Transaction) error { 327 t := spacetime.NewMeta(txn) 328 var err1 error 329 tblInfo, err1 = t.GetTable(schemaID, blockID) 330 if err1 != nil { 331 return errors.Trace(err1) 332 } 333 return nil 334 }) 335 if err != nil { 336 return nil, errors.Trace(err) 337 } 338 if tblInfo == nil { 339 return nil, errors.New("causet not found") 340 } 341 alloc := autoid.NewSlabPredictor(d.causetstore, schemaID, false, autoid.RowIDAllocType) 342 tbl, err := causet.TableFromMeta(autoid.NewSlabPredictors(alloc), tblInfo) 343 if err != nil { 344 return nil, errors.Trace(err) 345 } 346 return tbl, nil 347 } 348 349 func (s *testTableSuite) SetUpSuite(c *C) { 350 s.causetstore = testCreateStore(c, "test_block") 351 s.d = testNewDBSAndStart( 352 context.Background(), 353 c, 354 WithStore(s.causetstore), 355 WithLease(testLease), 356 ) 357 358 s.dbInfo = testSchemaInfo(c, s.d, "test") 359 testCreateSchema(c, testNewContext(s.d), s.d, s.dbInfo) 360 } 361 362 func (s *testTableSuite) TearDownSuite(c *C) { 363 testDropSchema(c, testNewContext(s.d), s.d, s.dbInfo) 364 s.d.Stop() 365 s.causetstore.Close() 366 } 367 368 func (s *testTableSuite) TestTable(c *C) { 369 d := s.d 370 371 ctx := testNewContext(d) 372 373 tblInfo := testTableInfo(c, d, "t", 3) 374 job := testCreateTable(c, ctx, d, s.dbInfo, tblInfo) 375 testCheckTableState(c, d, s.dbInfo, tblInfo, perceptron.StatePublic) 376 testCheckJobDone(c, d, job, true) 377 378 // Create an existing causet. 379 newTblInfo := testTableInfo(c, d, "t", 3) 380 doDBSJobErr(c, s.dbInfo.ID, newTblInfo.ID, perceptron.CausetActionCreateTable, []interface{}{newTblInfo}, ctx, d) 381 382 count := 2000 383 tbl := testGetTable(c, d, s.dbInfo.ID, tblInfo.ID) 384 for i := 1; i <= count; i++ { 385 _, err := tbl.AddRecord(ctx, types.MakeCausets(i, i, i)) 386 c.Assert(err, IsNil) 387 } 388 389 job = testDropTable(c, ctx, d, s.dbInfo, tblInfo) 390 testCheckJobDone(c, d, job, false) 391 392 // for truncate causet 393 tblInfo = testTableInfo(c, d, "tt", 3) 394 job = testCreateTable(c, ctx, d, s.dbInfo, tblInfo) 395 testCheckTableState(c, d, s.dbInfo, tblInfo, perceptron.StatePublic) 396 testCheckJobDone(c, d, job, true) 397 job = testTruncateTable(c, ctx, d, s.dbInfo, tblInfo) 398 testCheckTableState(c, d, s.dbInfo, tblInfo, perceptron.StatePublic) 399 testCheckJobDone(c, d, job, true) 400 401 // for rename causet 402 dbInfo1 := testSchemaInfo(c, s.d, "test_rename_block") 403 testCreateSchema(c, testNewContext(s.d), s.d, dbInfo1) 404 job = testRenameTable(c, ctx, d, dbInfo1.ID, s.dbInfo.ID, tblInfo) 405 testCheckTableState(c, d, dbInfo1, tblInfo, perceptron.StatePublic) 406 testCheckJobDone(c, d, job, true) 407 408 job = testLockTable(c, ctx, d, dbInfo1.ID, tblInfo, perceptron.TableLockWrite) 409 testCheckTableState(c, d, dbInfo1, tblInfo, perceptron.StatePublic) 410 testCheckJobDone(c, d, job, true) 411 checkTableLockedTest(c, d, dbInfo1, tblInfo, d.GetID(), ctx.GetStochastikVars().ConnectionID, perceptron.TableLockWrite) 412 }