ok

src/dialect_translation/hive.rs

@@ -9,7 +9,7 @@ use sqlparser::{ast, dialect::HiveDialect};
 pub struct HiveTranslator;
 
 // Using the same translations as in bigquery since it should be similar.
-// HiveTranslator is not tested at the moment.
+// HiveTranslator is not well tested at the moment.
 impl RelationToQueryTranslator for HiveTranslator {
     fn identifier(&self, value: &expr::Identifier) -> Vec<ast::Ident> {
         value
@@ -109,6 +109,41 @@ impl RelationToQueryTranslator for HiveTranslator {
         };
         function_builder("UNIX_SECONDS", vec![cast], false)
     }
+
+    fn set_operation(
+        &self,
+        with: Vec<ast::Cte>,
+        operator: ast::SetOperator,
+        quantifier: ast::SetQuantifier,
+        left: ast::Select,
+        right: ast::Select,
+    ) -> ast::Query {
+        // UNION in big query must use a quantifier that can be either
+        // ALL or Distinct.
+        let translated_quantifier = match quantifier {
+            ast::SetQuantifier::All => ast::SetQuantifier::All,
+            _ => ast::SetQuantifier::Distinct,
+        };
+        ast::Query {
+            with: (!with.is_empty()).then_some(ast::With {
+                recursive: false,
+                cte_tables: with,
+            }),
+            body: Box::new(ast::SetExpr::SetOperation {
+                op: operator,
+                set_quantifier: translated_quantifier,
+                left: Box::new(ast::SetExpr::Select(Box::new(left))),
+                right: Box::new(ast::SetExpr::Select(Box::new(right))),
+            }),
+            order_by: vec![],
+            limit: None,
+            offset: None,
+            fetch: None,
+            locks: vec![],
+            limit_by: vec![],
+            for_clause: None,
+        }
+    }
 }
 
 impl QueryToRelationTranslator for HiveTranslator {

src/dialect_translation/mssql.rs

@@ -273,6 +273,18 @@ impl RelationToQueryTranslator for MsSqlTranslator {
             options: None,
         }
     }
+
+    fn format_float_value(&self, value: f64) -> ast::Expr {
+        let max_precision = 37;
+        let formatted = if value.abs() < 1e-10 || value.abs() > 1e10 {
+            // If the value is too small or too large, switch to scientific notation
+            format!("{:.precision$e}", value, precision = max_precision)
+        } else {
+            // Otherwise, use the default float formatting with the specified precision
+            format!("{}", value)
+        };
+        ast::Expr::Value(ast::Value::Number(formatted, false))
+    }
 }
 
 impl QueryToRelationTranslator for MsSqlTranslator {