生成器

warning

目前，在支持的生成器中同时指定 arraySize 和 isUnique 将导致生成唯一值（而不是唯一数组），然后这些值将被打包成数组。

---

`default`

每次调用生成器时会生成相同的给定值。

	参数	默认值	类型
	`defaultValue`	—	`any`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      content: funcs.default({
        // 要生成的值
        defaultValue: "帖子内容",

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`valuesFromArray`

从给定数组生成值

参数	默认值	类型
`values`	—	`any[]` \| `{ weight: number; values: any[] }[]`
`isUnique`	数据库列的唯一性	`boolean`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      title: funcs.valuesFromArray({
        // 要生成的值数组（可以是加权值数组）
        values: ["标题1", "标题2", "标题3", "标题4", "标题5"],

        // 控制生成值是否唯一的属性
        isUnique: true,
        
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`intPrimaryKey`

生成从 1 开始的顺序整数。

	参数	默认值	类型
	—	—	—

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      id: funcs.intPrimaryKey(),
    },
  },
}));

`number`

在给定范围内生成带小数的数字

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`precision`	`100`	`number`
`maxValue`	`precision * 1000` 如果 isUnique 为 false `precision * count` 如果 isUnique 为 true	`number`
`minValue`	`-maxValue`	`number`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  products: {
    columns: {
      unitPrice: funcs.number({
        // 范围的下边界。
        minValue: 10,

        // 范围的上边界。
        maxValue: 120,
        
        // 生成数字的精度：
        // 精度为 10 意味着值精确到十分之一 (1.2, 34.6);
        // 精度为 100 意味着值精确到百分之一 (1.23, 34.67)。
        precision: 100,

        // 控制生成值是否唯一的属性。
        isUnique: false,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`int`

在给定范围内生成整数

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`maxValue`	`1000` 如果 isUnique 为 false `count * 10` 如果 isUnique 为 true	`number \| bigint`
`minValue`	`-maxValue`	`number \| bigint`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  products: {
    columns: {
      unitsInStock: funcs.int({
        // 范围的下边界。
        minValue: 0,

        // 范围的上边界。
        maxValue: 100,

        // 控制生成值是否唯一的属性。
        isUnique: false,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`boolean`

生成布尔值（真或假）

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      isAvailable: funcs.boolean({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`date`

在给定范围内生成日期

参数	默认值	类型
`minDate`	`new Date('2020-05-08')`	`string \| Date`
`maxDate`	`new Date('2028-05-08')`	`string \| Date`
`arraySize`	—	`number`

IMPORTANT

如果只提供了一个参数（minDate 或 maxDate），则未指定的参数将通过在指定参数上加减 8 年来计算

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthDate: funcs.date({
        // 范围的下边界。
        minDate: "1990-01-01",

        // 范围的上边界。
        maxDate: "2010-12-31",

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`time`

生成 24 小时制的时间

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthTime: funcs.time({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`timestamp`

生成时间戳

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.timestamp({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`datetime`

生成日期时间对象

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.datetime({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`year`

生成 YYYY 格式的年份

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthYear: funcs.year({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`json`

生成具有固定结构的 JSON 对象

{ email, name, isGraduated, hasJob, salary, startedWorking, visitedCountries}

// 或者

{ email, name, isGraduated, hasJob, visitedCountries }

JSON 结构将随机选择

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      metadata: funcs.json({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`interval`

生成时间间隔。

生成值的示例： 1 year 12 days 5 minutes

	参数	默认值	类型
	`isUnique`	列唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      timeSpentOnWebsite: funcs.interval({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`string`

生成随机字符串

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      hashedPassword: funcs.string({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: false,
        
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`uuid`

生成 v4 UUID 字符串

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  products: {
    columns: {
      id: funcs.uuid({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`firstName`

生成一个人的名字

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      firstName: funcs.firstName({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`lastName`

生成一个人的姓氏

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      lastName: funcs.lastName({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: false,
        
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`fullName`

生成一个人的全名

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      fullName: funcs.fullName({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`email`

生成唯一的电子邮件地址

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      email: funcs.email({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`phoneNumber`

生成唯一的电话号码

参数	默认值	类型
`template`	—	`string`
`prefixes`	用于前缀的数据集	`string[]`
`generatedDigitsNumbers`	`7` - `如果定义了前缀`	`number \| number[]`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

//使用模板属性生成电话号码
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      phoneNumber: funcs.phoneNumber({ 
        // `template` - 电话号码模板，其中所有 '#' 符号将被生成的数字替换。
        template: "+(380) ###-####",

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

//使用前缀和生成的数字数量属性生成电话号码
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      phoneNumber: funcs.phoneNumber({
        // `prefixes` - 你希望作为电话号码前缀的任何字符串的数组。（与 `template` 属性不兼容）
        prefixes: ["+380 99", "+380 67"],

        // `generatedDigitsNumbers` - 将添加到前缀后的数字数量。（与 `template` 属性不兼容）
        generatedDigitsNumbers: 7,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

//使用前缀和生成的数字数量属性生成电话号码，但为前缀使用不同的生成数字数量
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      phoneNumber: funcs.phoneNumber({
        // `prefixes` - 你希望作为电话号码前缀的任何字符串的数组。（与 `template` 属性不兼容）
        prefixes: ["+380 99", "+380 67", "+1"],

        // `generatedDigitsNumbers` - 将添加到前缀后的数字数量。（与 `template` 属性不兼容）
        generatedDigitsNumbers: [7, 7, 10],

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`country`

生成国家名称

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      country: funcs.country({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: false,
        
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`city`

生成城市名称

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      city: funcs.city({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: false,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`streetAddress`

生成街道地址

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      streetAddress: funcs.streetAddress({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: false,
        
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3 
      }),
    },
  },
}));

`jobTitle`

生成职位名称

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      jobTitle: funcs.jobTitle({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`postcode`

生成邮政编码

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      postcode: funcs.postcode({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`state`

生成美国州名

	参数	默认值	类型
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      state: funcs.state({
        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`companyName`

生成随机公司的名称

	参数	默认值	类型
	`isUnique`	数据库列的唯一性	`boolean`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      company: funcs.companyName({ 
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`loremIpsum`

生成 lorem ipsum 文本句子。

	参数	默认值	类型
	`sentencesCount`	1	`number`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      content: funcs.loremIpsum({
        // `sentencesCount` - 你希望生成作为一个生成值（字符串）的句子数量。
        sentencesCount: 2,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`point`

生成在 x 和 y 坐标的指定范围内的二维点。

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`maxXValue`	`10 * 1000` 如果 isUnique 为 false `10 * count` 如果 isUnique 为 true	`number`
`minXValue`	`-maxXValue`	`number`
`maxYValue`	`10 * 1000` 如果 isUnique 为 false `10 * count` 如果 isUnique 为 true	`number`
`minYValue`	`-maxYValue`	`number`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  triangles: {
    columns: {
      pointCoords: funcs.point({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // `minXValue` - x 坐标的下边界。
        minXValue: -5,

        // `maxXValue` - x 坐标的上边界。
        maxXValue: 20,

        // `minYValue` - y 坐标的下边界。
        minYValue: 0,

        // `maxYValue` - y 坐标的上边界。
        maxYValue: 30,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`line`

生成在指定范围内的二维线的 a、b 和 c 参数。

线方程： a*x + b*y + c = 0

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`maxAValue`	`10 * 1000` 如果 isUnique 为 false `10 * count` 如果 isUnique 为 true	`number`
`minAValue`	`-maxAValue`	`number`
`maxBValue`	`10 * 1000` 如果 isUnique 为 false `10 * count` 如果 isUnique 为 true	`number`
`minBValue`	`-maxBValue`	`number`
`maxCValue`	`10 * 1000` 如果 isUnique 为 false `10 * count` 如果 isUnique 为 true	`number`
`minCValue`	`-maxCValue`	`number`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  lines: {
    columns: {
      lineParams: funcs.point({
        // `isUnique` - 属性控制生成值是否将唯一
        isUnique: true,

        // `minAValue` - a 参数的下边界。
        minAValue: -5,

        // `maxAValue` - a 参数的上边界。
        maxAValue: 20,

        // `minBValue` - b 参数的下边界。
        minBValue: 0,

        // `maxBValue` - b 参数的上边界。
        maxBValue: 30,

        // `minCValue` - c 参数的下边界。
        minCValue: 0,

        // `maxCValue` - c 参数的上边界。
        maxCValue: 10,

        // 每个一维数组中的元素数量。 
        // （如指定，将生成数组。）
        arraySize: 3
      }),
    },
  },
}));

`bitString`

生成基于指定参数的位字符串。

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`dimensions`	数据库列位长度	`number`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  bitStringTable: {
    columns: {
      bit: funcs.bitString({
        // 期望的每个位字符串长度（例如，`dimensions = 3` 生成类似 `'010'` 的值）。
        dimensions: 12,

        // 控制生成值是否唯一的属性；
        isUnique: true,

        // 每个一维数组中的元素数量（如指定，将生成数组）；
        arraySize: 3,
      }),
    },
  },
}));

`inet`

基于指定参数生成 IP 地址。

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`arraySize`	—	`number`
`ipAddress`	`'ipv4'`	`'ipv4' \| 'ipv6'`
`includeCidr`	`true`	`boolean`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  inetTable: {
    columns: {
      inet: funcs.inet({
        // 控制生成值是否唯一的属性；
        isUnique: true,

        // 每个一维数组中的元素数量（如指定，将生成数组）；
        arraySize: 3,

        // 要生成的 IP 地址类型 — "ipv4" 或 "ipv6"；
        ipAddress: "ipv4",

        // 决定生成的 IP 是否包含 CIDR 后缀。
        includeCidr: true,
      }),
    },
  },
}));

`geometry`

基于给定参数生成几何对象。

warning

arraySize

srid

目前，如果你将 arraySize 设置为大于 1 的值，或者尝试通过 drizzle-orm 向 PostgreSQL 或 CockroachDB 中的 geometry(point, 0)[] 列插入多个 geometry point 元素，会遇到错误。

此问题已经列入待办事项。

❌

import { seed } from "drizzle-seed";
import { geometry, pgTable } from 'drizzle-orm/pg-core';

const geometryTable = pgTable('geometry_table', {
	geometryArray: geometry('geometry_array', { type: 'point', srid: 0 }).array(3),
});

await seed(db, { geometryTable }, { count: 1000 }).refine((funcs) => ({
  geometryTable: {
    columns: {
      geometryArray: funcs.geometry({
        // 目前不支持大于 1 的 arraySize
        arraySize: 3,
      }),
    },
  },
}));

✅

import { seed } from "drizzle-seed";
import { geometry, pgTable } from 'drizzle-orm/pg-core';

const geometryTable = pgTable('geometry_table', {
	geometryArray: geometry('geometry_array', { type: 'point', srid: 0 }).array(1),
});

await seed(db, { geometryTable }, { count: 1000 }).refine((funcs) => ({
  geometryTable: {
    columns: {
      geometryArray: funcs.geometry({
        // 这样设置将按预期工作
        arraySize: 1,
      }),
    },
  },
}));

目前，如果你在 drizzle-orm 表声明中将 geometry(point) 列的 SRID 设置为除 0 以外的其它值（例如 4326），在填充数据时会遇到错误。

此问题已经列入待办事项。

❌

import { seed } from "drizzle-seed";
import { geometry, pgTable } from 'drizzle-orm/pg-core';

const geometryTable = pgTable('geometry_table', {
	geometryColumn: geometry('geometry_column', { type: 'point', srid: 4326 }),
});

await seed(db, { geometryTable }, { count: 1000 }).refine((funcs) => ({
  geometryTable: {
    columns: {
      geometryColumn: funcs.geometry({
        srid: 4326,
      }),
    },
  },
}));

✅

import { seed } from "drizzle-seed";
import { geometry, pgTable } from 'drizzle-orm/pg-core';

const geometryTable = pgTable('geometry_table', {
	geometryColumn: geometry('geometry_column', { type: 'point', srid: 0 }),
});

await seed(db, { geometryTable }, { count: 1000 }).refine((funcs) => ({
  geometryTable: {
    columns: {
      geometryColumn: funcs.geometry({
        srid: 4326,
      }),
    },
  },
}));

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`arraySize`	—	`number`
`type`	`'point'`	`'point'`
`srid`	`4326`	`4326 \| 3857`
`decimalPlaces`	`6`	`1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  geometryTable: {
    columns: {
      geometryPointTuple: funcs.geometry({
        // 控制生成值是否唯一的属性；
        isUnique: true,

        // 每个一维数组中的元素数量（如指定，将生成数组）；
        arraySize: 1,

        // 要生成的几何类型；当前仅支持 `'point'`；
        type: "point",

        // 空间参考系统标识符：决定生成的点类型 — `4326` 或 `3857`；
        srid: 4326,

        // 当 `srid` 是 `4326` 时，点的小数位数（例如，`decimalPlaces = 3` 会生成类似 `'point(30.723 46.482)'` 的值）。
        decimalPlaces: 5,
      }),
    },
  },
}));

`vector`

基于提供的参数生成向量。

参数	默认值	类型
`isUnique`	数据库列的唯一性	`boolean`
`arraySize`	—	`number`
`decimalPlaces`	`2`	`number`
`dimensions`	数据库列的维数	`number`
`minValue`	`-1000`	`number`
`maxValue`	`1000`	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  vectorTable: {
    columns: {
      vector: funcs.vector({
        // 控制生成值是否唯一的属性；
        isUnique: true,

        // 每个一维数组中的元素数量（如指定，将生成数组）；
        arraySize: 3,

        // 每个向量元素的小数位数（例如，`decimalPlaces = 3` 生成如 `1.123` 的值）；
        decimalPlaces: 5,

        // 每个生成向量的元素数量（例如，`dimensions = 3` 生成如 `[1,2,3]` 的值）；
        dimensions: 12,

        // 每个向量元素允许的最小值；
        minValue: -100,

        // 每个向量元素允许的最大值。
        maxValue: 100,
      }),
    },
  },
}));