|
| 1 | +//! The unaliased select items whose column names Snowflake receipts record. |
| 2 | +
|
| 3 | +use serde_json::Value; |
| 4 | + |
| 5 | +use crate::conversion::_helpers::support::tree::{ |
| 6 | + LITERAL_NUMBER, LITERAL_STRING, list, node_kind, unexpected_fields, |
| 7 | +}; |
| 8 | +use crate::conversion::constants::{ |
| 9 | + OUTPUT_NAMED_AGGREGATES, OUTPUT_NAMED_ARITHMETIC, OUTPUT_NAMED_CAST_ENDINGS, |
| 10 | + OUTPUT_NAMED_FUNCTIONS, |
| 11 | +}; |
| 12 | + |
| 13 | +/// Whether an unaliased item written as `text` has a shape whose name receipts record. |
| 14 | +pub(crate) fn recorded_name_shape(item: &Value, text: &str) -> bool { |
| 15 | + let Some((kind, payload)) = node_kind(item) else { |
| 16 | + return false; |
| 17 | + }; |
| 18 | + let Some(fields) = payload.as_object() else { |
| 19 | + return matches!(kind, "null"); |
| 20 | + }; |
| 21 | + let only = |understood: &[&str]| unexpected_fields(fields, understood).is_empty(); |
| 22 | + let named = |names: &[&str]| { |
| 23 | + payload |
| 24 | + .get("name") |
| 25 | + .and_then(Value::as_str) |
| 26 | + .is_some_and(|name| names.contains(&name.to_ascii_uppercase().as_str())) |
| 27 | + }; |
| 28 | + let arguments = list(fields, "args"); |
| 29 | + match kind { |
| 30 | + "aggregate_function" => { |
| 31 | + only(&["name", "args", "distinct"]) |
| 32 | + && named(OUTPUT_NAMED_AGGREGATES) |
| 33 | + && arguments.len() == 1 |
| 34 | + && arguments.iter().all(|argument| { |
| 35 | + plain_column(argument) |
| 36 | + || (named(&["COUNT"]) && matches!(node_kind(argument), Some(("star", _)))) |
| 37 | + }) |
| 38 | + } |
| 39 | + "function" => { |
| 40 | + only(&["name", "args"]) |
| 41 | + && named(OUTPUT_NAMED_FUNCTIONS) |
| 42 | + && !arguments.is_empty() |
| 43 | + && arguments |
| 44 | + .iter() |
| 45 | + .all(|argument| plain_column(argument) || integer_literal(argument)) |
| 46 | + } |
| 47 | + "concat" => { |
| 48 | + only(&["left", "right"]) |
| 49 | + && payload.get("left").is_some_and(plain_column) |
| 50 | + && payload.get("right").is_some_and(string_literal) |
| 51 | + } |
| 52 | + "cast" => { |
| 53 | + let upper = text.to_ascii_uppercase(); |
| 54 | + only(&["this", "to", "double_colon_syntax"]) |
| 55 | + && payload.get("this").is_some_and(plain_column) |
| 56 | + && OUTPUT_NAMED_CAST_ENDINGS |
| 57 | + .iter() |
| 58 | + .any(|ending| upper.ends_with(ending)) |
| 59 | + } |
| 60 | + "neg" => { |
| 61 | + only(&["this"]) |
| 62 | + && payload.get("this").is_some_and(integer_literal) |
| 63 | + && text.strip_prefix('-').is_some_and(|rest| { |
| 64 | + !rest.is_empty() && rest.bytes().all(|byte| byte.is_ascii_digit()) |
| 65 | + }) |
| 66 | + } |
| 67 | + "literal" => recorded_literal(item), |
| 68 | + "null" | "boolean" => true, |
| 69 | + arithmetic if OUTPUT_NAMED_ARITHMETIC.contains(&arithmetic) => { |
| 70 | + only(&["left", "right"]) |
| 71 | + && payload.get("left").is_some_and(plain_column) |
| 72 | + && payload.get("right").is_some_and(integer_literal) |
| 73 | + } |
| 74 | + _ => false, |
| 75 | + } |
| 76 | +} |
| 77 | + |
| 78 | +/// A column, qualified or not, each part unquoted or quoted and already upper case. |
| 79 | +fn plain_column(node: &Value) -> bool { |
| 80 | + let Some(("column", payload)) = node_kind(node) else { |
| 81 | + return false; |
| 82 | + }; |
| 83 | + let Some(fields) = payload.as_object() else { |
| 84 | + return false; |
| 85 | + }; |
| 86 | + let upper_or_unquoted = |part: &Value| { |
| 87 | + let quoted = part.get("quoted").and_then(Value::as_bool) == Some(true); |
| 88 | + let name = part.get("name").and_then(Value::as_str).unwrap_or_default(); |
| 89 | + !name.is_empty() && (!quoted || name == name.to_ascii_uppercase()) |
| 90 | + }; |
| 91 | + unexpected_fields(fields, &["name", "table"]).is_empty() |
| 92 | + && payload.get("name").is_some_and(upper_or_unquoted) |
| 93 | + && payload |
| 94 | + .get("table") |
| 95 | + .filter(|table| !table.is_null()) |
| 96 | + .is_none_or(upper_or_unquoted) |
| 97 | +} |
| 98 | + |
| 99 | +/// A literal spelled as a receipt records: an integer, a decimal, an exponent or plain text. |
| 100 | +fn recorded_literal(node: &Value) -> bool { |
| 101 | + let Some(("literal", payload)) = node_kind(node) else { |
| 102 | + return false; |
| 103 | + }; |
| 104 | + let value = payload |
| 105 | + .get("value") |
| 106 | + .and_then(Value::as_str) |
| 107 | + .unwrap_or_default(); |
| 108 | + match payload.get("literal_type").and_then(Value::as_str) { |
| 109 | + Some(LITERAL_NUMBER) => { |
| 110 | + let (mantissa, exponent) = match value.split_once('e') { |
| 111 | + Some((mantissa, exponent)) => (mantissa, Some(exponent)), |
| 112 | + None => (value, None), |
| 113 | + }; |
| 114 | + let (whole, fraction) = match mantissa.split_once('.') { |
| 115 | + Some((whole, fraction)) => (whole, Some(fraction)), |
| 116 | + None => (mantissa, None), |
| 117 | + }; |
| 118 | + let digits = |text: &str| !text.is_empty() && text.bytes().all(|b| b.is_ascii_digit()); |
| 119 | + let leading_zero = whole.starts_with('0'); |
| 120 | + digits(whole) |
| 121 | + && (whole.len() == 1 || !leading_zero) |
| 122 | + && fraction.is_none_or(digits) |
| 123 | + && exponent |
| 124 | + .is_none_or(|exponent| fraction.is_none() && !leading_zero && digits(exponent)) |
| 125 | + } |
| 126 | + Some(LITERAL_STRING) => string_literal(node), |
| 127 | + _ => false, |
| 128 | + } |
| 129 | +} |
| 130 | + |
| 131 | +fn integer_literal(node: &Value) -> bool { |
| 132 | + recorded_literal(node) |
| 133 | + && node_kind(node) |
| 134 | + .and_then(|(_, payload)| payload.get("value")) |
| 135 | + .and_then(Value::as_str) |
| 136 | + .is_some_and(|value| value.bytes().all(|byte| byte.is_ascii_digit())) |
| 137 | +} |
| 138 | + |
| 139 | +/// Non-empty printable ASCII text without a quote or backslash, which has one spelling. |
| 140 | +fn string_literal(node: &Value) -> bool { |
| 141 | + let Some(("literal", payload)) = node_kind(node) else { |
| 142 | + return false; |
| 143 | + }; |
| 144 | + payload.get("literal_type").and_then(Value::as_str) == Some(LITERAL_STRING) |
| 145 | + && payload |
| 146 | + .get("value") |
| 147 | + .and_then(Value::as_str) |
| 148 | + .is_some_and(|value| { |
| 149 | + !value.is_empty() |
| 150 | + && value |
| 151 | + .bytes() |
| 152 | + .all(|byte| (b' '..=b'~').contains(&byte) && byte != b'\'' && byte != b'\\') |
| 153 | + }) |
| 154 | +} |
0 commit comments