Exploring SQL Server 2022 APPROX_PERCENTILE_DISC Function with JBDB Database

SQL Server 2022 introduces several powerful features to enhance data analysis and performance. Among these, the APPROX_PERCENTILE_DISC function offers an efficient way to calculate discrete percentiles from large datasets. This blog will explore this function in depth, using practical examples from the JBDB database, and provide a detailed business use case to illustrate its utility. Let’s dive into the world of approximate discrete percentiles! πŸŽ‰


Business Use Case: Analyzing Customer Satisfaction πŸ“Š

Imagine a retail company seeking to understand customer satisfaction across different store locations. The data, stored in the JBDB database, includes satisfaction scores ranging from 1 to 5, representing customers’ overall experience. The company aims to identify key percentiles such as the median (50th percentile) and the 90th percentile to gauge typical and top-tier satisfaction levels. Using APPROX_PERCENTILE_DISC, they can efficiently compute these discrete percentiles, helping to guide strategies for improving customer experience and focusing on high-impact areas.


Understanding the APPROX_PERCENTILE_DISC Function 🧠

The APPROX_PERCENTILE_DISC function in SQL Server 2022 is designed to calculate approximate discrete percentiles from a sorted set of values. Unlike the continuous APPROX_PERCENTILE_CONT, this function returns the value nearest to the percentile rank, which is particularly useful for ordinal data.

Syntax:

APPROX_PERCENTILE_DISC ( percentile ) WITHIN GROUP ( ORDER BY column_name )
  • percentile: A numeric value between 0 and 1, indicating the desired percentile.
  • column_name: The column used to order the dataset before calculating the percentile.

Example 1: Calculating Key Percentiles πŸ”

Let’s calculate the median (50th percentile) and 90th percentile of customer satisfaction scores.

Setup:

USE JBDB;
GO

CREATE TABLE CustomerSatisfaction (
    CustomerID INT PRIMARY KEY,
    StoreID INT,
    SatisfactionScore INT,
    ReviewDate DATE
);

INSERT INTO CustomerSatisfaction (CustomerID, StoreID, SatisfactionScore, ReviewDate)
VALUES
(1, 101, 5, '2023-01-15'),
(2, 102, 3, '2023-01-16'),
(3, 103, 4, '2023-01-17'),
(4, 101, 2, '2023-01-18'),
(5, 104, 5, '2023-01-19'),
(6, 105, 4, '2023-01-20'),
(7, 106, 3, '2023-01-21'),
(8, 102, 5, '2023-01-22');
GO

Query to Calculate 50th and 90th Percentiles:

SELECT 
    APPROX_PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY SatisfactionScore) AS MedianScore,
    APPROX_PERCENTILE_DISC(0.90) WITHIN GROUP (ORDER BY SatisfactionScore) AS Top10PercentScore
FROM CustomerSatisfaction;

Output:

MedianScoreTop10PercentScore
45

This output reveals that the median satisfaction score is 4, and the top 10% of scores are 5, indicating a high level of satisfaction among the top-tier customers.


Example 2: Store-Level Satisfaction Analysis πŸͺ

Next, let’s analyze satisfaction scores at different store locations to identify trends and areas for improvement.

Query for Store-Level Analysis:

SELECT 
    StoreID,
    APPROX_PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY SatisfactionScore) AS MedianScore,
    APPROX_PERCENTILE_DISC(0.90) WITHIN GROUP (ORDER BY SatisfactionScore) AS Top10PercentScore
FROM CustomerSatisfaction
GROUP BY StoreID;

Output:

StoreIDMedianScoreTop10PercentScore
10135
10245
10344
10455
10544
10633

This analysis helps identify which stores are excelling in customer satisfaction and which may need targeted improvements.


Example 3: Customer Segmentation by Satisfaction Levels πŸ“ˆ

To further analyze the data, let’s segment customers into different satisfaction levels based on key percentiles.

Step 1: Calculate Percentiles

-- Calculate the 25th, 50th, and 75th percentiles
SELECT 
    APPROX_PERCENTILE_DISC(0.25) WITHIN GROUP (ORDER BY SatisfactionScore) AS Q1,
    APPROX_PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY SatisfactionScore) AS Q2,
    APPROX_PERCENTILE_DISC(0.75) WITHIN GROUP (ORDER BY SatisfactionScore) AS Q3
INTO #Percentiles
FROM CustomerSatisfaction;

Step 2: Segment Customers

-- Join with the Percentiles table to categorize customers
SELECT 
    cs.CustomerID,
    cs.SatisfactionScore,
    CASE 
        WHEN cs.SatisfactionScore <= p.Q1 THEN 'Low'
        WHEN cs.SatisfactionScore <= p.Q2 THEN 'Medium'
        WHEN cs.SatisfactionScore <= p.Q3 THEN 'High'
        ELSE 'Very High'
    END AS SatisfactionLevel
FROM 
    CustomerSatisfaction cs
CROSS JOIN 
    #Percentiles p;

Cleanup

-- Drop the temporary table
DROP TABLE #Percentiles;

Explanation:

  1. Calculate Percentiles:
    • The first step calculates the 25th (Q1), 50th (Q2), and 75th (Q3) percentiles and stores them in a temporary table #Percentiles.
  2. Segment Customers:
    • The second step uses these percentile values to categorize each customer’s satisfaction score into levels: ‘Low’, ‘Medium’, ‘High’, or ‘Very High’.
  3. Cleanup:
    • Finally, the temporary table #Percentiles is dropped to clean up the session.

Analyzing Low Satisfaction Scores:

  • Identify stores with the lowest 10th percentile satisfaction scores:
SELECT 
    StoreID,
    APPROX_PERCENTILE_DISC(0.10) WITHIN GROUP (ORDER BY SatisfactionScore) AS Low10PercentScore
FROM CustomerSatisfaction
GROUP BY StoreID;

Comparing Satisfaction Over Time:

  • Compare median satisfaction scores between two periods:
SELECT 
    'Period 1' AS Period,
    APPROX_PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY SatisfactionScore) AS MedianScore
FROM CustomerSatisfaction
WHERE ReviewDate BETWEEN '2023-01-15' AND '2023-01-18'
UNION ALL
SELECT 
    'Period 2' AS Period,
    APPROX_PERCENTILE_DISC(0.50) WITHIN GROUP (ORDER BY SatisfactionScore) AS MedianScore
FROM CustomerSatisfaction
WHERE ReviewDate BETWEEN '2023-01-19' AND '2023-01-22';

3. Identifying High-Performing Stores:

  • List stores with a 90th percentile satisfaction score of 5:
SELECT StoreID
FROM CustomerSatisfaction
GROUP BY StoreID
HAVING APPROX_PERCENTILE_DISC(0.90) WITHIN GROUP (ORDER BY SatisfactionScore) = 5;

Conclusion 🏁

The APPROX_PERCENTILE_DISC function in SQL Server 2022 is a robust tool for efficiently estimating discrete percentiles. It offers a quick and practical solution for analyzing large datasets, making it invaluable for businesses looking to gain insights into customer behavior, product performance, and more. Whether you’re assessing customer satisfaction, analyzing sales data, or exploring other metrics, the APPROX_PERCENTILE_DISC function provides a clear and concise way to understand your data. Happy querying! πŸŽ‰

For more tutorials and tips on SQL Server, including performance tuning and database management, be sure to check out our JBSWiki YouTube channel.

Thank You,
Vivek Janakiraman

Disclaimer:
The views expressed on this blog are mine alone and do not reflect the views of my company or anyone else. All postings on this blog are provided β€œAS IS” with no warranties, and confers no rights.

SQL Server 2022 Query Store Enhancements: A Comprehensive Guide

SQL Server 2022 brings significant enhancements to the Query Store, a powerful feature for monitoring and optimizing query performance. In this blog, we’ll explore the improvements, how to leverage Query Store for performance tuning, and its application in Always On Availability Groups. We’ll also provide T-SQL queries to identify costly queries and discuss the advantages and business use cases of using Query Store.

What is Query Store? πŸ€”

Query Store is a feature in SQL Server that captures a history of queries, plans, and runtime statistics. It helps database administrators (DBAs) and developers identify and troubleshoot performance issues by providing insights into how queries are performing over time.

Key Enhancements in SQL Server 2022 πŸ› οΈ

  1. Support for Always On Availability Groups Read Replicas: One of the standout features in SQL Server 2022 is the extension of Query Store to read-only replicas in Always On Availability Groups. This allows monitoring of read workload performance without affecting the primary replica’s performance.
  2. Improved Query Performance Analysis: Enhancements in Query Store provide more granular control over data collection and retention policies, allowing for more precise performance tuning.
  3. Automatic Plan Correction: Query Store can automatically identify and revert to a previously good query plan if the current plan causes performance regressions.
  4. Enhanced Data Cleanup: SQL Server 2022 introduces more efficient data cleanup processes, ensuring that Query Store doesn’t consume unnecessary storage space.

Leveraging Query Store for Performance Tuning πŸŽ›οΈ

To make the most of Query Store, follow these steps:

Enable Query Store: Ensure that Query Store is enabled for your database. You can do this using the following T-SQL command.

    ALTER DATABASE [YourDatabaseName] SET QUERY_STORE = ON;

    Monitor Performance: Use Query Store views and built-in reports in SQL Server Management Studio (SSMS) to analyze query performance over time.

    Identify Regressions: Leverage the Automatic Plan Correction feature to detect and fix query performance regressions automatically.

    Optimize Queries: Use the insights from Query Store to optimize queries and indexes, reducing resource consumption and improving response times.

    Using Query Store on Always On Read Replicas πŸ›‘οΈ

    Query Store on read replicas allows you to monitor read-only workloads without impacting the primary replica. To enable and configure Query Store on read replicas, use the following steps:

    Enable Query Store on Primary and Read Replicas: Ensure that Query Store is enabled on both primary and secondary replicas.

      ALTER DATABASE [YourDatabaseName] SET QUERY_STORE = ON (OPERATION_MODE = READ_WRITE);

      On read replicas:

      ALTER DATABASE [YourDatabaseName] SET QUERY_STORE = ON (OPERATION_MODE = READ_ONLY);

      Monitor Read Workloads: Use Query Store to analyze read workload performance on secondary replicas. This helps in identifying and optimizing queries executed on read-only replicas.

      T-SQL Queries to Check Costly Queries πŸ”

      Here are some T-SQL queries to find costly queries in terms of CPU, reads, and duration:

      On Primary Replica

      Top Queries by CPU Usage:

      SELECT TOP 10
          qs.query_id,
          qs.execution_type_desc,
          qs.total_cpu_time / qs.execution_count AS avg_cpu_time,
          q.text AS query_text
      FROM
          sys.query_store_runtime_stats qs
      JOIN
          sys.query_store_query q ON qs.query_id = q.query_id
      ORDER BY
          avg_cpu_time DESC;

      Top Queries by Logical Reads:

      SELECT TOP 10
          qs.query_id,
          qs.execution_type_desc,
          qs.total_logical_reads / qs.execution_count AS avg_logical_reads,
          q.text AS query_text
      FROM
          sys.query_store_runtime_stats qs
      JOIN
          sys.query_store_query q ON qs.query_id = q.query_id
      ORDER BY
          avg_logical_reads DESC;

      Top Queries by Duration:

      SELECT TOP 10
          qs.query_id,
          qs.execution_type_desc,
          qs.total_duration / qs.execution_count AS avg_duration,
          q.text AS query_text
      FROM
          sys.query_store_runtime_stats qs
      JOIN
          sys.query_store_query q ON qs.query_id = q.query_id
      ORDER BY
          avg_duration DESC;

      On Read Replica

      The queries on the read replica are similar but consider that the Query Store on read replicas operates in a read-only mode:

      -- For CPU Usage, Logical Reads, and Duration, the same queries as above can be used.

      Advantages of Using Query Store 🌟

      1. Historical Performance Data: Query Store maintains historical data, making it easier to analyze and troubleshoot performance issues over time.
      2. Automated Plan Correction: Automatically detects and corrects query plan regressions, reducing the need for manual intervention.
      3. Enhanced Monitoring: Extended support to read replicas allows comprehensive monitoring of all workloads in Always On Availability Groups.
      4. Improved Resource Management: Helps in identifying resource-intensive queries, enabling better resource allocation and management.

      Business Use Case: E-commerce Website πŸ›’

      Consider an e-commerce platform where performance is critical, especially during peak shopping seasons. By leveraging Query Store:

      • The DBA can monitor and optimize queries that retrieve product details, prices, and inventory status, ensuring quick response times for users.
      • Automatic Plan Correction helps maintain optimal performance even when changes are made to the database or application code.
      • Using Query Store on read replicas allows offloading read workloads from the primary replica, ensuring that write operations remain unaffected.

      Conclusion πŸŽ‰

      SQL Server 2022’s Query Store enhancements offer a powerful toolset for monitoring and optimizing database performance. Whether you’re managing a high-traffic e-commerce site or a critical financial application, leveraging Query Store can lead to significant performance improvements and resource optimization. Start exploring these features today to get the most out of your SQL Server environment!

      For more tutorials and tips on SQL Server, including performance tuning and database management, be sure to check out our JBSWiki YouTube channel.

      Thank You,
      Vivek Janakiraman

      Disclaimer:
      The views expressed on this blog are mine alone and do not reflect the views of my company or anyone else. All postings on this blog are provided β€œAS IS” with no warranties, and confers no rights.