func parseAndNormalizeExpr(t *testing.T, sql string) (parser.Expr, qvalMap) {
q, err := parser.ParseTraditional("SELECT " + sql)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
expr := q[0].(*parser.Select).Exprs[0].Expr
expr, err = (parser.EvalContext{}).NormalizeExpr(expr)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
// Perform qualified name resolution because {analyze,simplify}Expr want
// expressions containing qvalues.
s := &scanNode{}
s.desc = testTableDesc()
s.visibleCols = s.desc.Columns
if err := s.desc.AllocateIDs(); err != nil {
t.Fatal(err)
}
expr, err = s.resolveQNames(expr)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
if _, err := parser.TypeCheckExpr(expr); err != nil {
t.Fatalf("%s: %v", sql, err)
}
return expr, s.qvals
}
// Test that we can resolve the qnames in an expression that has already been
// resolved.
func TestRetryResolveQNames(t *testing.T) {
defer leaktest.AfterTest(t)
q, err := parser.ParseTraditional(`SELECT COUNT(a)`)
if err != nil {
t.Fatal(err)
}
expr := q[0].(*parser.Select).Exprs[0].Expr
for i := 0; i < 2; i++ {
s := &scanNode{}
s.desc = testTableDesc()
s.visibleCols = s.desc.Columns
if err := s.desc.AllocateIDs(); err != nil {
t.Fatal(err)
}
_, err = s.resolveQNames(expr)
if err != nil {
t.Fatal(err)
}
if len(s.qvals) != 1 {
t.Fatalf("%d: expected 1 qvalue, but found %d", i, len(s.qvals))
}
if _, ok := s.qvals[ColumnID(1)]; !ok {
t.Fatalf("%d: unable to find qvalue for column ID 1", i)
}
}
}
func parseAndNormalizeExpr(t *testing.T, sql string) (parser.Expr, qvalMap) {
q, err := parser.ParseTraditional("SELECT " + sql)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
expr := q[0].(*parser.Select).Exprs[0].Expr
r, err := parser.NormalizeExpr(expr)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
// Perform qualified name resolution because {analyze,simplify}Expr want
// expressions containing qvalues.
s := &scanNode{}
s.desc = &TableDescriptor{
Columns: []ColumnDescriptor{
{Name: "a", ID: 1, Type: ColumnType{Kind: ColumnType_INT}},
{Name: "b", ID: 2, Type: ColumnType{Kind: ColumnType_INT}},
{Name: "c", ID: 3, Type: ColumnType{Kind: ColumnType_INT}},
{Name: "d", ID: 4, Type: ColumnType{Kind: ColumnType_INT}},
{Name: "e", ID: 5, Type: ColumnType{Kind: ColumnType_INT}},
},
}
s.visibleCols = s.desc.Columns
r, err = s.resolveQNames(r)
if err != nil {
t.Fatalf("%s: %v", sql, err)
}
return r, s.qvals
}
func (p *planner) query(sql string) (planNode, error) {
stmts, err := parser.ParseTraditional(sql)
if err != nil {
return nil, err
}
if len(stmts) != 1 {
return nil, util.Errorf("expected single statement, found %d", len(stmts))
}
return p.makePlan(stmts[0])
}
func TestPrimaryKeyUnspecified(t *testing.T) {
defer leaktest.AfterTest(t)
stmt, err := parser.ParseTraditional(
"CREATE TABLE foo.test (a INT, b INT, CONSTRAINT c UNIQUE (b))")
if err != nil {
t.Fatal(err)
}
create := stmt[0].(*parser.CreateTable)
if err := create.Table.NormalizeTableName(""); err != nil {
t.Fatal(err)
}
desc, err := makeTableDesc(create, 1)
if err != nil {
t.Fatal(err)
}
if err := desc.AllocateIDs(); err != errMissingPrimaryKey {
t.Fatal(err)
}
}
func createSystemTable(id ID, cmd string) TableDescriptor {
stmts, err := parser.ParseTraditional(cmd)
if err != nil {
log.Fatal(err)
}
desc, err := makeTableDesc(stmts[0].(*parser.CreateTable))
if err != nil {
log.Fatal(err)
}
// Assign max privileges to root user.
desc.Privileges = NewPrivilegeDescriptor(security.RootUser,
SystemAllowedPrivileges[id])
desc.ID = id
if err := desc.AllocateIDs(); err != nil {
log.Fatal(err)
}
return desc
}
func TestMakeTableDescColumns(t *testing.T) {
defer leaktest.AfterTest(t)
testData := []struct {
sqlType string
colType ColumnType
nullable bool
}{
{
"BIT(1)",
ColumnType{Kind: ColumnType_INT, Width: 1},
true,
},
{
"BOOLEAN",
ColumnType{Kind: ColumnType_BOOL},
true,
},
{
"INT",
ColumnType{Kind: ColumnType_INT},
true,
},
{
"FLOAT(3)",
ColumnType{Kind: ColumnType_FLOAT, Precision: 3},
true,
},
{
"DECIMAL(5,6)",
ColumnType{Kind: ColumnType_DECIMAL, Precision: 5, Width: 6},
true,
},
{
"DATE",
ColumnType{Kind: ColumnType_DATE},
true,
},
{
"TIMESTAMP",
ColumnType{Kind: ColumnType_TIMESTAMP},
true,
},
{
"INTERVAL",
ColumnType{Kind: ColumnType_INTERVAL},
true,
},
{
"CHAR",
ColumnType{Kind: ColumnType_STRING},
true,
},
{
"TEXT",
ColumnType{Kind: ColumnType_STRING},
true,
},
{
"BLOB",
ColumnType{Kind: ColumnType_BYTES},
true,
},
{
"INT NOT NULL",
ColumnType{Kind: ColumnType_INT},
false,
},
{
"INT NULL",
ColumnType{Kind: ColumnType_INT},
true,
},
}
for i, d := range testData {
stmt, err := parser.ParseTraditional(
"CREATE TABLE foo.test (a " + d.sqlType + " PRIMARY KEY)")
if err != nil {
t.Fatalf("%d: %v", i, err)
}
create := stmt[0].(*parser.CreateTable)
if err := create.Table.NormalizeTableName(""); err != nil {
t.Fatalf("%d: %v", i, err)
}
schema, err := makeTableDesc(create, 1)
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 d.nullable != schema.Columns[0].Nullable {
t.Fatalf("%d: expected %+v, but got %+v", i, d.nullable, schema.Columns[0].Nullable)
}
}
}
func TestMakeTableDescIndexes(t *testing.T) {
defer leaktest.AfterTest(t)
testData := []struct {
sql string
primary IndexDescriptor
indexes []IndexDescriptor
}{
{
"a INT PRIMARY KEY",
IndexDescriptor{
Name: PrimaryKeyIndexName,
Unique: true,
ColumnNames: []string{"a"},
},
[]IndexDescriptor{},
},
{
"a INT UNIQUE, b INT PRIMARY KEY",
IndexDescriptor{
Name: "primary",
Unique: true,
ColumnNames: []string{"b"},
},
[]IndexDescriptor{
{
Name: "",
Unique: true,
ColumnNames: []string{"a"},
},
},
},
{
"a INT, b INT, CONSTRAINT c PRIMARY KEY (a, b)",
IndexDescriptor{
Name: "c",
Unique: true,
ColumnNames: []string{"a", "b"},
},
[]IndexDescriptor{},
},
{
"a INT, b INT, CONSTRAINT c UNIQUE (b), PRIMARY KEY (a, b)",
IndexDescriptor{
Name: "primary",
Unique: true,
ColumnNames: []string{"a", "b"},
},
[]IndexDescriptor{
{
Name: "c",
Unique: true,
ColumnNames: []string{"b"},
},
},
},
{
"a INT, b INT, PRIMARY KEY (a, b)",
IndexDescriptor{
Name: PrimaryKeyIndexName,
Unique: true,
ColumnNames: []string{"a", "b"},
},
[]IndexDescriptor{},
},
}
for i, d := range testData {
stmt, err := parser.ParseTraditional("CREATE TABLE foo.test (" + d.sql + ")")
if err != nil {
t.Fatalf("%d: %v", i, err)
}
create := stmt[0].(*parser.CreateTable)
if err := create.Table.NormalizeTableName(""); err != nil {
t.Fatalf("%d: %v", i, err)
}
schema, err := makeTableDesc(create, 1)
if err != nil {
t.Fatalf("%d: %v", i, err)
}
if !reflect.DeepEqual(d.primary, schema.PrimaryIndex) {
t.Fatalf("%d: expected %+v, but got %+v", i, d.primary, schema.PrimaryIndex)
}
if !reflect.DeepEqual(d.indexes, append([]IndexDescriptor{}, schema.Indexes...)) {
t.Fatalf("%d: expected %+v, but got %+v", i, d.indexes, schema.Indexes)
}
}
}
