dialect/sql/schema: initial work for incremental migration (#428)

This is a WIP PR and should be ignored this moment.
It's based on PR #221 created by Erik Hollensbe (He should
get his credit for his work before we land this).

dialect/sql/schema/sqlite.go

@@ -92,19 +92,15 @@ func (*SQLite) cType(c *Column) (t string) {
 	switch c.Type {
 	case field.TypeBool:
 		t = "bool"
-	case field.TypeInt8, field.TypeUint8, field.TypeInt, field.TypeInt16, field.TypeInt32, field.TypeUint, field.TypeUint16, field.TypeUint32:
+	case field.TypeInt8, field.TypeUint8, field.TypeInt16, field.TypeUint16, field.TypeInt32,
+		field.TypeUint32, field.TypeUint, field.TypeInt, field.TypeInt64, field.TypeUint64:
 		t = "integer"
-	case field.TypeInt64, field.TypeUint64:
-		t = "bigint"
 	case field.TypeBytes:
 		t = "blob"
 	case field.TypeString, field.TypeEnum:
-		size := c.Size
-		if size == 0 {
-			size = DefaultStringLen
-		}
-		// sqlite has no size limit on varchar.
-		t = fmt.Sprintf("varchar(%d)", size)
+		// SQLite does not impose any length restrictions on
+		// the length of strings, BLOBs or numeric values.
+		t = fmt.Sprintf("varchar(%d)", DefaultStringLen)
 	case field.TypeFloat32, field.TypeFloat64:
 		t = "real"
 	case field.TypeTime:
@@ -131,11 +127,6 @@ func (d *SQLite) addColumn(c *Column) *sql.ColumnBuilder {
 	return b
 }
 
-// alterColumn returns the DSL query for modifying the given column.
-func (d *SQLite) alterColumn(c *Column) []*sql.ColumnBuilder {
-	return []*sql.ColumnBuilder{d.addColumn(c)}
-}
-
 // addIndex returns the querying for adding an index to SQLite.
 func (d *SQLite) addIndex(i *Index, table string) *sql.IndexBuilder {
 	return i.Builder(table)
@@ -151,6 +142,146 @@ func (d *SQLite) dropIndex(ctx context.Context, tx dialect.Tx, idx *Index, table
 func (d *SQLite) fkExist(context.Context, dialect.Tx, string) (bool, error) { return true, nil }
 
 // table returns always error to indicate that SQLite dialect doesn't support incremental migration.
-func (d *SQLite) table(context.Context, dialect.Tx, string) (*Table, error) {
-	return nil, fmt.Errorf("sqlite dialect does not support incremental migration")
+func (d *SQLite) table(ctx context.Context, tx dialect.Tx, name string) (*Table, error) {
+	rows := &sql.Rows{}
+	query, args := sql.Select("name", "type", "notnull", "dflt_value", "pk").
+		From(sql.Table(fmt.Sprintf("pragma_table_info('%s')", name)).Unquote()).
+		OrderBy("pk").
+		Query()
+	if err := tx.Query(ctx, query, args, rows); err != nil {
+		return nil, fmt.Errorf("sqlite: reading table description %v", err)
+	}
+	// Call Close in cases of failures (Close is idempotent).
+	defer rows.Close()
+	t := NewTable(name)
+	for rows.Next() {
+		c := &Column{}
+		if err := d.scanColumn(c, rows); err != nil {
+			return nil, fmt.Errorf("sqlite: %v", err)
+		}
+		if c.PrimaryKey() {
+			t.PrimaryKey = append(t.PrimaryKey, c)
+		}
+		t.AddColumn(c)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, fmt.Errorf("sqlite: closing rows %v", err)
+	}
+	indexes, err := d.indexes(ctx, tx, name)
+	if err != nil {
+		return nil, err
+	}
+	// Add and link indexes to table columns.
+	for _, idx := range indexes {
+		t.AddIndex(idx.Name, idx.Unique, idx.columns)
+	}
+	return t, nil
+}
+
+// table loads the table indexes from the database.
+func (d *SQLite) indexes(ctx context.Context, tx dialect.Tx, name string) (Indexes, error) {
+	rows := &sql.Rows{}
+	query, args := sql.Select("name", "unique").
+		From(sql.Table(fmt.Sprintf("pragma_index_list('%s')", name)).Unquote()).
+		Query()
+	if err := tx.Query(ctx, query, args, rows); err != nil {
+		return nil, fmt.Errorf("reading table indexes %v", err)
+	}
+	defer rows.Close()
+	var idx Indexes
+	for rows.Next() {
+		i := &Index{}
+		if err := rows.Scan(&i.Name, &i.Unique); err != nil {
+			return nil, fmt.Errorf("scanning index description %v", err)
+		}
+		idx = append(idx, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, fmt.Errorf("closing rows %v", err)
+	}
+	for i := range idx {
+		columns, err := d.indexColumns(ctx, tx, idx[i].Name)
+		if err != nil {
+			return nil, err
+		}
+		idx[i].columns = columns
+	}
+	return idx, nil
+}
+
+// indexColumns loads index columns from index info.
+func (d *SQLite) indexColumns(ctx context.Context, tx dialect.Tx, name string) ([]string, error) {
+	rows := &sql.Rows{}
+	query, args := sql.Select("name").
+		From(sql.Table(fmt.Sprintf("pragma_index_info('%s')", name)).Unquote()).
+		OrderBy("seqno").
+		Query()
+	if err := tx.Query(ctx, query, args, rows); err != nil {
+		return nil, fmt.Errorf("reading table indexes %v", err)
+	}
+	defer rows.Close()
+	var names []string
+	if err := sql.ScanSlice(rows, &names); err != nil {
+		return nil, err
+	}
+	return names, nil
+}
+
+// scanColumn scans the column information from SQLite column description.
+func (d *SQLite) scanColumn(c *Column, rows *sql.Rows) error {
+	var (
+		pk       sql.NullInt64
+		notnull  sql.NullInt64
+		defaults sql.NullString
+	)
+	if err := rows.Scan(&c.Name, &c.typ, &notnull, &defaults, &pk); err != nil {
+		return fmt.Errorf("scanning column description: %v", err)
+	}
+	c.Nullable = notnull.Int64 == 0
+	if pk.Int64 > 0 {
+		c.Key = PrimaryKey
+	}
+	parts, _, _, err := parseColumn(c.typ)
+	if err != nil {
+		return err
+	}
+	switch parts[0] {
+	case "bool", "boolean":
+		c.Type = field.TypeBool
+	case "blob":
+		c.Type = field.TypeBytes
+	case "integer":
+		// All integer types have the same "type affinity".
+		c.Type = field.TypeInt
+	case "real", "float", "double":
+		c.Type = field.TypeFloat64
+	case "datetime":
+		c.Type = field.TypeTime
+	case "json":
+		c.Type = field.TypeJSON
+	case "uuid":
+		c.Type = field.TypeUUID
+	case "varchar", "text":
+		c.Size = DefaultStringLen
+		c.Type = field.TypeString
+	}
+	if defaults.Valid {
+		return c.ScanDefault(defaults.String)
+	}
+	return nil
+}
+
+// alterColumns returns the queries for applying the columns change-set.
+func (d *SQLite) alterColumns(table string, add, _, _ []*Column) sql.Queries {
+	queries := make(sql.Queries, 0, len(add))
+	for i := range add {
+		c := d.addColumn(add[i])
+		if fk := add[i].foreign; fk != nil {
+			c.Constraint(fk.DSL())
+		}
+		queries = append(queries, sql.Dialect(dialect.SQLite).AlterTable(table).AddColumn(c))
+	}
+	// Modifying and dropping columns is not supported and disabled until we
+	// will support https://www.sqlite.org/lang_altertable.html#otheralter
+	return queries
 }