fix(tsql): support default values on definitons and the OUTPUT/OUT/READ_ONLY syntax (#4704)

* fix(tsql): support default values on definitons and the OUTPUT/OUT/READ_ONLY syntax

* PR feedback 1

* PR feedback 1 v2

* PR feedback 1 (removed test)

* PR feedback 2

* PR feedback 2 (refactor)

Author: geooo109

sqlglot/dialects/tsql.py

@@ -598,6 +598,8 @@ class Parser(parser.Parser):
             ("ENCRYPTION", "RECOMPILE", "SCHEMABINDING", "NATIVE_COMPILATION", "EXECUTE"), tuple()
         )
 
+        COLUMN_DEFINITION_MODES = {"OUT", "OUTPUT", "READ_ONLY"}
+
         RETURNS_TABLE_TOKENS = parser.Parser.ID_VAR_TOKENS - {
             TokenType.TABLE,
             *parser.Parser.TYPE_TOKENS,
@@ -736,6 +738,18 @@ def _parse_convert(
             convert.set("strict", strict)
             return convert
 
+        def _parse_column_def(
+            self, this: t.Optional[exp.Expression], computed_column: bool = True
+        ) -> t.Optional[exp.Expression]:
+            this = super()._parse_column_def(this=this, computed_column=computed_column)
+            if not this:
+                return None
+            if self._match(TokenType.EQ):
+                this.set("default", self._parse_disjunction())
+            if self._match_texts(self.COLUMN_DEFINITION_MODES):
+                this.set("output", self._prev.text)
+            return this
+
         def _parse_user_defined_function(
             self, kind: t.Optional[TokenType] = None
         ) -> t.Optional[exp.Expression]:
@@ -1290,3 +1304,11 @@ def dpipe_sql(self, expression: exp.DPipe) -> str:
 
         def isascii_sql(self, expression: exp.IsAscii) -> str:
             return f"(PATINDEX(CONVERT(VARCHAR(MAX), 0x255b5e002d7f5d25) COLLATE Latin1_General_BIN, {self.sql(expression.this)}) = 0)"
+
+        def columndef_sql(self, expression: exp.ColumnDef, sep: str = " ") -> str:
+            this = super().columndef_sql(expression, sep)
+            default = self.sql(expression, "default")
+            default = f" = {default}" if default else ""
+            output = self.sql(expression, "output")
+            output = f" {output}" if output else ""
+            return f"{this}{default}{output}"

sqlglot/expressions.py

@@ -1675,6 +1675,8 @@ class ColumnDef(Expression):
         "constraints": False,
         "exists": False,
         "position": False,
+        "default": False,
+        "output": False,
     }
 
     @property

sqlglot/parser.py

@@ -5551,7 +5551,7 @@ def _parse_user_defined_function_expression(self) -> t.Optional[exp.Expression]:
         return self._parse_statement()
 
     def _parse_function_parameter(self) -> t.Optional[exp.Expression]:
-        return self._parse_column_def(self._parse_id_var())
+        return self._parse_column_def(this=self._parse_id_var(), computed_column=False)
 
     def _parse_user_defined_function(
         self, kind: t.Optional[TokenType] = None
@@ -5638,11 +5638,16 @@ def _parse_schema(self, this: t.Optional[exp.Expression] = None) -> t.Optional[e
     def _parse_field_def(self) -> t.Optional[exp.Expression]:
         return self._parse_column_def(self._parse_field(any_token=True))
 
-    def _parse_column_def(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
+    def _parse_column_def(
+        self, this: t.Optional[exp.Expression], computed_column: bool = True
+    ) -> t.Optional[exp.Expression]:
         # column defs are not really columns, they're identifiers
         if isinstance(this, exp.Column):
             this = this.this
 
+        if not computed_column:
+            self._match(TokenType.ALIAS)
+
         kind = self._parse_types(schema=True)
 
         if self._match_text_seq("FOR", "ORDINALITY"):

tests/dialects/test_tsql.py

@@ -456,6 +456,19 @@ def test_tsql(self):
         with self.assertRaises(ParseError):
             parse_one("SELECT begin", read="tsql")
 
+        self.validate_identity("CREATE PROCEDURE test(@v1 INTEGER = 1, @v2 CHAR(1) = 'c')")
+        self.validate_identity("DECLARE @v1 AS INTEGER = 1, @v2 AS CHAR(1) = 'c')")
+
+        for output in ("OUT", "OUTPUT", "READ_ONLY"):
+            self.validate_identity(
+                f"CREATE PROCEDURE test(@v1 INTEGER = 1 {output}, @v2 CHAR(1) {output})"
+            )
+
+        self.validate_identity(
+            "CREATE PROCEDURE test(@v1 AS INTEGER = 1, @v2 AS CHAR(1) = 'c')",
+            "CREATE PROCEDURE test(@v1 INTEGER = 1, @v2 CHAR(1) = 'c')",
+        )
+
     def test_option(self):
         possible_options = [
             "HASH GROUP",