func testTableDesc() *sqlbase.TableDescriptor { return &sqlbase.TableDescriptor{ Name: "test", ID: 1001, ParentID: 1000, Columns: []sqlbase.ColumnDescriptor{ {Name: "a", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}}, {Name: "b", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}}, {Name: "c", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}}, {Name: "d", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}}, {Name: "e", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}}, {Name: "f", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}}, {Name: "g", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}}, {Name: "h", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_FLOAT}}, {Name: "i", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_STRING}}, {Name: "j", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}}, }, PrimaryIndex: sqlbase.IndexDescriptor{ Name: "primary", Unique: true, ColumnNames: []string{"a"}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, Privileges: sqlbase.NewDefaultPrivilegeDescriptor(), FormatVersion: sqlbase.BaseFormatVersion, } }
// AddEventLogToMetadataSchema adds the range event log table to the supplied // MetadataSchema. func AddEventLogToMetadataSchema(schema *sqlbase.MetadataSchema) { desc := sql.CreateTableDescriptor( keys.RangeEventTableID, keys.SystemDatabaseID, storage.RangeEventTableSchema, sqlbase.NewDefaultPrivilegeDescriptor(), ) schema.AddDescriptor(keys.SystemDatabaseID, &desc) }
// TestSystemTableLiterals compares the result of evaluating the `CREATE TABLE` // statement strings that describe each system table with the TableDescriptor // literals that are actually used at runtime. This ensures we can use the hand- // written literals instead of having to evaluate the `CREATE TABLE` statements // before initialization and with limited SQL machinery bootstraped, while still // confident that the result is the same as if `CREATE TABLE` had been run. // // This test may also be useful when writing a new system table: // adding the new schema along with a trivial, empty TableDescriptor literal // will print the expected proto which can then be used to replace the empty // one (though pruning the explicit zero values may make it more readable). func TestSystemTableLiterals(t *testing.T) { defer leaktest.AfterTest(t)() type testcase struct { id sqlbase.ID schema string pkg sqlbase.TableDescriptor } // test the tables with specific permissions for _, test := range []testcase{ {keys.NamespaceTableID, sqlbase.NamespaceTableSchema, sqlbase.NamespaceTable}, {keys.DescriptorTableID, sqlbase.DescriptorTableSchema, sqlbase.DescriptorTable}, {keys.UsersTableID, sqlbase.UsersTableSchema, sqlbase.UsersTable}, {keys.ZonesTableID, sqlbase.ZonesTableSchema, sqlbase.ZonesTable}, } { gen := sql.CreateTableDescriptor(test.id, keys.SystemDatabaseID, test.schema, sqlbase.NewPrivilegeDescriptor(security.RootUser, sqlbase.SystemConfigAllowedPrivileges[test.id])) if !proto.Equal(&test.pkg, &gen) { t.Fatalf( "mismatch between re-generated version and pkg version of %s:\npkg:\n\t%#v\ngenerated\n\t%#v", test.pkg.Name, test.pkg, gen) } } // test the tables with non-specific NewDefaultPrivilegeDescriptor for _, test := range []testcase{ {keys.LeaseTableID, sqlbase.LeaseTableSchema, sqlbase.LeaseTable}, {keys.UITableID, sqlbase.UITableSchema, sqlbase.UITable}, } { gen := sql.CreateTableDescriptor(test.id, keys.SystemDatabaseID, test.schema, sqlbase.NewDefaultPrivilegeDescriptor()) if !proto.Equal(&test.pkg, &gen) { t.Fatalf( "mismatch between re-generated version and pkg version of %s:\npkg:\n\t%#v\ngenerated\n\t%#v", test.pkg.Name, test.pkg, gen) } } }
func TestComputeSplits(t *testing.T) { defer leaktest.AfterTest(t)() const ( start = keys.MaxReservedDescID + 1 reservedStart = keys.MaxSystemConfigDescID + 1 ) schema := sqlbase.MakeMetadataSchema() // Real SQL system tables only. baseSql := schema.GetInitialValues() // Real SQL system tables plus some user stuff. userSql := append(schema.GetInitialValues(), descriptor(start), descriptor(start+1), descriptor(start+5)) // Real SQL system with reserved non-system tables. priv := sqlbase.NewDefaultPrivilegeDescriptor() desc1 := sql.CreateTableDescriptor(reservedStart+1, keys.SystemDatabaseID, "CREATE TABLE system.test1 (i INT PRIMARY KEY)", priv) schema.AddDescriptor(keys.SystemDatabaseID, &desc1) desc2 := sql.CreateTableDescriptor(reservedStart+2, keys.SystemDatabaseID, "CREATE TABLE system.test2 (i INT PRIMARY KEY)", priv) schema.AddDescriptor(keys.SystemDatabaseID, &desc2) reservedSql := schema.GetInitialValues() // Real SQL system with reserved non-system and user database. allSql := append(schema.GetInitialValues(), descriptor(start), descriptor(start+1), descriptor(start+5)) sort.Sort(roachpb.KeyValueByKey(allSql)) allUserSplits := []uint32{start, start + 1, start + 2, start + 3, start + 4, start + 5} var allReservedSplits []uint32 for i := 0; i < schema.SystemDescriptorCount()-schema.SystemConfigDescriptorCount(); i++ { allReservedSplits = append(allReservedSplits, reservedStart+uint32(i)) } allSplits := append(allReservedSplits, allUserSplits...) testCases := []struct { values []roachpb.KeyValue start, end roachpb.RKey // Use ints in the testcase definitions, more readable. splits []uint32 }{ // No data. {nil, roachpb.RKeyMin, roachpb.RKeyMax, nil}, {nil, keys.MakeTablePrefix(start), roachpb.RKeyMax, nil}, {nil, keys.MakeTablePrefix(start), keys.MakeTablePrefix(start + 10), nil}, {nil, roachpb.RKeyMin, keys.MakeTablePrefix(start + 10), nil}, // No user data. {baseSql, roachpb.RKeyMin, roachpb.RKeyMax, allReservedSplits}, {baseSql, keys.MakeTablePrefix(start), roachpb.RKeyMax, nil}, {baseSql, keys.MakeTablePrefix(start), keys.MakeTablePrefix(start + 10), nil}, {baseSql, roachpb.RKeyMin, keys.MakeTablePrefix(start + 10), allReservedSplits}, // User descriptors. {userSql, keys.MakeTablePrefix(start - 1), roachpb.RKeyMax, allUserSplits}, {userSql, keys.MakeTablePrefix(start), roachpb.RKeyMax, allUserSplits[1:]}, {userSql, keys.MakeTablePrefix(start), keys.MakeTablePrefix(start + 10), allUserSplits[1:]}, {userSql, keys.MakeTablePrefix(start - 1), keys.MakeTablePrefix(start + 10), allUserSplits}, {userSql, keys.MakeTablePrefix(start + 4), keys.MakeTablePrefix(start + 10), allUserSplits[5:]}, {userSql, keys.MakeTablePrefix(start + 5), keys.MakeTablePrefix(start + 10), nil}, {userSql, keys.MakeTablePrefix(start + 6), keys.MakeTablePrefix(start + 10), nil}, {userSql, testutils.MakeKey(keys.MakeTablePrefix(start), roachpb.RKey("foo")), keys.MakeTablePrefix(start + 10), allUserSplits[1:]}, {userSql, testutils.MakeKey(keys.MakeTablePrefix(start), roachpb.RKey("foo")), keys.MakeTablePrefix(start + 5), allUserSplits[1:5]}, {userSql, testutils.MakeKey(keys.MakeTablePrefix(start), roachpb.RKey("foo")), testutils.MakeKey(keys.MakeTablePrefix(start+5), roachpb.RKey("bar")), allUserSplits[1:5]}, {userSql, testutils.MakeKey(keys.MakeTablePrefix(start), roachpb.RKey("foo")), testutils.MakeKey(keys.MakeTablePrefix(start), roachpb.RKey("morefoo")), nil}, // Reserved descriptors. {reservedSql, roachpb.RKeyMin, roachpb.RKeyMax, allReservedSplits}, {reservedSql, keys.MakeTablePrefix(reservedStart), roachpb.RKeyMax, allReservedSplits[1:]}, {reservedSql, keys.MakeTablePrefix(start), roachpb.RKeyMax, nil}, {reservedSql, keys.MakeTablePrefix(reservedStart), keys.MakeTablePrefix(start + 10), allReservedSplits[1:]}, {reservedSql, roachpb.RKeyMin, keys.MakeTablePrefix(reservedStart + 2), allReservedSplits[:2]}, {reservedSql, roachpb.RKeyMin, keys.MakeTablePrefix(reservedStart + 10), allReservedSplits}, {reservedSql, keys.MakeTablePrefix(reservedStart), keys.MakeTablePrefix(reservedStart + 2), allReservedSplits[1:2]}, {reservedSql, testutils.MakeKey(keys.MakeTablePrefix(reservedStart), roachpb.RKey("foo")), testutils.MakeKey(keys.MakeTablePrefix(start+10), roachpb.RKey("foo")), allReservedSplits[1:]}, // Reserved/User mix. {allSql, roachpb.RKeyMin, roachpb.RKeyMax, allSplits}, {allSql, keys.MakeTablePrefix(reservedStart + 1), roachpb.RKeyMax, allSplits[2:]}, {allSql, keys.MakeTablePrefix(start), roachpb.RKeyMax, allUserSplits[1:]}, {allSql, keys.MakeTablePrefix(reservedStart), keys.MakeTablePrefix(start + 10), allSplits[1:]}, {allSql, roachpb.RKeyMin, keys.MakeTablePrefix(start + 2), allSplits[:6]}, {allSql, testutils.MakeKey(keys.MakeTablePrefix(reservedStart), roachpb.RKey("foo")), testutils.MakeKey(keys.MakeTablePrefix(start+5), roachpb.RKey("foo")), allSplits[1:9]}, } cfg := config.SystemConfig{} for tcNum, tc := range testCases { cfg.Values = tc.values splits := cfg.ComputeSplitKeys(tc.start, tc.end) if len(splits) == 0 && len(tc.splits) == 0 { continue } // Convert ints to actual keys. expected := []roachpb.RKey{} for _, s := range tc.splits { expected = append(expected, keys.MakeRowSentinelKey(keys.MakeTablePrefix(s))) } if !reflect.DeepEqual(splits, expected) { t.Errorf("#%d: bad splits:\ngot: %v\nexpected: %v", tcNum, splits, expected) } } }
func makeDatabaseDesc(p *parser.CreateDatabase) sqlbase.DatabaseDescriptor { return sqlbase.DatabaseDescriptor{ Name: p.Name.String(), Privileges: sqlbase.NewDefaultPrivilegeDescriptor(), } }
func TestInitialKeys(t *testing.T) { defer leaktest.AfterTest(t)() const nonSystemDesc = 2 const keysPerDesc = 2 const nonDescKeys = 2 ms := sqlbase.MakeMetadataSchema() kv := ms.GetInitialValues() expected := nonDescKeys + keysPerDesc*(nonSystemDesc+ms.SystemConfigDescriptorCount()) if actual := len(kv); actual != expected { t.Fatalf("Wrong number of initial sql kv pairs: %d, wanted %d", actual, expected) } // Add an additional table. desc := sql.CreateTableDescriptor(keys.MaxSystemConfigDescID+1, keys.SystemDatabaseID, "CREATE TABLE testdb.x (val INTEGER PRIMARY KEY)", sqlbase.NewDefaultPrivilegeDescriptor()) ms.AddDescriptor(keys.SystemDatabaseID, &desc) kv = ms.GetInitialValues() expected = nonDescKeys + keysPerDesc*ms.SystemDescriptorCount() if actual := len(kv); actual != expected { t.Fatalf("Wrong number of initial sql kv pairs: %d, wanted %d", actual, expected) } // Verify that IDGenerator value is correct. found := false var idgenkv roachpb.KeyValue for _, v := range kv { if v.Key.Equal(keys.DescIDGenerator) { idgenkv = v found = true break } } if !found { t.Fatal("Could not find descriptor ID generator in initial key set") } // Expect 2 non-reserved IDs to have been allocated. i, err := idgenkv.Value.GetInt() if err != nil { t.Fatal(err) } if a, e := i, int64(keys.MaxReservedDescID+1); a != e { t.Fatalf("Expected next descriptor ID to be %d, was %d", e, a) } }