Esempio n. 1
0
// 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
}
Esempio n. 2
0
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
}
Esempio n. 3
0
// 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
}