Implementing feedback.

Author: Oxyjun

src/content/changelogs/d1.yaml

@@ -5,7 +5,7 @@ productLink: "/d1/"
 productArea: Developer platform
 productAreaLink: /workers/platform/changelog/platform/
 entries:
-  - publish_date: "2024-11-18"
+  - publish_date: "2024-11-01"
     title: Support for multiple queries in a single prepared statement
     description: |-
       You can now have multiple queries in a single prepared statement when using `db.prepare`. To use this feature, separate each query with a semi-colon. Prepared statements with multiple queries only returns the results of the last query, even though all queries are executed. Additionally, you can only bind parameters to the last query in the prepared statement.

src/content/docs/d1/get-started.mdx

@@ -532,5 +532,5 @@ In this tutorial, you have:
 If you have any feature requests or notice any bugs, share your feedback directly with the Cloudflare team by joining the [Cloudflare Developers community on Discord](https://discord.cloudflare.com).
 
 - See supported [Wrangler commands for D1](/workers/wrangler/commands/#d1).
-- Learn how to use the [D1 Worker Binding API](/d1/worker-api/) within your Worker.
+- Learn how to use the [D1 Worker Binding API](/d1/worker-api/) within your Worker, and test them from the [API playground](/d1/worker-api/#api-playground).
 - Explore [community projects built on D1](/d1/reference/community-projects/).

src/content/docs/d1/worker-api/index.mdx

@@ -7,7 +7,7 @@ sidebar:
 
 import { DirectoryListing, Details, Steps } from "~/components";
 
-You can execute queries on your D1 database through SQL query statements. To do this, you need to perform the following steps:
+You can execute SQL queries on your D1 database from a Worker using the Worker Binding API. To do this, you can perform the following steps:
 
 1. [Prepare a statement](/d1/worker-api/prepare-a-statement).
 2. [Run the prepared statement](/d1/worker-api/run-a-statement).
@@ -17,9 +17,9 @@ Refer to the relevant sections for the API documentation.
 
 ## Typescript support
 
-D1 Worker Bindings API is fully-typed via the `@cloudflare/workers-types` package, and also supports [generic types](https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-types) as part of its TypeScript API. A generic type allows you to provide an optional _type parameter_ so that a function understands the type of the data it is handling.
+D1 Worker Bindings API is fully-typed via the [`@cloudflare/workers-types`](/workers/languages/typescript/#typescript) package, and also supports [generic types](https://www.typescriptlang.org/docs/handbook/2/generics.html#generic-types) as part of its TypeScript API. A generic type allows you to provide an optional _type parameter_ so that a function understands the type of the data it is handling.
 
-When using the [query statement methods](#query-statement-methods) `stmt.run()`, `stmt.raw()` and `stmt.first()`, you can provide a type representing each database row. D1's API will [return the result object](#return-object) with the correct type.
+When using the [query statement methods](/d1/worker-api/run-a-statement) `stmt.run()`, `stmt.raw()` and `stmt.first()`, you can provide a type representing each database row. D1's API will [return the result object](#return-object) with the correct type.
 
 For example, providing an `OrderRow` type as a type parameter to `stmt.run()` will return a typed `Array<OrderRow>` object instead of the default `Record<string, unknown>` type:
 
@@ -56,40 +56,55 @@ Replace the contents of your `index.js` file with the below to view the effect o
 <Details header="index.js" open={false}>
 ```js
 export default {
-  async fetch(request, env) {
-    const { pathname } = new URL(request.url);
-
-    const companyName1 = `Bs Beverages`;
-    const companyName2 = `Around the Horn`;
-    const stmt = env.DB.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);
-
-    if (pathname === `/RUN`){
-    const returnValue = await stmt.bind(companyName1).run()
-    return Response.json(returnValue);
-
-  } else if (pathname === `/RAW`){
-    const returnValue = await stmt.bind(companyName1).raw();
-    return Response.json(returnValue);
-
-  } else if (pathname === `/FIRST`){
-    const returnValue = await stmt.bind(companyName1).first();
-    return Response.json(returnValue);
-
-  } else if (pathname === `/BATCH`) {
-    const batchResult = await env.DB.batch([
-      stmt.bind(companyName1),
-      stmt.bind(companyName2)
-    ]);
-    // const returnValue = await stmt.run();
-    return Response.json(batchResult);
-  }
-
-    return new Response(
-    `Welcome to the D1 API Playground!
-		\nChange the URL to test the methods inside your index.js file.`,
-    );
-  },
-  };
+	async fetch(request, env) {
+	  const { pathname } = new URL(request.url);
+
+	//   if (pathname === "/api/beverages") {
+	// 	// If you did not use `DB` as your binding name, change it here
+	// 	const { results } = await env.DB.prepare("SELECT * FROM Customers WHERE CompanyName = ?",).bind("Bs Beverages").all();
+	// 	return Response.json(results);
+	//   }
+
+		const companyName1 = `Bs Beverages`;
+		const companyName2 = `Around the Horn`;
+		const stmt = env.DB.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);
+		const stmtMulti = env.DB.prepare(`SELECT * FROM Customers; SELECT * FROM Customers WHERE CompanyName = ?`);
+
+	  if (pathname === `/RUN`){
+		const returnValue = await stmt.bind(companyName1).run();
+		return Response.json(returnValue);
+
+	} else if (pathname === `/RAW`){
+		const returnValue = await stmt.bind(companyName1).raw();
+		return Response.json(returnValue);
+
+	} else if (pathname === `/FIRST`){
+		const returnValue = await stmt.bind(companyName1).first();
+		return Response.json(returnValue);
+
+	} else if (pathname === `/BATCH`) {
+		const batchResult = await env.DB.batch([
+			stmt.bind(companyName1),
+			stmt.bind(companyName2)
+		]);
+		// const returnValue = await stmt.run();
+		return Response.json(batchResult);
+
+	} else if (pathname === `/RUNMULTI`){
+		const returnValue = await stmtMulti.bind(companyName1).run();
+		return Response.json(returnValue);
+
+	} else if (pathname === `/EXEC`){
+		const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
+		return Response.json(returnValue);
+	}
+
+	  return new Response(
+		`Welcome to the D1 API Playground!
+		\nChange the URL to test the various methods inside your index.js file.`,
+	  );
+	},
+};
 
 ```
 </Details>

src/content/docs/d1/worker-api/prepare-a-statement.mdx

@@ -31,12 +31,6 @@ const stmt = env.DB.prepare("SELECT * FROM Customers WHERE CompanyName = ?").bin
 
 #### Guidance
 
-- You can pass multiple queries into a single `.prepare()` statement. Simply delineate each query with a semi-colon.
-  - The statement only returns the results of the last query, even though all queries are executed.
-  - You can only bind parameters to the last query.
-	```js
-	const stmt = db.prepare(`SELECT * FROM users WHERE name = "Anthony"; SELECT * FROM users WHERE name = ?1`).bind("Joe")
-	```
 - D1 follows the [SQLite convention](https://www.sqlite.org/lang_expr.html#varparam) for prepared statements parameter binding. Currently, D1 only supports Ordered (`?NNNN`) and Anonymous (`?`) parameters. In the future, D1 will support named parameters as well.
 
 	| Syntax | Type      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
@@ -64,6 +58,13 @@ const stmt = env.DB.prepare("SELECT * FROM Customers WHERE CompanyName = ?").bin
 		.bind(1, "Alfreds Futterkiste");
 	```
 
+- You can pass multiple queries into a single `.prepare()` statement. Simply delineate each query with a semi-colon.
+  - The statement only returns the results of the last query, even though all queries are executed.
+  - You can only bind parameters to the last query.
+	```js
+	const stmt = db.prepare(`SELECT * FROM users WHERE name = "Anthony"; SELECT * FROM users WHERE name = ?1`).bind("Joe")
+	```
+
 ## Static statements
 
 D1 API supports static statements. Static statements are SQL statements where the variables have been hard coded. When writing a static statement, you manually type the variable within the statement string.

src/content/docs/d1/worker-api/return-object.mdx

@@ -1,11 +1,20 @@
 ---
-title: Return object
+title: Return objects
 pcx_content_type: concept
 sidebar:
   order: 3
 ---
 
-The methods `stmt.run()`, `db.exec()`, and `db.batch()` return a typed `D1Result` object for each query statement. This object contains:
+Some D1 Worker Binding APIs return a typed object.
+
+| D1 Worker Binding API     | Return object |
+| ------------------------- | ------------- |
+| `stmt.run()`, `db.batch()`| `D1Result`    |
+| `db.exec()`               | `D1ExecResult`|
+
+## D1Result
+
+The methods `stmt.run()` and `db.batch()` return a typed `D1Result` object for each query statement. This object contains:
 
 - The success status
 - A meta object with the internal duration of the operation in milliseconds
@@ -28,7 +37,7 @@ The methods `stmt.run()`, `db.exec()`, and `db.batch()` return a typed `D1Result
 }
 ```
 
-## Example:
+### Example
 
 ```js
 const someVariable = `Bs Beverages`;
@@ -62,4 +71,31 @@ return Response.json(result)
     }
   ]
 }
+```
+
+## D1ExecResult
+
+The method `db.exec()` returns a typed `D1ExecResult` object for each query statement. This object contains:
+
+- The number of executed queries
+- The duration of the operation in milliseconds
+
+```js
+{
+	"count": number, // the number of executed queries
+	"duration": number // the duration of the operation, in milliseconds
+}
+```
+
+### Example
+
+```js
+const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
+return Response.json(returnValue);
+```
+```js output
+{
+  "count": 1,
+  "duration": 1
+}
 ```

src/content/docs/d1/worker-api/run-a-statement.mdx

@@ -1,5 +1,5 @@
 ---
-title: Run a prepared statement
+title: Run a statement
 pcx_content_type: concept
 sidebar:
   order: 2
@@ -25,9 +25,9 @@ const returnValue = await stmt.run();
 
 #### Return value
 
-- <code>returnValue</code>: <Type text="Object"/>
+- <code>D1Result</code>: <Type text="Object"/>
   - An object containing the success status, a meta object, and an array of objects containing the query results.
-  - For more information on the returned object, refer to [Return objects](/d1/worker-api/return-object).
+  - For more information on the object, refer to [`D1Result`](/d1/worker-api/return-object/d1result).
 
 <Details header="Example of return values" open = {false}>
 ```js
@@ -294,8 +294,8 @@ const batchResult = await env.DB.batch([
 #### Return values
 
 - <code>results</code>: <Type text="Array"/>
-  - An array of objects containing the results of the `.db.prepare()` statements. Each object is in the array position corresponding to the array position of the initial `db.prepare()` statement within the `statementArray`.
-  - For more information on the returned object, refer to [Return objects](/d1/worker-api/return-object).
+  - An array of `D1Result` objects containing the results of the `.db.prepare()` statements. Each object is in the array position corresponding to the array position of the initial `db.prepare()` statement within the `statementArray`.
+  - Refer to [`D1Result`](/d1/worker-api/return-object/d1result) for more information about this object.
 
 <Details header="Example of return values" open={false}>
 
@@ -388,32 +388,33 @@ console.log(stmt[1].results);
 
 ### `db.exec()`
 
-Executes one or more queries directly without prepared statements or parameters binding.
+Executes one or more queries directly without prepared statements or parameter bindings.
 
 ```js
-const migration = await fetch("/migration.sql");
-const out = await db.exec(migration.text());
+const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
 ```
 
 #### Parameters
 
--
+- <code>queryString</code>: <Type text="String"/> <MetaInfo text="Required"/>
+  - The SQL query statement without parameter binding.
 
 #### Return values
 
-- <code>queryResult</code>: <Type text="Any"/>
-  - Result of the query.
+- <code>D1ExecResult</code>: <Type text="Object"/>
+  - The `count` property contains the number of executed queries.
+  - The `duration` property contains the duration of operation in milliseconds.
+	- Refer to [`D1ExecResult`](/d1/worker-api/return-object/#d1execresult) for more information.
 
 <Details header="Example of return values" open={false}>
 ```js
-const migration = await fetch("/migration.sql");
-const out = await db.exec(migration.text());
-console.log(out);
+const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
+return Response.json(returnValue);
 ```
 ```js output
 {
-  count: 80,
-  duration: 76
+  "count": 1,
+  "duration": 1
 }
 ```
 </Details>
@@ -445,9 +446,8 @@ return new Response(dump, {
 
 #### Parameters
 
--
+- None.
 
 #### Return values
 
--
-
+- None.