DuckDB 分析インスタンスの互換性 - ApsaraDB RDS - Alibaba Cloud ドキュメントセンター

このトピックでは、DuckDB 分析エンジンを使用する ApsaraDB RDS for MySQL インスタンスの互換性について説明します。

サポートされているデータ型

型	MySQL データ型	互換性に関する注意
数値型	`BOOLEAN`	互換
	`TINYINT`, `TINYINT UNSIGNED`	互換
	`SMALLINT`, `SMALLINT UNSIGNED`	互換
	`INT`, `INTEGER`, `INT UNSIGNED`, `INTEGER UNSIGNED`	互換
	`BIGINT`, `BIGINT UNSIGNED`	互換
	`FLOAT`	互換
	`DOUBLE`	互換
	`DECIMAL(m,d)`	`m` は数値の最大精度です。`m<=38` の場合、型は完全に互換性があります。`m>38` の場合、データはストレージ用に `DOUBLE` 型に変換され、精度が失われる可能性があります。
文字型	`CHAR`, `VARCHAR`	UTF-8 文字セットと照合順序のみがサポートされています。
	`TINYTEXT`, `TEXT`, `MEDIUMTEXT`, `LONGTEXT`	互換
	`JSON`	互換
	`SET`	互換
	`ENUM`	互換
バイナリ文字型	`BINARY`, `VARBINARY`	互換
	`BIT`	互換
	`TINYBLOB`, `BLOB`, `MEDIUMBLOB`, `LONGBLOB`	互換
時間型	`YEAR`	互換
	`TIME`	DuckDB 分析インスタンスは、`'00:00:00'` から `'23:59:59'` までの範囲を `'HH:MM:SS'` フォーマットでサポートします。一方、MySQL は `'-838:59:59'~'838:59:59'` の範囲をサポートします。この値の範囲の違いにより、データが DuckDB 分析インスタンスでサポートされている範囲外にある場合、クエリ結果に一貫性がなくなる可能性があります。
	`DATE`	DuckDB 分析インスタンスは、`'0001-01-01'` から `'9999-12-31'` までの範囲を `'YYYY-MM-DD'` フォーマットでサポートします。 MySQL は `'0000-00-00'` から `'0001-01-01'` までの範囲をサポートします。サポートされる範囲が異なるため、DuckDB 分析インスタンスの範囲外のデータは、クエリ結果に一貫性がなくなる可能性があります。
	`DATETIME`	DuckDB 分析インスタンスは、`'0001-01-01 00:00:00.000000' UTC` から `'9999-12-31 00:00:00.999999' UTC` までの範囲を `'YYYY-MM-DD HH:MM:SS.MS'` フォーマットでサポートします。 MySQL は `'0000-00-00 00:00:00'` から `'0001-01-01 00:00:00'` までの範囲をサポートします。サポートされる範囲が異なるため、DuckDB 分析インスタンスの範囲外のデータは、クエリ結果に一貫性がなくなる可能性があります。
	`TIMESTAMP`	互換
空間データ型	`GEOMETRY`, `POINT`, `LINESTRING`, `POLYGON`, `MULTIPOINT`, `MULTILINESTRING`, `MULTIPOLYGON`, `GEOMETRYCOLLECTION`	非互換

SELECT 文の制限

コメント
# で始まるコメントはサポートされていません。例:
```
SELECT * FROM t1 #comment;
;
```
文字セット変換
ターゲットの文字セットがサポートされているかどうかに関係なく、いかなる種類の文字セット変換もサポートされていません。例:
```
SELECT convert(id using gbk) FROM t1;
SELECT cast(id AS CHAR CHARACTER SET utf8mb4) FROM t1;
```
JOIN 構文
同じ SQL 文で明示的な JOIN と暗黙的な JOIN を使用することはサポートされていません。例:
```
SELECT * FROM t1 JOIN (t2, t3);
```

間隔単位

次の間隔単位はサポートされていません。

YEAR_MONTH, DAY_HOUR, HOUR_MINUTE, DAY_MINUTE, HOUR_SECOND, DAY_SECOND, SECOND_MICROSECOND, HOUR_MICROSECOND, DAY_MICROSECOND, MINUTE_SECOND, MINUTE_MICROSECOND, SQL_TSI_HOUR

間隔式

`Interval expr unit` 式で、`expr` が非定数式の場合、その範囲を定義するために括弧で囲む必要があります。例:

# 次の SQL 文はサポートされていません。
SELECT '2018-12-31 23:59:59' + INTERVAL -1 SECOND; 
# 文を次のように書き換えます:
SELECT '2018-12-31 23:59:59' + INTERVAL (-1) SECOND;

エイリアス定義

エイリアス構文 expr 'alias' および expr "alias" はサポートされていません。例:

# サポートされていません
SELECT 1 '1';
SELECT 1 "1";
# 文を次のように書き換えることができます:
SELECT 1 AS '1';
SELECT 1 AS "1";
SELECT 1 AS `1`;
SELECT 1 `1`;
# 上記の SQL 文は同等です。

エイリアスがキーワードの場合、`AS` またはバックティックを使用する必要があります。例:

SELECT id time FROM t1;

# 文を次のように書き換えます:
SELECT id AS time FROM t1;
SELECT id `time` FROM t1;
SELECT id AS `time` FROM t1;
SELECT id AS 'time' FROM t1;
SELECT id AS "time" FROM t1;

サブクエリ
非スカラーサブクエリとの等価比較はサポートされていません。例:
```
SELECT * FROM t1 WHERE (id, col1) = (SELECT id, col1 FROM t1);
```
データ型変換
BINARY(num)、SIGNED、または UNSIGNED データ型への明示的な変換はサポートされていません。例:
```
SELECT CAST('abc' AS binary(1));
SELECT CAST(1 AS SIGNED);
SELECT CAST(1 AS UNSIGNED);
```
列修飾子
列名の `Binary` 修飾子はサポートされていません。例:
```
SELECT binary id FROM t1;
```

複雑な算術式

複雑な算術式では、括弧を使用して操作の順序を指定し、解析エラーを防ぎます。

# 記号 (!=-) は DuckDB 分析インスタンスで正しく解析できません。
SELECT 1 !=-1;
# 文を次のように書き換えることをお勧めします:
SELECT 1 != (-1);

# 記号 (--) は DuckDB 分析インスタンスで正しく解析できません。
SELECT --1;
# 文を次のように書き換えることをお勧めします:
SELECT -(-1);

型変換の問題

実行効率を確保するため、DuckDB 分析インスタンスは厳密な型システムを使用します。クエリの実行中、システムはコンテキストに基づいて自動的に型変換を実行します。このプロセスは暗黙の型変換と呼ばれます。暗黙の変換が不可能なシナリオでは、CAST または CONVERT 関数を使用して明示的に型変換を指定する必要があります。これにより、クエリが正しく実行されることが保証されます。

関数における暗黙の型変換ルール

説明

/ 記号は、暗黙の型変換が関与しないことを示します。✔️ 記号は、暗黙の型変換がサポートされていることを示します。✖️ 記号は、暗黙の型変換がサポートされていないことを示します。
通常文字列型は、MySQL の型 CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT、JSON、SET、および ENUM を指します。
バイナリ文字列型は、MySQL の型 BINARY、VARBINARY、BIT、TINYBLOB、BLOB、MEDIUMBLOB、および LONGBLOB を指します。
より大きな範囲を持つ整数型をより小さな範囲を持つ整数型に変換することはサポートされていません。

基本スカラー型への変換

ソース型		基本スカラー型への暗黙の変換
ソース型		文字列リテラル	数値リテラル
基本スカラー	文字列リテラル	/	✖️
基本スカラー	数値リテラル	✖️	/
数値	BOOLEAN	✖️	✖️
	整数型	✖️	✖️
	FLOAT	✖️	✖️
	DOUBLE	✖️	✖️
	DECIMAL	✖️	✖️
文字列	通常の文字列	✖️	✖️
文字列	バイナリ文字列	✖️	✖️
日付と時刻	YEAR	✖️	✖️
	DATE	✖️	✖️
	TIME	✖️	✖️
	DATETIME	✖️	✖️
	TIMESTAMP	✖️	✖️

数値型への変換

ソース型		数値型への暗黙の変換
ソース型		BOOLEAN	整数型	FLOAT	DOUBLE	DECIMAL
基本スカラー	文字列リテラル	✖️	✖️	✖️	✔️	✖️
基本スカラー	数値リテラル	✖️	✔️	✔️	✔️	✔️
数値	BOOLEAN	/	✖️	✖️	✖️	✖️
	整数型	✖️	/	✔️	✔️	✔️
	FLOAT	✖️	✔️: BIGINT への変換のみサポートされています。	/	✔️	✖️
	DOUBLE	✖️	✔️: BIGINT への変換のみサポートされています。	✖️	/	✖️
	DECIMAL	✖️	✔️	✔️	✔️	/
文字列	通常の文字列	✖️	✖️	✖️	✔️	✖️
文字列	バイナリ文字列	✖️	✖️	✖️	✖️	✖️
日付と時刻	YEAR	✖️	✔️	✔️	✔️	✔️
	DATE	✖️	✖️	✖️	✔️	✖️
	TIME	✖️	✖️	✖️	✔️	✖️
	DATETIME	✖️	✖️	✖️	✔️	✖️
	TIMESTAMP	✖️	✖️	✖️	✔️	✖️

文字列型への変換

ソース型		文字列型への暗黙の変換
ソース型		通常の文字列	バイナリ文字列
基本スカラー	文字列リテラル	✔️	✖️
基本スカラー	数値リテラル	✖️	✖️
数値	BOOLEAN	✖️	✖️
	整数型	✔️	✖️
	FLOAT	✔️	✖️
	DOUBLE	✔️	✖️
	DECIMAL	✔️	✖️
文字列	通常の文字列	/	✖️
文字列	バイナリ文字列	✖️	/
日付と時刻	YEAR	✔️	✖️
	DATE	✔️	✖️
	TIME	✔️	✖️
	DATETIME	✔️	✖️
	TIMESTAMP	✔️	✖️

日付と時刻型への変換

ソース型		日付と時刻型への暗黙の変換
ソース型		YEAR	DATE	TIME	DATETIME	TIMESTAMP
基本スカラー	文字列リテラル	✖️	✖️	✖️	✖️	✖️
基本スカラー	数値リテラル	✔️	✖️	✖️	✖️	✖️
数値	BOOLEAN	✖️	✖️	✖️	✖️	✖️
	整数型	✖️	✖️	✖️	✖️	✖️
	FLOAT	✖️	✖️	✖️	✖️	✖️
	DOUBLE	✖️	✖️	✖️	✖️	✖️
	DECIMAL	✖️	✖️	✖️	✖️	✖️
文字列	通常の文字列	✖️	✖️	✖️	✖️	✖️
文字列	バイナリ文字列	✖️	✖️	✖️	✖️	✖️
日付と時刻	YEAR	/	✖️	✖️	✖️	✖️
	DATE	✖️	/	✖️	✔️	✔️
	TIME	✖️	✖️	/	✔️	✔️
	DATETIME	✖️	✖️	✖️	/	✔️
	TIMESTAMP	✖️	✖️	✖️	✔️	/

比較における暗黙の型変換ルール

DuckDB 分析インスタンスには、型変換と比較に関してより厳密で一貫性のあるルールがあります。ただし、一部のシナリオでは MySQL と動作が異なる場合があります。違いは次のとおりです:

文字列から日付への暗黙の型変換: 文字列が暗黙的に日付に変換される際、文字列フォーマットが有効な日付値に解析できない場合、SQL クエリは失敗し、エラーを返します。
整数型間の比較ルール: 異なる整数型が比較される場合、DuckDB 分析インスタンスはそれらをより大きな値の範囲を持つ整数型に変換します。
複数要素式の型変換順序: col1 in (col2, col3, col4, ...)、col1 between col2 and col3、および coalesce(col1, col2, col3, ...) のような複数要素式の場合、型変換は順次実行されます。

YEAR 型の互換性の違い: DuckDB 分析インスタンスでは、YEAR 型は比較のために INTEGER 型に変換されます。この動作は MySQL との非互換性を引き起こす可能性があります。例:

CREATE TABLE t1 (id YEAR PRIMARY KEY);
INSERT INTO t1 VALUES (1980);
SELECT * FROM t1 WHERE id BETWEEN 70 AND 90;

# MySQL クエリ結果
+------+
| id   |
+------+
| 1980 |
+------+

# DuckDB 分析インスタンスのクエリ結果
Empty set.

ブール値型の文字列変換ルール: DuckDB 分析インスタンスは、文字列 '1'、'0'、'yes'、'no'、'true'、および 'false' の BOOLEAN 型への変換をサポートします。他の文字列を変換しようとするとエラーが返されます。対照的に、MySQL は '1' を true に変換し、他のすべての文字列を false に変換します。したがって、次の SQL 文は一貫性のない結果を生成する可能性があります:
```
CREATE TABLE t1 (id INT PRIMARY KEY);
INSERT INTO t1 VALUES (1);
SELECT id FROM t1 WHERE 'true';

# MySQL クエリ結果
Empty set

# DuckDB 分析インスタンスのクエリ結果
+------+
| id   |
+------+
|    1 |
+------+
```

説明

異なる型のデータが比較される場合、システムは比較を実行する前に、次の表のルールに従ってデータを同じ型に変換します。サポートされていない比較 (✖️) の場合、エラーが返されます。
通常文字列型は、MySQL の型 CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT、JSON、SET、および ENUM を指します。
バイナリ文字列型は、MySQL の型 BINARY、VARBINARY、BIT、TINYBLOB、BLOB、MEDIUMBLOB、および LONGBLOB を指します。

基本スカラー型との比較

ソース型		基本スカラー型との比較
ソース型		文字列リテラル	数値リテラル
基本スカラー	文字列リテラル	文字列	数値リテラル
基本スカラー	数値リテラル	数値リテラル	より大きな範囲を持つ数値型
数値	BOOLEAN	BOOLEAN	より大きな範囲を持つ数値型
	整数型	整数型	より大きな範囲を持つ数値型
	FLOAT	FLOAT	より大きな範囲を持つ数値型
	DOUBLE	DOUBLE	より大きな範囲を持つ数値型
	DECIMAL	DECIMAL	より大きな範囲を持つ数値型
文字列	通常の文字列	通常の文字列	数値リテラル
文字列	バイナリ文字列	バイナリ文字列	✖️
日付と時刻	YEAR	YEAR	より大きな範囲を持つ数値型
	DATE	DATETIME	✖️
	TIME	TIME	✖️
	DATETIME	DATETIME	✖️
	TIMESTAMP	TIMESTAMP	✖️

数値型との比較

ソース型		数値型との比較
ソース型		BOOLEAN	整数型	FLOAT	DOUBLE	DECIMAL
基本スカラー	文字列リテラル	BOOLEAN	整数型	FLOAT	DOUBLE	DECIMAL
基本スカラー	数値リテラル	より大きな範囲を持つ数値型	より大きな範囲を持つ数値型	より大きな範囲を持つ数値型	より大きな範囲を持つ数値型	より大きな範囲を持つ数値型
数値	BOOLEAN	BOOLEAN	整数型	FLOAT (不等式比較 ✖️)	DOUBLE (不等式比較 ✖️)	DECIMAL (不等式比較 ✖️)
	整数型	整数型	整数型	FLOAT	DOUBLE	DECIMAL
	FLOAT	FLOAT (不等式比較 ✖️)	FLOAT	FLOAT	DOUBLE	FLOAT
	DOUBLE	DOUBLE (不等式比較 ✖️)	DOUBLE	DOUBLE	DOUBLE	DOUBLE
	DECIMAL	DECIMAL (不等式比較 ✖️)	DECIMAL	FLOAT	DOUBLE	DECIMAL
文字列	通常の文字列	BOOLEAN	整数型	FLOAT	DOUBLE	DECIMAL
文字列	バイナリ文字列	✖️	✖️	✖️	✖️	✖️
日付と時刻	YEAR	INTEGER	より大きな範囲を持つ数値型	FLOAT	DOUBLE	DECIMAL
	DATE	✖️	✖️	✖️	DOUBLE	✖️
	TIME	✖️	✖️	✖️	DOUBLE	✖️
	DATETIME	✖️	✖️	✖️	DOUBLE	✖️
	TIMESTAMP	✖️	✖️	✖️	DOUBLE	✖️

文字列型との比較

ソース型		文字列型との比較
ソース型		通常の文字列	バイナリ文字列
基本スカラー	文字列リテラル	通常の文字列	バイナリ文字列
基本スカラー	数値リテラル	数値リテラル	✖️
数値	BOOLEAN	BOOLEAN	✖️
	整数型	整数型	✖️
	FLOAT	FLOAT	✖️
	DOUBLE	DOUBLE	✖️
	DECIMAL	DECIMAL	✖️
文字列	通常の文字列	通常の文字列	バイナリ文字列
文字列	バイナリ文字列	バイナリ文字列	バイナリ文字列
日付と時刻	YEAR	INTEGER	✖️
	DATE	DATE	✖️
	TIME	TIME	✖️
	DATETIME	DATETIME	✖️
	TIMESTAMP	TIMESTAMP	✖️

日付と時刻型との比較

ソース型		日付と時刻型との比較
ソース型		YEAR	DATE	TIME	DATETIME	TIMESTAMP
基本スカラー	文字列リテラル	YEAR	DATETIME	TIME	DATETIME	TIMESTAMP
基本スカラー	数値リテラル	より大きな範囲を持つ数値型	✖️	✖️	✖️	✖️
数値	BOOLEAN	INTEGER	✖️	✖️	✖️	✖️
	整数型	より大きな範囲を持つ数値型	✖️	✖️	✖️	✖️
	FLOAT	FLOAT	✖️	✖️	✖️	✖️
	DOUBLE	DOUBLE	DOUBLE	DOUBLE	DOUBLE	DOUBLE
	DECIMAL	DECIMAL	✖️	✖️	✖️	✖️
文字列	通常の文字列	INTEGER	DATE	TIME	DATETIME	TIMESTAMP
文字列	バイナリ文字列	✖️	✖️	✖️	✖️	✖️
日付と時刻	YEAR	INTEGER	✖️	✖️	✖️	✖️
	DATE	✖️	DATE	✖️	DATETIME	TIMESTAMP
	TIME	✖️	✖️	TIME	✖️	✖️
	DATETIME	✖️	DATETIME	✖️	DATETIME	DATETIME
	TIMESTAMP	✖️	TIMESTAMP	✖️	DATETIME	TIMESTAMP

クエリ結果の潜在的な不整合

数値演算

浮動小数点数の比較には非互換性があります。例:

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 クエリ結果
+------+
| id   |
+------+
| 1.23 |
| 1.24 |
+------+

# DuckDB 分析インスタンスのクエリ結果
+------+
| id   |
+------+
| 1.24 |
+------+

浮動小数点数に対する複雑な複合演算の結果は、浮動小数点エラーのために一貫性がない場合があります。

整数型と DECIMAL 型の間で演算を実行する場合、結果は型の値の範囲を超えることはできません。超えた場合、オーバーフローにより実行が失敗する可能性があります。

CREATE TABLE t1 (id TINYINT PRIMARY KEY);
INSERT INTO t1 VALUES (100);
SELECT id * 2 FROM t1;

# MySQL クエリ結果
+--------+
| id * 2 |
+--------+
|    200 |
+--------+

# DuckDB 分析インスタンスのクエリ結果
ERROR 7577 (HY000): [DuckDB] Out of Range Error: Overflow in multiplication of INT8 (100 * 2)!.

照合順序ルールによる不整合

utf8mb4_0900_xx シリーズの照合順序は、一部の記号文字を比較する際に非互換です。例:

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

# MySQL クエリ結果
+----+
| id |
+----+
| _  |
| !  |
+----+

# DuckDB 分析インスタンスのクエリ結果
+----+
| id |
+----+
| !  |
| _  |
+----+

IN を使用したベクトルサブクエリにおける NULL 値の処理

DuckDB 分析インスタンスでは、`IN` を使用したベクターサブクエリが NULL 値を処理する方法に非互換性があります。例:

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 クエリ結果
+-----------------------------------------+
| (id, col1) in (select id, col1 from t2) |
+-----------------------------------------+
|                                    NULL |
|                                       0 |
+-----------------------------------------+

# DuckDB 分析インスタンスのクエリ結果
+-----------------------------------------+
| (id, col1) in (select id, col1 from t2) |
+-----------------------------------------+
|                                    NULL |
|                                    NULL |
+-----------------------------------------+

データ (2, 2) について、`IN` の後に一致するベクタープレフィックスがありません。MySQL は 0 を返しますが、DuckDB 分析インスタンスは NULL を返します。

関数の制限

集約関数

関数名	サポートされている	制限
`AVG`	はい	制限なし
`BIT_AND`	はい	文字列型、DECIMAL 型、および日付型はサポートされていません。
`BIT_OR`	はい	文字列型、DECIMAL 型、および日付型はサポートされていません。
`BIT_XOR`	はい	文字列型、DECIMAL 型、および日付型はサポートされていません。
`COUNT`	はい	制限なし
`COUNT(DISTINCT)`	はい	制限なし
`GROUP_CONCAT`	はい	複数列の `GROUP_CONCAT` と `SEPARATOR` はサポートされていません。
`JSON_ARRAYAGG`	いいえ	N/A
`JSON_OBJECTAGG`	いいえ	N/A
`MAX`	はい	制限なし
`MIN`	はい	制限なし
`STD`	はい	制限なし
`STDDEV`	はい	制限なし
`STDDEV_POP`	はい	制限なし
`STDDEV_SAMP`	はい	制限なし
`SUM`	はい	制限なし
`VAR_POP`	はい	制限なし
`VAR_SAMP`	はい	制限なし
`VARIANCE`	はい	制限なし

数値関数

数値関数は BOOLEAN 型をサポートしていません。

関数名	サポートされている	制限
`%`	はい	制限なし
`MOD`	はい	制限なし
`*`	はい	制限なし
`+`	はい	制限なし
`-`	はい	制限なし
`/`	はい	制限なし
`ABS()`	はい	制限なし
`ACOS()`	はい	制限なし
`ASIN()`	はい	制限なし
`ATAN()`	はい	`ATAN(y, x)` はサポートされていません。
`ATAN2()`	いいえ	N/A
`CEIL()`	はい	制限なし
`CEILING()`	はい	制限なし
`CONV()`	いいえ	N/A
`COS()`	はい	制限なし
`COT()`	はい	制限なし
`CRC32()`	いいえ	N/A
`DEGREES()`	はい	制限なし
`DIV`	はい	制限なし
`EXP()`	はい	制限なし
`FLOOR()`	はい	制限なし
`LN()`	はい	制限なし
`LOG()`	はい	制限なし
`LOG10()`	はい	制限なし
`LOG2()`	はい	制限なし
`MOD()`	はい	制限なし
`PI()`	はい	制限なし
`POW()`	はい	制限なし
`POWER()`	はい	制限なし
`RADIANS()`	はい	制限なし
`RAND()`	はい	制限なし
`ROUND()`	はい	制限なし
`SIGN()`	はい	制限なし
`SIN()`	はい	制限なし
`SQRT()`	はい	制限なし
`TAN()`	はい	制限なし
`TRUNCATE()`	いいえ	N/A

文字列関数

DuckDB 分析インスタンスは、BLOB や VARBINARY などのバイナリ文字列と、VARCHAR、TEXT、JSON などの通常文字列を厳密に区別します。したがって、次の文字列関数は入力として通常文字列のみを受け入れ、バイナリ文字列は受け入れません。バイナリ文字列を受け入れることができる関数については、特別な注意が記載されています。

関数名	サポートされている	制限
`ASCII()`	はい	制限なし
`BIN()`	はい	MySQL では、`BIN('')` は NULL を返します。DuckDB 分析インスタンスでは、`'0'` を返します。
`BIT_LENGTH()`	はい	制限なし
`CHAR()`	いいえ	N/A
`CHAR_LENGTH()`	はい	制限なし
`CHARACTER_LENGTH()`	はい	制限なし
`CONCAT()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`CONCAT_WS()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`ELT()`	いいえ	N/A
`EXPORT_SET()`	いいえ	N/A
`FIELD()`	いいえ	N/A
`FIND_IN_SET()`	はい	この関数の最初のパラメーターは文字型でなければなりません。非文字型は MySQL と一致しない結果を生成する可能性があります。
`FORMAT()`	いいえ	N/A
`FROM_BASE64()`	はい	この関数は Base64 デコードルールを使用します。デコードに失敗した場合、エラーが返されます。
`HEX()`	はい	制限なし
`INSERT()`	はい	制限なし
`INSTR()`	はい	制限なし
`LCASE()`	はい	制限なし
`LEFT()`	はい	制限なし
`LENGTH()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`LIKE`	はい	`LIKE` は照合順序ルールの影響を受けません。
`LOAD_FILE()`	いいえ	N/A
`LOCATE()`	はい	制限なし
`LOWER()`	はい	制限なし
`LPAD()`	はい	制限なし
`LTRIM()`	はい	制限なし
`MAKE_SET()`	いいえ	N/A
`MATCH()`	いいえ	N/A
`MID()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`NOT LIKE`	はい	`NOT LIKE` 関数は照合順序ルールの影響を受けません。
`NOT REGEXP`	いいえ	N/A
`OCT()`	はい	MySQL では、`OCT('')` は NULL を返します。DuckDB 分析インスタンスでは、`'0'` を返します。
`OCTET_LENGTH()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`ORD()`	はい	制限なし
`POSITION()`	はい	制限なし
`QUOTE()`	いいえ	N/A
`REGEXP`	いいえ	N/A
`REGEXP_INSTR()`	いいえ	N/A
`REGEXP_LIKE()`	いいえ	N/A
`REGEXP_REPLACE()`	いいえ	N/A
`REGEXP_SUBSTR()`	いいえ	N/A
`REPEAT()`	はい: バイナリ文字列を入力として受け入れることができます。	制限なし
`REPLACE()`	はい	制限なし
`REVERSE()`	はい	制限なし
`RIGHT()`	はい	制限なし
`RLIKE`	いいえ	N/A
`RPAD()`	はい	制限なし
`RTRIM()`	はい	制限なし
`SOUNDEX()`	いいえ	N/A
`SOUNDEX LIKE`	いいえ	N/A
`SPACE()`	はい	制限なし
`STRCMP()`	はい	制限なし
`SUBSTR()`	はい	構文 `SUBSTR(str FROM pos)` および `SUBSTR(str FROM pos FOR len)` はサポートされていません。
`SUBSTRING()`	はい	構文 `SUBSTRING(str FROM pos)` および `SUBSTRING(str FROM pos FOR len)` はサポートされていません。
`SUBSTRING_INDEX()`	はい	制限なし
`TO_BASE64()`	はい: バイナリ文字列を入力として受け入れることができます。	この関数はバイナリ文字列を返します。
`TRIM()`	はい	制限なし
`UCASE()`	はい	制限なし
`UNHEX()`	はい	この関数はバイナリ文字列を返します。 16 進数以外の数字が検出された場合、エラーが返されます。
`UPPER()`	はい	制限なし
`WEIGHT_STRING()`	いいえ	N/A

日付関数

DuckDB 分析インスタンスの日付関数は、現在、入力として文字列を受け付けません。まず明示的な型変換を実行する必要があります。例えば:

テーブル内の文字列型の列の場合:

SELECT ADDDATE(CAST(varchar_test as TIME), INTERVAL 1 DAY) FROM t1;
SELECT ADDDATE(CAST(varchar_test as DATE), INTERVAL 1 DAY) FROM t1;
SELECT ADDDATE(CAST(varchar_test as DATETIME), INTERVAL 1 DAY) FROM t1;

文字列リテラル定数の場合：

SELECT ADDDATE(TIME '12:00:00', INTERVAL 1 DAY) FROM t1;
SELECT ADDDATE(DATE '2020-01-01', INTERVAL 1 DAY) FROM t1;
SELECT ADDDATE(TIMESTAMP '2020-01-01 12:00:00', INTERVAL 1 DAY) FROM t1;

関数名	サポートされている	制限
`ADDDATE()`	はい	`ADDDATE` 関数の最初のパラメーターが `ADDDATE(TIME '12:00:00', INTERVAL 1 HOUR)` のように `TIME` 型の場合、この関数は計算のために `TIME` から `TIMESTAMP` への暗黙の型変換を実行します。この暗黙の型変換を避けるには、`DATE_ADD` 関数を使用します。
`ADDTIME()`	はい	戻り値が DuckDB 分析インスタンスの時間データ型の有効値を超えた場合、結果に一貫性がなくなります。
`CONVERT_TZ()`	はい	制限なし
`CURRENT_DATE()，CURRENT_DATE`	はい	制限なし
`CURRENT_TIME()，CURRENT_TIME`	はい	制限なし
`CURRENT_TIMESTAMP()，CURRENT_TIMESTAMP`	はい	制限なし
`CURTIME()`	はい	制限なし
`DATE()`	はい	制限なし
`DATE_ADD()`	はい	`DATE_ADD` 関数の最初のパラメーターが `DATE_ADD(TIME '12:00:00', INTERVAL 1 HOUR)` のように `TIME` 型の場合、この関数は `TIME` から `TIMESTAMP` への暗黙の型変換を実行しません。
`DATE_FORMAT()`	はい	`%X`、`%V`、および `%u` フォーマット指定子はサポートされていません。
`DATE_SUB()`	はい	`DATE_ADD()` と同じです。
`DATEDIFF()`	はい	制限なし
`DAY()`	はい	制限なし
`DAYNAME()`	はい	制限なし
`DAYOFMONTH()`	はい	制限なし
`DAYOFWEEK()`	はい	制限なし
`DAYOFYEAR()`	はい	制限なし
`EXTRACT()`	はい	制限なし
`FROM_DAYS()`	はい	制限なし
`FROM_UNIXTIME()`	はい	制限なし
`GET_FORMAT()`	いいえ	該当なし
`HOUR()`	はい	制限なし
`LAST_DAY`	はい	制限なし
`LOCALTIME()，LOCALTIME`	はい	制限なし
`LOCALTIMESTAMP，LOCALTIMESTAMP()`	はい	制限なし
`MAKEDATE()`	はい	制限なし
`MAKETIME()`	はい	制限なし
`MICROSECOND()`	はい	制限なし
`MINUTE()`	はい	制限なし
`MONTH()`	はい	制限なし
`MONTHNAME()`	はい	制限なし
`NOW()`	はい	制限なし
`PERIOD_ADD()`	はい	9999 を超える年はサポートされていません。
`PERIOD_DIFF()`	はい	9999 を超える年はサポートされていません。
`QUARTER()`	はい	制限なし
`SEC_TO_TIME()`	はい	戻り値が DuckDB 分析インスタンスの時間データ型の範囲を超えた場合、結果に一貫性がなくなります。
`SECOND()`	はい	制限なし
`STR_TO_DATE()`	はい	`%X`、`%V`、および `%u` フォーマット指定子はサポートされていません。 `format specifier` が正しく一致しない場合、関数は NULL を返します。
`SUBDATE()`	はい	`ADDDATE()` と同じです。
`SUBTIME()`	はい	戻り値が DuckDB 分析インスタンスの時間データ型の範囲を超えた場合、結果に一貫性がなくなります。
`SYSDATE()`	はい	制限なし
`TIME()`	いいえ	該当なし
`TIME_FORMAT()`	はい	制限なし
`TIME_TO_SEC()`	はい	DAY TIME フォーマットの入力はサポートされていません。例: `select time_to_sec('1 12:00:00');`
`TIMEDIFF()`	いいえ	該当なし
`TIMESTAMP()`	いいえ	該当なし
`TIMESTAMPADD()`	はい	制限なし
`TIMESTAMPDIFF()`	はい	制限なし
`TO_DAYS()`	はい	制限なし
`TO_SECONDS()`	はい	制限なし
`UNIX_TIMESTAMP()`	はい	制限なし
`UTC_DATE()`	はい	制限なし
`UTC_TIME()`	はい	制限なし
`UTC_TIMESTAMP()`	はい	制限なし
`WEEK()`	はい	制限なし
`WEEKDAY()`	はい	制限なし
`WEEKOFYEAR()`	はい	制限なし
`YEAR()`	はい	制限なし
`YEARWEEK()`	はい	制限なし

JSON 関数

関数名	サポート	制限
`JSON_ARRAY()`	はい	制限なし
`JSON_ARRAY_APPEND()`	いいえ	該当なし
`JSON_ARRAY_INSERT()`	いいえ	該当なし
`JSON_CONTAINS()`	いいえ	該当なし
`JSON_CONTAINS_PATH()`	いいえ	該当なし
`JSON_DEPTH()`	はい	制限なし
`JSON_EXTRACT()`	はい	制限なし
`JSON_INSERT()`	いいえ	該当なし
`JSON_KEYS()`	はい	制限なし
`JSON_LENGTH()`	はい	制限なし
`JSON_MERGE()`	いいえ	該当なし
`JSON_MERGE_PATCH()`	はい	2 つの JSON オブジェクトのマージのみをサポートします。マージされた JSON オブジェクトのフィールドの順序は、MySQL の順序とは異なる場合があります。
`JSON_MERGE_PRESERVE()`	いいえ	該当なし
`JSON_OBJECT()`	はい	制限なし
`JSON_OVERLAPS()`	はい	制限なし
`JSON_PRETTY()`	はい	制限なし
`JSON_QUOTE()`	はい	制限なし
`JSON_REMOVE()`	いいえ	該当なし
`JSON_REPLACE()`	いいえ	該当なし
`JSON_SCHEMA_VALID()`	いいえ	該当なし
`JSON_SCHEMA_VALIDATION_REPORT()`	いいえ	該当なし
`JSON_SEARCH()`	いいえ	該当なし
`JSON_SET()`	いいえ	該当なし
`JSON_STORAGE_FREE()`	いいえ	該当なし
`JSON_STORAGE_SIZE()`	いいえ	該当なし
`JSON_TABLE()`	いいえ	該当なし
`JSON_TYPE()`	いいえ	該当なし
`JSON_UNQUOTE()`	いいえ	該当なし
`JSON_VALID()`	はい	制限なし
`JSON_VALUE()`	いいえ	該当なし
`MEMBER OF()`	いいえ	該当なし

ウィンドウ関数

関数名	サポート	制限
`CUME_DIST()`	はい	制限なし
`DENSE_RANK()`	はい	制限なし
`FIRST_VALUE()`	はい	制限なし
`LAG()`	はい	制限なし
`LAST_VALUE()`	はい	制限なし
`LEAD()`	はい	制限なし
`NTH_VALUE()`	はい	制限なし
`NTILE()`	はい	制限なし
`PERCENT_RANK()`	はい	制限なし
`RANK()`	はい	制限なし
`ROW_NUMBER()`	はい	制限なし

その他の制限

DuckDB 分析インスタンスはビュークエリをサポートしていません。