@vetala/vetala 0.1.0-beta

package/skill/kysely-converter/references/insert.md

@@ -0,0 +1,386 @@
+# Kysely INSERT Reference
+
+## Basic INSERT
+```sql
+INSERT INTO person (first_name, last_name, age) VALUES ('Jennifer', 'Aniston', 40)
+```
+```ts
+db.insertInto('person')
+  .values({
+    first_name: 'Jennifer',
+    last_name: 'Aniston',
+    age: 40
+  })
+  .execute()
+```
+
+## Insert Single Row
+```sql
+INSERT INTO person (first_name, last_name, age) VALUES ('Jennifer', 'Aniston', 40)
+```
+```ts
+const result = await db
+  .insertInto('person')
+  .values({
+    first_name: 'Jennifer',
+    last_name: 'Aniston',
+    age: 40
+  })
+  .executeTakeFirst()
+
+// MySQL: result.insertId contains auto-increment id
+// PostgreSQL: use returning() to get inserted data
+```
+
+## Insert Multiple Rows
+```sql
+INSERT INTO person (first_name, last_name, age) VALUES
+  ('Jennifer', 'Aniston', 40),
+  ('Arnold', 'Schwarzenegger', 70)
+```
+```ts
+db.insertInto('person')
+  .values([
+    { first_name: 'Jennifer', last_name: 'Aniston', age: 40 },
+    { first_name: 'Arnold', last_name: 'Schwarzenegger', age: 70 }
+  ])
+  .execute()
+```
+
+## INSERT with RETURNING (PostgreSQL)
+```sql
+INSERT INTO person (first_name, last_name, age)
+VALUES ('Jennifer', 'Aniston', 40)
+RETURNING id, first_name
+```
+```ts
+const result = await db
+  .insertInto('person')
+  .values({
+    first_name: 'Jennifer',
+    last_name: 'Aniston',
+    age: 40
+  })
+  .returning(['id', 'first_name'])
+  .executeTakeFirstOrThrow()
+```
+
+### RETURNING All Columns
+```sql
+INSERT INTO person (first_name) VALUES ('Jennifer') RETURNING *
+```
+```ts
+db.insertInto('person')
+  .values({ first_name: 'Jennifer' })
+  .returningAll()
+  .executeTakeFirstOrThrow()
+```
+
+### RETURNING with Alias
+```sql
+INSERT INTO person (first_name) VALUES ('Jennifer')
+RETURNING id, first_name AS name
+```
+```ts
+db.insertInto('person')
+  .values({ first_name: 'Jennifer' })
+  .returning(['id', 'first_name as name'])
+  .executeTakeFirstOrThrow()
+```
+
+## INSERT with Expression Values
+```sql
+INSERT INTO person (first_name, last_name, middle_name, age)
+VALUES ('Jennifer', CONCAT('Ani', 'ston'), first_name, (SELECT AVG(age) FROM person))
+```
+```ts
+db.insertInto('person')
+  .values(({ ref, selectFrom, fn }) => ({
+    first_name: 'Jennifer',
+    last_name: sql<string>`CONCAT(${'Ani'}, ${'ston'})`,
+    middle_name: ref('first_name'),
+    age: selectFrom('person').select(fn.avg<number>('age').as('avg_age'))
+  }))
+  .execute()
+```
+
+## INSERT ... SELECT (Subquery)
+```sql
+INSERT INTO person (first_name, last_name, age)
+SELECT name, 'Petson', 7 FROM pet
+```
+```ts
+db.insertInto('person')
+  .columns(['first_name', 'last_name', 'age'])
+  .expression((eb) => eb
+    .selectFrom('pet')
+    .select((eb) => [
+      'pet.name',
+      eb.val('Petson').as('last_name'),
+      eb.lit(7).as('age')
+    ])
+  )
+  .execute()
+```
+
+## INSERT DEFAULT VALUES
+```sql
+INSERT INTO person DEFAULT VALUES
+```
+```ts
+db.insertInto('person')
+  .defaultValues()
+  .execute()
+```
+
+## ON CONFLICT (PostgreSQL, SQLite)
+
+### DO NOTHING
+```sql
+INSERT INTO pet (name, species, owner_id) VALUES ('Catto', 'cat', 3)
+ON CONFLICT (name) DO NOTHING
+```
+```ts
+db.insertInto('pet')
+  .values({
+    name: 'Catto',
+    species: 'cat',
+    owner_id: 3
+  })
+  .onConflict((oc) => oc
+    .column('name')
+    .doNothing()
+  )
+  .execute()
+```
+
+### DO UPDATE SET (Upsert)
+```sql
+INSERT INTO pet (name, species, owner_id) VALUES ('Catto', 'cat', 3)
+ON CONFLICT (name) DO UPDATE SET species = 'hamster'
+```
+```ts
+db.insertInto('pet')
+  .values({
+    name: 'Catto',
+    species: 'cat',
+    owner_id: 3
+  })
+  .onConflict((oc) => oc
+    .column('name')
+    .doUpdateSet({ species: 'hamster' })
+  )
+  .execute()
+```
+
+### ON CONFLICT with Constraint Name
+```sql
+INSERT INTO pet (name, species) VALUES ('Catto', 'cat')
+ON CONFLICT ON CONSTRAINT pet_name_key DO UPDATE SET species = 'hamster'
+```
+```ts
+db.insertInto('pet')
+  .values({ name: 'Catto', species: 'cat' })
+  .onConflict((oc) => oc
+    .constraint('pet_name_key')
+    .doUpdateSet({ species: 'hamster' })
+  )
+  .execute()
+```
+
+### ON CONFLICT with Multiple Columns
+```sql
+INSERT INTO pet (name, owner_id, species) VALUES ('Catto', 1, 'cat')
+ON CONFLICT (name, owner_id) DO UPDATE SET species = 'hamster'
+```
+```ts
+db.insertInto('pet')
+  .values({ name: 'Catto', owner_id: 1, species: 'cat' })
+  .onConflict((oc) => oc
+    .columns(['name', 'owner_id'])
+    .doUpdateSet({ species: 'hamster' })
+  )
+  .execute()
+```
+
+### ON CONFLICT with Expression
+```sql
+INSERT INTO pet (name, species) VALUES ('Catto', 'cat')
+ON CONFLICT (lower(name)) DO UPDATE SET species = 'hamster'
+```
+```ts
+db.insertInto('pet')
+  .values({ name: 'Catto', species: 'cat' })
+  .onConflict((oc) => oc
+    .expression(sql<string>`lower(name)`)
+    .doUpdateSet({ species: 'hamster' })
+  )
+  .execute()
+```
+
+### ON CONFLICT with WHERE
+```sql
+INSERT INTO pet (name, species) VALUES ('Catto', 'cat')
+ON CONFLICT (name) DO UPDATE SET species = 'hamster'
+WHERE excluded.name != 'Catto'
+```
+```ts
+db.insertInto('pet')
+  .values({ name: 'Catto', species: 'cat' })
+  .onConflict((oc) => oc
+    .column('name')
+    .doUpdateSet({ species: 'hamster' })
+    .where('excluded.name', '!=', 'Catto')
+  )
+  .execute()
+```
+
+### Using excluded Table (Upsert with Original Values)
+```sql
+INSERT INTO person (id, first_name, last_name, gender)
+VALUES (1, 'John', 'Doe', 'male')
+ON CONFLICT (id) DO UPDATE SET
+  first_name = excluded.first_name,
+  last_name = excluded.last_name
+```
+```ts
+db.insertInto('person')
+  .values({
+    id: 1,
+    first_name: 'John',
+    last_name: 'Doe',
+    gender: 'male'
+  })
+  .onConflict((oc) => oc
+    .column('id')
+    .doUpdateSet(({ ref }) => ({
+      first_name: ref('excluded.first_name'),
+      last_name: ref('excluded.last_name')
+    }))
+  )
+  .execute()
+```
+
+## ON DUPLICATE KEY UPDATE (MySQL)
+```sql
+INSERT INTO person (id, first_name, last_name, gender)
+VALUES (1, 'John', 'Doe', 'male')
+ON DUPLICATE KEY UPDATE updated_at = NOW()
+```
+```ts
+db.insertInto('person')
+  .values({
+    id: 1,
+    first_name: 'John',
+    last_name: 'Doe',
+    gender: 'male'
+  })
+  .onDuplicateKeyUpdate({ updated_at: new Date().toISOString() })
+  .execute()
+```
+
+### ON DUPLICATE KEY with Expression
+```ts
+db.insertInto('person')
+  .values({ id: 1, first_name: 'John' })
+  .onDuplicateKeyUpdate((eb) => ({
+    first_name: eb.ref('person.first_name'),
+    updated_at: sql`NOW()`
+  }))
+  .execute()
+```
+
+## INSERT IGNORE (MySQL)
+```sql
+INSERT IGNORE INTO person (first_name, last_name) VALUES ('John', 'Doe')
+```
+```ts
+db.insertInto('person')
+  .ignore()
+  .values({ first_name: 'John', last_name: 'Doe' })
+  .execute()
+```
+
+## INSERT OR IGNORE (SQLite)
+```sql
+INSERT OR IGNORE INTO person (first_name, last_name) VALUES ('John', 'Doe')
+```
+```ts
+db.insertInto('person')
+  .orIgnore()
+  .values({ first_name: 'John', last_name: 'Doe' })
+  .execute()
+```
+
+## INSERT OR REPLACE (SQLite)
+```sql
+INSERT OR REPLACE INTO person (first_name, last_name) VALUES ('John', 'Doe')
+```
+```ts
+db.insertInto('person')
+  .orReplace()
+  .values({ first_name: 'John', last_name: 'Doe' })
+  .execute()
+```
+
+## WITH CTE + INSERT
+```sql
+WITH jennifer AS (
+  SELECT id, first_name FROM person WHERE first_name = 'Jennifer' LIMIT 1
+)
+INSERT INTO pet (owner_id, name, species)
+SELECT id, first_name, 'cat' FROM jennifer
+```
+```ts
+db.with('jennifer', (db) => db
+    .selectFrom('person')
+    .where('first_name', '=', 'Jennifer')
+    .select(['id', 'first_name'])
+    .limit(1)
+  )
+  .insertInto('pet')
+  .columns(['owner_id', 'name', 'species'])
+  .expression((eb) => eb
+    .selectFrom('jennifer')
+    .select(['id', 'first_name', eb.val('cat').as('species')])
+  )
+  .execute()
+```
+
+## Raw SQL in Values
+```ts
+import { sql } from 'kysely'
+
+db.insertInto('person')
+  .values({
+    first_name: 'John',
+    created_at: sql`NOW()`,
+    uuid: sql`UUID()`
+  })
+  .execute()
+```
+
+## Conditional Insert ($if)
+```ts
+async function insertPerson(data: PersonInput, returnId: boolean) {
+  return await db
+    .insertInto('person')
+    .values(data)
+    .$if(returnId, (qb) => qb.returning('id'))
+    .execute()
+}
+```
+
+## Dialect Differences
+
+### MySQL
+- Uses backticks for identifiers: \`table\`.\`column\`
+- `ON DUPLICATE KEY UPDATE` for upsert
+- `INSERT IGNORE` for ignoring duplicate key errors
+- `insertId` available in result for auto-increment columns
+
+### PostgreSQL
+- Uses double quotes for identifiers: "table"."column"
+- `ON CONFLICT ... DO NOTHING / DO UPDATE` for upsert
+- `RETURNING` clause for getting inserted data
+- No `insertId` - use `RETURNING id` instead

package/skill/kysely-converter/references/operators.md

@@ -0,0 +1,331 @@
+# Kysely Operators Reference
+
+## Comparison Operators
+| SQL | Kysely |
+|-----|--------|
+| `=` | `'='` |
+| `==` | `'=='` |
+| `!=` or `<>` | `'!='` or `'<>'` |
+| `>` | `'>'` |
+| `>=` | `'>='` |
+| `<` | `'<'` |
+| `<=` | `'<='` |
+| `IN` | `'in'` |
+| `NOT IN` | `'not in'` |
+| `IS` | `'is'` |
+| `IS NOT` | `'is not'` |
+| `LIKE` | `'like'` |
+| `NOT LIKE` | `'not like'` |
+| `MATCH` | `'match'` |
+| `BETWEEN` | `'between'` |
+| `BETWEEN SYMMETRIC` | `'between symmetric'` |
+| `IS DISTINCT FROM` | `'is distinct from'` |
+| `IS NOT DISTINCT FROM` | `'is not distinct from'` |
+
+### PostgreSQL Specific
+| SQL | Kysely |
+|-----|--------|
+| `ILIKE` | `'ilike'` |
+| `NOT ILIKE` | `'not ilike'` |
+| `~` (regex match) | `'~'` |
+| `~*` (case-insensitive regex) | `'~*'` |
+| `!~` (not regex match) | `'!~'` |
+| `!~*` (case-insensitive not regex) | `'!~*'` |
+| `@@` (full-text search) | `'@@'` |
+| `@@@` | `'@@@'` |
+| `@>` (contains) | `'@>'` |
+| `<@` (contained by) | `'<@'` |
+| `^@` (starts with) | `'^@'` |
+| `&&` (overlap) | `'&&'` |
+| `?` (key exists) | `'?'` |
+| `?&` (all keys exist) | `'?&'` |
+| `?\|` (any key exists) | `'?\|'` |
+| `<->` (distance) | `'<->'` |
+
+### MySQL Specific
+| SQL | Kysely | 비고 |
+|-----|--------|------|
+| `REGEXP` | `'regexp'` | |
+| `RLIKE` | `'regexp'` | `REGEXP`의 동의어 |
+| `<=>` (null-safe equal) | `'<=>'` | |
+| `!<` | `'!<'` | |
+| `!>` | `'!>'` | |
+
+## Arithmetic Operators
+| SQL | Kysely | 비고 |
+|-----|--------|------|
+| `+` | `'+'` | |
+| `-` | `'-'` | |
+| `*` | `'*'` | |
+| `/` | `'/'` | |
+| `%` (modulo) | `'%'` | `MOD`와 동일 |
+| `^` | `'^'` | **PostgreSQL**: power, **MySQL**: bitwise XOR |
+| `&` (bitwise AND) | `'&'` | |
+| `\|` (bitwise OR) | `'\|'` | |
+| `#` (bitwise XOR) | `'#'` | PostgreSQL only |
+| `<<` (left shift) | `'<<'` | |
+| `>>` (right shift) | `'>>'` | |
+| `\|\|` (concat) | `'\|\|'` | **PostgreSQL**: 문자열/배열/JSONB 연결 |
+
+## JSON Operators
+| SQL | Kysely | 비고 |
+|-----|--------|------|
+| `->` (get JSON element) | `'->'` | |
+| `->>` (get JSON element as text) | `'->>'` | |
+| `->$` (JSON path) | `'->$'` | MySQL JSON path syntax |
+| `->>$` (JSON path as text) | `'->>$'` | MySQL JSON path unquoting |
+
+### JSON Path (for eb.ref)
+```ts
+// PostgreSQL JSON path
+eb.ref('column', '->').key('field').at(0)
+```
+```sql
+"column"->'field'->0
+```
+
+```ts
+// MySQL JSON path
+eb.ref('column', '->$').key('field').at('last')
+```
+```sql
+`column`->'$.field[last]'
+```
+
+## Unary Operators
+| SQL | Kysely | 비고 |
+|-----|--------|------|
+| `EXISTS` | `'exists'` | `eb.exists()` |
+| `NOT EXISTS` | `'not exists'` | |
+| `NOT` | `'not'` | `eb.not()` |
+| `-` (negative) | `'-'` | `eb.neg()` |
+| `!!` | `'!!'` | PostgreSQL boolean 테스트 |
+
+## Logical Operators
+
+### AND
+```ts
+// Chained where (implicit AND)
+.where('status', '=', 'active')
+.where('type', '=', 'user')
+
+// Explicit AND with expression builder
+.where((eb) => eb.and([
+  eb('status', '=', 'active'),
+  eb('type', '=', 'user')
+]))
+```
+```sql
+WHERE "status" = 'active' AND "type" = 'user'
+```
+
+### OR
+```ts
+.where((eb) => eb.or([
+  eb('status', '=', 'active'),
+  eb('status', '=', 'pending')
+]))
+```
+```sql
+WHERE ("status" = 'active' OR "status" = 'pending')
+```
+
+### Combined AND/OR
+```ts
+.where((eb) =>
+  eb.or([
+    eb.and([
+      eb('status', '=', 'active'),
+      eb('type', '=', 'a')
+    ]),
+    eb.and([
+      eb('status', '=', 'pending'),
+      eb('type', '=', 'b')
+    ])
+  ])
+)
+```
+```sql
+WHERE (("status" = 'active' AND "type" = 'a') OR ("status" = 'pending' AND "type" = 'b'))
+```
+
+## Usage Examples
+
+### Basic Comparison
+```ts
+.where('age', '>', 18)
+.where('status', '=', 'active')
+.where('name', 'like', '%john%')
+```
+```sql
+WHERE "age" > 18 AND "status" = 'active' AND "name" LIKE '%john%'
+```
+
+### NULL Checks
+```ts
+.where('deleted_at', 'is', null)
+.where('name', 'is not', null)
+```
+```sql
+WHERE "deleted_at" IS NULL AND "name" IS NOT NULL
+```
+
+### IN / NOT IN
+```ts
+.where('id', 'in', [1, 2, 3])
+.where('status', 'not in', ['deleted', 'archived'])
+```
+```sql
+WHERE "id" IN (1, 2, 3) AND "status" NOT IN ('deleted', 'archived')
+```
+
+### BETWEEN
+```ts
+.where('age', 'between', [18, 65])
+```
+```sql
+WHERE "age" BETWEEN 18 AND 65
+```
+
+### Column to Column (whereRef)
+```ts
+.whereRef('updated_at', '>', 'created_at')
+.whereRef('pet.owner_id', '=', 'person.id')
+```
+```sql
+WHERE "updated_at" > "created_at" AND "pet"."owner_id" = "person"."id"
+```
+
+### Arithmetic in SET
+```ts
+.set((eb) => ({
+  age: eb('age', '+', 1),
+  score: eb('score', '*', 2)
+}))
+```
+```sql
+SET "age" = "age" + 1, "score" = "score" * 2
+```
+
+## Dialect Differences
+
+### MySQL
+- Uses backticks for identifiers: \`table\`.\`column\`
+- `REGEXP` for regex matching
+- `<=>` for null-safe equality comparison
+
+### PostgreSQL
+- Uses double quotes for identifiers: "table"."column"
+- `ILIKE` for case-insensitive LIKE
+- `~`, `~*`, `!~`, `!~*` for regex operations
+- `@@` for full-text search
+- `@>`, `<@`, `&&` for array/JSON operations
+- `||` for string/array/JSONB concatenation
+
+## Array/Subquery Operators
+
+### ANY / SOME
+```ts
+// PostgreSQL: value = ANY(array_column)
+db.selectFrom('person')
+  .selectAll()
+  .where((eb) => eb(
+    eb.val('Jen'),
+    '=',
+    eb.fn.any('nicknames')  // nicknames is string[] column
+  ))
+```
+```sql
+SELECT * FROM "person" WHERE 'Jen' = ANY("nicknames")
+```
+
+```ts
+// With subquery
+db.selectFrom('person')
+  .selectAll()
+  .where((eb) => eb(
+    eb.val('dog'),
+    '=',
+    eb.fn.any(
+      eb.selectFrom('pet')
+        .select('species')
+        .whereRef('owner_id', '=', 'person.id')
+    )
+  ))
+```
+```sql
+SELECT * FROM "person" 
+WHERE 'dog' = ANY(SELECT "species" FROM "pet" WHERE "owner_id" = "person"."id")
+```
+
+## Raw SQL Required
+다음 연산자들은 Kysely에서 직접 지원하지 않으며 `sql` 템플릿 태그를 사용해야 합니다:
+
+### MySQL
+| SQL | 설명 |
+|-----|------|
+| `NOT REGEXP` / `NOT RLIKE` | 정규식 불일치 |
+| `DIV` | 정수 나눗셈 |
+| `XOR` | 논리적 XOR |
+| `SOUNDS LIKE` | 발음 유사성 비교 |
+| `BINARY` | 대소문자 구분 비교를 위한 바이너리 캐스팅 |
+
+### PostgreSQL
+| SQL | 설명 |
+|-----|------|
+| `SIMILAR TO` | SQL 표준 정규식 패턴 매칭 |
+| `NOT SIMILAR TO` | SIMILAR TO 부정 |
+| `#>` | JSON 경로로 JSON 객체 접근 |
+| `#>>` | JSON 경로로 텍스트 접근 |
+| `#-` | JSON 경로 삭제 |
+| `OVERLAPS` | 날짜/시간 범위 겹침 |
+
+### Common
+| SQL | 설명 |
+|-----|------|
+| `NOT BETWEEN` | BETWEEN 부정 |
+| `NOT BETWEEN SYMMETRIC` | BETWEEN SYMMETRIC 부정 (PostgreSQL) |
+| `ALL` | 배열/서브쿼리 전체 비교 |
+
+### Raw SQL Example
+```ts
+import { sql } from 'kysely'
+
+// NOT BETWEEN
+.where(sql`${sql.ref('age')} NOT BETWEEN ${18} AND ${65}`)
+```
+```sql
+WHERE "age" NOT BETWEEN 18 AND 65
+```
+
+```ts
+// DIV (MySQL)
+.select(sql<number>`${sql.ref('amount')} DIV 3`.as('quotient'))
+```
+```sql
+SELECT `amount` DIV 3 AS `quotient`
+```
+
+```ts
+// BINARY (MySQL) - 대소문자 구분 비교
+.where(sql`BINARY ${sql.ref('name')} = ${'John'}`)
+```
+```sql
+WHERE BINARY `name` = 'John'
+```
+
+```ts
+// SIMILAR TO (PostgreSQL)
+.where(sql`${sql.ref('name')} SIMILAR TO ${'%(John|Jane)%'}`)
+```
+```sql
+WHERE "name" SIMILAR TO '%(John|Jane)%'
+```
+
+```ts
+// OVERLAPS (PostgreSQL)
+.where(sql`(${sql.ref('start_date')}, ${sql.ref('end_date')}) OVERLAPS (${startDate}, ${endDate})`)
+```
+```sql
+WHERE ("start_date", "end_date") OVERLAPS ('2024-01-01', '2024-12-31')
+```