// SchemaFromModel allows the easy construction of a TableSchema 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.TableSchema, error) {
s := structured.TableSchema{}
m, err := getDBFields(deref(reflect.TypeOf(obj)))
if err != nil {
return s, err
}
s.Table.Name = strings.ToLower(reflect.TypeOf(obj).Name())
// Create the columns for the table.
for name := range m {
col := structured.Column{
Name: name,
Type: structured.Column_BYTES,
}
s.Columns = append(s.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 s, 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.Index
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, ":")
}
s.Indexes = append(s.Indexes, structured.TableSchema_IndexByName{
Index: index,
ColumnNames: params,
})
}
}
// Normalize the column and index order.
sort.Sort(columnsByName(s.Columns))
sort.Sort(indexesByName(s.Indexes))
return s, nil
}
// CreateTable creates a table from the specified schema. Table creation will
// fail if the table name is already in use. The table name is required to have
// the form "<namespace>.<table>".
func (db *DB) CreateTable(schema structured.TableSchema) error {
schema.Name = strings.ToLower(schema.Name)
desc := structured.TableDescFromSchema(schema)
if err := structured.ValidateTableDesc(desc); err != nil {
return err
}
nsID, name, err := db.lookupTable(desc.Name)
if err != nil {
return err
}
if name == "" {
return fmt.Errorf("empty table name: %s", desc.Name)
}
nameKey := keys.MakeNameMetadataKey(nsID, name)
// This isn't strictly necessary as the conditional put below will fail if
// the key already exists, but it seems good to avoid the table ID allocation
// in most cases when the table already exists.
if gr, err := db.Get(nameKey); err != nil {
return err
} else if gr.Exists() {
return fmt.Errorf("table \"%s\" already exists", desc.Name)
}
ir, err := db.Inc(keys.DescIDGenerator, 1)
if err != nil {
return err
}
desc.ID = uint32(ir.ValueInt() - 1)
// TODO(pmattis): Be cognizant of error messages when this is ported to the
// server. The error currently returned below is likely going to be difficult
// to interpret.
return db.Txn(func(txn *Txn) error {
descKey := keys.MakeDescMetadataKey(desc.ID)
b := &Batch{}
b.CPut(nameKey, descKey, nil)
b.Put(descKey, &desc)
return txn.Commit(b)
})
}
func makeSchema(p *parser.CreateTable) (structured.TableSchema, error) {
s := structured.TableSchema{}
s.Name = p.Table.String()
for _, def := range p.Defs {
switch d := def.(type) {
case *parser.ColumnTableDef:
col := structured.Column{
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.Width = int32(t.N)
col.Type.Precision = int32(t.Prec)
case *parser.DecimalType:
col.Type.Kind = structured.ColumnType_DECIMAL
col.Type.Width = int32(t.N)
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.DateTimeType:
col.Type.Kind = structured.ColumnType_DATETIME
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.BinaryType:
col.Type.Kind = structured.ColumnType_BINARY
col.Type.Width = int32(t.N)
case *parser.TextType:
col.Type.Kind = structured.ColumnType_TEXT
case *parser.BlobType:
col.Type.Kind = structured.ColumnType_BLOB
case *parser.EnumType:
col.Type.Kind = structured.ColumnType_ENUM
col.Type.Vals = t.Vals
case *parser.SetType:
col.Type.Kind = structured.ColumnType_SET
col.Type.Vals = t.Vals
}
s.Columns = append(s.Columns, col)
// Create any associated index.
if d.PrimaryKey || d.Unique {
index := structured.TableSchema_IndexByName{
Index: structured.Index{
Unique: true,
},
ColumnNames: []string{d.Name},
}
if d.PrimaryKey {
index.Name = "primary"
}
s.Indexes = append(s.Indexes, index)
}
case *parser.IndexTableDef:
index := structured.TableSchema_IndexByName{
Index: structured.Index{
Name: d.Name,
Unique: d.Unique,
},
ColumnNames: d.Columns,
}
s.Indexes = append(s.Indexes, index)
default:
return s, fmt.Errorf("unsupported table def: %T", def)
}
}
return s, nil
}
// SchemaFromModel allows the easy construction of a TableSchema 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.TableSchema, error) {
s := structured.TableSchema{}
m, err := getDBFields(deref(reflect.TypeOf(obj)))
if err != nil {
return s, err
}
s.Table.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.Column{
Name: name,
Type: colType,
}
s.Columns = append(s.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 s, 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.Index
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, ":")
}
s.Indexes = append(s.Indexes, structured.TableSchema_IndexByName{
Index: index,
ColumnNames: params,
})
}
}
// Normalize the column and index order.
sort.Sort(columnsByName(s.Columns))
sort.Sort(indexesByName(s.Indexes))
return s, nil
}