Snowflake SQL 转换指南

本文档详细介绍了 Snowflake 和 BigQuery 在 SQL 语法上的异同，有助于加快将 EDW（企业数据仓库）迁移至 BigQuery 的规划和执行过程。Snowflake 数据仓储系统旨在与 Snowflake 专属 SQL 语法协同工作。由于各服务之间的 SQL 方言存在差异，您可能需要修改为 Snowflake 编写的脚本，然后才能在 BigQuery 中使用它们。使用批量 SQL 转换来批量迁移 SQL 脚本，或使用交互式 SQL 转换来转换临时查询。 两个预览版的工具都支持 Snowflake SQL。

注意：在某些情况下，Snowflake 与 BigQuery 中的 SQL 元素之间不存在直接对应关系。但是，在大多数情况下，您可使用替代方法在 BigQuery 中实现能在 Snowflake 中实现的功能，如本文档中的示例所示。

数据类型

本部分介绍 Snowflake 和 BigQuery 中各种数据类型的等效项。

Snowflake	BigQuery	备注
NUMBER/ DECIMAL/NUMERIC	NUMERIC	Snowflake 中的 NUMBER 数据类型支持 38 位精度和 37 位标度。精度和标度均可由用户指定。 BigQuery 支持 NUMERIC 和 BIGNUMERIC，并在一定范围内酌情指定精度和小数位数。
INT/INTEGER	BIGNUMERIC	INT/INTEGER 和其他所有类似 INT 的数据类型，例如 BIGINT, TINYINT, SMALLINT, BYTEINT 表示 NUMBER 数据类型的别名，其中无法指定精度和比例，并且始终为 NUMBER(38, 0)
BIGINT	BIGNUMERIC
SMALLINT	BIGNUMERIC
TINYINT	BIGNUMERIC
BYTEINT	BIGNUMERIC
FLOAT/ FLOAT4/ FLOAT8	FLOAT64	Snowflake 中的 FLOAT 数据类型采用“> X”的模式建立“NaN”，其中 X 是任意的 FLOAT 值（“NaN”本身除外）。 BigQuery 中的 FLOAT 数据类型采用“< X”的模式建立“NaN”，其中 X 是任意的 FLOAT 值（“NaN”本身除外）。
DOUBLE/ DOUBLE PRECISION/ REAL	FLOAT64	Snowflake 中的 DOUBLE 数据类型与 Snowflake 中的 FLOAT 数据类型含义相同，因此通常会被错误地显示为 FLOAT。但在存储时，该数据类型会被正确地存储为 DOUBLE。
VARCHAR	STRING	Snowflake 中的 VARCHAR 数据类型的最大长度为 16 MB（未压缩）。如果未指定长度，则默认为最大长度。 BigQuery 中的 STRING 数据类型作为 UTF-8 编码的可变长度 Unicode 进行存储。最大长度为 16,000 个字符。
CHAR/CHARACTER	STRING	Snowflake 中的 CHAR 数据类型的最大长度为 1。
STRING/TEXT	STRING	Snowflake 中的 STRING 数据类型与 Snowflake 的 VARCHAR 含义相同。
BINARY	BYTES
VARBINARY	BYTES
BOOLEAN	BOOL	BigQuery 中的 BOOL 数据类型仅接受 TRUE/FALSE；Snowflake 中的 BOOL 数据类型则不同，它可以接受 TRUE/FALSE/NULL。
DATE	DATE	Snowflake 中的 DATE 类型可接受大多数常见日期格式；BigQuery 中的 DATE 类型则不同，它仅接受采用“YYYY-[M]M-[D]D”格式的日期。
TIME	TIME	Snowflake 中的 TIME 类型支持 0 至 9 纳秒的精度，而 BigQuery 中的 TIME 类型支持 0 至 6 纳秒的精度。
TIMESTAMP	DATETIME	TIMESTAMP 是用户可配置的别名，默认为 TIMESTAMP_NTZ，映射到 BigQuery 中的 DATETIME。
TIMESTAMP_LTZ	TIMESTAMP
TIMESTAMP_NTZ/DATETIME	DATETIME
TIMESTAMP_TZ	TIMESTAMP
OBJECT	JSON	Snowflake 中的 OBJECT 类型不支持具有明确类型的值。值均为 VARIANT 类型。
VARIANT	JSON	Snowflake 中的 OBJECT 类型不支持具有明确类型的值。值均为 VARIANT 类型。
ARRAY	ARRAY<JSON>	Snowflake 中的 ARRAY 类型仅支持 VARIANT 类型，而 BigQuery 中的 ARRAY 类型可支持除数组本身之外的所有数据类型。

BigQuery 还具有以下数据类型，这些数据类型在 Snowflake 中没有直接的对应项：

• DATETIME
• GEOGRAPHY

查询语法和查询运算符

本部分介绍了 Snowflake 与 BigQuery 在查询语法上的差异。

SELECT 语句

大多数 Snowflake SELECT 语句都与 BigQuery 兼容。下表列出了一些细微差异。

Snowflake		BigQuery
SELECT TOP ... FROM table		SELECT expression FROM table ORDER BY expression DESC LIMIT number
SELECT x/total AS probability, ROUND(100 * probability, 1) AS pct FROM raw_data 注意：Snowflake 支持在同一 SELECT 语句中创建和引用别名。		SELECT x/total AS probability, ROUND(100 * (x/total), 1) AS pct FROM raw_data
SELECT * FROM ( VALUES (1), (2), (3) )		SELECT AS VALUE STRUCT(1, 2, 3)

默认情况下，Snowflake 别名和标识符不区分大小写。如需保留大小写，可以使用英文双引号 (") 将别名和标识符括起来。

此外，BigQuery 支持在 SELECT 语句中使用以下表达式，这些表达式没有 Snowflake 等效项：

• EXCEPT
• REPLACE

FROM 子句

查询中的 FROM 子句指定可在 SELECT 语句中使用的表、视图、子查询或表函数。BigQuery 支持所有这些表引用。

下表列出了一些细微差异。

Snowflake		BigQuery
SELECT $1, $2 FROM (VALUES (1, 'one'), (2, 'two'));		WITH table1 AS ( SELECT STRUCT(1 as number, 'one' as spelling) UNION ALL SELECT STRUCT(2 as number, 'two' as spelling) ) SELECT * FROM table1
SELECT* FROM table SAMPLE(10)		SELECT* FROM table TABLESAMPLE BERNOULLI (0.1 PERCENT)
SELECT * FROM table1 AT(TIMESTAMP => timestamp) SELECT * FROM table1 BEFORE(STATEMENT => statementID)		SELECT * FROM table FOR SYSTEM_TIME AS OF timestamp 注意：对于 Snowflake 中使用语句 ID 的 BEFORE 函数，BigQuery 没有直接的对应项。“timestamp”的值不得早于当前时间戳之前 7 天。
@[namespace]<stage_name>[/path]		BigQuery 不支持暂存文件的概念。
SELECT* FROM table START WITH predicate CONNECT BY [PRIOR] col1 = [PRIOR] col2 [, ...] ...		对于 Snowflake 中的 CONNECT BY，BigQuery 没有直接的对应项。

您可以通过以下方法在 FROM 子句中引用 BigQuery 表：

• [project_id].[dataset_id].[table_name]
• [dataset_id].[table_name]
• [table_name]

BigQuery 还支持其他表引用：

• 表定义的历史版本和使用 FOR SYSTEM_TIME AS OF 的行
• 字段路径，或解析为数据类型中的某字段的任何路径（即 STRUCT）
• 展平数组

WHERE 子句

Snowflake WHERE 子句与 BigQuery WHERE 子句大体相同，但有以下细微差异：

Snowflake		BigQuery
SELECT col1, col2 FROM table1, table2 WHERE col1 = col2(+)		SELECT col1, col2 FROM table1 INNER JOIN table2 ON col1 = col2 注意：BigQuery 不支持 JOIN 的 (+) 语法

JOIN 类型

Snowflake 和 BigQuery 都支持以下联接类型：

• [INNER] JOIN
• LEFT [OUTER] JOIN
• RIGHT [OUTER] JOIN
• FULL [OUTER] JOIN
• CROSS JOIN 以及等效的隐式“逗号交叉联接”

Snowflake 和 BigQuery 都支持 ON 和 USING 子句。

下表列出了一些细微差异。

Snowflake		BigQuery
SELECT col1 FROM table1 NATURAL JOIN table2		SELECT col1 FROM table1 INNER JOIN table2 USING (col1, col2 [, ...]) 注意：在 BigQuery 中，除非 JOIN 子句是 CROSS JOIN 或其中一个联接表是数据类型或数组中的某个字段，否则都需要使用 JOIN 条件。
SELECT ... FROM table1 AS t1, LATERAL ( SELECT* FROM table2 AS t2 WHERE t1.col = t2.col ) 注意：与非横向联接的输出不同，横向联接的输出仅包含从内嵌视图生成的行。左侧的行不需要联接到右侧，因为左侧的行已通过传递到内嵌视图而被考虑在内。		SELECT ... FROM table1 as t1 LEFT JOIN table2 as t2 ON t1.col = t2.col 注意：对于 LATERAL JOIN，BigQuery 没有直接的对应项。

WITH 子句

BigQuery WITH 子句包含一个或多个已命名的子查询，每当有后续 SELECT 语句引用这些子查询时，都会执行这些子查询。Snowflake WITH 子句的行为与 BigQuery 大体相同，唯一的区别是 BigQuery 不支持 WITH RECURSIVE。

GROUP BY 子句

Snowflake GROUP BY 子句支持 GROUP BY、GROUP BY ROLLUP、GROUP BY GROUPING SETS 和 GROUP BY CUBE，而 BigQuery GROUP BY 子句支持 GROUP BY 和 GROUP BY ROLLUP。

Snowflake HAVING 和 BigQuery HAVING 具有相同含义。请注意，HAVING 出现在 GROUP BY 和聚合之后、ORDER BY 之前。

Snowflake		BigQuery
SELECT col1 as one, col2 as two FROM table GROUP BY (one, 2)		SELECT col1 as one, col2 as two FROM table GROUP BY (one, 2)
SELECT col1 as one, col2 as two FROM table GROUP BY ROLLUP (one, 2)		SELECT col1 as one, col2 as two FROM table GROUP BY ROLLUP (one, 2)
SELECT col1 as one, col2 as two FROM table GROUP BY GROUPING SETS (one, 2) 注意：Snowflake 允许一个查询块中最多有 128 个分组集		对于 Snowflake 中的 GROUP BY GROUPING SETS，BigQuery 没有直接的对应项。
SELECT col1 as one, col2 as two FROM table GROUP BY CUBE (one,2) 注意：Snowflake 允许每个多维数据集中最多有 7 个元素（128 个分组集）		对于 Snowflake 中的 GROUP BY CUBE，BigQuery 没有直接的对应项。

ORDER BY 子句

Snowflake 中的 ORDER BY 子句与 BigQuery 中的 ORDER BY 子句之间存在一些细微差异。

Snowflake		BigQuery
在 Snowflake 中，NULL 默认排在最后（升序）。		在 BigQuery 中，NULLS 默认排在最前（升序）。
您可以使用 NULLS FIRST 或 NULLS LAST 来分别指定 NULL 值排在最前或最后。		在 BigQuery 中，没有等效项可用来指定 NULL 值是排在最前还是最后。

LIMIT/FETCH 子句

Snowflake 中的 LIMIT/FETCH 子句会限制语句或子查询返回的最大行数。LIMIT（Postgres 语法）和 FETCH（ANSI 语法）会产生相同的结果。

在 Snowflake 和 BigQuery 中，对查询应用 LIMIT 子句不会影响读取的数据量。

Snowflake		BigQuery
SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start SELECT ... FROM ... ORDER BY ... OFFSET start {[ROW | ROWS]} FETCH {[FIRST | NEXT]} count {[ROW | ROWS]} [ONLY] 注意：NULL、空字符串 ('') 和 $$$$ 值可被接受并且会被视为“无限制”；主要用于连接器和驱动程序。		SELECT col1, col2 FROM table ORDER BY col1 LIMIT count OFFSET start 注意：BigQuery 不支持 FETCH；它会用 LIMIT 来取代 FETCH。 注意：在 BigQuery 中，OFFSET 必须与 LIMIT count 搭配使用。为获得最佳性能，请务必将 count 的 INT64 值设置为所需的最小有序行数。不必对所有结果行进行排序，因为这会导致查询的执行性能降低。

QUALIFY 子句

Snowflake 中的 QUALIFY 子句用于过滤窗口函数的结果，它与使用聚合函数和 GROUP BY 子句的 HAVING 效果类似。

Snowflake		BigQuery
SELECT col1, col2 FROM table QUALIFY ROW_NUMBER() OVER (PARTITION BY col1 ORDER BY col2) = 1;		具有分析函数（如 ROW_NUMBER() 和 COUNT()）且包含 OVER PARTITION BY 的 Snowflake QUALIFY 子句在 BigQuery 中表示为包含该分析值的子查询的 WHERE 子句。 使用 ROW_NUMBER()： SELECT col1, col2 FROM ( SELECT col1, col2 ROW NUMBER() OVER (PARTITION BY col1 ORDER by col2) RN FROM table ) WHERE RN = 1; 使用 ARRAY_AGG()（支持更大的分区）： SELECT result.* FROM ( SELECT ARRAY_AGG(table ORDER BY table.col2 DESC LIMIT 1) [OFFSET(0)] FROM table GROUP BY col1 ) AS result;

函数

以下部分列出了 Snowflake 函数及其 BigQuery 等效项。

聚合函数

下表展示了常见的 Snowflake 聚合、聚合分析和近似聚合函数与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
ANY_VALUE([DISTINCT] expression) [OVER ...] 注意：DISTINCT 不会产生任何效果	ANY_VALUE(expression) [OVER ...]
APPROX_COUNT_DISTINCT([DISTINCT] expression) [OVER ...] 注意：DISTINCT 不会产生任何效果	APPROX_COUNT_DISTINCT(expression) 注意：BigQuery 不支持将 APPROX_COUNT_DISTINCT 与窗口函数搭配使用
APPROX_PERCENTILE(expression, percentile) [OVER ...] 注意：Snowflake 未提供 RESPECT NULLS 选项	APPROX_QUANTILES([DISTINCT] expression,100) [OFFSET((CAST(TRUNC(percentile * 100) as INT64))] 注意：BigQuery 不支持将 APPROX_QUANTILES 与窗口函数搭配使用
APPROX_PERCENTILE_ACCUMULATE (expression)	在预测近似值时，BigQuery 不支持存储中间状态。
APPROX_PERCENTILE_COMBINE(state)	在预测近似值时，BigQuery 不支持存储中间状态。
APPROX_PERCENTILE_ESTIMATE(state, percentile)	在预测近似值时，BigQuery 不支持存储中间状态。
APPROX_TOP_K(expression, [number [counters]] 注意：如果未指定 number 参数，则默认为 1。计数器数量应远大于 number 参数的值。	APPROX_TOP_COUNT(expression, number) 注意：BigQuery 不支持将 APPROX_TOP_COUNT 与窗口函数搭配使用。
APPROX_TOP_K_ACCUMULATE(expression, counters)	在预测近似值时，BigQuery 不支持存储中间状态。
APPROX_TOP_K_COMBINE(state, [counters])	在预测近似值时，BigQuery 不支持存储中间状态。
APPROX_TOP_K_ESTIMATE(state, [k])	在预测近似值时，BigQuery 不支持存储中间状态。
APPROXIMATE_JACCARD_INDEX([DISTINCT] expression)	您可以使用自定义 UDF 来实现包含 k distinct 哈希函数的 MINHASH。另一种减小 MINHASH 中方差的方法是保留 一个哈希函数最小值中的 k。在这种情况下，Jaccard 指数近似如下： WITH minhash_A AS ( SELECT DISTINCT FARM_FINGERPRINT(TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k), minhash_B AS ( SELECT DISTINCT FARM_FINGERPRINT(TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k) SELECT COUNT(*) / k AS APPROXIMATE_JACCARD_INDEX FROM minhash_A INNER JOIN minhash_B ON minhash_A.h = minhash_B.h
APPROXIMATE_SIMILARITY([DISTINCT] expression)	它与 APPROXIMATE_JACCARD_INDEX 含义相同，可通过相同的方式实现。
ARRAY_AGG([DISTINCT] expression1) [WITHIN GROUP (ORDER BY ...)] [OVER ([PARTITION BY expression2])] Note: Snowflake does not support ability to IGNORE|RESPECT NULLS and to LIMIT directly in ARRAY_AGG.	ARRAY_AGG([DISTINCT] expression1 [{IGNORE|RESPECT}] NULLS] [ORDER BY ...] LIMIT ...]) [OVER (...)]
AVG([DISTINCT] expression) [OVER ...]	AVG([DISTINCT] expression) [OVER ...] 注意：BigQuery 中的 AVG 不会对 STRING 执行自动类型转换。
BITAND_AGG(expression) [OVER ...]	BIT_AND(expression) [OVER ...] 注意：BigQuery 不会将字符/文本列隐式转换为最接近的 INTEGER。
BITOR_AGG(expression) [OVER ...]	BIT_OR(expression) [OVER ...] 注意：BigQuery 不会将字符/文本列隐式转换为最接近的 INTEGER。
BITXOR_AGG([DISTINCT] expression) [OVER ...]	BIT_XOR([DISTINCT] expression) [OVER ...] 注意：BigQuery 不会将字符/文本列隐式转换为最接近的 INTEGER。
BOOLAND_AGG(expression) [OVER ...] 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	LOGICAL_AND(expression) [OVER ...]
BOOLOR_AGG(expression) [OVER ...] 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	LOGICAL_OR(expression) [OVER ...]
BOOLXOR_AGG(expression) [OVER ([PARTITION BY <partition_expr> ]) 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	对于数值表达式： SELECT CASE COUNT(*) WHEN 1 THEN TRUE WHEN 0 THEN NULL ELSE FALSE END AS BOOLXOR_AGG FROM T WHERE expression != 0 如需使用 OVER，您可以运行以下命令（提供了布尔示例）： SELECT CASE COUNT(expression) OVER (PARTITION BY partition_expr) WHEN 0 THEN NULL ELSE CASE COUNT( CASE expression WHEN TRUE THEN 1 END) OVER (PARTITION BY partition_expr) WHEN 1 THEN TRUE ELSE FALSE END END AS BOOLXOR_AGG FROM T
CORR(dependent, independent) [OVER ...]	CORR(dependent, independent) [OVER ...]
COUNT([DISTINCT] expression [,expression2]) [OVER ...]	COUNT([DISTINCT] expression [,expression2]) [OVER ...]
COVAR_POP(dependent, independent) [OVER ...]	COVAR_POP(dependent, independent) [OVER ...]
COVAR_SAMP(dependent, independent) [OVER ...]	COVAR_SAMP(dependent, independent) [OVER ...]
GROUPING(expression1, [,expression2...])	对于 Snowflake 中的 GROUPING，BigQuery 没有直接的对应项。可通过用户定义的函数实现。
GROUPING_ID(expression1, [,expression2...])	对于 Snowflake 中的 GROUPING_ID，BigQuery 没有直接的对应项。可通过用户定义的函数实现。
HASH_AGG([DISTINCT] expression1, [,expression2]) [OVER ...]	SELECT BIT_XOR( FARM_FINGERPRINT( TO_JSON_STRING(t))) [OVER] FROM t
SELECT HLL([DISTINCT] expression1, [,expression2]) [OVER ...] 注意：Snowflake 不允许指定精度。	SELECT HLL_COUNT.EXTRACT(sketch) FROM ( SELECT HLL_COUNT.INIT(expression) AS sketch FROM table ) 注意：BigQuery 不支持将 HLL_COUNT… 与窗口函数搭配使用。用户无法在单个 HLL_COUNT... 函数中添加多个表达式。
HLL_ACCUMULATE([DISTINCT] expression) 注意：Snowflake 不允许指定精度。	HLL_COUNT.INIT(expression [, precision])
HLL_COMBINE([DISTINCT] state)	HLL_COUNT.MERGE_PARTIAL(sketch)
HLL_ESTIMATE(state)	HLL_COUNT.EXTRACT(sketch)
HLL_EXPORT(binary)	对于 Snowflake 中的 HLL_EXPORT，BigQuery 没有直接的对应项。
HLL_IMPORT(object)	对于 Snowflake 中的 HLL_IMPORT，BigQuery 没有直接的对应项。
KURTOSIS(expression) [OVER ...]	对于 Snowflake 中的 KURTOSIS，BigQuery 没有直接的对应项。
LISTAGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]	STRING_AGG( [DISTINCT] aggregate_expression [, delimiter] ) [OVER ...]
MEDIAN(expression) [OVER ...] 注意：Snowflake 不支持直接在 ARRAY_AGG. 中执行 IGNORE|RESPECT NULLS 和 LIMIT	PERCENTILE_CONT( value_expression, 0.5 [ {RESPECT | IGNORE} NULLS] ) OVER()
MAX(expression) [OVER ...] MIN(expression) [OVER ...]	MAX(expression) [OVER ...] MIN(expression) [OVER ...]
MINHASH(k, [DISTINCT] expressions)	您可以使用自定义 UDF 来实现包含 k distinct 哈希函数的 MINHASH。另一种减小 MINHASH 中方差的方法是保留一个哈希函数最小值中的 k： SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS MINHASH FROM t ORDER BY MINHASH LIMIT k
MINHASH_COMBINE([DISTINCT] state)	<code<select FROM ( SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TA AS t ORDER BY h LIMIT k UNION SELECT DISTINCT FARM_FINGERPRINT( TO_JSON_STRING(t)) AS h FROM TB AS t ORDER BY h LIMIT k ) ORDER BY h LIMIT k
MODE(expr1) OVER ( [ PARTITION BY <expr2> ] )	SELECT expr1 FROM ( SELECT expr1, ROW_NUMBER() OVER ( PARTITION BY expr2 ORDER BY cnt DESC) rn FROM ( SELECT expr1, expr2, COUNTIF(expr1 IS NOT NULL) OVER (PARTITION BY expr2, expr1) cnt FROM t)) WHERE rn = 1
OBJECT_AGG(key, value) [OVER ...]	您可以考虑使用 TO_JSON_STRING 将值转换为 JSON 格式的字符串
PERCENTILE_CONT(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_CONT( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
PERCENTILE_DISC(percentile) WITHIN GROUP (ORDER BY value_expression) [OVER ...]	PERCENTILE_DISC( value_expression, percentile [ {RESPECT | IGNORE} NULLS] ) OVER()
REGR_AVGX(dependent, independent) [OVER ...]	SELECT AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_AVGY(dependent, independent) [OVER ...]	SELECT AVG(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_COUNT(dependent, independent) [OVER ...]	SELECT COUNT(*) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) )
REGR_INTERCEPT(dependent, independent) [OVER ...]	SELECT AVG(dependent) - COVAR_POP(dependent,independent)/ VAR_POP(dependent) * AVG(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_R2(dependent, independent) [OVER ...]	SELECT CASE WHEN VAR_POP(independent) = 0 THEN NULL WHEN VAR_POP(dependent) = 0 AND VAR_POP(independent) != 0 THEN 1 ELSE POWER(CORR(dependent, independent), 2) END AS ... FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SLOPE(dependent, independent) [OVER ...]	SELECT COVAR_POP(dependent,independent)/ VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SXX(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(independent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
REGR_SYY(dependent, independent) [OVER ...]	SELECT COUNT(*)*VAR_POP(dependent) [OVER ...] FROM table WHERE ( (dependent IS NOT NULL) AND (independent IS NOT NULL) ) [GROUP BY ...]
SKEW(expression)	对于 Snowflake 中的 SKEW，BigQuery 没有直接的对应项。
STDDEV([DISTINCT] expression) [OVER ...]	STDDEV([DISTINCT] expression) [OVER ...]
STDDEV_POP([DISTINCT] expression) [OVER ...]	STDDEV_POP([DISTINCT] expression) [OVER ...]
STDDEV_SAMP([DISTINCT] expression) [OVER ...]	STDDEV_SAMP([DISTINCT] expression) [OVER ...]
SUM([DISTINCT] expression) [OVER ...]	SUM([DISTINCT] expression) [OVER ...]
VAR_POP([DISTINCT] expression) [OVER ...] 注意：Snowflake 支持将 VARCHAR 转换为浮点值。	VAR_POP([DISTINCT] expression) [OVER ...]
VARIANCE_POP([DISTINCT] expression) [OVER ...] 注意：Snowflake 支持将 VARCHAR 转换为浮点值。	VAR_POP([DISTINCT] expression) [OVER ...]
VAR_SAMP([DISTINCT] expression) [OVER ...] 注意：Snowflake 支持将 VARCHAR 转换为浮点值。	VAR_SAMP([DISTINCT] expression) [OVER ...]
VARIANCE([DISTINCT] expression) [OVER ...] 注意：Snowflake 支持将 VARCHAR 转换为浮点值。	VARIANCE([DISTINCT] expression) [OVER ...]

BigQuery 还提供以下聚合、聚合分析和近似聚合函数，这些函数在 Snowflake 中没有直接对应项：

• COUNTIF
• ARRAY_CONCAT_AGG
• HLL_COUNT.MERGE

按位表达式函数

下表展示了常见的 Snowflake 按位表达式函数与其 BigQuery 等效项之间的对应关系。

如果表达式的数据类型不是 INTEGER，Snowflake 会尝试将其转换为 INTEGER。但是，BigQuery 不会尝试将其转换为 INTEGER。

Snowflake	BigQuery
BITAND(expression1, expression2)	BIT_ADD(x) FROM UNNEST([expression1, expression2]) AS x expression1 & expression2
BITNOT(expression)	~ expression
BITOR(expression1, expression2)	BIT_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 | expression2
BITSHIFTLEFT (expression, n)	expression << n
BITSHIFTRIGHT (expression, n)	expression >> n
BITXOR(expression, expression) 注意：Snowflake 不支持 DISTINCT.	BIT_XOR([DISTINCT] x) FROM UNNEST([expression1, expression2]) AS x expression ^ expression

条件表达式函数

下表展示了常见的 Snowflake 条件表达式与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
expression [ NOT ] BETWEEN lower AND upper	(expression >= lower AND expression <= upper)
BOOLAND(expression1, expression2) 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	LOGICAL_AND(x) FROM UNNEST([expression1, expression2]) AS x expression1 AND expression2
BOOLNOT(expression1) 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	NOT expression
BOOLOR 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	LOGICAL_OR(x) FROM UNNEST([expression1, expression2]) AS x expression1 OR expression2
BOOLXOR 注意：Snowflake 允许将非零数值、小数和浮点值视为 TRUE。	对于 Snowflake 中的 BOOLXOR.，BigQuery 没有直接的对应项。
CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END
COALESCE(expr1, expr2, [,...]) 注意：Snowflake 至少需要两个表达式；而 BigQuery 只需要一个表达式。	COALESCE(expr1, [,...])
DECODE(expression, search1, result1, [search2, result2...] [,default])	CASE [expression] WHEN condition1 THEN result1 [WHEN condition2 THEN result2] [...] [ELSE result3] END 注意：BigQuery 支持在条件语句中使用子查询。这可用于重现 Snowflake 的 DECODE。用户必须使用 IS NULL 代替 = NULL 来将 NULL 选择表达式与 NULL 搜索表达式进行匹配。
EQUAL_NULL(expression1, expression2)	对于 Snowflake 中的 EQUAL_NULL.，BigQuery 没有直接的对应项。
GREATEST(expression1, [,expression2]...)	GREATEST(expression1, [,expression2]...)
IFF(condition, true_result, false_result)	IF(condition, true_result, false_result)
IFNULL(expression1, expression2)	IFNULL(expression1, expression2)
[ NOT ] IN ...	[ NOT ] IN ...
expression1 IS [ NOT ] DISTINCT FROM expression2	对于 Snowflake 中的 IS [ NOT ] DISTINCT FROM.，BigQuery 没有直接的对应项。
expression IS [ NOT ] NULL	expression IS [ NOT ] NULL
IS_NULL_VALUE(variant_expr)	BigQuery 不支持 VARIANT 数据类型。
LEAST(expression,...)	LEAST(expression,...)
NULLIF(expression1,expression2)	NULLIF(expression1,expression2)
NVL(expression1, expression2)	IFNULL(expression1,expression2)
NVL2(expr1,expr2,expr2)	IF(expr1 IS NOT NULL, expr2,expr3)
REGR_VALX(expr1,expr2)	IF(expr1 IS NULL, NULL, expr2) 注意：对于 Snowflake 中的 REGR... 函数，BigQuery 没有直接的对应项。
REGR_VALY(expr1,expr2)	IF(expr2 IS NULL, NULL, expr1) 注意：对于 Snowflake 中的 REGR... 函数，BigQuery 没有直接的对应项。
ZEROIFNULL(expression)	IFNULL(expression,0)

上下文函数

下表展示了常见的 Snowflake 上下文函数与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
CURRENT_ACCOUNT()	SESSION_USER() 注意：无法直接对比。Snowflake 返回账号 ID，而 BigQuery 返回用户电子邮件地址。
CURRENT_CLIENT()	BigQuery 中未使用该概念
CURRENT_DATABASE()	SELECT catalog_name FROM INFORMATION_SCHEMA.SCHEMATA 这会返回一个项目名称表。无法直接对比。
CURRENT_DATE[()] 注意：Snowflake 不会在 CURRENT_DATE 命令后强制添加“()”，以符合 ANSI 标准。	CURRENT_DATE([timezone]) 注意：BigQuery 的 CURRENT_DATE 支持可选的时区规范。
CURRENT_REGION()	SELECT location FROM INFORMATION_SCHEMA.SCHEMATA 注意：与 Snowflake 的 CURRENT_REGION() 相比，BigQuery 的 INFORMATION_SCHEMA.SCHEMATA 会返回更广义的位置引用。无法直接对比。
CURRENT_ROLE()	BigQuery 中未使用该概念
CURRENT_SCHEMA()	SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA 这会返回一个表，其中包含项目或区域中可用的数据集（也称为架构）。无法直接对比。
CURRENT_SCHEMAS()	BigQuery 中未使用该概念
CURRENT_SESSION()	BigQuery 中未使用该概念
CURRENT_STATEMENT()	SELECT query FROM INFORMATION_SCHEMA.JOBS_BY_* 注意：BigQuery 的 INFORMATION_SCHEMA.JOBS_BY_* 允许按作业类型、开始/结束类型等过滤条件搜索查询。
CURRENT_TIME[([frac_sec_prec])] 注意：Snowflake 支持可选的小数秒精度。有效值的范围为 0-9 纳秒。默认值为 9。在调用该函数时可以不添加“()”，以符合 ANSI 标准。	CURRENT_TIME()
CURRENT_TIMESTAMP[([frac_sec_prec])] 注意：Snowflake 支持可选的小数秒精度。有效值的范围为 0-9 纳秒。默认值为 9。在调用该函数时可以不添加“()”，以符合 ANSI 标准。将 TIMEZONE 设置为会话参数。	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() 注意：CURRENT_DATETIME 会返回 DATETIME 数据类型（Snowflake 中不支持该类型）。CURRENT_TIMESTAMP 会返回 TIMESTAMP 数据类型。
CURRENT_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* 注意：BigQuery 的 INFORMATION_SCHEMA.JOBS_BY_* 允许按作业类型、开始/结束类型等过滤条件搜索作业 ID。
CURRENT_USER[()] 注意：Snowflake 不会在 CURRENT_USER 命令后强制添加“()”，以符合 ANSI 标准。	SESSION_USER() SELECT user_email FROM INFORMATION_SCHEMA.JOBS_BY_* 注意：无法直接对比。Snowflake 返回用户名，而 BigQuery 返回用户电子邮件地址。
CURRENT_VERSION()	BigQuery 中未使用该概念
CURRENT_WAREHOUSE()	SELECT catalg_name FROM INFORMATION_SCHEMA.SCHEMATA
LAST_QUERY_ID([num])	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* 注意：BigQuery 的 INFORMATION_SCHEMA.JOBS_BY_* 允许按作业类型、开始/结束类型等过滤条件搜索作业 ID。
LAST_TRANSACTION()	SELECT job_id FROM INFORMATION_SCHEMA.JOBS_BY_* 注意：BigQuery 的 INFORMATION_SCHEMA.JOBS_BY_* 允许按作业类型、开始/结束类型等过滤条件搜索作业 ID。
LOCALTIME() 注意：Snowflake 不会在 LOCALTIME 命令后强制添加“()”，以符合 ANSI 标准。	CURRENT_TIME()
LOCALTIMESTAMP()	CURRENT_DATETIME([timezone]) CURRENT_TIMESTAMP() 注意：CURRENT_DATETIME 会返回 DATETIME 数据类型（Snowflake 中不支持该类型）。CURRENT_TIMESTAMP 会返回 TIMESTAMP 数据类型。

转换函数

下表展示了常见的 Snowflake 转换函数与其 BigQuery 等效项之间的对应关系。

请注意，Snowflake 和 BigQuery 中看似相同的函数可能会返回不同的数据类型。

Snowflake	BigQuery
CAST(expression AS type) expression :: type	CAST(expression AS type)
TO_ARRAY(expression)	[expression] ARRAY(subquery)
TO_BINARY(expression[, format]) 注意：Snowflake 支持 HEX、BASE64 和 UTF-8 转换。Snowflake 还支持使用 VARIANT 数据类型的 TO_BINARY。对于 VARIANT 数据类型，BigQuery 没有对应项。	TO_HEX(CAST(expression AS BYTES)) TO_BASE64(CAST(expression AS BYTES)) CAST(expression AS BYTES) 注意：BigQuery 的默认 STRING 类型转换使用 UTF-8 编码。Snowflake 不支持 BASE32 编码。
TO_BOOLEAN(expression) 注意： INT64 TRUE: ，否则 FALSE: 0 STRING TRUE: "true"/"t"/"yes"/"y"/"on"/"1", FALSE: "false"/"f"/"no"/"n"/"off"/"0"	CAST(expression AS BOOL) 注意： INT64 TRUE: ，否则 FALSE: 0 STRING TRUE: "true", FALSE: "false"
TO_CHAR(expression[, format]) TO_VARCHAR(expression[, format]) 注意：您可以在此处找到 Snowflake 的格式模型。对于 VARIANT 数据类型，BigQuery 没有对应项。	CAST(expression AS STRING) 注意：BigQuery 的输入表达式可以使用 FORMAT_DATE、FORMAT_DATETIME、FORMAT_TIME 或 FORMAT_TIMESTAMP 设置格式。
TO_DATE(expression[, format]) DATE(expression[, format]) 注意：Snowflake 支持将 INTEGER 类型直接转换为 DATE 类型。您可以在此处找到 Snowflake 的格式模型。对于 VARIANT 数据类型，BigQuery 没有对应项。	CAST(expression AS DATE) 注意：BigQuery 的输入表达式可以使用 FORMAT、FORMAT_DATETIME 或 FORMAT_TIMESTAMP 设置格式。
TO_DECIMAL(expression[, format] [,precision[, scale]] TO_NUMBER(expression[, format] [,precision[, scale]] TO_NUMERIC(expression[, format] [,precision[, scale]] 注意：您可以在此处找到 Snowflake 中适用于 DECIMAL、NUMBER 和 NUMERIC 数据类型的格式模型。对于 VARIANT 数据类型，BigQuery 没有对应项。	ROUND(CAST(expression AS NUMERIC) , x) 注意：BigQuery 的输入表达式可以使用 FORMAT. 设置格式。
TO_DOUBLE(expression[, format]) 注意：您可以在此处找到 Snowflake 中适用于 DOUBLE 数据类型的格式模型。对于 VARIANT 数据类型，BigQuery 没有对应项。	CAST(expression AS FLOAT64) 注意：BigQuery 的输入表达式可以使用 FORMAT. 设置格式。
TO_JSON(variant_expression)	对于 Snowflake 中的 VARIANT 数据类型，BigQuery 没有对应项。
TO_OBJECT(variant_expression)	对于 Snowflake 中的 VARIANT 数据类型，BigQuery 没有对应项。
TO_TIME(expression[, format]) TIME(expression[, format]) 注意：您可以在此处找到 Snowflake 中适用于 STRING 数据类型的格式模型。对于 VARIANT 数据类型，BigQuery 没有对应项。	CAST(expression AS TIME) 注意：对于 Snowflake 中的 VARIANT 数据类型，BigQuery 没有对应项。BigQuery 的输入表达式可以使用 FORMAT、FORMAT_DATETIME、FORMAT_TIMESTAMP 或 FORMAT_TIME 设置格式。
TO_TIMESTAMP(expression[, scale]) TO_TIMESTAMP_LTZ(expression[, scale]) TO_TIMESTAMP_NTZ(expression[, scale]) TO_TIMESTAMP_TZ(expression[, scale]) 注意：对于 VARIANT 数据类型，BigQuery 没有对应项。	CAST(expression AS TIMESTAMP) 注意：BigQuery 的输入表达式可以使用 FORMAT、FORMAT_DATE、FORMAT_DATETIME 或 FORMAT_TIME 设置格式。可以通过 FORMAT_TIMESTAMP 参数选择添加/不添加时区。
TO_VARIANT(expression)	对于 Snowflake 中的 VARIANT 数据类型，BigQuery 没有对应项。
TO_XML(variant_expression)	对于 Snowflake 中的 VARIANT 数据类型，BigQuery 没有对应项。
TRY_CAST(expression AS type)	SAFE_CAST(expression AS type)
TRY_TO_BINARY(expression[, format])	TO_HEX(SAFE_CAST(expression AS BYTES)) TO_BASE64(SAFE_CAST(expression AS BYTES)) SAFE_CAST(expression AS BYTES)
TRY_TO_BOOLEAN(expression)	SAFE_CAST(expression AS BOOL)
TRY_TO_DATE(expression)	SAFE_CAST(expression AS DATE)
TRY_TO_DECIMAL(expression[, format] [,precision[, scale]] TRY_TO_NUMBER(expression[, format] [,precision[, scale]] TRY_TO_NUMERIC(expression[, format] [,precision[, scale]]	ROUND( SAFE_CAST(expression AS NUMERIC) , x)
TRY_TO_DOUBLE(expression)	SAFE_CAST(expression AS FLOAT64)
TRY_TO_TIME(expression)	SAFE_CAST(expression AS TIME)
TRY_TO_TIMESTAMP(expression) TRY_TO_TIMESTAMP_LTZ(expression) TRY_TO_TIMESTAMP_NTZ(expression) TRY_TO_TIMESTAMP_TZ(expression)	SAFE_CAST(expression AS TIMESTAMP)

BigQuery 还提供以下转换函数，这些函数在 Snowflake 中没有直接对应项：

• CODE_POINTS_TO_BYTES
• CODE_POINTS_TO_STRING
• FORMAT
• FROM_BASE32
• FROM_BASE64
• FROM_HEX
• SAFE_CONVERT_BYTES_TO_STRING
• TO_BASE32
• TO_CODE_POINTS

数据生成函数

下表展示了常见的 Snowflake 数据生成函数与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
NORMAL(mean, stddev, gen)	对于 Snowflake 中的 NORMAL.，BigQuery 没有直接的对应项。
RANDOM([seed])	IF(RAND()>0.5, CAST(RAND()*POW(10, 18) AS INT64), (-1)*CAST(RAND()*POW(10, 18) AS INT64)) 注意：BigQuery 不支持种子设定
RANDSTR(length, gen)	对于 Snowflake 中的 RANDSTR.，BigQuery 没有直接的对应项。
SEQ1 / SEQ2 / SEQ4 / SEQ8	对于 Snowflake 中的 SEQ_.，BigQuery 没有直接的对应项。
UNIFORM(min, max, gen)	CAST(min + RAND()*(max-min) AS INT64) 注意：对于 Snowflake 中的 UNIFORM，可以使用永久性 UDF 来创建等效项。请参阅此处的示例。
UUID_STRING([uuid, name]) 注意：Snowflake 会返回 128 个随机位。Snowflake 支持版本 4（随机）和版本 5（命名）UUID。	GENERATE_UUID() 注意：BigQuery 会返回 122 个随机位。BigQuery 仅支持版本 4 UUID。
ZIPF(s, N, gen)	对于 Snowflake 中的 ZIPF.，BigQuery 没有直接的对应项。

日期和时间函数

下表展示了常见的 Snowflake 日期和时间函数与其 BigQuery 等效项之间的对应关系。BigQuery 数据和时间函数包括日期函数、日期时间函数、时间函数和时间戳函数。

Snowflake	BigQuery
ADD_MONTHS(date, months)	CAST( DATE_ADD( date, INTERVAL integer MONTH ) AS TIMESTAMP )
CONVERT_TIMEZONE(source_tz, target_tz, source_timestamp) CONVERT_TIMEZONE(target_tz, source_timestamp)	PARSE_TIMESTAMP( "%c%z", FORMAT_TIMESTAMP( "%c%z", timestamp, target_timezone ) ) 注意：在 BigQuery 中，source_timezone 始终为 UTC
DATE_FROM_PARTS(year, month, day) 注意：Snowflake 支持溢出日期和负日期。例如，DATE_FROM_PARTS(2000, 1 + 24, 1) 会返回 2002 年 1 月 1 日。BigQuery 则不支持此行为。	DATE(year, month, day) DATE(timestamp_expression[, timezone]) DATE(datetime_expression)
DATE_PART(part, dateOrTime) 注意：Snowflake 支持 ISO 格式星期几、纳秒以及纪元秒/毫秒/微秒/纳秒分部类型。BigQuery 则不支持此行为。您可以在此处.找到 Snowflake 分部类型的完整列表	EXTRACT(part FROM dateOrTime) 注意：BigQuery 支持 week(<weekday>)、微秒和毫秒分部类型。Snowflake 则不支持此行为。您可以在此处以及此处找到 BigQuery 分部类型的完整列表。
DATE_TRUNC(part, dateOrTime) 注意：Snowflake 支持纳秒分部类型。BigQuery 则不支持此行为。您可以在此处.找到 Snowflake 分部类型的完整列表	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) 注意：BigQuery 支持 week(<weekday>)、ISO 格式周数和 ISO 格式年份分部类型。Snowflake 则不支持此行为。
DATEADD(part, value, dateOrTime)	DATE_ADD(date, INTERVAL value part)
DATEDIFF( part, expression1, expression2 ) 注意：Snowflake 支持在此函数中计算两种日期、时间和时间戳类型之间的差异。	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) 注意：BigQuery 支持 week(<weekday>) 和 ISO 格式年份分部类型。
DAYNAME(dateOrTimestamp)	FORMAT_DATE('%a', date) FORMAT_DATETIME('%a', datetime) FORMAT_TIMESTAMP('%a', timestamp)
EXTRACT(part FROM dateOrTime) 注意：Snowflake 支持 ISO 格式星期几、纳秒以及纪元秒/毫秒/微秒/纳秒分部类型。BigQuery 则不支持此行为。您可以在此处.找到 Snowflake 分部类型的完整列表	EXTRACT(part FROM dateOrTime) 注意：BigQuery 支持 week(<weekday>)、微秒和毫秒分部类型。Snowflake 则不支持此行为。您可以在此处以及此处找到 BigQuery 分部类型的完整列表。
[HOUR, MINUTE, SECOND](timeOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])
LAST_DAY(dateOrTime[, part])	DATE_SUB( DATE_TRUNC( DATE_ADD(date, INTERVAL 1 part), part), INTERVAL 1 DAY)
MONTHNAME(dateOrTimestamp)	FORMAT_DATE('%b', date) FORMAT_DATETIME('%b', datetime) FORMAT_TIMESTAMP('%b', timestamp)
NEXT_DAY(dateOrTime, dowString)	DATE_ADD( DATE_TRUNC( date, WEEK(dowString)), INTERVAL 1 WEEK) 注意：dowString 可能需要重新设置格式。例如，Snowflake 中的“su”对应 BigQuery 中的“SUNDAY”。
PREVIOUS_DAY(dateOrTime, dowString)	DATE_TRUNC( date, WEEK(dowString) ) 注意：dowString 可能需要重新设置格式。例如，Snowflake 中的“su”对应 BigQuery 中的“SUNDAY”。
TIME_FROM_PARTS(hour, minute, second[, nanosecond) 注意：Snowflake 支持溢出时间。例如，TIME_FROM_PARTS(0, 100, 0) 会返回 01:40:00...BigQuery 则不支持此行为。BigQuery 不支持纳秒。	TIME(hour, minute, second) TIME(timestamp, [timezone]) TIME(datetime)
TIME_SLICE(dateOrTime, sliceLength, part[, START] TIME_SLICE(dateOrTime, sliceLength, part[, END]	DATE_TRUNC( DATE_SUB(CURRENT_DATE(), INTERVAL value MONTH), MONTH) DATE_TRUNC( DATE_ADD(CURRENT_DATE(), INTERVAL value MONTH), MONTH) 注意：对于 Snowflake 中的 TIME_SLICE，BigQuery 没有直接的确切对应项。可使用 DATETINE_TRUNC、TIME_TRUNC 和 TIMESTAMP_TRUNC 作为相应的数据类型。
TIMEADD(part, value, dateOrTime)	TIME_ADD(time, INTERVAL value part)
TIMEDIFF( part, expression1, expression2, ) 注意：Snowflake 支持在此函数中计算两种日期、时间和时间戳类型之间的差异。	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) 注意：BigQuery 支持 week(<weekday>) 和 ISO 格式年份分部类型。
TIMESTAMP_[LTZ, NTZ, TZ _]FROM_PARTS (year, month, day, hour, second [, nanosecond][, timezone])	TIMESTAMP( string_expression[, timezone] | date_expression[, timezone] | datetime_expression[, timezone] ) 注意：BigQuery 要求时间戳以 STRING 类型进行输入。示例："2008-12-25 15:30:00"
TIMESTAMPADD(part, value, dateOrTime)	TIMESTAMPADD(timestamp, INTERVAL value part)
TIMESTAMPDIFF( part, expression1, expression2, ) 注意：Snowflake 支持在此函数中计算两种日期、时间和时间戳类型之间的差异。	DATE_DIFF( dateExpression1, dateExpression2, part ) DATETIME_DIFF( datetimeExpression1, datetimeExpression2, part ) TIME_DIFF( timeExpression1, timeExpression2, part ) TIMESTAMP_DIFF( timestampExpression1, timestampExpression2, part ) 注意：BigQuery 支持 week(<weekday>) 和 ISO 格式年份分部类型。
TRUNC(dateOrTime, part) 注意：Snowflake 支持纳秒分部类型。BigQuery 则不支持此行为。您可以在此处.找到 Snowflake 分部类型的完整列表	DATE_TRUNC(date, part) DATETIME_TRUNC(datetime, part) TIME_TRUNC(time, part) TIMESTAMP_TRUNC(timestamp, part[, timezone]) 注意：BigQuery 支持 week(<weekday>)、ISO 格式周数和 ISO 格式年份分部类型。Snowflake 则不支持此行为。
[YEAR*, DAY*, WEEK*, MONTH, QUARTER](dateOrTimestamp)	EXTRACT(part FROM timestamp [AT THE ZONE timezone])

BigQuery 还提供以下日期和时间函数，这些函数在 Snowflake 中没有直接对应项：

DATE_SUB PARSE_DATE DATETIME_ADD PARSE_DATETIME PARSE_TIME TIMESTAMP_SUB TIMESTAMP_SECONDS UNIX_SECONDS	DATE_FROM_UNIX_DATE UNIX_DATE DATETIME_SUB TIME_SUB STRING FORMAT_TIMESTAMP TIMESTAMP_MILLIS UNIX_MILLIS	FORMAT_DATE DATETIME FORMAT_DATETIME FORMAT_TIME TIMESTAMP_ADD PARSE_TIMESTAMP TIMESTAMP_MICROS UNIX_MICROS

信息架构和表函数

BigQuery 在概念上不支持 Snowflake 中的许多信息架构和表函数。Snowflake 提供以下信息架构和表函数，这些函数在 BigQuery 中没有直接对应项：

• AUTOMATIC_CLUSTERING_HISTORY
• COPY_HISTORY
• DATA_TRANSFER_HISTORY
• DATABASE_REFRESH_HISTORY
• DATABASE_REFRESH_PROGRESS, DATABASE_REFRESH_PROGRESS_BY_JOB
• DATABASE_STORAGE_USAGE_HISTORY
• EXTERNAL_TABLE_FILES
• EXTERNAL_TABLE_FILE_REGISTRATION_HISTORY
• LOGIN_HISTORY、LOGIN_HISTORY_BY_USER
• MATERIALIZED_VIEW_REFRESH_HISTORY
• PIPE_USAGE_HISTORY
• REPLICATION_USAGE_HISTORY
• STAGE_STORAGE_USAGE_HISTORY
• TASK_DEPENDENTS
• VALIDATE_PIPE_LOAD
• WAREHOUSE_LOAD_HISTORY
• WAREHOUSE_METERING_HISTORY

以下是关联的 BigQuery 和 Snowflake 信息架构和表函数的列表。

Snowflake	BigQuery
QUERY_HISTORY QUERY_HISTORY_BY_*	INFORMATION_SCHEMA.JOBS_BY_* 注意：并非直接对应项。
TASK_HISTORY	INFORMATION_SCHEMA.JOBS_BY_* 注意：并非直接对应项。

BigQuery 提供以下信息架构和表函数，这些函数在 Snowflake 中没有直接对应项：

• INFORMATION_SCHEMA.SCHEMATA
• INFORMATION_SCHEMA.ROUTINES
• INFORMATION_SCHEMA.TABLES
• INFORMATION_SCHEMA.VIEWS

数值函数

下表展示了常见的 Snowflake 数值函数与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
ABS(expression)	ABS(expression)
ACOS(expression)	ACOS(expression)
ACOSH(expression)	ACOSH(expression)
ASIN(expression)	ASIN(expression)
ASINH(expression)	ASINH(expression)
ATAN(expression)	ATAN(expression)
ATAN2(y, x)	ATAN2(y, x)
ATANH(expression)	ATANH(expression)
CBRT(expression)	POW(expression, ⅓)
CEIL(expression [, scale])	CEIL(expression) 注意：BigQuery 中的 CEIL 不支持指示精度或标度。 ROUND 不允许指定向上舍入。
COS(expression)	COS(expression)
COSH(expression)	COSH(expression)
COT(expression)	1/TAN(expression)
DEGREES(expression)	(expression)*(180/ACOS(-1))
EXP(expression)	EXP(expression)
FACTORIAL(expression)	对于 Snowflake 中的 FACTORIAL，BigQuery 没有直接的对应项。可使用用户定义的函数来实现此行为。
FLOOR(expression [, scale])	FLOOR(expression) 注意：BigQuery 中的 FLOOR 不支持指示精度或标度。 ROUND 不允许指定向上舍入。对于正数，TRUNC 效果类似，对于负数则不然，因为它会对绝对值求值。
HAVERSINE(lat1, lon1, lat2, lon2)	ST_DISTANCE( ST_GEOGPOINT(lon1, lat1), ST_GEOGPOINT(lon2, lat2) )/1000 注意：并非完全匹配，但足够接近。
LN(expression)	LN(expression)
LOG(base, expression)	LOG(expression [,base]) LOG10(expression) 注意：LOG 的默认基数为 10。
MOD(expression1, expression2)	MOD(expression1, expression2)
PI()	ACOS(-1)
POW(x, y) POWER(x, y)	POW(x, y) POWER(x, y)
RADIANS(expression)	(expression)*(ACOS(-1)/180)
ROUND(expression [, scale])	ROUND(expression, [, scale])
SIGN(expression)	SIGN(expression)
SIN(expression)	SIN(expression)
SINH(expression)	SINH(expression)
SQRT(expression)	SQRT(expression)
SQUARE(expression)	POW(expression, 2)
TAN(expression)	TAN(expression)
TANH(expression)	TANH(expression)
TRUNC(expression [, scale]) TRUNCATE(expression [, scale])	TRUNC(expression [, scale]) 注意：BigQuery 的返回值必须小于表达式值，不支持等于表达式值。

BigQuery 还提供以下数学函数，这些函数在 Snowflake 中没有直接对应项：

• IS_INF
• IS_NAN
• IEEE_DIVIDE
• DIV
• SAFE_DIVIDE
• SAFE_MULTIPLY
• SAFE_NEGATE
• SAFE_ADD
• SAFE_SUBTRACT
• RANGE_BUCKET

半结构化数据函数

Snowflake	BigQuery
ARRAY_APPEND	自定义用户定义的函数
ARRAY_CAT	ARRAY_CONCAT
ARRAY_COMPACT	自定义用户定义的函数
ARRAY_CONSTRUCT	[ ]
ARRAY_CONSTRUCT_COMPACT	自定义用户定义的函数
ARRAY_CONTAINS	自定义用户定义的函数
ARRAY_INSERT	自定义用户定义的函数
ARRAY_INTERSECTION	自定义用户定义的函数
ARRAY_POSITION	自定义用户定义的函数
ARRAY_PREPEND	自定义用户定义的函数
ARRAY_SIZE	ARRAY_LENGTH
ARRAY_SLICE	自定义用户定义的函数
ARRAY_TO_STRING	ARRAY_TO_STRING
ARRAYS_OVERLAP	自定义用户定义的函数
AS_<object_type>	CAST
AS_ARRAY	CAST
AS_BINARY	CAST
AS_BOOLEAN	CAST
AS_CHAR , AS_VARCHAR	CAST
AS_DATE	CAST
AS_DECIMAL , AS_NUMBER	CAST
AS_DOUBLE , AS_REAL	CAST
AS_INTEGER	CAST
AS_OBJECT	CAST
AS_TIME	CAST
AS_TIMESTAMP_*	CAST
CHECK_JSON	自定义用户定义的函数
CHECK_XML	自定义用户定义的函数
FLATTEN	UNNEST
GET	自定义用户定义的函数
GET_IGNORE_CASE	自定义用户定义的函数
GET_PATH , :	自定义用户定义的函数
IS_<object_type>	自定义用户定义的函数
IS_ARRAY	自定义用户定义的函数
IS_BINARY	自定义用户定义的函数
IS_BOOLEAN	自定义用户定义的函数
IS_CHAR , IS_VARCHAR	自定义用户定义的函数
IS_DATE , IS_DATE_VALUE	自定义用户定义的函数
IS_DECIMAL	自定义用户定义的函数
IS_DOUBLE , IS_REAL	自定义用户定义的函数
IS_INTEGER	自定义用户定义的函数
IS_OBJECT	自定义用户定义的函数
IS_TIME	自定义用户定义的函数
IS_TIMESTAMP_*	自定义用户定义的函数
OBJECT_CONSTRUCT	自定义用户定义的函数
OBJECT_DELETE	自定义用户定义的函数
OBJECT_INSERT	自定义用户定义的函数
PARSE_JSON	JSON_EXTRACT
PARSE_XML	自定义用户定义的函数
STRIP_NULL_VALUE	自定义用户定义的函数
STRTOK_TO_ARRAY	SPLIT
TRY_PARSE_JSON	自定义用户定义的函数
TYPEOF	自定义用户定义的函数
XMLGET	自定义用户定义的函数

字符串和二进制函数

Snowflake	BigQuery
string1 || string2	CONCAT(string1, string2)
ASCII	TO_CODE_POINTS(string1)[OFFSET(0)]
BASE64_DECODE_BINARY	SAFE_CONVERT_BYTES_TO_STRING( FROM_BASE64(<bytes_input>) )
BASE64_DECODE_STRING	SAFE_CONVERT_BYTES_TO_STRING( FROM_BASE64(<string1>) )
BASE64_ENCODE	TO_BASE64( SAFE_CAST(<string1> AS BYTES) )
BIT_LENGTH	BYTE_LENGTH * 8 CHARACTER_LENGTH
CHARINDEX(substring, string)	STRPOS(string, substring)
CHR,CHAR	CODE_POINTS_TO_STRING([number])
COLLATE	自定义用户定义的函数
COLLATION	自定义用户定义的函数
COMPRESS	自定义用户定义的函数
CONCAT(string1, string2)	CONCAT(string1, string2) 注意：BigQuery 的 CONCAT(...) 支持串联任意数量的字符串。
CONTAINS	自定义用户定义的函数
DECOMPRESS_BINARY	自定义用户定义的函数
DECOMPRESS_STRING	自定义用户定义的函数
EDITDISTANCE	自定义用户定义的函数
ENDSWITH	自定义用户定义的函数
HEX_DECODE_BINARY	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_DECODE_STRING	SAFE_CONVERT_BYTES_TO_STRING( FROM_HEX(<string1>)
HEX_ENCODE	TO_HEX( SAFE_CAST(<string1> AS BYTES))
ILIKE	自定义用户定义的函数
ILIKE ANY	自定义用户定义的函数
INITCAP	INITCAP
INSERT	自定义用户定义的函数
LEFT	用户定义的函数
LENGTH	LENGTH(expression)
LIKE	LIKE
LIKE ALL	自定义用户定义的函数
LIKE ANY	自定义用户定义的函数
LOWER	LOWER(string)
LPAD	LPAD(string1, length[, string2])
LTRIM	LTRIM(string1, trim_chars)
MD5,MD5_HEX	MD5(string)
MD5_BINARY	自定义用户定义的函数
OCTET_LENGTH	自定义用户定义的函数
PARSE_IP	自定义用户定义的函数
PARSE_URL	自定义用户定义的函数
POSITION	STRPOS(string, substring)
REPEAT	REPEAT(string, integer)
REPLACE	REPLACE(string1, old_chars, new_chars)
REVERSE number_characters )	REVERSE(expression)
RIGHT	用户定义的函数
RPAD	RPAD
RTRIM	RTRIM(string, trim_chars)
RTRIMMED_LENGTH	自定义用户定义的函数
SHA1,SHA1_HEX	SHA1(string)
SHA1_BINARY	自定义用户定义的函数
SHA2,SHA2_HEX	自定义用户定义的函数
SHA2_BINARY	自定义用户定义的函数
SOUNDEX	自定义用户定义的函数
SPACE	自定义用户定义的函数
SPLIT	SPLIT
SPLIT_PART	自定义用户定义的函数
SPLIT_TO_TABLE	自定义用户定义的函数
STARTSWITH	自定义用户定义的函数
STRTOK	SPLIT(instring, delimiter)[ORDINAL(tokennum)] 注意：整个分隔符字符串参数用作单个分隔符。默认分隔符为英文逗号。
STRTOK_SPLIT_TO_TABLE	自定义用户定义的函数
SUBSTR,SUBSTRING	SUBSTR
TRANSLATE	自定义用户定义的函数
TRIM	TRIM
TRY_BASE64_DECODE_BINARY	自定义用户定义的函数
TRY_BASE64_DECODE_STRING	SUBSTR(string, 0, integer)
TRY_HEX_DECODE_BINARY	SUBSTR(string, -integer)
TRY_HEX_DECODE_STRING	LENGTH(expression)
UNICODE	自定义用户定义的函数
UPPER	UPPER

字符串函数（正则表达式）

Snowflake	BigQuery
REGEXP	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_COUNT	ARRAY_LENGTH( REGEXP_EXTRACT_ALL( source_string, pattern ) ) 如果指定了 position： ARRAY_LENGTH( REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) ) 注意：BigQuery 通过 re2 库提供正则表达式支持；如需了解正则表达式的语法，请参阅该文档。
REGEXP_INSTR	IFNULL( STRPOS( source_string, REGEXP_EXTRACT( source_string, pattern) ), 0) 如果指定了 position： IFNULL( STRPOS( SUBSTR(source_string, IF(position <= 0, 1, position)), REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern) ) + IF(position <= 0, 1, position) - 1, 0) 如果指定了 occurrence： IFNULL( STRPOS( SUBSTR(source_string, IF(position <= 0, 1, position)), REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] ) + IF(position <= 0, 1, position) - 1, 0) 注意：BigQuery 通过 re2 库提供正则表达式支持；如需了解正则表达式的语法，请参阅该文档。
REGEXP_LIKE	IF(REGEXP_CONTAINS,1,0)=1
REGEXP_REPLACE	REGEXP_REPLACE( source_string, pattern, "" ) 如果指定了 replace_string： REGEXP_REPLACE( source_string, pattern, replace_string ) 如果指定了 position： CASE WHEN position > LENGTH(source_string) THEN source_string WHEN position <= 0 THEN REGEXP_REPLACE( source_string, pattern, "" ) ELSE CONCAT( SUBSTR( source_string, 1, position - 1), REGEXP_REPLACE( SUBSTR(source_string, position), pattern, replace_string ) ) END 注意：BigQuery 通过 re2 库提供正则表达式支持；如需了解正则表达式的语法，请参阅该文档。
REGEXP_SUBSTR	REGEXP_EXTRACT( source_string, pattern ) 如果指定了 position： REGEXP_EXTRACT( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern ) 如果指定了 occurrence： REGEXP_EXTRACT_ALL( SUBSTR(source_string, IF(position <= 0, 1, position)), pattern )[SAFE_ORDINAL(occurrence)] 注意：BigQuery 通过 re2 库提供正则表达式支持；如需了解正则表达式的语法，请参阅该文档。
RLIKE	IF(REGEXP_CONTAINS,1,0)=1

系统函数

Snowflake	BigQuery
SYSTEM$ABORT_SESSION	自定义用户定义的函数
SYSTEM$ABORT_TRANSACTION	自定义用户定义的函数
SYSTEM$CANCEL_ALL_QUERIES	自定义用户定义的函数
SYSTEM$CANCEL_QUERY	自定义用户定义的函数
SYSTEM$CLUSTERING_DEPTH	自定义用户定义的函数
SYSTEM$CLUSTERING_INFORMATION	自定义用户定义的函数
SYSTEM$CLUSTERING_RATIO — Deprecated	自定义用户定义的函数
SYSTEM$CURRENT_USER_TASK_NAME	自定义用户定义的函数
SYSTEM$DATABASE_REFRESH_HISTORY	自定义用户定义的函数
SYSTEM$DATABASE_REFRESH_PROGRESS , SYSTEM$DATABASE_REFRESH_PROGRESS_BY_JOB	自定义用户定义的函数
SYSTEM$GET_AWS_SNS_IAM_POLICY	自定义用户定义的函数
SYSTEM$GET_PREDECESSOR_RETURN_VALUE	自定义用户定义的函数
SYSTEM$LAST_CHANGE_COMMIT_TIME	自定义用户定义的函数
SYSTEM$PIPE_FORCE_RESUME	自定义用户定义的函数
SYSTEM$PIPE_STATUS	自定义用户定义的函数
SYSTEM$SET_RETURN_VALUE	自定义用户定义的函数
SYSTEM$SHOW_OAUTH_CLIENT_SECRETS	自定义用户定义的函数
SYSTEM$STREAM_GET_TABLE_TIMESTAMP	自定义用户定义的函数
SYSTEM$STREAM_HAS_DATA	自定义用户定义的函数
SYSTEM$TASK_DEPENDENTS_ENABLE	自定义用户定义的函数
SYSTEM$TYPEOF	自定义用户定义的函数
SYSTEM$USER_TASK_CANCEL_ONGOING_EXECUTIONS	自定义用户定义的函数
SYSTEM$WAIT	自定义用户定义的函数
SYSTEM$WHITELIST	自定义用户定义的函数
SYSTEM$WHITELIST_PRIVATELINK	自定义用户定义的函数

表函数

Snowflake		BigQuery
GENERATOR		自定义用户定义的函数
GET_OBJECT_REFERENCES		自定义用户定义的函数
RESULT_SCAN		自定义用户定义的函数
VALIDATE		自定义用户定义的函数

实用程序和哈希函数

Snowflake		BigQuery
GET_DDL		功能请求
HASH		HASH 是 Snowflake 专用的专有函数。如果不了解 Snowflake 使用的基础逻辑，请勿随意转换。

窗口函数

Snowflake		BigQuery
CONDITIONAL_CHANGE_EVENT		自定义用户定义的函数
CONDITIONAL_TRUE_EVENT		自定义用户定义的函数
CUME_DIST		CUME_DIST
DENSE_RANK		DENSE_RANK
FIRST_VALUE		FIRST_VALUE
LAG		LAG
LAST_VALUE		LAST_VALUE
LEAD		LEAD
NTH_VALUE		NTH_VALUE
NTILE		NTILE
PERCENT_RANK		PERCENT_RANK
RANK		RANK
RATIO_TO_REPORT		自定义用户定义的函数
ROW_NUMBER		ROW_NUMBER
WIDTH_BUCKET		自定义用户定义的函数

BigQuery 还支持 SAFE_CAST（采用“表达式 AS 类型名称”格式），如果 BigQuery 无法执行类型转换，则返回 NULL（例如，SAFE_CAST("apple" AS INT64) 便会返回 NULL）。

运算符

以下部分列出了 Snowflake 运算符及其 BigQuery 等效项。

算术运算符

下表展示了 Snowflake 算术运算符与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
(Unary) (+'5')	CAST("5" AS NUMERIC)
a + b	a + b
(Unary) (-'5')	(-1) * CAST("5" AS NUMERIC) 注意：BigQuery 支持标准一元取反，但不会将字符串格式的整数转换为 INT64、NUMERIC 或 FLOAT64 类型。
a - b	a - b
date1 - date2 date1 - 365	DATE_DIFF(date1, date2, date_part) DATE_SUB(date1, date2, date_part)
a * b	a * b
a / b	a / b
a % b	MOD(a, b)

如需了解在执行算术运算时适用的 Snowflake 标度和精度详情，请参阅 Snowflake 文档。

比较运算符

Snowflake 的比较运算符与 BigQuery 的比较运算符相同。

逻辑/布尔运算符

Snowflake 的逻辑/布尔运算符与 BigQuery 的逻辑/布尔运算符相同。

集合运算符

下表展示了 Snowflake 集合运算符与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
SELECT ... INTERSECT SELECT ...	SELECT ... INTERSECT DISTINCT SELECT...
SELECT ... MINUS SELECT ... SELECT ... EXCEPT SELECT … 注意：MINUS 与 EXCEPT 的含义相同。	SELECT ... EXCEPT DISTINCT SELECT ...
SELECT ... UNION SELECT ... SELECT ... UNION ALL SELECT ...	SELECT ... UNION DISTINCT SELECT ... SELECT ... UNION ALL SELECT ...

子查询运算符

下表展示了 Snowflake 子查询运算符与其 BigQuery 等效项之间的对应关系。

Snowflake	BigQuery
SELECT ... FROM ... WHERE col <operator> ALL … SELECT ... FROM ... WHERE col <operator> ANY ...	对于 Snowflake 中的 ALL/ANY，BigQuery 没有直接的对应项。
SELECT ... FROM ... WHERE [NOT] EXISTS...	SELECT ... FROM ... WHERE [NOT] EXISTS...
SELECT ... FROM ... WHERE [NOT] IN...	SELECT ... FROM ... WHERE [NOT] IN...
SELECT * FROM table1 UNION SELECT * FROM table2 EXCEPT SELECT * FROM table3	SELECT * FROM table1 UNION ALL ( SELECT * FROM table2 EXCEPT SELECT * FROM table3 ) 注意：BigQuery 需要使用英文括号来分隔不同的集合运算。如果重复同一集合运算符，则不需要使用英文括号。

DML 语法

本部分介绍了 Snowflake 和 BigQuery 在数据管理语言语法上的差异。

INSERT 语句

Snowflake 为列提供可配置的 DEFAULT 关键字。在 BigQuery 中，可为 null 的列的 DEFAULT 值为 NULL，而必需的列不支持 DEFAULT。大多数 Snowflake INSERT 语句都与 BigQuery 兼容。下表显示了例外情况。

Snowflake	BigQuery
INSERT [OVERWRITE] INTO table VALUES [... | DEFAULT | NULL] ... 注意：BigQuery 不支持通过 INSERT 语句.插入 JSON 对象	INSERT [INTO] table (column1 [, ...]) VALUES (DEFAULT [, ...]) 注意：对于 Snowflake 中的 OVERWRITE，BigQuery 没有直接的对应项。请改用 DELETE。
INSERT INTO table (column1 [, ...]) SELECT... FROM ...	INSERT [INTO] table (column1, [,...]) SELECT ... FROM ...
INSERT [OVERWRITE] ALL <intoClause> ... INSERT [OVERWRITE] {FIRST | ALL} {WHEN condition THEN <intoClause>} [...] [ELSE <intoClause>] ... 注意：<intoClause> 表示标准 INSERT statement，如上所示。	BigQuery 不支持有条件和无条件多表 INSERTs。

BigQuery 还支持使用子查询插入值（其中一个值使用子查询计算得出），Snowflake 不支持此行为。例如：

INSERT INTO table (column1, column2)
VALUES ('value_1', (
  SELECT column2
  FROM table2
))

COPY 语句

Snowflake 支持将数据从暂存文件复制到现有表以及从表复制到命名的内部暂存区、命名的外部暂存区和外部位置（Amazon S3、Google Cloud Storage 或 Microsoft Azure）。

• COPY INTO <table>
• COPY INTO <location>

BigQuery 不使用 SQL COPY 命令加载数据，但您可以使用多种非 SQL 工具和选项的任何一种将数据加载到 BigQuery 表中。您还可以使用 Apache Spark 或 Apache Beam 中提供的数据流水线接收器将数据写入 BigQuery 中。

UPDATE 语句

大多数 Snowflake UPDATE 语句都与 BigQuery 兼容。下表显示了例外情况。

Snowflake		BigQuery
UPDATE table SET col = value [,...] [FROM ...] [WHERE ...]		UPDATE table SET column = expression [,...] [FROM ...] WHERE TRUE 注意：BigQuery 中的所有 UPDATE 语句都需要 WHERE 关键字，后跟一个条件。

DELETE 和 TRUNCATE TABLE 语句

DELETE 和 TRUNCATE TABLE 语句都是在不影响表架构或索引的情况下从表中移除行的方法。

在 Snowflake 中，DELETE 和 TRUNCATE TABLE 都会通过 Snowflake 的时间旅行来保留已删除的数据，以便能够在数据保留期限内恢复数据。不过，DELETE 不会删除外部文件加载记录和加载元数据。

在 BigQuery 中，DELETE 语句必须具有 WHERE 子句。 如需详细了解 BigQuery 中的 DELETE，请参阅 DML 文档中的 BigQuery DELETE 示例。

Snowflake	BigQuery
DELETE FROM table_name [USING ...] [WHERE ...] TRUNCATE [TABLE] [IF EXISTS] table_name	DELETE [FROM] table_name [alias] WHERE ... 注意：BigQuery DELETE 语句需要有 WHERE 子句。

MERGE 语句

MERGE 语句可以将 INSERT、UPDATE 和 DELETE 操作合并为一个“upsert”语句，并自动执行这些操作。对应每个目标行，MERGE 操作必须匹配最多一个源行。

由于 BigQuery 表每天最多只能运行 1,000 个 DML 语句，因此您最好将 INSERT、UPDATE 和 DELETE 语句合并到一个 MERGE 语句中，如下表所示：

Snowflake	BigQuery
MERGE INTO target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'Filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col1 = source.col2, ... 注意：Snowflake 支持使用 ERROR_ON_NONDETERMINISTIC_MERGE 会话参数来处理不确定性结果。	MERGE target USING source ON target.key = source.key WHEN MATCHED AND source.filter = 'filter_exp' THEN UPDATE SET target.col1 = source.col1, target.col2 = source.col2, ... 注意：如果更新所有列，则必须列出所有列。

GET 和 LIST 语句

GET 语句会将数据文件从以下任一 Snowflake 暂存区下载到客户端机器上的本地目录/文件夹：

• 命名的内部暂存区
• 指定表的内部暂存区
• 当前用户的内部暂存区

LIST (LS) 语句会返回以下任一 Snowflake 暂存区中暂存（即从本地文件系统上传或从表中卸载）的文件的列表：

• 命名的内部暂存区
• 命名的外部暂存区
• 指定表的暂存区
• 当前用户的暂存区

BigQuery 不支持暂存概念，并且没有 GET 和 LIST 等效项。

PUT 和 REMOVE 语句

PUT 语句会将数据文件从客户端机器上的本地目录/文件夹上传（即暂存）到以下任一 Snowflake 暂存区：

• 命名的内部暂存区
• 指定表的内部暂存区
• 当前用户的内部暂存区

REMOVE (RM) 语句会移除已暂存到以下任一 Snowflake 内部暂存区的文件：

• 命名的内部暂存区
• 指定表的暂存区
• 当前用户的暂存区

BigQuery 不支持暂存概念，并且没有 PUT 和 REMOVE 等效项。

DDL 语法

本部分介绍了 Snowflake 和 BigQuery 在数据定义语言语法上的差异。

数据库、架构和共享 DDL

Snowflake 的大多数术语都与 BigQuery 的术语相同，唯一不同的是，Snowflake 数据库对应的是 BigQuery 数据集。请参阅 Snowflake 与 BigQuery 的详细术语对应关系。

CREATE DATABASE 语句

Snowflake 支持通过数据库管理命令创建和管理数据库；而 BigQuery 则提供了多种可用来创建数据集的方法，例如使用控制台、CLI 或客户端库等等。本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者之间的差异。

Snowflake	BigQuery
CREATE DATABASE <name> 注意：Snowflake 对于数据库的命名有一些要求。名称中只能包含 255 个字符。	bq mk <name> 注意：BigQuery 也有与 Snowflake 类似的数据集命名要求，不同之处在于它允许在名称中包含 1024 个字符。
CREATE OR REPLACE DATABASE <name>	BigQuery 不支持替换数据集。
CREATE TRANSIENT DATABASE <name>	BigQuery 不支持创建临时数据集。
CREATE DATABASE IF NOT EXISTS <name>	BigQuery 不支持该概念
CREATE DATABASE <name> CLONE <source_db> [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]	BigQuery 尚不支持克隆数据集。
CREATE DATABASE <name> DATA_RETENTION_TIME_IN_DAYS = <num>	BigQuery 不支持数据集级层的时间旅行。不过，支持表和查询结果的时间旅行。
CREATE DATABASE <name> DEFAULT_DDL_COLLATION = '<collation_specification>'	BigQuery 不支持 DDL 中的排序规则。
CREATE DATABASE <name> COMMENT = '<string_literal>'	bq mk \ --description "<string_literal>" \ <name>
CREATE DATABASE <name> FROM SHARE <provider_account>.<share_name>	BigQuery 不支持创建共享数据集。不过，创建数据集后，用户可以通过控制台/界面共享数据集。
CREATE DATABASE <name> AS REPLICA OF <region>.<account>.<primary_db_name> AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE } 注意：Snowflake 支持在辅助数据库中自动维护具体化视图的背景，而 BigQuery 则不支持此行为。	bq mk --transfer_config \ --target_dataset = <name> \ --data_source = cross_region_copy \ --params=' {"source_dataset_id":"<primary_db_name>" ,"source_project_id":"<project_id>" ,"overwrite_destination_table":"true"}' 注意：BigQuery 支持使用 BigQuery Data Transfer Service 复制数据集。点击此处了解复制数据集需满足的前提条件。

BigQuery 还提供以下 bq mk 命令选项，这些选项在 Snowflake 中没有直接对应项：

• --location <dataset_location>
• --default_table_expiration <time_in_seconds>
• --default_partition_expiration <time_in_seconds>

ALTER DATABASE 语句

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在 ALTER 语句方面的差异。

Snowflake	BigQuery
ALTER DATABASE [ IF EXISTS ] <name> RENAME TO <new_db_name>	BigQuery 不支持重命名数据集，但支持复制数据集。
ALTER DATABASE <name> SWAP WITH <target_db_name>	BigQuery 不支持交换数据集。
ALTER DATABASE <name> SET [DATA_RETENTION_TIME_IN_DAYS = <num>] [ DEFAULT_DDL_COLLATION = '<value>']	BigQuery 不支持在数据集级层管理数据保留和排序规则。
ALTER DATABASE <name> SET COMMENT = '<string_literal>'	bq update \ --description "<string_literal>" <name>
ALTER DATABASE <name> ENABLE REPLICATION TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]	BigQuery 不支持该概念。
ALTER DATABASE <name> DISABLE REPLICATION [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	BigQuery 不支持该概念。
ALTER DATABASE <name> SET AUTO_REFRESH_MATERIALIZED_VIEWS_ON_SECONDARY = { TRUE | FALSE }	BigQuery 不支持该概念。
ALTER DATABASE <name> REFRESH	BigQuery 不支持该概念。
ALTER DATABASE <name> ENABLE FAILOVER TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]	BigQuery 不支持该概念。
ALTER DATABASE <name> DISABLE FAILOVER [ TO ACCOUNTS <snowflake_region>.<account_name> [ , <snowflake_region>.<account_name> ... ]]	BigQuery 不支持该概念。
ALTER DATABASE <name> PRIMARY	BigQuery 不支持该概念。

DROP DATABASE 语句

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在 DROP 语句方面的差异。

Snowflake	BigQuery
DROP DATABASE [ IF EXISTS ] <name> [ CASCADE | RESTRICT ] 注意：在 Snowflake 中，丢弃数据库并不会将其从系统中永久移除。系统会将丢弃的数据库版本保留一定的天数，该天数由数据库的 DATA_RETENTION_TIME_IN_DAYS 参数指定。	bq rm -r -f -d <name> Where -r 用于移除数据集中的所有对象 -f is to skip confirmation for execution -d 用于指示数据集 注意：在 BigQuery 中，删除数据集属于一项永久性操作。此外，由于数据集中的所有数据和对象都会被删除，因此数据集级层不支持级联。

Snowflake 还支持 UNDROP DATASET 命令，用于恢复已丢弃数据集的最新版本。BigQuery 目前在数据集级层不支持此行为。

USE DATABASE 语句

Snowflake 支持使用 USE DATABASE 命令为用户会话设置数据库。这样就无需在 SQL 命令中指定完全限定的对象名称。对于 Snowflake 中的 USE DATABASE 命令，BigQuery 没有任何对应项。

SHOW DATABASE 语句

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在 SHOW 语句方面的差异。

Snowflake	BigQuery
SHOW DATABASES 注意：Snowflake 提供了一个选项，用于列出和显示有关所有数据库（包括尚在保留期限内的已丢弃数据库）的详细信息。	bq ls --format=prettyjson 和/或 bq show <dataset_name> 注意：在 BigQuery 中，ls 命令仅提供数据集名称和基本信息；而 show 命令会提供数据集的详细信息，例如上次修改时间戳、ACL 和标签。BigQuery 还通过信息架构提供有关数据集的更多详细信息。
SHOW TERSE DATABASES 注意：使用 TERSE 选项时，Snowflake 仅允许显示有关数据集的特定信息/字段。	BigQuery 不支持该概念。
SHOW DATABASES HISTORY	BigQuery 在数据集级层不支持时间旅行概念。
SHOW DATABASES [LIKE '<pattern>'] [STARTS WITH '<name_string>']	BigQuery 不支持按数据集名称过滤结果。不过，支持按标签过滤。
SHOW DATABASES LIMIT <rows> [FROM '<name_string>'] 注意：默认情况下，Snowflake 对结果数量没有限制。但是，LIMIT 的值不能超过 10K。	bq ls \ --max_results <rows> 注意：默认情况下，BigQuery 仅显示 50 个结果。

BigQuery 还提供以下 bq 命令选项，这些选项在 Snowflake 中没有直接对应项：

• bq ls --format=pretty：返回采用基本格式的结果
• *bq ls -a：*仅返回匿名数据集（即以下划线开头的数据集）
• bq ls --all：返回所有数据集（包括匿名数据集）
• bq ls --filter labels.key:value：返回按数据集标签过滤的结果
• bq ls --d：从结果中排除匿名数据集
• bq show --format=pretty：返回所有数据集的详细结果（采用基本格式）

SCHEMA 管理

Snowflake 提供多个与其数据库管理命令类似的架构管理命令。BigQuery 不支持创建和管理架构的概念。

不过，BigQuery 允许您在将数据加载到表中时以及创建空表时指定表架构。对于支持的数据格式，您还可以使用架构自动检测功能。

SHARE 管理

Snowflake 提供多个与其数据库和架构管理命令类似的共享管理命令。BigQuery 不支持创建和管理共享的概念。

表、视图和序列 DDL

CREATE TABLE 语句

大多数 Snowflake CREATE TABLE 语句都与 BigQuery 兼容，但以下语法元素在 BigQuery 中不适用：

Snowflake	BigQuery
CREATE TABLE table_name ( col1 data_type1 NOT NULL, col2 data_type2 NULL, col3 data_type3 UNIQUE, col4 data_type4 PRIMARY KEY, col5 data_type5 ) 注意：UNIQUE 和 PRIMARY KEY 限制条件仅供参考，不会由 Snowflake 系统强制执行。	CREATE TABLE table_name ( col1 data_type1 NOT NULL, col2 data_type2, col3 data_type3, col4 data_type4, col5 data_type5, )
CREATE TABLE table_name ( col1 data_type1[,...] table_constraints ) 其中 table_constraints 为： [UNIQUE(column_name [, ... ])] [PRIMARY KEY(column_name [, ...])] [FOREIGN KEY(column_name [, ...]) REFERENCES reftable [(refcolumn)] 注意：UNIQUE 和 PRIMARY KEY 限制条件仅供参考，不会由 Snowflake 系统强制执行。	CREATE TABLE table_name ( col1 data_type1[,...] ) PARTITION BY column_name CLUSTER BY column_name [, ...] 注意：BigQuery 不使用 UNIQUE、PRIMARY KEY 或 FOREIGN KEY 表限制条件。如需实现这些限制条件在查询执行期间提供的类似优化，请对 BigQuery 表进行分区和聚簇。CLUSTER BY 最多支持四列。
CREATE TABLE table_name LIKE original_table_name	请参阅此示例，了解如何使用 INFORMATION_SCHEMA 表将列名称、数据类型和 NOT NULL 限制条件复制到新表。
CREATE TABLE table_name ( col1 data_type1 ) BACKUP NO 注意：在 Snowflake 中，系统会指定 BACKUP NO 设置以“在创建快照以及从快照恢复数据时节省处理时间，并减少存储空间用量”。	系统将不使用或不需要 BACKUP NO 表选项，因为 BigQuery 会自动将所有表的历史版本保留长达 7 天，而不会影响处理时间或付费存储空间。
CREATE TABLE table_name ( col1 data_type1 ) table_attributes 其中 table_attributes 为： [DISTSTYLE {AUTO|EVEN|KEY|ALL}] [DISTKEY (column_name)] [[COMPOUND|INTERLEAVED] SORTKEY (column_name [, ...])]	BigQuery 支持聚簇，从而能够按排列顺序存储键。
CREATE TABLE table_name AS SELECT ...	CREATE TABLE table_name AS SELECT ...
CREATE TABLE IF NOT EXISTS table_name ...	CREATE TABLE IF NOT EXISTS table_name ...

BigQuery 还支持 DDL 语句 CREATE OR REPLACE TABLE，该语句会覆盖已存在的表。

BigQuery 的 CREATE TABLE 语句还支持以下子句，这些子句没有 Snowflake 等效项：

• PARTITION BY partition_statement
• CLUSTER BY clustering_column_list
• OPTIONS(table_options_list)

如需详细了解 BigQuery 中的 CREATE TABLE，请参阅 DML 文档中的 BigQuery CREATE 示例。

ALTER TABLE 语句

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在表的 ALTER 语句方面的差异。

Snowflake	BigQuery
ALTER TABLE [ IF EXISTS ] <name> RENAME TO <new_name>	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (friendly_name="<new_name>")
ALTER TABLE <name> SWAP WITH <target_db_name>	BigQuery 不支持交换表。
ALTER TABLE <name> SET [DEFAULT_DDL_COLLATION = '<value>']	BigQuery 不支持管理表的数据排序规则。
ALTER TABLE <name> SET [DATA_RETENTION_TIME_IN_DAYS = <num>]	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (expiration_timestamp=<timestamp>)
ALTER TABLE <name> SET COMMENT = '<string_literal>'	ALTER TABLE [IF EXISTS] <name> SET OPTIONS (description='<string_literal>')

此外，Snowflake 还提供聚簇、列和限制条件选项来更改表，BigQuery 则不支持此行为。

DROP TABLE 和 UNDROP TABLE 语句

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在 DROP 和 UNDROP 语句方面的差异。

Snowflake	BigQuery
DROP TABLE [IF EXISTS] <table_name> [CASCADE | RESTRICT] 注意：在 Snowflake 中，丢弃表并不会将其从系统中永久移除。系统会将丢弃的表版本保留一定的天数，该天数由数据库的 DATA_RETENTION_TIME_IN_DAYS 参数指定。	bq rm -r -f -d <dataset_name>.<table_name> Where -r 用于移除数据集中的所有对象 -f 用于跳过执行确认步骤 -d 用于指示数据集 注意：在 BigQuery 中，删除表也不是一项永久性的操作，但删除的快照目前仅保留 7 天。
UNDROP TABLE <table_name>	bq cp \ <dataset_name>.<table_name>@<unix_timestamp> <dataset_name>.<new_table_name> 注意：在 BigQuery 中，首先需要确定表存在时长的 UNIX 时间戳（以毫秒为单位）。然后，将该时间戳的表复制到新表。 新表不得采用已删除表的名称。

CREATE EXTERNAL TABLE 语句

BigQuery 允许创建永久和临时外部表，并允许直接从以下对象查询数据：

• Bigtable
• Cloud Storage
• Google 云端硬盘
• Cloud SQL（Beta 版）

Snowflake 允许创建永久外部表，查询该表时，会从指定的外部暂存区中的一个或多个文件读取数据。

本部分将通过 Snowflake 命令及其相对应的 BigQuery CLI 命令来介绍两者在 CREATE EXTERNAL TABLE 语句方面的差异。

Snowflake	BigQuery
CREATE [OR REPLACE] EXTERNAL TABLE table ((<col_name> <col_type> AS <expr> ) | (<part_col_name> <col_type> AS <part_expr>)[ inlineConstraint ] [ , ... ] ) LOCATION = externalStage FILE_FORMAT = ({FORMAT_NAME='<file_format_name>' |TYPE=source_format [formatTypeOptions]}) Where: externalStage = @[namespace.]ext_stage_name[/path] 注意：Snowflake 允许暂存包含要读取的数据的文件，并允许为外部表指定格式类型选项。Snowflake 格式格式 - CSV、JSON、AVRO、PARQUET、ORC 均受 BigQuery 支持（但 XML 类型除外）。	[1] bq mk \ --external_table_definition=definition_file \ dataset.table OR [2] bq mk \ --external_table_definition=schema_file@source_format={Cloud Storage URI | drive_URI} \ dataset.table OR [3] bq mk \ --external_table_definition=schema@source_format = {Cloud Storage URI | drive_URI} \ dataset.table 注意：BigQuery 允许使用表定义文件 [1]、JSON 架构文件 [2] 或内嵌架构定义 [3] 创建链接到数据源的永久表。BigQuery 不支持暂存要读取的文件，也不支持指定格式类型选项。
CREATE [OR REPLACE] EXTERNAL TABLE [IF EXISTS] <table_name> ((<col_name> <col_type> AS <expr> ) [ , ... ] ) [PARTITION BY (<identifier>, ...)] LOCATION = externalStage [REFRESH_ON_CREATE = {TRUE|FALSE}] [AUTO_REFRESH = {TRUE|FALSE}] [PATTERN = '<regex_pattern>'] FILE_FORMAT = ({FORMAT_NAME = '<file_format_name>' | TYPE = { CSV | JSON | AVRO | ORC | PARQUET} [ formatTypeOptions]}) [COPY GRANTS] [COMMENT = '<string_literal>']	bq mk \ --external_table_definition=definition_file \ dataset.table 注意：BigQuery 目前不支持 Snowflake 提供的任何用于创建外部表的可选参数选项。对于分区，BigQuery 支持使用 _FILE_NAME 伪列在外部表之上创建分区表/视图。如需了解详情，请参阅查询 _FILE_NAME 伪列。

此外，BigQuery 还支持使用默认 hive 分区布局查询存储在 Google Cloud Storage 中的 AVRO、PARQUET、ORC、JSON 和 CSV 格式的外部分区数据。

CREATE VIEW 语句

下表显示了 Snowflake 和 BigQuery 中 CREATE VIEW 语句的等效项。

Snowflake	BigQuery
CREATE VIEW view_name AS SELECT ...	CREATE VIEW view_name AS SELECT ...
CREATE OR REPLACE VIEW view_name AS SELECT ...	CREATE OR REPLACE VIEW view_name AS SELECT ...
CREATE VIEW view_name (column_name, ...) AS SELECT ...	CREATE VIEW view_name AS SELECT ...
不支持	CREATE VIEW IF NOT EXISTS view_name OPTIONS(view_option_list) AS SELECT ...
CREATE VIEW view_name AS SELECT ... WITH NO SCHEMA BINDING	在 BigQuery 中，如需创建视图，所有引用的对象都必须已存在。 BigQuery 允许查询外部数据源。

CREATE SEQUENCE 语句

序列在 BigQuery 中不适用，但可通过以下批处理方法实现。如需详细了解代理键和缓慢变化维度 (SCD)，请参阅以下指南：

• BigQuery 代理键
• 一种在 BigQuery 中使用代理键的可行方法

INSERT INTO dataset.table SELECT *, ROW_NUMBER() OVER () AS id FROM dataset.table

数据加载和卸载 DDL

Snowflake 支持通过暂存区、文件格式和管道管理命令来加载和卸载数据。BigQuery 还提供了多种方法来实现此行为，例如 bq load、BigQuery Data Transfer Service、bq extract 等等。本部分重点介绍了这些方法在数据加载和卸载方面的用法差异。

账号和会话 DDL

Snowflake 中的账号和会话概念在 BigQuery 中不受支持。BigQuery 允许通过 Cloud IAM 在所有级层管理账号。此外，BigQuery 尚不支持多语句事务。

用户定义的函数 (UDF)

借助 UDF，您可以为自定义操作创建函数。这些函数接受输入列、执行操作，然后以值的形式返回这些操作的结果。

Snowflake 和 BigQuery 均支持使用 SQL 表达式和 JavaScript 代码编写的 UDF。

如需了解常见 BigQuery UDF 库，请参阅 GoogleCloudPlatform/bigquery-utils/ GitHub 代码库。

CREATE FUNCTION 语法

下表介绍了 Snowflake 和 BigQuery 在 SQL UDF 创建语法方面的差异。

Snowflake	BigQuery
CREATE [ OR REPLACE ] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition s	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) AS sql_function_definition 注意：在 BigQuery SQL UDF 中，返回数据类型是可选的。当查询调用函数时，BigQuery 会通过 SQL 函数正文推断出函数的结果类型。
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS TABLE (col_name, col_data_type[,..]) AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：在 BigQuery SQL UDF 中，目前不支持返回表类型，但我们已在产品路线图中规划此功能并且很快就会推出。不过，BigQuery 支持返回 STRUCT 类型的 ARRAY。
CREATE [SECURE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：Snowflake 提供了安全的方法来将 UDF 定义和详细信息设为仅限授权用户（即被授予视图所有者角色的用户）访问。	CREATE FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：在 BigQuery 中，函数安全性不是可配置参数。BigQuery 支持创建 IAM 角色和权限，以限制对底层数据和函数定义的访问。
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [ { CALLED ON NULL INPUT | { RETURNS NULL ON NULL INPUT | STRICT } } ] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：null 输入的函数行为会在 BigQuery 中隐式处理，无需通过单独的选项来指定该行为。
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：在 BigQuery 中，函数波动性不是可配置参数。所有 BigQuery UDF 波动性等效于 Snowflake 的 IMMUTABLE 波动性（即不执行数据库查找，也不使用非直接存在于其参数列表中的信息）。
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS [' | $$] sql_function_definition [' | $$]	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition 注意：使用英文单引号或诸如美元引用符号等字符序列 ($$) is not required or supported in BigQuery. BigQuery implicitly interprets the SQL expression.
CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type [COMMENT = '<string_literal>'] AS sql_function_definition	CREATE [OR REPLACE] FUNCTION function_name ([sql_arg_name sql_arg_data_type[,..]]) RETURNS data_type AS sql_function_definition Note:Adding comments or descriptions in UDFs is currently not supported in BigQuery.
CREATE [OR REPLACE] FUNCTION function_name (x integer, y integer) RETURNS integer AS $$ SELECT x + y $$ Note: Snowflake does not support ANY TYPE for SQL UDFs. However, it supports using VARIANT data types.	CREATE [OR REPLACE] FUNCTION function_name (x ANY TYPE, y ANY TYPE) AS SELECT x + y Note: BigQuery supports using ANY TYPE as argument type. The function will accept an input of any type for this argument. For more information, see templated parameter in BigQuery.

BigQuery also supports the CREATE FUNCTION IF NOT EXISTSstatement which treats the query as successful and takes no action if a function with the same name already exists.

BigQuery's CREATE FUNCTIONstatement also supports creating TEMPORARY or TEMP functions, which do not have a Snowflake equivalent. See calling UDFs for details on executing a BigQuery persistent UDF.

DROP FUNCTION syntax

The following table addresses differences in DROP FUNCTION syntax between Snowflake and BigQuery.

Snowflake	BigQuery
DROP FUNCTION [IF EXISTS] function_name ([arg_data_type, ... ])	DROP FUNCTION [IF EXISTS] dataset_name.function_name Note: BigQuery does not require using the function's signature (argument data type) for deleting the function.

BigQuery requires that you specify the project_name if the function is not located in the current project.

Additional function commands

This section covers additional UDF commands supported by Snowflake that are not directly available in BigQuery.

ALTER FUNCTION syntax

Snowflake supports the following operations using ALTER FUNCTION syntax.

• Renaming a UDF
• Converting to (or reverting from) a secure UDF
• Adding, overwriting, removing a comment for a UDF

As configuring function security and adding function comments is not available in BigQuery, ALTER FUNCTION syntax is currently not supported. However, the CREATE FUNCTION statement can be used to create a UDF with the same function definition but a different name.

DESCRIBE FUNCTION syntax

Snowflake supports describing a UDF using DESC[RIBE] FUNCTION syntax. This is currently not supported in BigQuery. However, querying UDF metadata via INFORMATION SCHEMA will be available soon as part of the product roadmap.

SHOW USER FUNCTIONS syntax

In Snowflake, SHOW USER FUNCTIONS syntax can be used to list all UDFs for which users have access privileges. This is currently not supported in BigQuery. However, querying UDF metadata via INFORMATION SCHEMA will be available soon as part of the product roadmap.

Stored procedures

Snowflake stored procedures are written in JavaScript, which can execute SQL statements by calling a JavaScript API. In BigQuery, stored procedures are defined using a block of SQL statements.

CREATE PROCEDURE syntax

In Snowflake, a stored procedure is executed with a CALL command while in BigQuery, stored procedures are executed like any other BigQuery function.

The following table addresses differences in stored procedure creation syntax between Snowflake and BigQuery.

Snowflake	BigQuery
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS procedure_definition; Note: Snowflake requires that stored procedures return a single value. Hence, return data type is a required option.	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_mode arg_name arg_data_type[,..]]) BEGIN procedure_definition END; arg_mode: IN | OUT | INOUT Note: BigQuery doesn't support a return type for stored procedures. Also, it requires specifying argument mode for each argument passed.
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type AS $$ javascript_code $$;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN statement_list END;
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [{CALLED ON NULL INPUT | {RETURNS NULL ON NULL INPUT | STRICT}}] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; 注意：null 输入的过程行为会在 BigQuery 中隐式处理，无需通过单独的选项来指定该行为。
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [VOLATILE | IMMUTABLE] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; 注意：在 BigQuery 中，过程波动性不是可配置参数。它等效于 Snowflake 的 IMMUTABLE 波动性。
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [COMMENT = '<string_literal>'] AS procedure_definition;	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; 注意：BigQuery 目前不支持在过程定义中添加注释或说明。
CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) RETURNS data_type [EXECUTE AS { CALLER | OWNER }] AS procedure_definition; 注意：Snowflake 支持指定执行过程的调用方或所有者	CREATE [OR REPLACE] PROCEDURE procedure_name ([arg_name arg_data_type[,..]]) BEGIN procedure_definition END; 注意：BigQuery 的存储过程始终作为调用方执行

BigQuery 还支持 CREATE PROCEDURE IF NOT EXISTS 语句，该语句将查询视为成功，如果已存在同名函数，则不会执行任何操作。

DROP PROCEDURE 语法

下表介绍了 Snowflake 和 BigQuery 在 DROP FUNCTION 语法方面的差异。

Snowflake	BigQuery
DROP PROCEDURE [IF EXISTS] procedure_name ([arg_data_type, ... ])	DROP PROCEDURE [IF EXISTS] dataset_name.procedure_name 注意：BigQuery 不要求使用过程的签名（参数数据类型）来删除过程。

如果该过程不在当前项目中，则 BigQuery 会要求您指定 project_name。

其他过程命令

Snowflake 还提供其他命令（例如 ALTER PROCEDURE、DESC[RIBE] PROCEDURE 和 SHOW PROCEDURES）来管理存储过程。BigQuery 目前不支持这些命令。

元数据和事务 SQL 语句

Snowflake	BigQuery
BEGIN [ { WORK | TRANSACTION } ] [ NAME <name> ]; START_TRANSACTION [ name <name> ];	BigQuery 始终使用快照隔离。如需了解详情，请参阅本文档其他位置的一致性保证。
COMMIT;	在 BigQuery 中不使用。
ROLLBACK;	在 BigQuery 中不适用。
SHOW LOCKS [ IN ACCOUNT ]; SHOW TRANSACTIONS [ IN ACCOUNT ]; Note: If the user has the ACCOUNTADMIN role, the user can see locks/transactions for all users in the account.	在 BigQuery 中不使用。

多语句和多行 SQL 语句

Snowflake 和 BigQuery 都支持事务（会话），因此支持用分号分隔并始终一起执行的语句。如需了解详情，请参阅多语句事务。

暂存文件的元数据列

Snowflake 会自动为内部和外部暂存区中的文件生成元数据。可以查询此元数据，并将其与常规数据列一起加载到表中。可以使用以下元数据列：

• METADATA$FILENAME
• METADATA$FILE_ROW_NUMBER

一致性保证和事务隔离

Snowflake 和 BigQuery 都是原子性的，也就是说，在多行的每个变更级别都符合 ACID。

交易

每个 Snowflake 事务都分配有一个唯一的开始时间（以毫秒为单位），该时间会用来设置事务 ID。Snowflake 仅支持 READ COMMITTED 隔离级别。但是，如果语句在同一个事务中，那么一个语句可以看到另一个语句所做的更改，即使这些更改尚未提交也是如此。Snowflake 事务会在资源被修改时获取资源（表）锁定。用户可以调整被阻止的语句在语句超时之前等待的最长时间。如果 AUTOCOMMIT 参数已启用，则 DML 语句会自动提交。

BigQuery 也支持事务。BigQuery 使用快照隔离帮助确保乐观并发控制（首先提交胜出），其中查询在查询开始之前读取最后提交的数据。此方法可保证每行的每个变更和同一 DML 语句中的各行具有相同的一致性级别，同时避免死锁。如果对同一个表进行了多个 DML 更新，BigQuery 会切换为悲观并发控制。加载作业可以完全独立运行并附加到表。然而，BigQuery 尚未提供明确的事务边界或会话。

回滚

如果 Snowflake 事务的会话在事务提交或回滚之前意外终止，则事务将保持分离状态。用户应运行 SYSTEM$ABORT_TRANSACTION 来中止分离的事务，否则 Snowflake 将在 4 小时空闲时间后回滚分离的事务。如果发生死锁，Snowflake 会检测死锁并选择要回滚的较新语句。如果有明确打开的事务中的 DML 语句失败，则系统会回滚所做的更改，但事务在提交或回滚之前会保持打开状态。Snowflake 中的 DDL 语句无法回滚，因为它们会自动提交。

BigQuery 支持 ROLLBACK TRANSACTION 语句。BigQuery 中没有 ABORT 语句。

数据库限制

请务必查看 BigQuery 公开文档，了解最新的配额和限制。大批量用户的许多配额都可通过联系 Cloud 支持团队提高。

默认情况下，所有 Snowflake 账号都设置了软性限额。软性限额是在账号创建期间设置的，根据具体情况可能会有所不同。Snowflake 的许多软性限额都可通过 Snowflake 客户支持团队或通过提交支持服务工单来提高。

下表显示了 Snowflake 和 BigQuery 数据库限制的比较。

限额	Snowflake	BigQuery
查询文本的大小	1 MB	1 MB
并发查询数上限	XS 型仓库 - 8 S 型仓库 - 16 M 型仓库 - 32 L 型仓库 - 64 XL 型仓库 - 128	100