// 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, err := sql.CreateTestTableDescriptor(
keys.SystemDatabaseID,
test.id,
test.schema,
sqlbase.NewPrivilegeDescriptor(security.RootUser, sqlbase.SystemConfigAllowedPrivileges[test.id]),
)
if err != nil {
t.Fatal(err)
}
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.EventLogTableID, sqlbase.EventLogTableSchema, sqlbase.EventLogTable},
{keys.RangeEventTableID, sqlbase.RangeEventTableSchema, sqlbase.RangeEventTable},
{keys.UITableID, sqlbase.UITableSchema, sqlbase.UITable},
} {
gen, err := sql.CreateTestTableDescriptor(
keys.SystemDatabaseID, test.id, test.schema, sqlbase.NewDefaultPrivilegeDescriptor(),
)
if err != nil {
t.Fatal(err)
}
if !proto.Equal(&test.pkg, &gen) {
s1 := fmt.Sprintf("%#v", test.pkg)
s2 := fmt.Sprintf("%#v", gen)
for i := range s1 {
if s1[i] != s2[i] {
t.Fatalf(
"mismatch between %s:\npkg:\n\t%#v\npartial-gen\n\t%#v\ngen\n\t%#v",
test.pkg.Name, s1[:i+3], s2[:i+3], gen)
}
}
panic("did not locate mismatch between re-generated version and pkg version")
}
}
}
func TestInitialKeys(t *testing.T) {
defer leaktest.AfterTest(t)()
const nonSystemDesc = 4
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, err := sql.CreateTestTableDescriptor(
keys.SystemDatabaseID,
keys.MaxSystemConfigDescID+1,
"CREATE TABLE testdb.x (val INTEGER PRIMARY KEY)",
sqlbase.NewDefaultPrivilegeDescriptor(),
)
if err != nil {
t.Fatal(err)
}
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)
}
}