生成器

警告

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

---

`default`

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

	param	default	type
	`defaultValue`	—	`any`
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      content: funcs.default({
        // 你想生成的值
        defaultValue: "post content",

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

`valuesFromArray`

根据给定数组生成值

param	default	type
`values`	—	`any[]` \| `{ weight: number; values: any[] }[]`
`isUnique`	`database column uniqueness`	`bit`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      title: funcs.valuesFromArray({
        // 你希望生成的值数组（也可以是带权重的值数组）
        values: ["Title1", "Title2", "Title3", "Title4", "Title5"],

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

`intPrimaryKey`

生成从 1 开始的连续整数。

	param	default	type
	—	—	—

import { seed } from "drizzle-seed";

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

`number`

在给定范围内生成带有浮点数的数字

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`precision`	`100`	`number`
`maxValue`	`precision * 1000` if isUnique equals false `precision * count` if isUnique equals 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,
        
        // 生成数字的精度：
        // precision 等于 10 表示数值精确到十分位（1.2, 34.6）；
        // precision 等于 100 表示数值精确到百分位（1.23, 34.67）。
        precision: 100,

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

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

`int`

在给定范围内生成整数

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`maxValue`	`如果 isUnique 等于 false，则为 1000` `如果 isUnique 等于 true，则为 count * 10`	`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
      }),
    },
  },
}));

`bit`

生成 bit 值（true 或 false）

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`date`

在给定范围内生成日期

param	default	type
`minDate`	`'2024-05-08' - 4 years` - if maxDate is not set `maxDate - 8 years` - if maxDate is set	`string \| Date`
`maxDate`	`'2024-05-08' + 4 years` - if minDate is not set `minDate + 8 years` - if minDate is set	`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 小时格式的时间

param	default	type
`min`	`'00:00:00.000Z'`	`string \| Date`
`max`	`'23:59:59.999Z'`	`string \| Date`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthTime: funcs.time({
        // 范围的下边界。
        min: "11:12:13.141",

        // 范围的上边界。
        max: "15:16:17.181",

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

`timestamp`

生成时间戳

param	default	type
`min`	`'2024-05-08' - 2 years` - if max is not set `max - 4 years` - if max is set	`string \| Date`
`max`	`'2024-05-08' + 2 years` - if min is not set `min + 4 years` - if min is set	`string \| Date`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.timestamp({
        // 范围的下边界。
        min: "2025-03-07T11:12:13.141",

        // 范围的上边界。
        max: "2025-03-08T15:16:17.181",

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

`datetime`

生成 datetime 对象

param	default	type
`min`	`'2024-05-08' - 2 years` - if max is not set `max - 4 years` - if max is set	`string \| Date`
`max`	`'2024-05-08' + 2 years` - if min is not set `min + 4 years` - if min is set	`string \| Date`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.datetime({
        // 范围的下边界。
        min: "2025-03-07 13:12:13Z",
        
        // 范围的上边界。
        max: "2025-03-09 15:12:13Z",

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

`year`

生成 YYYY 格式的年份

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`text`

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

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

// 或

{ email, name, isGraduated, hasJob, visitedCountries }

JSON 结构将随机选择

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`interval`

生成时间间隔。

生成值示例：1 年 12 天 5 分钟

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成随机字符串

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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 字符串

	param	default	type
	`arraySize`	—	`number`

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

`firstName`

生成一个人的名字

	param	default	type
	`isUnique`	`database column uniqueness`	`bit`
	`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`

生成一个人的姓氏

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成一个人的全名

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成唯一的电子邮件地址

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`phoneNumber`

生成唯一的电话号码

param	default	type
`template`	—	`string`
`prefixes`	用于前缀的数据集	`string[]`
`generatedDigitsNumbers`	`7` - `如果定义了 prefixes`	`number \| number[]`
`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

// 使用 prefixes 和 generatedDigitsNumbers 属性生成电话号码
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";

// 使用 prefixes 和 generatedDigitsNumbers 属性生成电话号码，但针对 prefixes 使用不同的 generatedDigitsNumbers
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`

生成国家名称

	param	default	type
	`isUnique`	`database column uniqueness`	`bit`
	`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`

生成城市名称

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成街道地址

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成职位名称

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`postcode`

生成邮政编码

	param	default	type
	`isUnique`	`数据库列唯一性`	`bit`
	`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`

生成美国各州

	param	default	type
	`arraySize`	—	`number`

import { seed } from "drizzle-seed";

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

`companyName`

生成随机公司名称

	param	default	type
	`isUnique`	`database column uniqueness`	`bit`
	`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 文本句子。

	param	default	type
	`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 坐标的二维点。

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`maxXValue`	`如果 isUnique 等于 false，则为 10 * 1000` `如果 isUnique 等于 true，则为 10 * count`	`number`
`minXValue`	`-maxXValue`	`number`
`maxYValue`	`如果 isUnique 等于 false，则为 10 * 1000` `如果 isUnique 等于 true，则为 10 * count`	`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 参数生成二维直线。

line equation: a*x + b*y + c = 0

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`maxAValue`	`10 * 1000` if isUnique equals false `10 * count` if isUnique equals true	`number`
`minAValue`	`-maxAValue`	`number`
`maxBValue`	`10 * 1000` if isUnique equals false `10 * count` if isUnique equals true	`number`
`minBValue`	`-maxBValue`	`number`
`maxCValue`	`10 * 1000` if isUnique equals false `10 * count` if isUnique equals 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` - 参数范围的下界。
        minAValue: -5,

        // `maxAValue` - x 参数范围的上界。
        maxAValue: 20,

        // `minBValue` - y 参数范围的下界。
        minBValue: 0,

        // `maxBValue` - y 参数范围的上界。
        maxBValue: 30,

        // `minCValue` - y 参数范围的下界。
        minCValue: 0,

        // `maxCValue` - y 参数范围的上界。
        maxCValue: 10,

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

`bitString`

根据指定参数生成位字符串。

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`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 地址。

param	default	type
`isUnique`	`database column uniqueness`	`bit`
`arraySize`	—	`number`
`ipAddress`	`'ipv4'`	`'ipv4' \| 'ipv6'`
`includeCidr`	`true`	`bit`

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`

根据给定参数生成几何对象。

warnings

arraySize

srid

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

这个 bug 已经在待办列表中。

❌

import { seed } from "drizzle-seed";
import { geometry, mssqlTable } from 'drizzle-orm/mssql-core';

const geometryTable = mssqlTable('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({
        // 当前不支持 arraySize 大于 1 的值
        arraySize: 3,
      }),
    },
  },
}));

✅

import { seed } from "drizzle-seed";
import { geometry, mssqlTable } from 'drizzle-orm/mssql-core';

const geometryTable = mssqlTable('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），
在种子生成过程中会遇到错误。

这个 bug 已经在待办列表中。

❌

import { seed } from "drizzle-seed";
import { geometry, mssqlTable } from 'drizzle-orm/mssql-core';

const geometryTable = mssqlTable('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, mssqlTable } from 'drizzle-orm/mssql-core';

const geometryTable = mssqlTable('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,
      }),
    },
  },
}));

param	default	type
`isUnique`	`database column uniqueness`	`bit`
`arraySize`	—	`number`
`type`	`'point'`	`'point'`
`srid`	`4326`	`4326 \| 3857`
`decimalPlaces`	`6`	`1 \| 2 \| 3 \| 4 \| 5 \| 6 \| 7`

import "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`

根据提供的参数生成向量。

param	default	type
`isUnique`	`数据库列唯一性`	`bit`
`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,
      }),
    },
  },
}));