数据库迁移

    在应用程序初始化过程中运行自动迁移逻辑：

    Create 创建你项目 ent 部分所需的的数据库资源 。 默认情况下，Create以“append-only”模式工作；这意味着，它只创建新表和索引，将列追加到表或扩展列类型。 例如，将int改为bigint。

    想要删除列或索引怎么办？

    删除资源

    WithDropIndex 和 WithDropColumn 是用于删除表列和索引的两个选项。

    1. package main
    4. import (
    5.     "context"
    6.     "log"
    9.     "<project>/ent"
    10.     "<project>/ent/migrate"
    11. )
    14. func main() {
    15.     client, err := ent.Open("mysql", "root:pass@tcp(localhost:3306)/test")
    16.     if err != nil {
    17.         log.Fatalf("failed connecting to mysql: %v", err)
    18.     }
    19.     defer client.Close()
    20.     ctx := context.Background()
    21.     // Run migration.
    22.     err = client.Schema.Create(
    23.         ctx, 
    24.         migrate.WithDropIndex(true),
    25.         migrate.WithDropColumn(true), 
    26.     )
    27.     if err != nil {
    28.         log.Fatalf("failed creating schema resources: %v", err)
    29.     }
    30. }

    为了在调试模式下运行迁移 (打印所有SQL查询)，请运行：

    This does not work well if you work with , which requires the object ID to be unique.

    To enable the Universal-IDs support for your project, pass the WithGlobalUniqueID option to the migration.

    1. package main
    4. import (
    5.     "context"
    6.     "log"
    9.     "<project>/ent/migrate"
    10. )
    13. func main() {
    14.     client, err := ent.Open("mysql", "root:pass@tcp(localhost:3306)/test")
    15.     if err != nil {
    16.         log.Fatalf("failed connecting to mysql: %v", err)
    17.     }
    18.     defer client.Close()
    19.     ctx := context.Background()
    20.     // Run migration.
    21.     if err := client.Schema.Create(ctx, migrate.WithGlobalUniqueID(true)); err != nil {
    22.         log.Fatalf("failed creating schema resources: %v", err)
    23.     }
    24. }

    How does it work? ent migration allocates a 1<<32 range for the IDs of each entity (table), and store this information in a table named ent_types. For example, type A will have the range of [1,4294967296) for its IDs, and type B will have the range of [4294967296,8589934592), etc.

    Note that if this option is enabled, the maximum number of possible tables is 65535.

    Offline Mode

    Offline mode allows you to write the schema changes to an io.Writer before executing them on the database. It’s useful for verifying the SQL commands before they’re executed on the database, or to get an SQL script to run manually.

    Write changes to a file

    1. package main
    4. import (
    5.     "context"
    6.     "log"
    7.     "os"
    10.     "<project>/ent"
    11.     "<project>/ent/migrate"
    12. )
    15. func main() {
    16.     client, err := ent.Open("mysql", "root:pass@tcp(localhost:3306)/test")
    17.     if err != nil {
    18.         log.Fatalf("failed connecting to mysql: %v", err)
    19.     }
    20.     defer client.Close()
    21.     ctx := context.Background()
    22.     // Dump migration changes to an SQL script.
    23.     f, err := os.Create("migrate.sql")
    24.     if err != nil {
    25.     }
    26.     defer f.Close()
    27.     if err := client.Schema.WriteTo(ctx, f); err != nil {
    28.         log.Fatalf("failed printing schema changes: %v", err)
    29.     }
    30. }

    By default, ent uses foreign-keys when defining relationships (edges) to enforce correctness and consistency on the database side.

    However, ent also provide an option to disable this functionality using the WithForeignKeys option. You should note that setting this option to false, will tell the migration to not create foreign-keys in the schema DDL and the edges validation and clearing must be handled manually by the developer.

    We expect to provide a set of hooks for implementing the foreign-key constraints in the application level in the near future.

    Migration Hooks

    The framework provides an option to add hooks (middlewares) to the migration phase. This option is ideal for modifying or filtering the tables that the migration is working on, or for creating custom resources in the database.

    1. package main
    4. import (
    5.     "context"
    6.     "log"
    9.     "<project>/ent"
    10.     "<project>/ent/migrate"
    13.     "entgo.io/ent/dialect/sql/schema"
    14. )
    17. func main() {
    18.     client, err := ent.Open("mysql", "root:pass@tcp(localhost:3306)/test")
    19.     if err != nil {
    20.         log.Fatalf("failed connecting to mysql: %v", err)
    21.     }
    22.     defer client.Close()
    23.     ctx := context.Background()
    24.     // Run migration.
    25.     err = client.Schema.Create(
    26.         ctx,
    27.         schema.WithHooks(func(next schema.Creator) schema.Creator {
    28.             return schema.CreateFunc(func(ctx context.Context, tables ...*schema.Table) error {
    29.                 // Run custom code here.
    30.                 return next.Create(ctx, tables...)
    31.             })
    32.         }),
    33.     )
    34.     if err != nil {
    35.         log.Fatalf("failed creating schema resources: %v", err)
    36.     }