Merge commit '2121f65f7ba78d27d74d5bdc5a58abc5e2534819'

AlexBlokh · AlexBlokh · commit 10aa7eeb0827 · 2024-10-16T22:06:12.000+03:00
diff --git a/src/content/documentation/docs/connect-cloudflare-d1.mdx b/src/content/documentation/docs/connect-cloudflare-d1.mdx
@@ -10,8 +10,8 @@ import CodeTabs from "@mdx/CodeTabs.astro";
 
 <Prerequisites>
 - Database [connection basics](/docs/connect-overview) with Drizzle
-- D1 Database - [website](https://docs.turso.tech/introduction)
-- D1 driver - [website](https://docs.turso.tech/sdk/ts/reference) & [GitHub](https://github.com/tursodatabase/libsql-client-ts)
+- D1 Database - [website](https://developers.cloudflare.com/d1/)
+- D1 driver - [website](https://developers.cloudflare.com/d1/build-with-d1/d1-client-api/)
 </Prerequisites>
 
 According to the **[official website](https://developers.cloudflare.com/d1/)**, 
diff --git a/src/content/documentation/docs/delete.mdx b/src/content/documentation/docs/delete.mdx
@@ -12,6 +12,42 @@ And you can delete with filters and conditions:
 await db.delete(users).where(eq(users.name, 'Dan'));
 ```
 
+### Limit
+
+<IsSupportedChipGroup chips={{ 'PostgreSQL': false, 'MySQL': true, 'SQLite': true }} />
+
+Use `.limit()` to add `limit` clause to the query - for example:
+<Section>
+```typescript
+await db.delete(users).where(eq(users.name, 'Dan')).limit(2);
+```
+```sql
+delete from "users" where "users"."name" = $1 limit $2;
+```
+</Section>
+
+### Order By
+Use `.orderBy()` to add `order by` clause to the query, sorting the results by the specified fields:
+<Section>
+```typescript
+import { asc, desc } from 'drizzle-orm';
+
+await db.delete(users).where(eq(users.name, 'Dan')).orderBy(users.name);
+await db.delete(users).where(eq(users.name, 'Dan')).orderBy(desc(users.name));
+
+// order by multiple fields
+await db.delete(users).where(eq(users.name, 'Dan')).orderBy(users.name, users.name2);
+await db.delete(users).where(eq(users.name, 'Dan')).orderBy(asc(users.name), desc(users.name2));
+```
+```sql
+delete from "users" where "users"."name" = $1 order by "name";
+delete from "users" where "users"."name" = $1 order by "name" desc;
+
+delete from "users" where "users"."name" = $1 order by "name", "name2";
+delete from "users" where "users"."name" = $1 order by "name" asc, "name2" desc;
+```
+</Section>
+
 ### Delete with return
 <IsSupportedChipGroup chips={{ 'PostgreSQL': true, 'SQLite': true, 'MySQL': false }} />
 You can delete a row and get it back in PostgreSQL and SQLite:
diff --git a/src/content/documentation/docs/indexes-constraints.mdx b/src/content/documentation/docs/indexes-constraints.mdx
@@ -317,9 +317,95 @@ If you define a `CHECK` constraint on a column it will allow only certain values
 
 If you define a `CHECK` constraint on a table it can limit the values in certain columns based on values in other columns in the row.
 
-<Callout type="error" emoji="🛑">
-  NOT YET IMPLEMENTED IN DRIZZLE ORM
-</Callout>
+<Tabs items={['PostgreSQL', 'MySQL', 'SQLite']}>
+  <Tab>
+    <Section>
+      ```typescript copy
+      import { sql } from "drizzle-orm";
+      import { check, integer, pgTable, text, uuid } from "drizzle-orm/pg-core";
+
+      export const users = pgTable(
+        "users",
+        {
+          id: uuid().defaultRandom().primaryKey(),
+          username: text().notNull(),
+          age: integer(),
+        },
+        (table) => ({
+          checkConstraint: check("age_check1", sql`${table.age} > 21`),
+        })
+      );
+      ```
+      ```sql
+      CREATE TABLE IF NOT EXISTS "users" (
+	      "id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	      "username" text NOT NULL,
+	      "age" integer,
+	      CONSTRAINT "age_check1" CHECK ("users"."age" > 21)
+      );
+      ```
+    </Section>
+
+  </Tab> 
+  <Tab>
+    <Section>
+      ```typescript copy
+      import { sql } from "drizzle-orm";
+      import { check, int, mysqlTable, text } from "drizzle-orm/mysql-core";
+
+      export const users = mysqlTable(
+        "users",
+        {
+          id: int().primaryKey(),
+          username: text().notNull(),
+          age: int(),
+        },
+        (table) => ({
+          checkConstraint: check("age_check1", sql`${table.age} > 21`),
+        })
+      );
+      ```
+      ```sql
+      CREATE TABLE `users` (
+	      `id` int NOT NULL,
+	      `username` text NOT NULL,
+	      `age` int,
+	      CONSTRAINT `users_id` PRIMARY KEY(`id`),
+	      CONSTRAINT `age_check1` CHECK(`users`.`age` > 21)
+      );
+      ```
+    </Section>
+  </Tab>
+  <Tab>
+   <Section>
+      ```typescript copy
+      import { sql } from "drizzle-orm";
+      import { check, int, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+      export const users = sqliteTable(
+        "users",
+        {
+          id: int().primaryKey(),
+          username: text().notNull(),
+          age: int(),
+        },
+        (table) => ({
+          checkConstraint: check("age_check1", sql`${table.age} > 21`),
+        })
+      );
+      ```
+      ```sql
+      CREATE TABLE `users` (
+	      `id` integer PRIMARY KEY NOT NULL,
+	      `username` text NOT NULL,
+	      `age` integer,
+	      CONSTRAINT "age_check1" CHECK("users"."age" > 21)
+      );
+      ```
+    </Section>
+
+  </Tab>
+</Tabs>
 
 ### Primary Key
 
diff --git a/src/content/documentation/docs/update.mdx b/src/content/documentation/docs/update.mdx
@@ -20,6 +20,42 @@ await db.update(users)
   .where(eq(users.name, 'Dan'));
 ```
 
+### Limit
+
+<IsSupportedChipGroup chips={{ 'PostgreSQL': false, 'MySQL': true, 'SQLite': true }} />
+
+Use `.limit()` to add `limit` clause to the query - for example:
+<Section>
+```typescript
+await db.update(usersTable).set({ verified: true }).limit(2);
+```
+```sql
+update "users" set "verified" = $1 limit $2;
+```
+</Section>
+
+### Order By
+Use `.orderBy()` to add `order by` clause to the query, sorting the results by the specified fields:
+<Section>
+```typescript
+import { asc, desc } from 'drizzle-orm';
+
+await db.update(usersTable).set({ verified: true }).orderBy(usersTable.name);
+await db.update(usersTable).set({ verified: true }).orderBy(desc(usersTable.name));
+
+// order by multiple fields
+await db.update(usersTable).set({ verified: true }).orderBy(usersTable.name, usersTable.name2);
+await db.update(usersTable).set({ verified: true }).orderBy(asc(usersTable.name), desc(usersTable.name2));
+```
+```sql
+update "users" set "verified" = $1 order by "name";
+update "users" set "verified" = $1 order by "name" desc;
+
+update "users" set "verified" = $1 order by "name", "name2";
+update "users" set "verified" = $1 order by "name" asc, "name2" desc;
+```
+</Section>
+
 ### Update with returning
 <IsSupportedChipGroup chips={{ 'PostgreSQL': true, 'SQLite': true, 'MySQL': false }} />
 You can update a row and get it back in PostgreSQL and SQLite:
diff --git a/src/content/documentation/docs/views.mdx b/src/content/documentation/docs/views.mdx
@@ -4,12 +4,7 @@ import IsSupportedChipGroup from '@components/markdown/IsSupportedChipGroup.astr
 import Callout from '@components/markdown/Callout.astro';
 import Section from '@components/markdown/Section.astro';
 
-# Views (WIP)
-<Callout type="warning" emoji="⚠️">
-  Views are currently only implemented in the `drizzle-orm`, `drizzle-kit` does not support views yet. 
-  You can query the views that already exist in the database, but they won't be added to `drizzle-kit` migrations or `db push` as of now.
-</Callout>
-
+# Views
 ## Views declaration
 There're several ways you can declare views with Drizzle ORM.  
 
@@ -28,11 +23,11 @@ yet when you use `sql` you have to explicitly declare view columns schema.
       import { pgTable, pgView, serial, text, timestamp } from "drizzle-orm/pg-core";
 
       export const user = pgTable("user", {
-        id: serial("id"),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: serial(),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: timestamp("created_at"),
         updatedAt: timestamp("updated_at"),
       });
@@ -52,11 +47,11 @@ yet when you use `sql` you have to explicitly declare view columns schema.
       import { text, mysqlTable, mysqlView, int, timestamp } from "drizzle-orm/mysql-core";
 
       export const user = mysqlTable("user", {
-        id: int("id").primaryKey().autoincrement(),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: int().primaryKey().autoincrement(),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: timestamp("created_at"),
         updatedAt: timestamp("updated_at"),
       });
@@ -76,11 +71,11 @@ yet when you use `sql` you have to explicitly declare view columns schema.
       import { integer, text, sqliteView, sqliteTable } from "drizzle-orm/sqlite-core";
 
       export const user = sqliteTable("user", {
-        id: integer("id").primaryKey({ autoIncrement: true }),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: integer().primaryKey({ autoIncrement: true }),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: integer("created_at"),
         updatedAt: integer("updated_at"),
       });
@@ -124,11 +119,11 @@ You can also declare views using `standalone query builder`, it works exactly th
       const qb = new QueryBuilder();
 
       export const user = pgTable("user", {
-        id: serial("id"),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: serial(),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: timestamp("created_at"),
         updatedAt: timestamp("updated_at"),
       });
@@ -150,11 +145,11 @@ You can also declare views using `standalone query builder`, it works exactly th
       const qb = new QueryBuilder();
 
       export const user = mysqlTable("user", {
-        id: int("id").primaryKey().autoincrement(),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: int().primaryKey().autoincrement(),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: timestamp("created_at"),
         updatedAt: timestamp("updated_at"),
       });
@@ -176,11 +171,11 @@ You can also declare views using `standalone query builder`, it works exactly th
       const qb = new QueryBuilder();
 
       export const user = sqliteTable("user", {
-        id: integer("id").primaryKey({ autoIncrement: true }),
-        name: text("name"),
-        email: text("email"),
-        password: text("password"),
-        role: text("role").$type<"admin" | "customer">(),
+        id: integer().primaryKey({ autoIncrement: true }),
+        name: text(),
+        email: text(),
+        password: text(),
+        role: text().$type<"admin" | "customer">(),
         createdAt: integer("created_at"),
         updatedAt: integer("updated_at"),
       });
@@ -221,11 +216,11 @@ When you're provided with a read only access to an existing view in the database
 `drizzle-kit` will ignore and will not generate a `create view` statement in the generated migration.
 ```ts
 export const user = pgTable("user", {
-  id: serial("id"),
-  name: text("name"),
-  email: text("email"),
-  password: text("password"),
-  role: text("role").$type<"admin" | "customer">(),
+  id: serial(),
+  name: text(),
+  email: text(),
+  password: text(),
+  role: text().$type<"admin" | "customer">(),
   createdAt: timestamp("created_at"),
   updatedAt: timestamp("updated_at"),
 });
diff --git a/src/data/progress.ts b/src/data/progress.ts
@@ -1 +1 @@
-export default 40;
+export default 70;
diff --git a/src/data/roadmap.md b/src/data/roadmap.md
@@ -5,11 +5,11 @@
 - [x] Brocli integration to Drizzle Kit
 - [ ] Generated SQL migration strict mode without `try catches` and `if not exists`
 - [x] Drizzle Kit goes OSS steam 🎉
-- [ ] PostgreSQL enums alternations improvements
+- [x] PostgreSQL enums alternations improvements
 - [ ] PostgreSQL RLS support
-- [ ] `check` constraint support in Drizzle Kit
+- [x] `check` constraint support in Drizzle Kit
 - [x] Exposed API for programmatic access in Drizzle Kit
-- [ ] `materialised views` support in Drizzle Kit
+- [x] `materialised views` support in Drizzle Kit
 - [ ] Drizzle Kit support for consuming schemas and migrations from Prisma, TypeORM and Sequelise to enrich ->Drizzle migration process
 - [ ] Drizzle Studio `mkcert` fixes for dockerised environments
 
@@ -22,7 +22,7 @@
 - [ ] Down migrations, better rollbacks and improvements to `migrate` experience in Drizzle Kit
 - [x] Optional database aliases for columns in table declarations -> `id: serial()`
 - [ ] PostgreSQL RLS support
-- [ ] Relational Querie V2 API
+- [ ] Relational Queries V2 API
 - [x] `drizzle('pg', ...)` driver instantiation to lower the entrance learning curve
 - [ ] CockroachDB support (supported with strict SQL migrations)
 - [ ] Native seeding

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-export default 40;`
	`1`	`+export default 70;`