生成器

import { seed } from "drizzle-seed";

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

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

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
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

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

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
      }),
    },
  },
}));

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
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

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

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
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

// 或者

{ email, name, isGraduated, hasJob, visitedCountries }

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

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
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

import { seed } from "drizzle-seed";

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

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

import { seed } from "drizzle-seed";

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

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

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
      }),
    },
  },
}));

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
      }),
    },
  },
}));