Merge branch 'main' into driver-adapter

content/800-data-platform/100-accelerate/100-what-is-accelerate.mdx

@@ -20,16 +20,10 @@ The goal of Accelerate is to improve response times and reduce database load. It
 
 While Accelerate is beneficial for all types of applications, being at the edge provides additional benefits to edge function environments like [Vercel Edge Functions](https://vercel.com/docs/concepts/functions/edge-functions), [Cloudflare Workers](https://workers.cloudflare.com/), and [Deno Deploy](https://deno.com/deploy). Cache hits can be served from data centers near the user regardless of the region of the database.
 
-<Admonition type="info">
-
-Accelerate is in Preview. While we have high confidence in our product, the nature of an Preview product is that significant iterations might happen at any time, so we would advise against placing it in a system that requires stability.
-
-</Admonition>
-
 </TopBlock>
 
 ## See Accelerate in action
 
 We built a small sample application, [Accelerate Speed Test](https://accelerate-speed-test.prisma.io/). The app compares the performance of cached and uncached queries side by side. The app is [open source](https://github.com/prisma/accelerate-speed-test) and you can clone it to try it yourself.
 
-![Screenshot of the Accelerate Speed Test app showing cached query performance](./images/speed-test.png)
+![Screenshot of the Accelerate Speed Test app showing cached query performance](./images/accelerate.png)

content/800-data-platform/100-accelerate/550-testing.mdx

@@ -0,0 +1,228 @@
+---
+title: 'Testing'
+metaTitle: 'Accelerate: Testing'
+metaDescription: 'Learn about testing Prisma Accelerate.'
+tocDepth: 3
+toc: true
+---
+
+<TopBlock>
+
+Prisma Accelerate optimizes database interactions through advanced connection pooling and global edge caching. Its connection pooler is available in 16 regions and helps applications load-balance and scale database requests based on demand.
+
+Considering the information above, we recommend testing Accelerate with high volume to see it perform under load.
+
+</TopBlock>
+
+## How Accelerate's connection pool optimizes performance under load
+
+Prisma Accelerate employs a dynamic, serverless connection pooling infrastructure. When a request is made, a connection pool is quickly provisioned for the project in the region assigned while configuring Prisma Accelerate. This connection pool remains active, serving many additional requests while reusing established database connections. The connection pool will disconnect after a period of inactivity, so it’s important to test Prisma Accelerate with a consistent stream of traffic.
+
+**Key Benefits:**
+
+- **Optimized Query Performance:** The serverless connection pooler adapts to the query load, ensuring the database connections are managed efficiently during peak demand.
+
+  > Prisma Accelerate’s connection pooler cannot improve the performance of queries in the database. In scenarios where query performance is an issue, we recommend optimizing the Prisma query, applying indexes, or utilizing Accelerate’s edge caching.
+
+- **Maximize Connection Reuse:** Executing a consistent volume of queries helps maintain active instances of Accelerate connection poolers. This increases connection reuse, ensuring faster response times for subsequent queries.
+
+By understanding and harnessing this mechanism, you can ensure that your database queries perform consistently and efficiently at scale.
+
+## Testing Prisma Accelerate connection pooling performance
+
+Below you will find an example of how to test Prisma Accelerate using a sample model:
+
+```prisma
+model Notes {
+  id        Int       @id @default(autoincrement())
+  title     String
+  createdAt DateTime  @default(now())
+  updatedAt DateTime? @updatedAt
+}
+```
+
+```typescript
+import { PrismaClient } from '@prisma/client'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+
+function calculateStatistics(numbers: number[]): {
+  average: number
+  p50: number
+  p75: number
+  p99: number
+} {
+  if (numbers.length === 0) {
+    throw new Error('The input array is empty.')
+  }
+
+  // Sort the array in ascending order
+  numbers.sort((a, b) => a - b)
+
+  const sum = numbers.reduce((acc, num) => acc + num, 0)
+  const count = numbers.length
+
+  const average = sum / count
+  const p50 = getPercentile(numbers, 50)
+  const p75 = getPercentile(numbers, 75)
+  const p99 = getPercentile(numbers, 99)
+
+  return { average, p50, p75, p99 }
+}
+
+function getPercentile(numbers: number[], percentile: number): number {
+  if (percentile <= 0 || percentile >= 100) {
+    throw new Error('Percentile must be between 0 and 100.')
+  }
+
+  const index = (percentile / 100) * (numbers.length - 1)
+  if (Number.isInteger(index)) {
+    // If the index is an integer, return the corresponding value
+    return numbers[index]
+  } else {
+    // If the index is not an integer, interpolate between two adjacent values
+    const lowerIndex = Math.floor(index)
+    const upperIndex = Math.ceil(index)
+    const lowerValue = numbers[lowerIndex]
+    const upperValue = numbers[upperIndex]
+    const interpolationFactor = index - lowerIndex
+    return lowerValue + (upperValue - lowerValue) * interpolationFactor
+  }
+}
+
+async function main() {
+  const timings = []
+
+  // fire a query before going to the loop
+  await prisma.notes.findMany({
+    take: 20,
+  })
+
+  // we recommend testing Prisma Accelerate with a large loop
+  const LOOP_LENGTH = 10000
+
+  for (let i = 0; i < LOOP_LENGTH; i++) {
+    const start = Date.now()
+    await prisma.notes.findMany({
+      take: 20,
+    })
+
+    timings.push(Date.now() - start)
+  }
+
+  const statistics = calculateStatistics(timings)
+  console.log('Average:', statistics.average)
+  console.log('P50:', statistics.p50)
+  console.log('P75:', statistics.p75)
+  console.log('P99:', statistics.p99)
+}
+
+main()
+  .then(async () => {
+    await prisma.$disconnect()
+  })
+  .catch((e) => {
+    await prisma.$disconnect()
+    process.exit(1)
+  })
+```
+
+## Testing Prisma Accelerate caching performance
+
+Prisma Accelerate’s edge cache is also optimized for a high volume of queries. The cache automatically optimizes for repeated queries. As a result, the cache hit rate will increase as the query frequency does. Adding a query result to the cache is also non-blocking, so a short burst of queries might not utilize the cache or a sustained load.
+
+To test Accelerate’s edge caching, you can modify the above script with the below:
+
+```typescript
+import { PrismaClient } from '@prisma/client'
+import { withAccelerate } from '@prisma/extension-accelerate'
+
+const prisma = new PrismaClient().$extends(withAccelerate())
+
+function calculateStatistics(numbers: number[]): {
+  average: number
+  p50: number
+  p75: number
+  p99: number
+} {
+  if (numbers.length === 0) {
+    throw new Error('The input array is empty.')
+  }
+
+  // Sort the array in ascending order
+  numbers.sort((a, b) => a - b)
+
+  const sum = numbers.reduce((acc, num) => acc + num, 0)
+  const count = numbers.length
+
+  const average = sum / count
+  const p50 = getPercentile(numbers, 50)
+  const p75 = getPercentile(numbers, 75)
+  const p99 = getPercentile(numbers, 99)
+
+  return { average, p50, p75, p99 }
+}
+
+function getPercentile(numbers: number[], percentile: number): number {
+  if (percentile <= 0 || percentile >= 100) {
+    throw new Error('Percentile must be between 0 and 100.')
+  }
+
+  const index = (percentile / 100) * (numbers.length - 1)
+  if (Number.isInteger(index)) {
+    // If the index is an integer, return the corresponding value
+    return numbers[index]
+  } else {
+    // If the index is not an integer, interpolate between two adjacent values
+    const lowerIndex = Math.floor(index)
+    const upperIndex = Math.ceil(index)
+    const lowerValue = numbers[lowerIndex]
+    const upperValue = numbers[upperIndex]
+    const interpolationFactor = index - lowerIndex
+    return lowerValue + (upperValue - lowerValue) * interpolationFactor
+  }
+}
+
+async function main() {
+  const timings = []
+
+  // fire a query before going to the loop
+  await prisma.notes.findMany({
+    take: 20,
+    cacheStrategy: {
+      ttl: 30,
+    },
+  })
+
+  // we recommend testing Prisma Accelerate with a large loop
+  const LOOP_LENGTH = 10000
+
+  for (let i = 0; i < LOOP_LENGTH; i++) {
+    const start = Date.now()
+    await prisma.notes.findMany({
+      take: 20,
+      cacheStrategy: {
+        ttl: 30,
+      },
+    })
+
+    timings.push(Date.now() - start)
+  }
+
+  const statistics = calculateStatistics(timings)
+  console.log('Average:', statistics.average)
+  console.log('P50:', statistics.p50)
+  console.log('P75:', statistics.p75)
+  console.log('P99:', statistics.p99)
+}
+
+main()
+  .then(async () => {
+    await prisma.$disconnect()
+  })
+  .catch((e) => {
+    await prisma.$disconnect()
+    process.exit(1)
+  })
+```

content/800-data-platform/100-accelerate/600-faq.mdx

@@ -14,13 +14,9 @@ Accelerate's cache performs best when it observes a higher load from a project.
 
 Prisma operations are sent to Accelerate over HTTP. As a result, the first request to Accelerate must establish an HTTP handshake and may have additional latency as a result. We're exploring ways to reduce this initial request latency in the future.
 
-## What happens to my Scale plan subscription if I switch to Accelerate?
-
-While Accelerate is in Preview, you do not need a subscription or a monthly plan. With Accelerate, you can use the same Data Proxy [connection pooling features](/data-platform/accelerate/getting-started#no-cache-strategy-to-only-use-connection-pool) on top of the Accelerate global cache.
-
 ## What is the pricing of Accelerate?
 
-When we officially launch Accelerate and make it generally available, we will provide pricing details.
+You can find more details on our [Accelerate pricing page](https://www.prisma.io/pricing)
 
 ## VS Code does not recognize the `$extends` method