版本控制

drizzle-seed 使用版本控制来管理静态和动态数据的输出。为了确保真正的确定性，请确保使用相同的 seed 编号时值保持不变。如果对静态数据源或动态数据生成逻辑进行了更改，版本将更新，你可以选择保留旧版本或使用最新版本。

你可以升级到最新的 drizzle-seed 版本以获得新功能，例如额外的生成器，同时在需要时保持与先前版本相同的确定性输出。当你需要在访问新功能时依赖现有的确定性数据时，这尤其有用。

await seed(db, schema, { version: '2' });

历史

API 版本npm 版本更改了生成器
v10.1.1
v2 (LTS) 0.2.1string(), interval({ isUnique: true })

How it works under the hood?

这不是实际的 API 变更；这只是一个示例，说明我们将如何处理 drizzle-seed 版本控制。

例如，lastName 生成器已更改，并且该生成器的新版本 V2 已发布。

后来，firstName 生成器进行了更改，推出了该生成器的 V3 版本。

V1V2V3(latest)
LastNameGenLastNameGenV1LastNameGenV2
FirstNameGenFirstNameGenV1FirstNameGenV3
使用版本 3 的 firstName 生成器和 lastName 生成器版本 2
await seed(db, schema);

如果你尚未准备好立即使用最新的生成器版本，你可以指定要使用的最高版本。

使用版本 1 的 firstName 生成器和版本 2 的 lastName 生成器
await seed(db, schema, { version: '2' });
使用版本 1 的 firstName 生成器和版本 1 的 lastName 生成器。
await seed(db, schema, { version: '1' });

版本 2

唯一值 interval 生成器已更改

Reason for upgrade

旧版本的生成器可以生成像 1 minute 60 seconds 和 2 minutes 0 seconds 这样的区间，并将它们视为不同的区间。但是，当 1 minute 60 seconds 间隔插入到 PostgreSQL 数据库时，它会自动转换为 2 minutes 0 seconds。因此，之后尝试将 2 minutes 0 seconds 区间插入到唯一列中将导致错误。

如果你的表中包含一个 interval 类型的唯一列，则会受到影响：

PostgreSQL 
import { drizzle } from "drizzle-orm/node-postgres";
import { pgTable, interval } from "drizzle-orm/pg-core";
import { seed } from "drizzle-seed";

const intervals = pgTable("intervals", {
    interval: interval().unique()
});

async function main() {
  const db = drizzle(process.env.DATABASE_URL!);

  await seed(db, { intervals });
}

main();

如果你在种子脚本中使用唯一的 interval 生成器，则会受到影响，如下脚本所示：

PostgreSQL
MySQL
SQLite 
import { drizzle } from "drizzle-orm/node-postgres";
import { pgTable, interval, char, varchar, text } from "drizzle-orm/pg-core";
import { seed } from "drizzle-seed";

const intervals = pgTable("intervals", {
    interval: interval().unique(),
    interval1: interval(),
    interval2: char({ length: 256 }).unique(),
    interval3: char({ length: 256 }),
    interval4: varchar().unique(),
    interval5: varchar(),
    interval6: text().unique(),
    interval7: text(),
});

async function main() {
  const db = drizzle(process.env.DATABASE_URL!);

  await seed(db, { intervals }).refine((f) => ({
    intervals: {
        columns: {
            interval: f.interval({ isUnique: true }),
            interval1: f.interval({ isUnique: true }),
            interval2: f.interval({ isUnique: true }),
            interval3: f.interval({ isUnique: true }),
            interval4: f.interval({ isUnique: true }),
            interval5: f.interval({ isUnique: true }),
            interval6: f.interval({ isUnique: true }),
            interval7: f.interval({ isUnique: true }),
        }
    }
  }));
}

main();

string 生成器已更改：非唯一和唯一

Reason to upgrade

能够根据文本列的长度生成唯一字符串（例如 varchar(20)）。

如果你的表中包含一个带有最大长度参数的文本类型列或一个文本类型的唯一列，则会受到影响：

PostgreSQL
MySQL
SQLite 
import { drizzle } from "drizzle-orm/node-postgres";
import { pgTable, char, varchar, text } from "drizzle-orm/pg-core";
import { seed } from "drizzle-seed";

const strings = pgTable("strings", {
    string2: char({ length: 256 }).unique(),
    string3: char({ length: 256 }),
    string4: varchar().unique(),
    string5: varchar({ length: 256 }).unique(),
    string6: varchar({ length: 256 }),
    string7: text().unique(),
});

async function main() {
  const db = drizzle(process.env.DATABASE_URL!);

  await seed(db, { strings });
}

main();

如果你在种子脚本中使用 string 生成器，则会受到影响，如下脚本所示：

PostgreSQL
MySQL
SQLite 
import { drizzle } from "drizzle-orm/node-postgres";
import { pgTable, char, varchar, text } from "drizzle-orm/pg-core";
import { seed } from "drizzle-seed";

const strings = pgTable("strings", {
    string1: char({ length: 256 }).unique(),
    string2: char({ length: 256 }),
    string3: char({ length: 256 }),
    string4: varchar(),
    string5: varchar().unique(),
    string6: varchar({ length: 256 }).unique(),
    string7: varchar({ length: 256 }),
    string8: varchar({ length: 256 }),
    string9: text().unique(),
    string10: text(),
});

async function main() {
  const db = drizzle(process.env.DATABASE_URL!);

  await seed(db, { strings }).refine((f) => ({
    strings: {
        columns: {
            string1: f.string({ isUnique: true }),
            string2: f.string(),
            string3: f.string({ isUnique: true }),
            string4: f.string({ isUnique: true }),
            string5: f.string({ isUnique: true }),
            string6: f.string({ isUnique: true }),
            string7: f.string(),
            string8: f.string({ isUnique: true }),
            string9: f.string({ isUnique: true }),
            string10: f.string({ isUnique: true }),
        }
    }
  }));
}

main();