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)
}
}
}