ApsaraDB RDS:Compatibilidade de instâncias analíticas baseadas em DuckDB

Regras para conversão implícita de tipos em funções

Regras para conversão implícita de tipos em comparações

Instâncias analíticas baseadas em DuckDB possuem regras mais rigorosas e consistentes para conversão de tipos e comparação. No entanto, esse comportamento pode diferir do MySQL em alguns cenários:

• Conversão implícita de string para data: Quando uma string é convertida implicitamente para data, se o formato da string não puder ser analisado corretamente como um valor de data válido, a consulta SQL falhará e reportará um erro.

• Regras de comparação entre tipos inteiros: Ao comparar diferentes tipos inteiros, instâncias analíticas baseadas em DuckDB os convertem para o tipo inteiro com o maior intervalo de valores.

• Ordem de conversão de tipos para expressões com múltiplos operandos: Para expressões com múltiplos operandos, como col1 in (col2, col3, col4, ...), col1 between col2 and col3, coalesce(col1, col2, col3, ...), a conversão de tipos é realizada sequencialmente.

• Diferença de compatibilidade para o tipo YEAR: Em instâncias analíticas baseadas em DuckDB, o tipo YEAR é convertido para o tipo INTEGER para comparação, o que pode causar incompatibilidade com o MySQL. Exemplo:

  CREATE TABLE t1 (id YEAR PRIMARY KEY);
  INSERT INTO t1 VALUES (1980);
  SELECT * FROM t1 WHERE id BETWEEN 70 AND 90;
  
  # MySQL query result
  +------+
  | id   |
  +------+
  | 1980 |
  +------+
  
  # DuckDB-based analytical instance query result
  Empty set.

• Regras de conversão de string para o tipo Boolean: Instâncias analíticas baseadas em DuckDB suportam a conversão de seis strings ('1', '0', 'yes', 'no', 'true' e 'false') para o tipo BOOLEAN. Qualquer tentativa de converter outras strings resulta em erro. O MySQL converte '1' para true e todas as outras strings para false. Portanto, a seguinte instrução SQL pode retornar resultados inconsistentes:

  CREATE TABLE t1 (id INT PRIMARY KEY);
  INSERT INTO t1 VALUES (1);
  SELECT id FROM t1 WHERE 'true';
  
  # MySQL query result
  Empty set
  
  # DuckDB-based analytical instance query result
  +------+
  | id   |
  +------+
  |    1 |
  +------+

Operações numéricas

• Comparações de números de ponto flutuante podem ser incompatíveis. Exemplo:

  CREATE TABLE t1 (id FLOAT PRIMARY KEY);
  INSERT INTO t1 VALUES (1.22), (1.23), (1.24);
  SELECT * FROM t1 WHERE t1.id > 1.23;
  
  # MySQL query result
  +------+
  | id   |
  +------+
  | 1.23 |
  | 1.24 |
  +------+
  
  # DuckDB-based analytical instance query result
  +------+
  | id   |
  +------+
  | 1.24 |
  +------+

• Resultados de operações complexas com números de ponto flutuante podem ser inconsistentes devido a erros de ponto flutuante.

• Ao realizar uma operação entre tipos inteiros e DECIMAL, o resultado não deve exceder o intervalo de valores do tipo. Caso contrário, um erro de estouro pode causar falha na execução.

  CREATE TABLE t1 (id TINYINT PRIMARY KEY);
  INSERT INTO t1 VALUES (100);
  SELECT id * 2 FROM t1;
  
  # MySQL query result
  +--------+
  | id * 2 |
  +--------+
  |    200 |
  +--------+
  
  # DuckDB-based analytical instance query result
  ERROR 7577 (HY000): [DuckDB] Out of Range Error: Overflow in multiplication of INT8 (100 * 2)!.

Resultados inconsistentes causados por regras de collation

Collations da série utf8mb4_0900_xx são incompatíveis ao comparar certos caracteres de símbolos. Por exemplo:

CREATE TABLE t1 ( id varchar(20) COLLATE utf8mb4_0900_ai_ci PRIMARY KEY );
INSERT INTO t1 VALUES ('!'), ('_');
SELECT * FROM t1 ORDER BY id;

# MySQL query result
+----+
| id |
+----+
| _  |
| !  |
+----+

# DuckDB-based analytical instance query result
+----+
| id |
+----+
| !  |
| _  |
+----+

Tratamento de valores NULL em subconsultas vetoriais com IN

Em instâncias analíticas baseadas em DuckDB, o tratamento de valores NULL em subconsultas vetoriais com IN pode ser incompatível com o MySQL. Exemplo:

CREATE TABLE t1 (id INT PRIMARY KEY, col1 INT);
INSERT INTO t1 VALUES (1, 1), (2, 2);
CREATE TABLE t2 (id INT PRIMARY KEY, col1 INT);
INSERT INTO t2 VALUES (1, NULL);

select (id, col1) in (select id, col1 from t2) from t1;

# MySQL query result
+-----------------------------------------+
| (id, col1) in (select id, col1 from t2) |
+-----------------------------------------+
|                                    NULL |
|                                       0 |
+-----------------------------------------+

# DuckDB-based analytical instance query result
+-----------------------------------------+
| (id, col1) in (select id, col1 from t2) |
+-----------------------------------------+
|                                    NULL |
|                                    NULL |
+-----------------------------------------+

Para os dados (2, 2), não existe nenhum item correspondente para o prefixo vetorial na cláusula IN. Nesse caso, o MySQL retorna 0, enquanto a instância analítica baseada em DuckDB retorna NULL.

Funções de agregação

Funções numéricas

Funções numéricas não suportam o tipo BOOLEAN.

Funções de string

O DuckDB distingue estritamente entre strings binárias (como BLOB e VARBINARY) e strings (como VARCHAR, TEXT e JSON). Portanto, as seguintes limitações de uso para funções de string aplicam-se apenas a entradas de string, e não a entradas de string binária. Algumas funções que aceitam strings binárias como entrada incluem: CONCAT(), CONCAT_WS(), LENGTH(), MID(), OCTET_LENGTH(), REPEAT() e TO_BASE64(). Salvo indicação em contrário, essas funções não possuem restrições de uso.

Funções de data

Funções JSON

Funções de janela