제너레이터(Generators)

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      content: funcs.default({
        // 생성할 값
        defaultValue: "post content",

        // 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됨)
        arraySize: 3
      }),
    },
  },
}));

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,
        
        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됨)
        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,
        
        // 생성된 숫자의 정밀도:
        // precision이 10이면 값은 소수점 첫째 자리까지 정확함 (예: 1.2, 34.6);
        // precision이 100이면 값은 소수점 둘째 자리까지 정확함 (예: 1.23, 34.67).
        precision: 100,

        // 생성된 값이 고유해야 하는지 여부를 제어하는 속성
        isUnique: false,

        // 1차원 배열의 요소 수
        // (지정된 경우 배열이 생성됨)
        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,

        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됨)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      isAvailable: funcs.boolean({
        // 각 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        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",

        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthTime: funcs.time({
        // 각 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.timestamp({
        // 각 1차원 배열의 요소 개수.
        // (지정된 경우, 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  orders: {
    columns: {
      shippedDate: funcs.datetime({
        // 각 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      birthYear: funcs.year({
        // 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        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({
        // 각 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      timeSpentOnWebsite: funcs.interval({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: true,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      hashedPassword: funcs.string({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: false,
        
        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됨)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  products: {
    columns: {
      id: funcs.uuid({
        // 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      firstName: funcs.firstName({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: true,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      lastName: funcs.lastName({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: false,
        
        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      fullName: funcs.fullName({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: true,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      email: funcs.email({
        // 각 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

// template 속성을 사용하여 전화번호 생성
await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      phoneNumber: funcs.phoneNumber({ 
        // `template` - 전화번호 템플릿. 모든 '#' 기호는 생성된 숫자로 대체됩니다.
        template: "+(380) ###-####",

        // 1차원 배열의 요소 수. 
        // (지정된 경우 배열이 생성됩니다.)
        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,

        // 1차원 배열의 요소 수. 
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

// prefixes와 generatedDigitsNumbers 속성을 사용하지만, 각 접두사에 대해 다른 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],

        // 1차원 배열의 요소 수. 
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      country: funcs.country({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: false,
        
        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      city: funcs.city({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: false,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      streetAddress: funcs.streetAddress({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: false,
        
        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됨)
        arraySize: 3 
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      jobTitle: funcs.jobTitle({
        // 각 1차원 배열의 요소 개수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      postcode: funcs.postcode({
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: true,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      state: funcs.state({
        // 각 1차원 배열의 요소 개수
        // (지정하면 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  users: {
    columns: {
      company: funcs.companyName({ 
        // `isUnique` - 생성된 값이 고유한지 여부를 제어하는 속성
        isUnique: true,

        // 각 1차원 배열의 요소 수.
        // (지정된 경우 배열이 생성됩니다.)
        arraySize: 3
      }),
    },
  },
}));

import { seed } from "drizzle-seed";

await seed(db, schema, { count: 1000 }).refine((funcs) => ({
  posts: {
    columns: {
      content: funcs.loremIpsum({
        // `sentencesCount` - 생성할 문장의 개수 (하나의 생성된 값으로 문자열 반환)
        sentencesCount: 2,

        // 1차원 배열의 요소 개수
        // (지정된 경우 배열이 생성됨)
        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,

        // 각 1차원 배열의 요소 수
        // (지정된 경우 배열이 생성됨)
        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,

        // 1차원 배열의 요소 개수 (지정 시 배열이 생성됨)
        arraySize: 3
      }),
    },
  },
}));