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}}, {Name: "k", Type: sqlbase.ColumnType{Kind: sqlbase.ColumnType_BYTES}}, }, PrimaryIndex: sqlbase.IndexDescriptor{ Name: "primary", Unique: true, ColumnNames: []string{"a"}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, Privileges: sqlbase.NewDefaultPrivilegeDescriptor(), FormatVersion: sqlbase.FamilyFormatVersion, } }
// 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) } }
func TestPrimaryKeyUnspecified(t *testing.T) { defer leaktest.AfterTest(t)() s := "CREATE TABLE foo.test (a INT, b INT, CONSTRAINT c UNIQUE (b))" desc, err := CreateTestTableDescriptor(1, 100, s, sqlbase.NewDefaultPrivilegeDescriptor()) if err != nil { t.Fatal(err) } desc.PrimaryIndex = sqlbase.IndexDescriptor{} err = desc.ValidateTable() if !testutils.IsError(err, sqlbase.ErrMissingPrimaryKey.Error()) { t.Fatalf("unexpected error: %v", err) } }
func makeDatabaseDesc(p *parser.CreateDatabase) sqlbase.DatabaseDescriptor { return sqlbase.DatabaseDescriptor{ Name: string(p.Name), Privileges: sqlbase.NewDefaultPrivilegeDescriptor(), } }
func TestMakeTableDescColumns(t *testing.T) { defer leaktest.AfterTest(t)() testData := []struct { sqlType string colType sqlbase.ColumnType nullable bool }{ { "BIT", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT, Width: 1}, true, }, { "BIT(3)", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT, Width: 3}, true, }, { "BOOLEAN", sqlbase.ColumnType{Kind: sqlbase.ColumnType_BOOL}, true, }, { "INT", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}, true, }, { "FLOAT(3)", sqlbase.ColumnType{Kind: sqlbase.ColumnType_FLOAT, Precision: 3}, true, }, { "DECIMAL(6,5)", sqlbase.ColumnType{Kind: sqlbase.ColumnType_DECIMAL, Precision: 6, Width: 5}, true, }, { "DATE", sqlbase.ColumnType{Kind: sqlbase.ColumnType_DATE}, true, }, { "TIMESTAMP", sqlbase.ColumnType{Kind: sqlbase.ColumnType_TIMESTAMP}, true, }, { "INTERVAL", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INTERVAL}, true, }, { "CHAR", sqlbase.ColumnType{Kind: sqlbase.ColumnType_STRING}, true, }, { "TEXT", sqlbase.ColumnType{Kind: sqlbase.ColumnType_STRING}, true, }, { "BLOB", sqlbase.ColumnType{Kind: sqlbase.ColumnType_BYTES}, true, }, { "INT NOT NULL", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}, false, }, { "INT NULL", sqlbase.ColumnType{Kind: sqlbase.ColumnType_INT}, true, }, } for i, d := range testData { s := "CREATE TABLE foo.test (a " + d.sqlType + " PRIMARY KEY, b " + d.sqlType + ")" schema, err := CreateTestTableDescriptor(1, 100, s, sqlbase.NewDefaultPrivilegeDescriptor()) if err != nil { t.Fatalf("%d: %v", i, err) } if !reflect.DeepEqual(d.colType, schema.Columns[0].Type) { t.Fatalf("%d: expected %+v, but got %+v", i, d.colType, schema.Columns[0]) } if schema.Columns[0].Nullable { t.Fatalf("%d: expected non-nullable primary key, but got %+v", i, schema.Columns[0].Nullable) } if !reflect.DeepEqual(d.colType, schema.Columns[1].Type) { t.Fatalf("%d: expected %+v, but got %+v", i, d.colType, schema.Columns[1]) } if d.nullable != schema.Columns[1].Nullable { t.Fatalf("%d: expected %+v, but got %+v", i, d.nullable, schema.Columns[1].Nullable) } } }
func TestMakeTableDescIndexes(t *testing.T) { defer leaktest.AfterTest(t)() testData := []struct { sql string primary sqlbase.IndexDescriptor indexes []sqlbase.IndexDescriptor }{ { "a INT PRIMARY KEY", sqlbase.IndexDescriptor{ Name: sqlbase.PrimaryKeyIndexName, ID: 1, Unique: true, ColumnNames: []string{"a"}, ColumnIDs: []sqlbase.ColumnID{1}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, []sqlbase.IndexDescriptor{}, }, { "a INT UNIQUE, b INT PRIMARY KEY", sqlbase.IndexDescriptor{ Name: "primary", ID: 1, Unique: true, ColumnNames: []string{"b"}, ColumnIDs: []sqlbase.ColumnID{2}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, []sqlbase.IndexDescriptor{ { Name: "test_a_key", ID: 2, Unique: true, ColumnNames: []string{"a"}, ColumnIDs: []sqlbase.ColumnID{1}, ImplicitColumnIDs: []sqlbase.ColumnID{2}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, }, }, { "a INT, b INT, CONSTRAINT c PRIMARY KEY (a, b)", sqlbase.IndexDescriptor{ Name: "c", ID: 1, Unique: true, ColumnNames: []string{"a", "b"}, ColumnIDs: []sqlbase.ColumnID{1, 2}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC, sqlbase.IndexDescriptor_ASC}, }, []sqlbase.IndexDescriptor{}, }, { "a INT, b INT, CONSTRAINT c UNIQUE (b), PRIMARY KEY (a, b)", sqlbase.IndexDescriptor{ Name: "primary", ID: 1, Unique: true, ColumnNames: []string{"a", "b"}, ColumnIDs: []sqlbase.ColumnID{1, 2}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC, sqlbase.IndexDescriptor_ASC}, }, []sqlbase.IndexDescriptor{ { Name: "c", ID: 2, Unique: true, ColumnNames: []string{"b"}, ColumnIDs: []sqlbase.ColumnID{2}, ImplicitColumnIDs: []sqlbase.ColumnID{1}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC}, }, }, }, { "a INT, b INT, PRIMARY KEY (a, b)", sqlbase.IndexDescriptor{ Name: sqlbase.PrimaryKeyIndexName, ID: 1, Unique: true, ColumnNames: []string{"a", "b"}, ColumnIDs: []sqlbase.ColumnID{1, 2}, ColumnDirections: []sqlbase.IndexDescriptor_Direction{sqlbase.IndexDescriptor_ASC, sqlbase.IndexDescriptor_ASC}, }, []sqlbase.IndexDescriptor{}, }, } for i, d := range testData { s := "CREATE TABLE foo.test (" + d.sql + ")" schema, err := CreateTestTableDescriptor(1, 100, s, sqlbase.NewDefaultPrivilegeDescriptor()) if err != nil { t.Fatalf("%d (%s): %v", i, d.sql, err) } if !reflect.DeepEqual(d.primary, schema.PrimaryIndex) { t.Fatalf("%d (%s): primary mismatch: expected %+v, but got %+v", i, d.sql, d.primary, schema.PrimaryIndex) } if !reflect.DeepEqual(d.indexes, append([]sqlbase.IndexDescriptor{}, schema.Indexes...)) { t.Fatalf("%d (%s): index mismatch: expected %+v, but got %+v", i, d.sql, d.indexes, schema.Indexes) } } }