func makeTableDesc(p *parser.CreateTable) (structured.TableDescriptor, error) {
desc := structured.TableDescriptor{}
desc.Name = p.Table.Table()
for _, def := range p.Defs {
switch d := def.(type) {
case *parser.ColumnTableDef:
col := structured.ColumnDescriptor{
Name: string(d.Name),
Nullable: (d.Nullable != parser.NotNull),
}
switch t := d.Type.(type) {
case *parser.BitType:
col.Type.Kind = structured.ColumnType_BIT
col.Type.Width = int32(t.N)
case *parser.BoolType:
col.Type.Kind = structured.ColumnType_BOOL
case *parser.IntType:
col.Type.Kind = structured.ColumnType_INT
col.Type.Width = int32(t.N)
case *parser.FloatType:
col.Type.Kind = structured.ColumnType_FLOAT
col.Type.Precision = int32(t.Prec)
case *parser.DecimalType:
col.Type.Kind = structured.ColumnType_DECIMAL
col.Type.Width = int32(t.Scale)
col.Type.Precision = int32(t.Prec)
case *parser.DateType:
col.Type.Kind = structured.ColumnType_DATE
case *parser.TimeType:
col.Type.Kind = structured.ColumnType_TIME
case *parser.TimestampType:
col.Type.Kind = structured.ColumnType_TIMESTAMP
case *parser.CharType:
col.Type.Kind = structured.ColumnType_CHAR
col.Type.Width = int32(t.N)
case *parser.TextType:
col.Type.Kind = structured.ColumnType_TEXT
case *parser.BlobType:
col.Type.Kind = structured.ColumnType_BLOB
default:
panic(fmt.Sprintf("unexpected type %T", t))
}
desc.Columns = append(desc.Columns, col)
// Create any associated index.
if d.PrimaryKey || d.Unique {
index := structured.IndexDescriptor{
Unique: true,
ColumnNames: []string{string(d.Name)},
}
if d.PrimaryKey {
index.Name = structured.PrimaryKeyIndexName
desc.PrimaryIndex = index
} else {
desc.Indexes = append(desc.Indexes, index)
}
}
case *parser.IndexTableDef:
index := structured.IndexDescriptor{
Name: string(d.Name),
Unique: d.Unique,
ColumnNames: d.Columns,
}
if d.PrimaryKey {
// Only override the index name if it hasn't been set by the user.
if index.Name == "" {
index.Name = structured.PrimaryKeyIndexName
}
desc.PrimaryIndex = index
} else {
desc.Indexes = append(desc.Indexes, index)
}
default:
return desc, fmt.Errorf("unsupported table def: %T", def)
}
}
return desc, nil
}
func makeTableDesc(p *parser.CreateTable) (structured.TableDescriptor, error) {
desc := structured.TableDescriptor{}
desc.Name = p.Table.String()
for _, def := range p.Defs {
switch d := def.(type) {
case *parser.ColumnTableDef:
col := structured.ColumnDescriptor{
Name: d.Name,
Nullable: (d.Nullable != parser.NotNull),
}
switch t := d.Type.(type) {
case *parser.BitType:
col.Type.Kind = structured.ColumnType_BIT
col.Type.Width = int32(t.N)
case *parser.IntType:
col.Type.Kind = structured.ColumnType_INT
col.Type.Width = int32(t.N)
case *parser.FloatType:
col.Type.Kind = structured.ColumnType_FLOAT
col.Type.Precision = int32(t.Prec)
case *parser.DecimalType:
col.Type.Kind = structured.ColumnType_DECIMAL
col.Type.Width = int32(t.Scale)
col.Type.Precision = int32(t.Prec)
case *parser.DateType:
col.Type.Kind = structured.ColumnType_DATE
case *parser.TimeType:
col.Type.Kind = structured.ColumnType_TIME
case *parser.TimestampType:
col.Type.Kind = structured.ColumnType_TIMESTAMP
case *parser.CharType:
col.Type.Kind = structured.ColumnType_CHAR
col.Type.Width = int32(t.N)
case *parser.TextType:
col.Type.Kind = structured.ColumnType_TEXT
case *parser.BlobType:
col.Type.Kind = structured.ColumnType_BLOB
}
desc.Columns = append(desc.Columns, col)
// Create any associated index.
if d.PrimaryKey || d.Unique {
index := structured.IndexDescriptor{
Unique: true,
ColumnNames: []string{d.Name},
}
if d.PrimaryKey {
index.Name = "primary"
}
desc.Indexes = append(desc.Indexes, index)
}
case *parser.IndexTableDef:
index := structured.IndexDescriptor{
Name: d.Name,
Unique: d.Unique,
ColumnNames: d.Columns,
}
desc.Indexes = append(desc.Indexes, index)
default:
return desc, fmt.Errorf("unsupported table def: %T", def)
}
}
return desc, nil
}
// SchemaFromModel allows the easy construction of a TableDescriptor from a Go
// struct. Columns are created for each exported field in the struct. The "db"
// struct tag is used to control the mapping of field name to column name and
// to indicate exported fields which should be skipped.
//
// type User struct {
// ID int
// Name string `db:"old_name"`
// Ignored int `db:"-"`
// }
//
// Indexes are specified using the "roach" struct tag declaration.
//
// type User struct {
// ID int `roach:"primary key"`
// Name string `db:"old_name" roach:"index"`
// }
//
// The following "roach" options are supported:
//
// "primary key [(columns...)]" - creates a unique index on <columns> and
// marks it as the primary key for the table. If <columns> is not specified
// it defaults to the name of the column the option is associated with.
//
// "index" [(columns...)]" - creates an index on <columns>.
//
// "unique index" [(columns...)]" - creates a unique index on <columns>.
func SchemaFromModel(obj interface{}) (structured.TableDescriptor, error) {
desc := structured.TableDescriptor{}
m, err := getDBFields(deref(reflect.TypeOf(obj)))
if err != nil {
return desc, err
}
desc.Name = strings.ToLower(reflect.TypeOf(obj).Name())
// Create the columns for the table.
for name, sf := range m {
colType := structured.ColumnType{}
// TODO(pmattis): The mapping from Go-type Kind to column-type Kind is
// likely not complete or correct, but this is probably going away pretty
// soon with the move to SQL.
switch sf.Type.Kind() {
case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
reflect.Uint64, reflect.Uintptr:
colType.Kind = structured.ColumnType_INT
case reflect.Float32, reflect.Float64:
colType.Kind = structured.ColumnType_FLOAT
case reflect.String:
colType.Kind = structured.ColumnType_TEXT
}
col := structured.ColumnDescriptor{
Name: name,
Type: colType,
}
desc.Columns = append(desc.Columns, col)
}
// Create the indexes for the table.
for name, f := range m {
tag := f.Tag.Get("roach")
if tag == "" {
continue
}
for _, opt := range strings.Split(tag, ";") {
match := schemaOptRE.FindStringSubmatch(opt)
if match == nil {
return desc, fmt.Errorf("invalid schema option: %s", opt)
}
cmd := match[1]
var params []string
if len(match[2]) > 0 {
params = strings.Split(match[2], ",")
} else {
params = []string{name}
}
var index structured.IndexDescriptor
switch strings.ToLower(cmd) {
case "primary key":
index.Name = structured.PrimaryKeyIndexName
index.Unique = true
case "unique index":
index.Name = strings.Join(params, ":")
index.Unique = true
case "index":
index.Name = strings.Join(params, ":")
}
index.ColumnNames = params
desc.Indexes = append(desc.Indexes, index)
}
}
// Normalize the column and index order.
sort.Sort(columnsByName(desc.Columns))
sort.Sort(indexesByName(desc.Indexes))
return desc, nil
}