Optimization of the SQL template algorithm - Database Autonomy Service

A partir del 1 de septiembre de 2024, se optimiza el algoritmo de plantillas SQL de Database Autonomy Service (DAS) para mejorar la precisión y la agrupación de las plantillas.

Información de contexto

DAS utiliza el algoritmo de plantillas SQL para procesar sentencias SQL y convertirlas en plantillas para su agrupación y análisis en escenarios de consultas lentas y auditoría SQL. El algoritmo anterior no gestiona bien las sentencias SQL truncadas. Por ejemplo, el truncamiento en posiciones impredecibles puede provocar la expansión de las plantillas y dificultar la agrupación.

Fecha de entrada en vigor

A partir del 1 de septiembre de 2024, se optimiza el algoritmo de plantillas SQL para consultas lentas y auditorías SQL.

Nota

Después del 1 de septiembre de 2024, no se enviarán más notificaciones sobre optimizaciones iterativas del algoritmo de plantillas SQL. Las respuestas de la API reflejan los cambios más recientes.

Ámbito de aplicación

La optimización se aplica a los motores de base de datos que se enumeran a continuación: ApsaraDB RDS for MySQL, ApsaraDB RDS for PostgreSQL, ApsaraDB RDS for SQL Server, ApsaraDB RDS for MariaDB y PolarDB for MySQL.

Contenido

A continuación se proporcionan las optimizaciones:

$$ se reconoce como delimitador de constantes de cadena para ApsaraDB RDS for PostgreSQL, y los identificadores ya no se reemplazan incorrectamente por signos de interrogación (?).

Considere, por ejemplo, la sentencia SQL original que se muestra a continuación:
```
UPDATE "study" SET "name" = 'xiaoming', "ext" = $${"math":90,"english":91}$$ where id=128;
```
Antes de la optimización, se genera la plantilla SQL que se muestra a continuación:
```
UPDATE ?  SET ?  = ?, ?  = $${?:?,?:?}$$ where id=?;
```
Después de la optimización, se genera la plantilla SQL que se muestra a continuación:
```
UPDATE "study" SET "name"=?,"ext"=?  WHERE id=?;
```
Los sufijos numéricos en los nombres de tablas y columnas se reemplazan por marcadores de posición para reducir la cantidad de plantillas.

En este caso, por ejemplo, se utiliza la sentencia SQL original que se muestra a continuación:
```
select * from [school_3].[class].[student_25];
```
Con el algoritmo anterior, la plantilla SQL generada es la que se incluye a continuación:
```
select * from [school_3].[class].[student_25];
```
Con la optimización aplicada, la plantilla SQL generada es la que se incluye a continuación:
```
SELECT * FROM [school_?].[class].[student_?];
```
Para las instancias de ApsaraDB RDS for SQL Server, se eliminan los prefijos de las sentencias SQL para mejorar el análisis sintáctico del tipo de sentencia.

Por ejemplo, la sentencia SQL original que se usa es la que se muestra a continuación:
```
(@P0 nvarchar(4000))select id, name from student WHERE name = @P0;
```
Previo a la optimización, se obtiene la plantilla SQL que aparece a continuación:
```
Generated SQL template: (@P0 nvarchar(?))select id, name from student WHERE name = @P0;
Parsed type of the SQL statement: p0
```
Tras la optimización, se obtiene la plantilla SQL que aparece a continuación:
```
Generated SQL template: SELECT id,name FROM student WHERE name=?;
Parsed type of the SQL statement: select
```
Se eliminan los espacios innecesarios y se conservan las mayúsculas y minúsculas originales de las palabras clave sin afectar la sintaxis.

Como referencia, por ejemplo, se parte de la sentencia SQL original que se incluye a continuación:
```
select `name` from `student` 
  where `id` = 1 and (`name` = 'xiaoming' or `class` = 2);
```
Previamente a la optimización, la plantilla SQL resultante es la que se indica a continuación:
```
SELECT `name` FROM `student` WHERE `id` = ?  AND (`name` = ?  OR `class` = ?)
```
Una vez aplicada la optimización, la plantilla SQL resultante es la que se indica a continuación:
```
SELECT `name` FROM `student` WHERE `id`=?  AND (`name`=?  OR `class`=?);
```
Se conservan todos los paréntesis (()) de la sentencia SQL original.

El caso siguiente, por ejemplo, parte de la sentencia SQL original que se presenta a continuación:
```
select `name` from `student` where `id` = 1 and (`name` = 'xiaoming');
```
Para el comportamiento previo, se produce la plantilla SQL que se presenta a continuación:
```
SELECT `name` FROM `student` WHERE `id` = ?  AND `name` = ?
```
Respecto al nuevo comportamiento, se produce la plantilla SQL que se presenta a continuación:
```
SELECT `name` FROM `student` WHERE `id`=?  AND (`name`=?);
```
Los paréntesis (()) que rodean la expresión CASE ya no se convierten en "AS".

Para ilustrarlo, por ejemplo, se emplea la sentencia SQL original que se presenta a continuación:
```
select `name`, ( CASE WHEN score > 90 THEN 'A' END ) `grade` from `student`;
```
Sin la optimización, la plantilla SQL generada es la que se lista a continuación:
```
SELECT `name` , CASE  WHEN score > ?  THEN ?  END AS `grade` FROM `student`
```
Ya con la optimización, la plantilla SQL generada es la que se lista a continuación:
```
SELECT `name`,(CASE WHEN score>?  THEN ?  END)`grade` FROM `student`;
```
El contenido que sigue al signo de número (#) se puede analizar correctamente.

Suponga, por ejemplo, la sentencia SQL original que se muestra a continuación:
```
select `name`, `#grade` from `student`;
```
Anteriormente a la optimización, se obtiene la plantilla SQL que se muestra a continuación:
```
SELECT `name`, `
```
Posteriormente a la optimización, se obtiene la plantilla SQL que se muestra a continuación:
```
SELECT `name`,`#grade` FROM `student`;
```
En las sentencias SQL truncadas, se descarta el contenido de los paréntesis no emparejados para reducir la cantidad de plantillas.

Adicionalmente, por ejemplo, se emplea la sentencia SQL original que se lista a continuación:
```
select `name`, `grade` from `student` where id = (select uid from 
```
Según la versión anterior, se genera la plantilla SQL que se indica a continuación:
```
select `name`, `grade` from `student` where id = (select uid from
```
Al aplicar el nuevo algoritmo, se genera la plantilla SQL que se indica a continuación:
```
SELECT `name`,`grade` FROM `student` WHERE id=
```

Se fusionan expresiones similares para evitar la expansión de plantillas.

Esta situación, por ejemplo, considera la sentencia SQL original que se indica a continuación:

SELECT 
    CASE 
        WHEN score >= 90 THEN 'A'
        WHEN score >= 80 THEN 'B'
        WHEN score >= 70 THEN 'C'
        WHEN score >= 60 THEN 'D'
        ELSE 'F'
    END AS grade
FROM 
    students;

En el estado previo, la plantilla SQL resultante es la que se presenta a continuación:

SELECT CASE  WHEN score >= ?  THEN ?  WHEN score >= ?  THEN ?  WHEN score >= ?  THEN ?  WHEN score >= ?  THEN ?  ELSE ?  END AS grade FROM students

Durante el estado optimizado, la plantilla SQL resultante es la que se presenta a continuación:

SELECT CASE WHEN score>=?  THEN ?  ELSE ?  END AS grade FROM students;

Impacto

Después de la optimización, el valor de SQLHash para un SQLText determinado cambia si llama a la operación DescribeSlowLogs o DescribeSlowLogRecords.
Tras la optimización, el valor de SqlId cambia si llama a la operación GetFullRequestStatResultByInstanceId o GetAsyncErrorRequestListByCode.