New rule L069: Consistent syntax for sql type casting

src/sqlfluff/core/default_config.cfg

@@ -266,3 +266,7 @@ force_enable = False
 [sqlfluff:rules:L066]
 min_alias_length = None
 max_alias_length = None
+
+[sqlfluff:rules:L069]
+# SQL type casting
+preferred_type_casting_style = consistent

src/sqlfluff/core/rules/config_info.py

@@ -202,6 +202,10 @@
         "validation": ["single", "multiple"],
         "definition": "Treatment of wildcards. Defaults to ``single``.",
     },
+    "preferred_type_casting_style": {
+        "validation": ["consistent", "shorthand", "convert", "cast"],
+        "definition": ("The expectation for using sql type casting"),
+    },
 }
 
 

src/sqlfluff/dialects/dialect_ansi.py

@@ -1075,7 +1075,18 @@ class ShorthandCastSegment(BaseSegment):
 
     type = "cast_expression"
     match_grammar: Matchable = Sequence(
-        Ref("CastOperatorSegment"), Ref("DatatypeSegment"), allow_gaps=True
+        OneOf(
+            Ref("Expression_D_Grammar"),
+            Ref("CaseExpressionSegment"),
+        ),
+        AnyNumberOf(
+            Sequence(
+                Ref("CastOperatorSegment"),
+                Ref("DatatypeSegment"),
+                Ref("TimeZoneGrammar", optional=True),
+            ),
+            min_times=1,
+        ),
     )
 
 
@@ -1885,8 +1896,9 @@ class CaseExpressionSegment(BaseSegment):
                 Ref("Expression_D_Grammar"),
                 Ref("CaseExpressionSegment"),
             ),
-            AnyNumberOf(Ref("ShorthandCastSegment"), Ref("TimeZoneGrammar")),
+            AnyNumberOf(Ref("TimeZoneGrammar")),
         ),
+        Ref("ShorthandCastSegment"),
     ),
     # Expression_D_Grammar
     # https://www.cockroachlabs.com/docs/v20.2/sql-grammar.htm#d_expr
@@ -3298,7 +3310,6 @@ class SetClauseSegment(BaseSegment):
             Ref("ValuesClauseSegment"),
             "DEFAULT",
         ),
-        AnyNumberOf(Ref("ShorthandCastSegment")),
     )
 
 

src/sqlfluff/rules/L013.py

@@ -64,6 +64,18 @@ def _eval(self, context: RuleContext) -> Optional[LintResult]:
         ):
             return None
 
+        # Ignore if it's a cast_expression with non-function enclosed children
+        # For example, we do not want to ignore something like func()::type
+        # but we can ignore something like a::type
+        if children.children().select(
+            sp.is_type("cast_expression")
+        ) and not children.children().select(
+            sp.is_type("cast_expression")
+        ).children().any(
+            sp.is_type("function")
+        ):
+            return None
+
         parent_stack = functional_context.parent_stack
 
         # Ignore if it is part of a CTE with column names
@@ -101,7 +113,6 @@ def _recursively_check_is_complex(select_clause_or_exp_children: Segments) -> bo
         "newline",
         "column_reference",
         "wildcard_expression",
-        "cast_expression",
         "bracketed",
     ]
     selector = sp.not_(sp.is_type(*forgiveable_types))

src/sqlfluff/rules/L034.py

@@ -141,9 +141,15 @@ def _eval(self, context: RuleContext) -> EvalResultType:
                                     "column_reference",
                                     "object_reference",
                                     "literal",
+                                    "cast_expression",
                                 )
                                 # len == 2 to ensure the expression is 'simple'
-                                and len(segment.get_child("expression").segments) == 2
+                                and (
+                                    len(segment.get_child("expression").segments) == 2
+                                    # cast_expression is one length
+                                    or len(segment.get_child("expression").segments)
+                                    == 1
+                                )
                             ):
                                 self._validate(i, segment)
                         except AttributeError: