const updateCount = await db.update(db.foo).set({ name: `Test` }).where(db.foo.value.gt(0));

UPDATE foo
SET
  name = $1
WHERE
  value > $2

const rows = await db
  .insertInto(db.foo)
  .values({
    name: `Test`,
    value: 123,
  })
  .returning(`id`);

INSERT INTO foo (
  name,
  value
) VALUES (
  $1,
  $2
)
RETURNING
  id

const affectedCount = await db
  .insertInto(db.foo, ['name'])
  .select(db.bar.name)
  .from(db.bar)
  .where(db.bar.name.isNotNull());

INSERT INTO foo (name)
SELECT
  bar.name
FROM bar
WHERE
  bar.name IS NOT NULL

db.select(count()).from(db.foo);

SELECT COUNT(*) FROM foo

db.select(arrayAgg(db.foo.name.orderBy(db.foo.name.desc()))).from(db.foo);

SELECT array_agg(foo.name ORDER BY foo.name DESC) "arrayAgg" FROM foo

db.with(
  `regionalSales`,
  () =>
    db
      .select(db.orderLog.region, sum(db.orderLog.amount).as(`totalSales`))
      .from(db.orderLog)
      .groupBy(db.orderLog.region),
  `topRegions`,
  ({ regionalSales }) =>
    db
      .select(regionalSales.region)
      .from(regionalSales)
      .where(
        regionalSales.totalSales.gt(
          db.select(sum(regionalSales.totalSales).divide(10)).from(regionalSales),
        ),
      ),
  ({ topRegions }) =>
    db
      .select(
        db.orderLog.region,
        db.orderLog.product,
        sum(db.orderLog.quantity).as(`productUnits`),
        sum(db.orderLog.amount).as(`productSales`),
      )
      .from(db.orderLog)
      .where(db.orderLog.region.in(db.select(topRegions.region).from(topRegions)))
      .groupBy(db.orderLog.region, db.orderLog.product),
);

WITH "regionalSales" AS (SELECT order_log.region, SUM (order_log.amount) "totalSales" FROM order_log GROUP BY order_log.region), "topRegions" AS (SELECT "regionalSales".region FROM "regionalSales" WHERE "regionalSales"."totalSales" > (SELECT SUM ("regionalSales"."totalSales") / $1 FROM "regionalSales")) SELECT order_log.region, order_log.product, SUM (order_log.quantity) "productUnits", SUM (order_log.amount) "productSales" FROM order_log WHERE order_log.region IN (SELECT "topRegions".region FROM "topRegions") GROUP BY order_log.region, order_log.product

• [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
• SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ] — Mostly supported. Distinct not yet.
• [ * | expression [ [ AS ] output_name ] [, ...] ] — mostly supported. Selecting certain expressions like update queries, insert and delete queries are not supported yet. Select queries are though.
• [ FROM from_item [, ...] ] — partially supported. Only 1 table is currently supported in the from.
• [ WHERE condition ] — mostly supported. The condition concept is pretty broad but it should contain a lot of cases.
• [ GROUP BY grouping_element [, ...] ] — supported.
• [ HAVING condition [, ...] ] — supported.
• [ WINDOW window_name AS ( window_definition ) [, ...] ] — not supported.
• [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] — not supported yet
• [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ] — supported, but expressions are pretty broad and there might be cases not covered yet.
• [ LIMIT { count | ALL } ] — supported.
• [ OFFSET start [ ROW | ROWS ] ] — supported.
• [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ] — supported
• [ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ] [ NOWAIT | SKIP LOCKED ] [...] ] — supported

• [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
• UPDATE [ ONLY ] table_name [ * ] [ [ AS ] alias ] — supported
• SET { column_name = { expression | DEFAULT } | — supported, but expression concept is very broad and might be incomplete
• ( column_name [, ...] ) = [ ROW ] ( { expression | DEFAULT } [, ...] ) | — supported, but expression concept is very broad and might be incomplete in some cases
• ( column_name [, ...] ) = ( sub-SELECT ) — not supported
• } [, ...]
• [ FROM from_item [, ...] ] — partially supported. Only 1 table as from item is supported
• [ WHERE condition | WHERE CURRENT OF cursor_name ] — supported, but the condition concept is very broad and is incomplete in some cases.
• [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ] — supported, but up to 10 expressions

• [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
• DELETE FROM [ ONLY ] table_name [ * ] [ [ AS ] alias ] — supported
• [ USING from_item [, ...] ] — supported
• [ WHERE condition | WHERE CURRENT OF cursor_name ] — supported, but the condition concept is very broad and might be incomplete
• [ RETURNING * | output_expression [ [ AS ] output_name ] [, ... ] ] — supported, but up to 10 expressions

• [ WITH [ RECURSIVE ] with_query [, ...] ] — Partial support. Recursive not supported yet.
• INSERT INTO table_name [ AS alias ] [ ( column_name [, ...] ) ] — supported
• [ OVERRIDING { SYSTEM | USER } VALUE ] — not supported
• { DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | query } - supported, but expression is a broad concept and may not be complete
• [ ON CONFLICT [ conflict_target ] conflict_action ] — supported
• [ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ] — supported, but limited to 10 expressions

• RESTART IDENTITY
• CASCADE