Parser gaps-f: Snowflake CALL, DATA METRIC FUNCTION, POLICY_CONTEXT and recorded expression fixes

corpora/polyglot-check/expected_differences.toml

@@ -1142,3 +1142,80 @@ id = "snowflake_scripting_block"
 marker = "BEGIN"
 sqlquack_node = "scripting_block"
 note = "a Snowflake Scripting block parses into its declarations, statements and handlers; crates/sqlquack-syntax/tests/parser/test_scripting.rs pins the tree"
+
+[[rejection]]
+id = "snowflake_stage_reserved_name"
+sql = "SELECT @select"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected a stage name after @"
+note = "Snowflake reads @ as a stage reference and refuses a bare reserved word as the stage name (recorded syntax_error)"
+
+[[rejection]]
+id = "snowflake_stage_quoted_blank_name"
+sql = "SELECT @`a b`"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected a stage name after @"
+note = "Snowflake refuses a stage reference whose quoted name holds a blank (recorded syntax_error); backticks are no Snowflake quote either"
+
+[[rejection]]
+id = "snowflake_stage_string_name"
+sql = "SELECT @JOIN, @'foo'"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected a stage name after @"
+note = "Snowflake reads @ as a stage reference and refuses a string as the stage name (recorded syntax_error for @'v1')"
+
+[[rejection]]
+id = "snowflake_bare_interval_type_double_colon"
+sql = "SELECT interval '00:00:01'::interval AS foo"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_bare_interval_type_cast"
+sql = "SELECT CAST(INTERVAL '00:00:01' AS INTERVAL) AS foo"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_bare_interval_type_double_colon_window"
+sql = "SELECT ROW_NUMBER() OVER(PARTITION BY event_time + interval '00:00:01'::interval) AS foo FROM t"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_bare_interval_type_cast_window"
+sql = "SELECT ROW_NUMBER() OVER (PARTITION BY event_time + CAST(INTERVAL '00:00:01' AS INTERVAL)) AS foo FROM t"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_bare_interval_type_cast_string"
+sql = "CAST('1 DAY' AS INTERVAL)"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_type_bare_interval_cast"
+sql = "SELECT CAST(x AS INTERVAL)"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_type_bare_interval_try_cast"
+sql = "SELECT TRY_CAST(x AS INTERVAL)"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"
+
+[[rejection]]
+id = "snowflake_type_bare_interval_double_colon"
+sql = "SELECT x::INTERVAL"
+dialects = ["Snowflake"]
+sqlquack_error = "Expected an interval field such as DAY or YEAR TO MONTH"
+note = "Snowflake's INTERVAL type needs a field (recorded errno 1003 for CAST ( NULL AS INTERVAL ))"

crates/sqlquack-core/src/classification/main/cast_type_name.rs

@@ -46,7 +46,7 @@ pub fn cast_type_name(data_type: &DataType) -> String {
         DataType::Enum { .. } => "ENUM",
         DataType::Set { .. } => "SET",
         DataType::Union { .. } => "UNION",
-        DataType::Nullable { inner } => return cast_type_name(inner),
+        DataType::Nullable { inner } | DataType::NotNull { inner } => return cast_type_name(inner),
         DataType::Custom { name } => return custom_type_name(name),
         DataType::Geometry { .. } => "GEOMETRY",
         DataType::Geography { .. } => "GEOGRAPHY",

crates/sqlquack-polyglot-check/src/comparison/_helpers/outcomes.rs

@@ -42,13 +42,38 @@ pub(crate) fn lossless_failure(sql: &str, dialect: Dialect, parsed: bool) -> Opt
     }
 }
 
+/// `value` with each Snowflake `NOT NULL` element wrapper replaced by its inner type, which polyglot lacks.
+fn without_not_null(value: serde_json::Value) -> serde_json::Value {
+    match value {
+        serde_json::Value::Object(mut object)
+            if object.get("data_type").and_then(serde_json::Value::as_str) == Some("not_null") =>
+        {
+            object
+                .remove("inner")
+                .map(without_not_null)
+                .unwrap_or(serde_json::Value::Object(object))
+        }
+        serde_json::Value::Object(object) => serde_json::Value::Object(
+            object
+                .into_iter()
+                .map(|(key, field)| (key, without_not_null(field)))
+                .collect(),
+        ),
+        serde_json::Value::Array(items) => {
+            serde_json::Value::Array(items.into_iter().map(without_not_null).collect())
+        }
+        other => other,
+    }
+}
+
 /// polyglot's Snowflake rendering of `data_type`, cut to its upper-case base name.
 pub(crate) fn polyglot_base_type_name(
     data_type: &sqlquack_syntax::DataType,
     dialect: polyglot_sql::DialectType,
 ) -> String {
-    let converted =
-        serde_json::to_value(data_type).and_then(serde_json::from_value::<polyglot_sql::DataType>);
+    let converted = serde_json::to_value(data_type)
+        .map(without_not_null)
+        .and_then(serde_json::from_value::<polyglot_sql::DataType>);
     let theirs = match converted {
         Ok(theirs) => theirs,
         Err(_) => return "<unconvertible>".to_owned(),

crates/sqlquack-polyglot-check/tests/runs/test_exact.rs

@@ -49,6 +49,8 @@ fn given_committed_corpora_when_parsed_by_both_parsers_then_results_are_identica
                     ("snowflake_show_profile".to_owned(), 1),
                     ("snowflake_show_groups".to_owned(), 1),
                     ("snowflake_show_create_table".to_owned(), 1),
+                    ("snowflake_stage_reserved_name".to_owned(), 1),
+                    ("snowflake_stage_quoted_blank_name".to_owned(), 1),
                 ]),
                 differences: Vec::new(),
                 tokens_lost: Vec::new(),
@@ -87,6 +89,15 @@ fn given_committed_corpora_when_parsed_by_both_parsers_then_results_are_identica
                     ("snowflake_describe_formatted".to_owned(), 1),
                     ("snowflake_describe_query".to_owned(), 1),
                     ("snowflake_describe_bare_quoted_name".to_owned(), 1),
+                    ("snowflake_stage_string_name".to_owned(), 1),
+                    ("snowflake_bare_interval_type_double_colon".to_owned(), 1),
+                    ("snowflake_bare_interval_type_cast".to_owned(), 1),
+                    (
+                        "snowflake_bare_interval_type_double_colon_window".to_owned(),
+                        1,
+                    ),
+                    ("snowflake_bare_interval_type_cast_window".to_owned(), 1),
+                    ("snowflake_bare_interval_type_cast_string".to_owned(), 1),
                 ]),
                 differences: Vec::new(),
                 tokens_lost: Vec::new(),
@@ -157,7 +168,11 @@ fn given_committed_corpora_when_parsed_by_both_parsers_then_results_are_identica
             entries: load_corpus(&corpora.join("snowflake_types.json")),
             expected_outcome: ExactOutcome {
                 loaded: true,
-                rejected: BTreeMap::new(),
+                rejected: BTreeMap::from([
+                    ("snowflake_type_bare_interval_cast".to_owned(), 1),
+                    ("snowflake_type_bare_interval_try_cast".to_owned(), 1),
+                    ("snowflake_type_bare_interval_double_colon".to_owned(), 1),
+                ]),
                 differences: Vec::new(),
                 tokens_lost: Vec::new(),
                 type_names: Vec::new(),

crates/sqlquack-semantics/src/lineage/_helpers/checks/families.rs

@@ -215,7 +215,7 @@ pub(crate) fn data_type_family(data_type: &DataType) -> Family {
         | DataType::Union { .. }
         | DataType::Geometry { .. }
         | DataType::Geography { .. } => Family::Struct,
-        DataType::Nullable { inner } => data_type_family(inner),
+        DataType::Nullable { inner } | DataType::NotNull { inner } => data_type_family(inner),
         DataType::Custom { name } => type_family(name),
         _ => Family::Unknown,
     }

crates/sqlquack-syntax/src/expressions/columns/models.rs

@@ -551,9 +551,59 @@ pub enum ColumnPosition {
     After(Identifier),
 }
 
+/// Snowflake `{ ADD | DROP | MODIFY } DATA METRIC FUNCTION <name> ON ( ... ) [ <clause> ], ...`.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct DataMetricFunctionAction {
+    /// `ADD`, `DROP` or `MODIFY`.
+    pub kind: String,
+    pub items: Vec<DataMetricFunctionItem>,
+}
+
+/// One `<name> ON ( <argument>, ... )` of a data metric function action, with its clauses.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct DataMetricFunctionItem {
+    pub name: TableRef,
+    pub arguments: Vec<Expression>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub clauses: Vec<DataMetricFunctionClause>,
+}
+
+/// A clause after a data metric function's arguments.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum DataMetricFunctionClause {
+    /// `SENSITIVITY = <value>` or `ANOMALY_DETECTION = <value>`.
+    Property {
+        name: String,
+        value: Expression,
+    },
+    /// `[ ADD | DROP | MODIFY ] EXPECTATION <expectation>, ...`.
+    Expectations {
+        action: Option<String>,
+        expectations: Vec<DataMetricExpectation>,
+    },
+    /// `WITHIN GROUP ( <column>, ... ) [ GROUP LIMIT <n> ]`.
+    WithinGroup {
+        columns: Vec<Expression>,
+        limit: Option<Expression>,
+    },
+    ExecuteAsRole(Identifier),
+    /// `FILTER ( [ <condition> ] )`.
+    Filter(Option<Expression>),
+    /// `SUSPEND` or `RESUME`.
+    State(String),
+}
+
+/// A data metric function expectation: its name and, except under DROP, its condition.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct DataMetricExpectation {
+    pub name: Identifier,
+    pub condition: Option<Expression>,
+}
+
 /// Actions for ALTER TABLE
 #[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum AlterTableAction {
+    DataMetricFunction(DataMetricFunctionAction),
     AddColumn {
         column: ColumnDef,
         if_not_exists: bool,

crates/sqlquack-syntax/src/expressions/schema_objects/models.rs

@@ -215,6 +215,7 @@ pub struct AlterView {
 pub enum AlterViewAction {
     /// Rename the view
     Rename(Box<TableRef>),
+    DataMetricFunction(crate::expressions::columns::models::DataMetricFunctionAction),
     /// Change owner
     OwnerTo(Identifier),
     /// Set schema

crates/sqlquack-syntax/src/expressions/statements/models.rs

@@ -352,6 +352,14 @@ pub struct ExecuteStatement {
     pub suffix: Option<String>,
 }
 
+/// Snowflake `EXECUTE USING POLICY_CONTEXT ( <name> => <value> , ... ) AS <query>`.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteUsingPolicyContext {
+    /// The named arguments of POLICY_CONTEXT.
+    pub arguments: Vec<Expression>,
+    pub query: Expression,
+}
+
 /// Snowflake `EXECUTE ALERT | TASK [ GRAPH ] | DCM PROJECT <name>` with its action.
 #[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ExecuteObject {
@@ -1603,6 +1611,7 @@ pub enum ScriptingDeclaration {
     Cursor(ScriptingCursor),
     Resultset(ScriptingResultset),
     Exception(ScriptingException),
+    Procedure(Box<ScriptingProcedure>),
 }
 
 /// `name [type] [{DEFAULT | :=} expression]`.
@@ -1678,6 +1687,19 @@ pub struct ScriptingException {
     pub message: Option<Expression>,
 }
 
+/// `name PROCEDURE ( [<arg> <type>, ...] ) RETURNS { <type> | TABLE ( ... ) } AS <block>`.
+#[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ScriptingProcedure {
+    #[serde(default, skip_serializing_if = "SourceSpan::is_absent")]
+    #[ast(skip)]
+    pub span: SourceSpan,
+    pub name: Identifier,
+    pub parameters: Vec<crate::expressions::schema_objects::models::FunctionParameter>,
+    pub return_type: Option<DataType>,
+    pub returns_table: Option<Vec<StructField>>,
+    pub body: ScriptingBlock,
+}
+
 /// One body member, terminated by its own semicolon.
 #[derive(sqlquack_syntax_derive::AstNode, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]

crates/sqlquack-syntax/src/expressions/tree/_helpers/accessors.rs

@@ -133,6 +133,7 @@ impl Expression {
             | Expression::Prepare(_)
             | Expression::Execute(_)
             | Expression::ExecuteObject(_)
+            | Expression::ExecuteUsingPolicyContext(_)
             | Expression::Declare(_)
             | Expression::Refresh(_)
             | Expression::AlterSession(_)

crates/sqlquack-syntax/src/expressions/tree/_helpers/api.rs

@@ -446,6 +446,7 @@ impl Expression {
             Expression::Prepare(_) => "prepare",
             Expression::Execute(_) => "execute",
             Expression::ExecuteObject(_) => "execute_object",
+            Expression::ExecuteUsingPolicyContext(_) => "execute_using_policy_context",
             Expression::Raw(_) => "raw",
             Expression::CreateTask(_) => "create_task",
             Expression::Paren(_) => "paren",

crates/sqlquack-syntax/src/expressions/tree/models.rs

@@ -387,6 +387,7 @@ use crate::expressions::statements::models::Detach;
 use crate::expressions::statements::models::DropPartition;
 use crate::expressions::statements::models::ExecuteObject;
 use crate::expressions::statements::models::ExecuteStatement;
+use crate::expressions::statements::models::ExecuteUsingPolicyContext;
 use crate::expressions::statements::models::Get;
 use crate::expressions::statements::models::Grant;
 use crate::expressions::statements::models::GrantPrincipal;
@@ -1222,6 +1223,7 @@ pub enum Expression {
     /// EXEC/EXECUTE statement (TSQL stored procedure call)
     Execute(Box<ExecuteStatement>),
     ExecuteObject(Box<ExecuteObject>),
+    ExecuteUsingPolicyContext(Box<ExecuteUsingPolicyContext>),
 
     /// Snowflake CREATE TASK statement
     CreateTask(Box<CreateTask>),

crates/sqlquack-syntax/src/expressions/types/models.rs

@@ -299,6 +299,11 @@ pub enum DataType {
         inner: Box<DataType>,
     },
 
+    /// An element or value type declared NOT NULL, as in Snowflake's `ARRAY ( INT NOT NULL )`.
+    NotNull {
+        inner: Box<DataType>,
+    },
+
     Custom {
         name: String,
     },
@@ -334,7 +339,7 @@ impl DataType {
             DataType::Array { element_type, .. } | DataType::List { element_type } => {
                 element_type.contains_unknown()
             }
-            DataType::Nullable { inner } => inner.contains_unknown(),
+            DataType::Nullable { inner } | DataType::NotNull { inner } => inner.contains_unknown(),
             DataType::Map {
                 key_type,
                 value_type,
@@ -362,8 +367,12 @@ impl DataType {
         }
         match (self, refined) {
             (DataType::Unknown, _) => true,
-            (DataType::Nullable { inner }, other) => inner.matches_shape_of(other),
-            (this, DataType::Nullable { inner }) => this.matches_shape_of(inner),
+            (DataType::Nullable { inner } | DataType::NotNull { inner }, other) => {
+                inner.matches_shape_of(other)
+            }
+            (this, DataType::Nullable { inner } | DataType::NotNull { inner }) => {
+                this.matches_shape_of(inner)
+            }
             (
                 DataType::Array { element_type, .. } | DataType::List { element_type },
                 DataType::Array {

crates/sqlquack-syntax/src/parser/_helpers/ddl/alter.rs

@@ -39,7 +39,9 @@ use crate::tokens::types::Result;
 impl Parser {
     /// Parse ALTER TABLE action
     pub(crate) fn parse_alter_action(&mut self) -> Result<AlterTableAction> {
-        if self.match_token(TokenType::Add) {
+        if let Some(action) = self.parse_data_metric_function_action()? {
+            Ok(AlterTableAction::DataMetricFunction(action))
+        } else if self.match_token(TokenType::Add) {
             self.parse_alter_add_action()
         } else if self.match_token(TokenType::Drop) {
             self.parse_alter_drop_action()