SQL Compilation
Tags: opengauss, database
Published: 2023-03-14 06:45:36

**DDL**
**·** [Proposal] In openGauss, you are advised to execute DDL operations, such as creating table or making comments, separately from batch processing jobs to avoid performance deterioration caused by many concurrent transactions.
**·** [Proposal] Execute data truncation after unlogged tables are used because openGauss cannot ensure the security of unlogged tables in abnormal scenarios.
**·** [Proposal] Suggestions on the storage mode of temporary and unlogged tables are the same as those on base tables. Create temporary tables in the same storage mode as the base tables to avoid high computing costs caused by hybrid row and column correlation.
**·** [Proposal] The total length of an index column cannot exceed 50 bytes. Otherwise, the index size will increase greatly, resulting in large storage cost and low index performance.
**·** [Proposal] Do not delete objects using **DROP…CASCADE**, unless the dependency between objects is specified. Otherwise, the objects may be deleted by mistake.
**Data Loading and Uninstalling**
**·** [Proposal] Provide the inserted column list in the insert statement. Example:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n021bhteyyky5gcojzpv.png)

**·** [Proposal] After data is imported to the database in batches or the data increment reaches the threshold, you are advised to analyze tables to prevent the execution plan from being degraded due to inaccurate statistics.

**·** [Proposal] To clear all data in a table, you are advised to use **TRUNCATE TABLE** instead of **DELETE TABLE**. **DELETE TABLE** is not efficient and cannot release disk space occupied by the deleted data.

**Type Conversion**
· [Proposal] Convert data types explicitly. If you perform implicit conversion, the result may differ from expected.
· [Proposal] During data query, explicitly specify the data type for constants, and do not attempt to perform any implicit data type conversion.
· [Notice] If **sql_compatibility** is set to **A**, null strings will be automatically converted to **NULL** during data import. If null strings need to be reserved, set **sql_compatibility** to **C**.

**Query Operation**
**·** [Proposal] Do not return a large number of result sets to a client except the ETL program. If a large result set is returned, consider modifying your service design.

**·** [Proposal] Perform DDL and DML operations encapsulated in transactions. Operations like table truncation, update, deletion, and dropping, cannot be rolled back once committed. You are advised to encapsulate such operations in transactions so that you can roll back the operations if necessary.

**·** [Proposal] During query compilation, you are advised to list all columns to be queried and avoid using **SELECT ***. Doing so reduces output lines, improves query performance, and avoids the impact of adding or deleting columns on front-end service compatibility.

**·** [Proposal] During table object access, add the schema prefix to the table object to avoid accessing an unexpected table due to schema switchover.

**·** [Proposal] The cost of joining more than three tables or views, especially full joins, is difficult to be estimated. You are advised to use the **WITH TABLE AS** statement to create interim tables to improve the readability of SQL statements.

**·** [Proposal] Avoid using Cartesian products or full joins. Cartesian products and full joins will result in a sharp expansion of result sets and poor performance.

**·** [Notice] Only **IS NULL** and **IS NOT NULL** can be used to determine NULL value comparison results. If any other method is used, **NULL** is returned. For example, **NULL** instead of expected Boolean values is returned for **NULL<>NULL, NULL=NULL**, and **NULL<>1**.

**·** [Notice] Do not use **count(col)** instead of **count(*)** to count the total number of records in a table. **count(*)** counts the NULL value (actual rows) while **count(col)** does not.

**·** [Notice] While executing **count(col)**, the number of NULL record rows is counted as 0. While executing **sum(col)**, NULL is returned if all records are **NULL**. If not all the records are NULL, the number of NULL record rows is counted as 0.

**·** [Notice] To count multiple columns using **count()**, column names must be enclosed in parentheses. For example, count ((col1, col2, col3)). Note: When multiple columns are used to count the number of NULL record rows, a row is counted even if all the selected columns are NULL. The result is the same as that when **count(*)** is executed.

**·** [Notice] NULL records are not counted when **count(distinct col)** is used to calculate the number of non-NULL columns that are not repeated.

**·** [Notice] If all statistical columns are NULL when **count(distinct (col1,col2,…))** is used to count the number of unique values in multiple columns, NULL records are also counted, and the records are considered the same.

**·** [Proposal] Use the connection operator || to replace the **concat** function for string connection because the execution plan generated by the **concat** function cannot be pushed down to disks. As a result, the query performance severely deteriorates.

**·** [Proposal] Use the following time-related macros to replace the **now** function and obtain the current time because the execution plan generated by the **now** function cannot be pushed down to disks. As a result, the query performance severely deteriorates.

Table 1 Time-related macros

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mzez5nr1irq0dvzrqa4o.png)

· [Proposal] Do not use scalar subquery statements. A scalar subquery appears in the output list of a SELECT statement. In the following example, the underlined part is a scalar subquery statement:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/if0o3m1d8rdsff2hyw1g.png)

Scalar subqueries often result in query performance deterioration. During application development, scalar subqueries need to be converted into equivalent table associations based on the service logic.

**·** [Proposal] In **WHERE** clauses, the filter conditions should be collated. The condition that few records are selected for reading (the number of filtered records is small) is listed at the beginning.

**·** [Proposal] Filter conditions in **WHERE** clauses should comply with unilateral rules, that is, to place the column name on one side of a comparison operator. In this way, the optimizer automatically performs pruning optimization in some scenarios. Filter conditions in a **WHERE** clause will be displayed in col op expression format, where col indicates a table column, op indicates a comparison operator, such as = and >, and expression indicates an expression that does not contain a column name. Example:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uch38ni87im8i04agsvp.png)

The modification is as follows:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/484nimw2dxm91sfv3eqf.png)

**·** [Proposal] Do not perform unnecessary collation operations. Collation requires a large amount of memory and CPU. If service logic permits, **ORDER BY** and **LIMIT** can be combined to reduce resource overheads. By default, openGauss perform collation by ASC & NULL LAST.

**·** [Proposal] When the **ORDER BY** clause is used for collation, specify collation modes (ASC or DESC), and use NULL FIRST or NULL LAST for NULL record sorting.

**·** [Proposal] Do not rely on only the **LIMIT** clause to return the result set displayed in a specific sequence. Combine **ORDER BY** and **LIMIT** clauses for some specific result sets and use **OFFSET** to skip specific results if necessary.

**·** [Proposal] If the service logic is accurate, you are advised to use **UNION ALL** instead of **UNION**.

**·** [Proposal] If a filter condition contains only an **OR** expression, convert the **OR **expression to **UNION ALL** to improve performance. SQL statements that use **OR** expressions cannot be optimized, resulting in slow execution. Example:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0596bb6430tm8s9u8v64.png)

Convert the statement to the following:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2f2a3jv96m7ttt3v3x4d.png)

**·** [Proposal] If an **in(val1, val2, val3…)** expression contains a large number of columns, you are advised to replace it with the **in (values (va11), (val2),(val3)…)** statement. The optimizer will automatically convert the **IN** constraint into a non-correlated subquery to improve the query performance.

**·** [Proposal] Replace **(not) in** with **(not) exist** when associated columns do not contain **NULL** values. For example, in the following query statement, if the **T1.C1** column does not contain any **NULL** value, add the **NOT NULL** constraint to the **T1.C1** column, and then rewrite the statements.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8vv0jqo494p0alaiodn9.png)

Rewrite the statement as follows:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/boookasrnuaiviwivvg3.png)

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lic10k97usntnxlqm14v.png)

**·** [Proposal] Use cursors instead of the **LIMIT OFFSET** syntax to perform pagination queries to avoid resource overheads caused by multiple executions. A cursor must be used in a transaction, and you must disable the cursor and commit the transaction once the query is finished.