sqlglot 27.29.0__py3-none-any.whl → 28.4.0__py3-none-any.whl

sqlglot/parser.py

@@ -7,7 +7,14 @@ import typing as t
 from collections import defaultdict
 
 from sqlglot import exp
-from sqlglot.errors import ErrorLevel, ParseError, TokenError, concat_messages, merge_errors
+from sqlglot.errors import (
+    ErrorLevel,
+    ParseError,
+    TokenError,
+    concat_messages,
+    highlight_sql,
+    merge_errors,
+)
 from sqlglot.helper import apply_index_offset, ensure_list, seq_get
 from sqlglot.time import format_time
 from sqlglot.tokens import Token, Tokenizer, TokenType
@@ -97,6 +104,8 @@ def build_extract_json_with_path(expr_type: t.Type[E]) -> t.Callable[[t.List, Di
         )
         if len(args) > 2 and expr_type is exp.JSONExtract:
             expression.set("expressions", args[2:])
+        if expr_type is exp.JSONExtractScalar:
+            expression.set("scalar_only", dialect.JSON_EXTRACT_SCALAR_SCALAR_ONLY)
 
         return expression
 
@@ -226,7 +235,12 @@ class Parser(metaclass=_Parser):
             end=seq_get(args, 1),
             step=seq_get(args, 2) or exp.Interval(this=exp.Literal.string(1), unit=exp.var("DAY")),
         ),
+        "GENERATE_UUID": lambda args, dialect: exp.Uuid(
+            is_string=dialect.UUID_IS_STRING_TYPE or None
+        ),
         "GLOB": lambda args: exp.Glob(this=seq_get(args, 1), expression=seq_get(args, 0)),
+        "GREATEST": lambda args: exp.Greatest(this=seq_get(args, 0), expressions=args[1:]),
+        "LEAST": lambda args: exp.Least(this=seq_get(args, 0), expressions=args[1:]),
         "HEX": build_hex,
         "JSON_EXTRACT": build_extract_json_with_path(exp.JSONExtract),
         "JSON_EXTRACT_SCALAR": build_extract_json_with_path(exp.JSONExtractScalar),
@@ -265,6 +279,7 @@ class Parser(metaclass=_Parser):
         ),
         "UNNEST": lambda args: exp.Unnest(expressions=ensure_list(seq_get(args, 0))),
         "UPPER": build_upper,
+        "UUID": lambda args, dialect: exp.Uuid(is_string=dialect.UUID_IS_STRING_TYPE or None),
         "VAR_MAP": build_var_map,
     }
 
@@ -274,9 +289,13 @@ class Parser(metaclass=_Parser):
         TokenType.CURRENT_TIME: exp.CurrentTime,
         TokenType.CURRENT_TIMESTAMP: exp.CurrentTimestamp,
         TokenType.CURRENT_USER: exp.CurrentUser,
+        TokenType.LOCALTIME: exp.Localtime,
+        TokenType.LOCALTIMESTAMP: exp.Localtimestamp,
+        TokenType.CURRENT_ROLE: exp.CurrentRole,
     }
 
     STRUCT_TYPE_TOKENS = {
+        TokenType.FILE,
         TokenType.NESTED,
         TokenType.OBJECT,
         TokenType.STRUCT,
@@ -316,6 +335,7 @@ class Parser(metaclass=_Parser):
         TokenType.UINT,
         TokenType.BIGINT,
         TokenType.UBIGINT,
+        TokenType.BIGNUM,
         TokenType.INT128,
         TokenType.UINT128,
         TokenType.INT256,
@@ -346,6 +366,7 @@ class Parser(metaclass=_Parser):
         TokenType.TINYTEXT,
         TokenType.TIME,
         TokenType.TIMETZ,
+        TokenType.TIME_NS,
         TokenType.TIMESTAMP,
         TokenType.TIMESTAMP_S,
         TokenType.TIMESTAMP_MS,
@@ -376,6 +397,7 @@ class Parser(metaclass=_Parser):
         TokenType.DECIMAL64,
         TokenType.DECIMAL128,
         TokenType.DECIMAL256,
+        TokenType.DECFLOAT,
         TokenType.UDECIMAL,
         TokenType.BIGDECIMAL,
         TokenType.UUID,
@@ -533,12 +555,14 @@ class Parser(metaclass=_Parser):
         TokenType.LIMIT,
         TokenType.LOAD,
         TokenType.LOCK,
+        TokenType.MATCH,
         TokenType.MERGE,
         TokenType.NATURAL,
         TokenType.NEXT,
         TokenType.OFFSET,
         TokenType.OPERATOR,
         TokenType.ORDINALITY,
+        TokenType.OVER,
         TokenType.OVERLAPS,
         TokenType.OVERWRITE,
         TokenType.PARTITION,
@@ -615,6 +639,7 @@ class Parser(metaclass=_Parser):
         TokenType.CURRENT_TIMESTAMP,
         TokenType.CURRENT_TIME,
         TokenType.CURRENT_USER,
+        TokenType.CURRENT_CATALOG,
         TokenType.FILTER,
         TokenType.FIRST,
         TokenType.FORMAT,
@@ -626,6 +651,8 @@ class Parser(metaclass=_Parser):
         TokenType.ILIKE,
         TokenType.INSERT,
         TokenType.LIKE,
+        TokenType.LOCALTIME,
+        TokenType.LOCALTIMESTAMP,
         TokenType.MERGE,
         TokenType.NEXT,
         TokenType.OFFSET,
@@ -634,6 +661,7 @@ class Parser(metaclass=_Parser):
         TokenType.REPLACE,
         TokenType.RLIKE,
         TokenType.ROW,
+        TokenType.SESSION_USER,
         TokenType.UNNEST,
         TokenType.VAR,
         TokenType.LEFT,
@@ -747,7 +775,7 @@ class Parser(metaclass=_Parser):
         TokenType.ARROW: lambda self, expressions: self.expression(
             exp.Lambda,
             this=self._replace_lambda(
-                self._parse_assignment(),
+                self._parse_disjunction(),
                 expressions,
             ),
             expressions=expressions,
@@ -755,7 +783,7 @@ class Parser(metaclass=_Parser):
         TokenType.FARROW: lambda self, expressions: self.expression(
             exp.Kwarg,
             this=exp.var(expressions[0].name),
-            expression=self._parse_assignment(),
+            expression=self._parse_disjunction(),
         ),
     }
 
@@ -780,6 +808,7 @@ class Parser(metaclass=_Parser):
             this=this,
             expression=self.dialect.to_json_path(path),
             only_json_types=self.JSON_ARROWS_REQUIRE_JSON_TYPE,
+            scalar_only=self.dialect.JSON_EXTRACT_SCALAR_SCALAR_ONLY,
         ),
         TokenType.HASH_ARROW: lambda self, this, path: self.expression(
             exp.JSONBExtract,
@@ -807,7 +836,7 @@ class Parser(metaclass=_Parser):
         exp.Cluster: lambda self: self._parse_sort(exp.Cluster, TokenType.CLUSTER_BY),
         exp.Column: lambda self: self._parse_column(),
         exp.ColumnDef: lambda self: self._parse_column_def(self._parse_column()),
-        exp.Condition: lambda self: self._parse_assignment(),
+        exp.Condition: lambda self: self._parse_disjunction(),
         exp.DataType: lambda self: self._parse_types(allow_identifiers=False, schema=True),
         exp.Expression: lambda self: self._parse_expression(),
         exp.From: lambda self: self._parse_from(joins=True),
@@ -882,33 +911,33 @@ class Parser(metaclass=_Parser):
     }
 
     STRING_PARSERS = {
-        TokenType.HEREDOC_STRING: lambda self, token: self.expression(
-            exp.RawString, this=token.text
-        ),
-        TokenType.NATIONAL_STRING: lambda self, token: self.expression(
-            exp.National, this=token.text
-        ),
-        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, this=token.text),
+        TokenType.HEREDOC_STRING: lambda self, token: self.expression(exp.RawString, token=token),
+        TokenType.NATIONAL_STRING: lambda self, token: self.expression(exp.National, token=token),
+        TokenType.RAW_STRING: lambda self, token: self.expression(exp.RawString, token=token),
         TokenType.STRING: lambda self, token: self.expression(
-            exp.Literal, this=token.text, is_string=True
+            exp.Literal, token=token, is_string=True
         ),
         TokenType.UNICODE_STRING: lambda self, token: self.expression(
             exp.UnicodeString,
-            this=token.text,
+            token=token,
             escape=self._match_text_seq("UESCAPE") and self._parse_string(),
         ),
     }
 
     NUMERIC_PARSERS = {
-        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, this=token.text),
-        TokenType.BYTE_STRING: lambda self, token: self.expression(exp.ByteString, this=token.text),
+        TokenType.BIT_STRING: lambda self, token: self.expression(exp.BitString, token=token),
+        TokenType.BYTE_STRING: lambda self, token: self.expression(
+            exp.ByteString,
+            token=token,
+            is_bytes=self.dialect.BYTE_STRING_IS_BYTES_TYPE or None,
+        ),
         TokenType.HEX_STRING: lambda self, token: self.expression(
             exp.HexString,
-            this=token.text,
+            token=token,
             is_integer=self.dialect.HEX_STRING_IS_INTEGER_TYPE or None,
         ),
         TokenType.NUMBER: lambda self, token: self.expression(
-            exp.Literal, this=token.text, is_string=False
+            exp.Literal, token=token, is_string=False
         ),
     }
 
@@ -1244,6 +1273,7 @@ class Parser(metaclass=_Parser):
         "EXTRACT": lambda self: self._parse_extract(),
         "FLOOR": lambda self: self._parse_ceil_floor(exp.Floor),
         "GAP_FILL": lambda self: self._parse_gap_fill(),
+        "INITCAP": lambda self: self._parse_initcap(),
         "JSON_OBJECT": lambda self: self._parse_json_object(),
         "JSON_OBJECTAGG": lambda self: self._parse_json_object(agg=True),
         "JSON_TABLE": lambda self: self._parse_json_table(),
@@ -1443,6 +1473,8 @@ class Parser(metaclass=_Parser):
     # The style options for the DESCRIBE statement
     DESCRIBE_STYLES = {"ANALYZE", "EXTENDED", "FORMATTED", "HISTORY"}
 
+    SET_ASSIGNMENT_DELIMITERS = {"=", ":=", "TO"}
+
     # The style options for the ANALYZE statement
     ANALYZE_STYLES = {
         "BUFFER_USAGE_LIMIT",
@@ -1717,15 +1749,15 @@ class Parser(metaclass=_Parser):
         error level setting.
         """
         token = token or self._curr or self._prev or Token.string("")
-        start = token.start
-        end = token.end + 1
-        start_context = self.sql[max(start - self.error_message_context, 0) : start]
-        highlight = self.sql[start:end]
-        end_context = self.sql[end : end + self.error_message_context]
+        formatted_sql, start_context, highlight, end_context = highlight_sql(
+            sql=self.sql,
+            positions=[(token.start, token.end)],
+            context_length=self.error_message_context,
+        )
+        formatted_message = f"{message}. Line {token.line}, Col: {token.col}.\n  {formatted_sql}"
 
         error = ParseError.new(
-            f"{message}. Line {token.line}, Col: {token.col}.\n"
-            f"  {start_context}\033[4m{highlight}\033[0m{end_context}",
+            formatted_message,
             description=message,
             line=token.line,
             col=token.col,
@@ -1740,7 +1772,11 @@ class Parser(metaclass=_Parser):
         self.errors.append(error)
 
     def expression(
-        self, exp_class: t.Type[E], comments: t.Optional[t.List[str]] = None, **kwargs
+        self,
+        exp_class: t.Type[E],
+        token: t.Optional[Token] = None,
+        comments: t.Optional[t.List[str]] = None,
+        **kwargs,
     ) -> E:
         """
         Creates a new, validated Expression.
@@ -1753,7 +1789,11 @@ class Parser(metaclass=_Parser):
         Returns:
             The target expression.
         """
-        instance = exp_class(**kwargs)
+        if token:
+            instance = exp_class(this=token.text, **kwargs)
+            instance.update_positions(token)
+        else:
+            instance = exp_class(**kwargs)
         instance.add_comments(comments) if comments else self._add_comments(instance)
         return self.validate_expression(instance)
 
@@ -2247,7 +2287,10 @@ class Parser(metaclass=_Parser):
             return self._parse_sortkey(compound=True)
 
         if self._match_text_seq("SQL", "SECURITY"):
-            return self.expression(exp.SqlSecurityProperty, definer=self._match_text_seq("DEFINER"))
+            return self.expression(
+                exp.SqlSecurityProperty,
+                this=self._match_texts(("DEFINER", "INVOKER")) and self._prev.text.upper(),
+            )
 
         index = self._index
 
@@ -2366,10 +2409,8 @@ class Parser(metaclass=_Parser):
         self._match(TokenType.EQ)
         prop = self.expression(
             exp.WithSystemVersioningProperty,
-            **{  # type: ignore
-                "on": True,
-                "with": with_,
-            },
+            on=True,
+            with_=with_,
         )
 
         if self._match_text_seq("OFF"):
@@ -2684,7 +2725,7 @@ class Parser(metaclass=_Parser):
 
     def _parse_partition_by(self) -> t.List[exp.Expression]:
         if self._match(TokenType.PARTITION_BY):
-            return self._parse_csv(self._parse_assignment)
+            return self._parse_csv(self._parse_disjunction)
         return []
 
     def _parse_partition_bound_spec(self) -> exp.PartitionBoundSpec:
@@ -2942,15 +2983,9 @@ class Parser(metaclass=_Parser):
             self._match(TokenType.TABLE)
             is_function = self._match(TokenType.FUNCTION)
 
-            this = (
-                self._parse_table(schema=True, parse_partition=True)
-                if not is_function
-                else self._parse_function()
-            )
-            if isinstance(this, exp.Table) and self._match(TokenType.ALIAS, advance=False):
-                this.set("alias", self._parse_table_alias())
+            this = self._parse_function() if is_function else self._parse_insert_table()
 
-        returning = self._parse_returning()
+        returning = self._parse_returning()  # TSQL allows RETURNING before source
 
         return self.expression(
             exp.Insert,
@@ -2961,7 +2996,8 @@ class Parser(metaclass=_Parser):
             stored=self._match_text_seq("STORED") and self._parse_stored(),
             by_name=self._match_text_seq("BY", "NAME"),
             exists=self._parse_exists(),
-            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE) and self._parse_assignment(),
+            where=self._match_pair(TokenType.REPLACE, TokenType.WHERE)
+            and self._parse_disjunction(),
             partition=self._match(TokenType.PARTITION_BY) and self._parse_partitioned_by(),
             settings=self._match_text_seq("SETTINGS") and self._parse_settings_property(),
             default=self._match_text_seq("DEFAULT", "VALUES"),
@@ -2974,6 +3010,12 @@ class Parser(metaclass=_Parser):
             source=self._match(TokenType.TABLE) and self._parse_table(),
         )
 
+    def _parse_insert_table(self) -> t.Optional[exp.Expression]:
+        this = self._parse_table(schema=True, parse_partition=True)
+        if isinstance(this, exp.Table) and self._match(TokenType.ALIAS, advance=False):
+            this.set("alias", self._parse_table_alias())
+        return this
+
     def _parse_kill(self) -> exp.Kill:
         kind = exp.var(self._prev.text) if self._match_texts(("CONNECTION", "QUERY")) else None
 
@@ -3040,10 +3082,8 @@ class Parser(metaclass=_Parser):
             return None
         return self.expression(
             exp.SerdeProperties,
-            **{  # type: ignore
-                "expressions": self._parse_wrapped_properties(),
-                "with": with_,
-            },
+            expressions=self._parse_wrapped_properties(),
+            with_=with_,
         )
 
     def _parse_row_format(
@@ -3118,6 +3158,7 @@ class Parser(metaclass=_Parser):
             cluster=self._match(TokenType.ON) and self._parse_on_property(),
             where=self._parse_where(),
             returning=returning or self._parse_returning(),
+            order=self._parse_order(),
             limit=self._parse_limit(),
         )
 
@@ -3131,7 +3172,7 @@ class Parser(metaclass=_Parser):
             elif self._match(TokenType.RETURNING, advance=False):
                 kwargs["returning"] = self._parse_returning()
             elif self._match(TokenType.FROM, advance=False):
-                kwargs["from"] = self._parse_from(joins=True)
+                kwargs["from_"] = self._parse_from(joins=True)
             elif self._match(TokenType.WHERE, advance=False):
                 kwargs["where"] = self._parse_where()
             elif self._match(TokenType.ORDER_BY, advance=False):
@@ -3188,7 +3229,7 @@ class Parser(metaclass=_Parser):
         return self.expression(
             exp.Partition,
             subpartition=self._prev.text.upper() == "SUBPARTITION",
-            expressions=self._parse_wrapped_csv(self._parse_assignment),
+            expressions=self._parse_wrapped_csv(self._parse_disjunction),
         )
 
     def _parse_value(self, values: bool = True) -> t.Optional[exp.Tuple]:
@@ -3221,8 +3262,8 @@ class Parser(metaclass=_Parser):
             # Support parentheses for duckdb FROM-first syntax
             select = self._parse_select(from_=from_)
             if select:
-                if not select.args.get("from"):
-                    select.set("from", from_)
+                if not select.args.get("from_"):
+                    select.set("from_", from_)
                 this = select
             else:
                 this = exp.select("*").from_(t.cast(exp.From, from_))
@@ -3285,8 +3326,11 @@ class Parser(metaclass=_Parser):
                 self.raise_error("Failed to parse any statement following CTE")
                 return cte
 
-            if "with" in this.arg_types:
-                this.set("with", cte)
+            while isinstance(this, exp.Subquery) and this.is_wrapper:
+                this = this.this
+
+            if "with_" in this.arg_types:
+                this.set("with_", cte)
             else:
                 self.raise_error(f"{this.key} does not support CTE")
                 this = cte
@@ -3295,7 +3339,7 @@ class Parser(metaclass=_Parser):
 
         # duckdb supports leading with FROM x
         from_ = (
-            self._parse_from(consume_pipe=True)
+            self._parse_from(joins=True, consume_pipe=True)
             if self._match(TokenType.FROM, advance=False)
             else None
         )
@@ -3352,7 +3396,7 @@ class Parser(metaclass=_Parser):
                 from_ = self._parse_from()
 
             if from_:
-                this.set("from", from_)
+                this.set("from_", from_)
 
             this = self._parse_query_modifiers(this)
         elif (table or nested) and self._match(TokenType.L_PAREN):
@@ -3372,12 +3416,6 @@ class Parser(metaclass=_Parser):
             return self.expression(exp.Summarize, this=this, table=table)
         elif self._match(TokenType.DESCRIBE):
             this = self._parse_describe()
-        elif self._match_text_seq("STREAM"):
-            this = self._parse_function()
-            if this:
-                this = self.expression(exp.Stream, this=this)
-            else:
-                self._retreat(self._index - 1)
         else:
             this = None
 
@@ -3524,7 +3562,7 @@ class Parser(metaclass=_Parser):
     def _implicit_unnests_to_explicit(self, this: E) -> E:
         from sqlglot.optimizer.normalize_identifiers import normalize_identifiers as _norm
 
-        refs = {_norm(this.args["from"].this.copy(), dialect=self.dialect).alias_or_name}
+        refs = {_norm(this.args["from_"].this.copy(), dialect=self.dialect).alias_or_name}
         for i, join in enumerate(this.args.get("joins") or []):
             table = join.this
             normalized_table = table.copy()
@@ -3589,7 +3627,7 @@ class Parser(metaclass=_Parser):
                         continue
                 break
 
-        if self.SUPPORTS_IMPLICIT_UNNEST and this and this.args.get("from"):
+        if self.SUPPORTS_IMPLICIT_UNNEST and this and this.args.get("from_"):
             this = self._implicit_unnests_to_explicit(this)
 
         return this
@@ -3809,6 +3847,16 @@ class Parser(metaclass=_Parser):
             ordinality=ordinality,
         )
 
+    def _parse_stream(self) -> t.Optional[exp.Stream]:
+        index = self._index
+        if self._match_text_seq("STREAM"):
+            this = self._try_parse(self._parse_table)
+            if this:
+                return self.expression(exp.Stream, this=this)
+
+        self._retreat(index)
+        return None
+
     def _parse_join_parts(
         self,
     ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]:
@@ -3864,11 +3912,11 @@ class Parser(metaclass=_Parser):
             )
 
         if method:
-            kwargs["method"] = method.text
+            kwargs["method"] = method.text.upper()
         if side:
-            kwargs["side"] = side.text
+            kwargs["side"] = side.text.upper()
         if kind:
-            kwargs["kind"] = kind.text
+            kwargs["kind"] = kind.text.upper()
         if hint:
             kwargs["hint"] = hint
 
@@ -3876,7 +3924,7 @@ class Parser(metaclass=_Parser):
             kwargs["match_condition"] = self._parse_wrapped(self._parse_comparison)
 
         if self._match(TokenType.ON):
-            kwargs["on"] = self._parse_assignment()
+            kwargs["on"] = self._parse_disjunction()
         elif self._match(TokenType.USING):
             kwargs["using"] = self._parse_using_identifiers()
         elif (
@@ -3889,7 +3937,7 @@ class Parser(metaclass=_Parser):
             joins: t.Optional[list] = list(self._parse_joins())
 
             if joins and self._match(TokenType.ON):
-                kwargs["on"] = self._parse_assignment()
+                kwargs["on"] = self._parse_disjunction()
             elif joins and self._match(TokenType.USING):
                 kwargs["using"] = self._parse_using_identifiers()
             else:
@@ -3915,7 +3963,7 @@ class Parser(metaclass=_Parser):
         return self.expression(exp.Join, comments=comments, **kwargs)
 
     def _parse_opclass(self) -> t.Optional[exp.Expression]:
-        this = self._parse_assignment()
+        this = self._parse_disjunction()
 
         if self._match_texts(self.OPCLASS_FOLLOW_KEYWORDS, advance=False):
             return this
@@ -4101,6 +4149,10 @@ class Parser(metaclass=_Parser):
         parse_partition: bool = False,
         consume_pipe: bool = False,
     ) -> t.Optional[exp.Expression]:
+        stream = self._parse_stream()
+        if stream:
+            return stream
+
         lateral = self._parse_lateral()
         if lateral:
             return lateral
@@ -4163,6 +4215,11 @@ class Parser(metaclass=_Parser):
         if alias:
             this.set("alias", alias)
 
+        if self._match(TokenType.INDEXED_BY):
+            this.set("indexed", self._parse_table_parts())
+        elif self._match_text_seq("NOT", "INDEXED"):
+            this.set("indexed", False)
+
         if isinstance(this, exp.Table) and self._match_text_seq("AT"):
             return self.expression(
                 exp.AtIndex, this=this.to_column(copy=False), expression=self._parse_id_var()
@@ -4402,7 +4459,7 @@ class Parser(metaclass=_Parser):
         expressions = self._match(TokenType.ON) and self._parse_csv(_parse_on)
         into = self._parse_unpivot_columns()
         using = self._match(TokenType.USING) and self._parse_csv(
-            lambda: self._parse_alias(self._parse_function())
+            lambda: self._parse_alias(self._parse_column())
         )
         group = self._parse_group()
 
@@ -4431,16 +4488,18 @@ class Parser(metaclass=_Parser):
 
         value = self._parse_column()
 
-        if not self._match_pair(TokenType.IN, TokenType.L_PAREN):
-            self.raise_error("Expecting IN (")
+        if not self._match(TokenType.IN):
+            self.raise_error("Expecting IN")
 
-        if self._match(TokenType.ANY):
-            exprs: t.List[exp.Expression] = ensure_list(exp.PivotAny(this=self._parse_order()))
-        else:
-            exprs = self._parse_csv(_parse_aliased_expression)
+        if self._match(TokenType.L_PAREN):
+            if self._match(TokenType.ANY):
+                exprs: t.List[exp.Expression] = ensure_list(exp.PivotAny(this=self._parse_order()))
+            else:
+                exprs = self._parse_csv(_parse_aliased_expression)
+            self._match_r_paren()
+            return self.expression(exp.In, this=value, expressions=exprs)
 
-        self._match_r_paren()
-        return self.expression(exp.In, this=value, expressions=exprs)
+        return self.expression(exp.In, this=value, field=self._parse_id_var())
 
     def _parse_pivot_aggregation(self) -> t.Optional[exp.Expression]:
         func = self._parse_function()
@@ -4560,7 +4619,7 @@ class Parser(metaclass=_Parser):
             return None
 
         return self.expression(
-            exp.PreWhere, comments=self._prev_comments, this=self._parse_assignment()
+            exp.PreWhere, comments=self._prev_comments, this=self._parse_disjunction()
         )
 
     def _parse_where(self, skip_where_token: bool = False) -> t.Optional[exp.Where]:
@@ -4568,7 +4627,7 @@ class Parser(metaclass=_Parser):
             return None
 
         return self.expression(
-            exp.Where, comments=self._prev_comments, this=self._parse_assignment()
+            exp.Where, comments=self._prev_comments, this=self._parse_disjunction()
         )
 
     def _parse_group(self, skip_group_by_token: bool = False) -> t.Optional[exp.Group]:
@@ -4593,7 +4652,7 @@ class Parser(metaclass=_Parser):
                 self._parse_csv(
                     lambda: None
                     if self._match_set((TokenType.CUBE, TokenType.ROLLUP), advance=False)
-                    else self._parse_assignment()
+                    else self._parse_disjunction()
                 )
             )
 
@@ -4643,19 +4702,19 @@ class Parser(metaclass=_Parser):
         if not skip_having_token and not self._match(TokenType.HAVING):
             return None
         return self.expression(
-            exp.Having, comments=self._prev_comments, this=self._parse_assignment()
+            exp.Having, comments=self._prev_comments, this=self._parse_disjunction()
         )
 
     def _parse_qualify(self) -> t.Optional[exp.Qualify]:
         if not self._match(TokenType.QUALIFY):
             return None
-        return self.expression(exp.Qualify, this=self._parse_assignment())
+        return self.expression(exp.Qualify, this=self._parse_disjunction())
 
     def _parse_connect_with_prior(self) -> t.Optional[exp.Expression]:
         self.NO_PAREN_FUNCTION_PARSERS["PRIOR"] = lambda self: self.expression(
             exp.Prior, this=self._parse_bitwise()
         )
-        connect = self._parse_assignment()
+        connect = self._parse_disjunction()
         self.NO_PAREN_FUNCTION_PARSERS.pop("PRIOR")
         return connect
 
@@ -4663,7 +4722,7 @@ class Parser(metaclass=_Parser):
         if skip_start_token:
             start = None
         elif self._match(TokenType.START_WITH):
-            start = self._parse_assignment()
+            start = self._parse_disjunction()
         else:
             return None
 
@@ -4672,14 +4731,14 @@ class Parser(metaclass=_Parser):
         connect = self._parse_connect_with_prior()
 
         if not start and self._match(TokenType.START_WITH):
-            start = self._parse_assignment()
+            start = self._parse_disjunction()
 
         return self.expression(exp.Connect, start=start, connect=connect, nocycle=nocycle)
 
     def _parse_name_as_expression(self) -> t.Optional[exp.Expression]:
         this = self._parse_id_var(any_token=True)
         if self._match(TokenType.ALIAS):
-            this = self.expression(exp.Alias, alias=this, this=self._parse_assignment())
+            this = self.expression(exp.Alias, alias=this, this=self._parse_disjunction())
         return this
 
     def _parse_interpolate(self) -> t.Optional[t.List[exp.Expression]]:
@@ -4713,7 +4772,7 @@ class Parser(metaclass=_Parser):
     def _parse_ordered(
         self, parse_method: t.Optional[t.Callable] = None
     ) -> t.Optional[exp.Ordered]:
-        this = parse_method() if parse_method else self._parse_assignment()
+        this = parse_method() if parse_method else self._parse_disjunction()
         if not this:
             return None
 
@@ -4742,12 +4801,10 @@ class Parser(metaclass=_Parser):
         if self._match_text_seq("WITH", "FILL"):
             with_fill = self.expression(
                 exp.WithFill,
-                **{  # type: ignore
-                    "from": self._match(TokenType.FROM) and self._parse_bitwise(),
-                    "to": self._match_text_seq("TO") and self._parse_bitwise(),
-                    "step": self._match_text_seq("STEP") and self._parse_bitwise(),
-                    "interpolate": self._parse_interpolate(),
-                },
+                from_=self._match(TokenType.FROM) and self._parse_bitwise(),
+                to=self._match_text_seq("TO") and self._parse_bitwise(),
+                step=self._match_text_seq("STEP") and self._parse_bitwise(),
+                interpolate=self._parse_interpolate(),
             )
         else:
             with_fill = None
@@ -5016,7 +5073,7 @@ class Parser(metaclass=_Parser):
                 return this
 
             this = expression
-        elif self._match(TokenType.ISNULL):
+        elif self._match(TokenType.ISNULL) or (negate and self._match(TokenType.NULL)):
             this = self.expression(exp.Is, this=this, expression=exp.Null())
 
         # Postgres supports ISNULL and NOTNULL for conditions.
@@ -5060,10 +5117,13 @@ class Parser(metaclass=_Parser):
             unique = self._match(TokenType.UNIQUE)
             self._match_text_seq("KEYS")
             expression: t.Optional[exp.Expression] = self.expression(
-                exp.JSON, **{"this": kind, "with": _with, "unique": unique}
+                exp.JSON,
+                this=kind,
+                with_=_with,
+                unique=unique,
             )
         else:
-            expression = self._parse_primary() or self._parse_null()
+            expression = self._parse_null() or self._parse_bitwise()
             if not expression:
                 self._retreat(index)
                 return None
@@ -5270,7 +5330,7 @@ class Parser(metaclass=_Parser):
 
     def _parse_factor(self) -> t.Optional[exp.Expression]:
         parse_method = self._parse_exponent if self.EXPONENT else self._parse_unary
-        this = parse_method()
+        this = self._parse_at_time_zone(parse_method())
 
         while self._match_set(self.FACTOR):
             klass = self.FACTOR[self._prev.token_type]
@@ -5295,14 +5355,14 @@ class Parser(metaclass=_Parser):
     def _parse_unary(self) -> t.Optional[exp.Expression]:
         if self._match_set(self.UNARY_PARSERS):
             return self.UNARY_PARSERS[self._prev.token_type](self)
-        return self._parse_at_time_zone(self._parse_type())
+        return self._parse_type()
 
     def _parse_type(
         self, parse_interval: bool = True, fallback_to_identifier: bool = False
     ) -> t.Optional[exp.Expression]:
         interval = parse_interval and self._parse_interval()
         if interval:
-            return interval
+            return self._parse_column_ops(interval)
 
         index = self._index
         data_type = self._parse_types(check_func=True, allow_identifiers=False)
@@ -5508,7 +5568,7 @@ class Parser(metaclass=_Parser):
                 self.raise_error("Expecting >")
 
             if self._match_set((TokenType.L_BRACKET, TokenType.L_PAREN)):
-                values = self._parse_csv(self._parse_assignment)
+                values = self._parse_csv(self._parse_disjunction)
                 if not values and is_struct:
                     values = None
                     self._retreat(self._index - 1)
@@ -5600,12 +5660,14 @@ class Parser(metaclass=_Parser):
                 break
 
             matched_array = False
-            values = self._parse_csv(self._parse_assignment) or None
+            values = self._parse_csv(self._parse_disjunction) or None
             if (
                 values
                 and not schema
                 and (
-                    not self.dialect.SUPPORTS_FIXED_SIZE_ARRAYS or datatype_token == TokenType.ARRAY
+                    not self.dialect.SUPPORTS_FIXED_SIZE_ARRAYS
+                    or datatype_token == TokenType.ARRAY
+                    or not self._match(TokenType.R_BRACKET, advance=False)
                 )
             ):
                 # Retreating here means that we should not parse the following values as part of the data type, e.g. in DuckDB
@@ -5663,7 +5725,9 @@ class Parser(metaclass=_Parser):
     def _parse_at_time_zone(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
         if not self._match_text_seq("AT", "TIME", "ZONE"):
             return this
-        return self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
+        return self._parse_at_time_zone(
+            self.expression(exp.AtTimeZone, this=this, zone=self._parse_unary())
+        )
 
     def _parse_column(self) -> t.Optional[exp.Expression]:
         this = self._parse_column_reference()
@@ -5854,7 +5918,9 @@ class Parser(metaclass=_Parser):
                     expressions.append(exp.Literal.string(self._prev.text))
 
                 if len(expressions) > 1:
-                    return self.expression(exp.Concat, expressions=expressions)
+                    return self.expression(
+                        exp.Concat, expressions=expressions, coalesce=self.dialect.CONCAT_COALESCE
+                    )
 
             return primary
 
@@ -6070,7 +6136,7 @@ class Parser(metaclass=_Parser):
     def _parse_introducer(self, token: Token) -> exp.Introducer | exp.Identifier:
         literal = self._parse_primary()
         if literal:
-            return self.expression(exp.Introducer, this=token.text, expression=literal)
+            return self.expression(exp.Introducer, token=token, expression=literal)
 
         return self._identifier_expression(token)
 
@@ -6109,7 +6175,7 @@ class Parser(metaclass=_Parser):
 
         if self._match(TokenType.DISTINCT):
             this = self.expression(
-                exp.Distinct, expressions=self._parse_csv(self._parse_assignment)
+                exp.Distinct, expressions=self._parse_csv(self._parse_disjunction)
             )
         else:
             this = self._parse_select_or_expression(alias=alias)
@@ -6157,7 +6223,7 @@ class Parser(metaclass=_Parser):
         ):
             persisted = self._prev.text.upper() == "MATERIALIZED"
             constraint_kind = exp.ComputedColumnConstraint(
-                this=self._parse_assignment(),
+                this=self._parse_disjunction(),
                 persisted=persisted or self._match_text_seq("PERSISTED"),
                 data_type=exp.Var(this="AUTO")
                 if self._match_text_seq("AUTO")
@@ -6472,6 +6538,14 @@ class Parser(metaclass=_Parser):
             and self._prev.token_type == TokenType.DESC
         )
 
+        this = None
+        if (
+            self._curr.text.upper() not in self.CONSTRAINT_PARSERS
+            and self._next
+            and self._next.token_type == TokenType.L_PAREN
+        ):
+            this = self._parse_id_var()
+
         if not in_props and not self._match(TokenType.L_PAREN, advance=False):
             return self.expression(
                 exp.PrimaryKeyColumnConstraint,
@@ -6485,13 +6559,14 @@ class Parser(metaclass=_Parser):
 
         return self.expression(
             exp.PrimaryKey,
+            this=this,
             expressions=expressions,
             include=self._parse_index_params(),
             options=self._parse_key_constraint_options(),
         )
 
     def _parse_bracket_key_value(self, is_map: bool = False) -> t.Optional[exp.Expression]:
-        return self._parse_slice(self._parse_alias(self._parse_assignment(), explicit=True))
+        return self._parse_slice(self._parse_alias(self._parse_disjunction(), explicit=True))
 
     def _parse_odbc_datetime_literal(self) -> exp.Expression:
         """
@@ -6571,9 +6646,16 @@ class Parser(metaclass=_Parser):
         return self._parse_bracket(this)
 
     def _parse_slice(self, this: t.Optional[exp.Expression]) -> t.Optional[exp.Expression]:
-        if self._match(TokenType.COLON):
-            return self.expression(exp.Slice, this=this, expression=self._parse_assignment())
-        return this
+        if not self._match(TokenType.COLON):
+            return this
+
+        if self._match_pair(TokenType.DASH, TokenType.COLON, advance=False):
+            self._advance()
+            end: t.Optional[exp.Expression] = -exp.Literal.number("1")
+        else:
+            end = self._parse_unary()
+        step = self._parse_unary() if self._match(TokenType.COLON) else None
+        return self.expression(exp.Slice, this=this, expression=end, step=step)
 
     def _parse_case(self) -> t.Optional[exp.Expression]:
         if self._match(TokenType.DOT, advance=False):
@@ -6585,16 +6667,16 @@ class Parser(metaclass=_Parser):
         default = None
 
         comments = self._prev_comments
-        expression = self._parse_assignment()
+        expression = self._parse_disjunction()
 
         while self._match(TokenType.WHEN):
-            this = self._parse_assignment()
+            this = self._parse_disjunction()
             self._match(TokenType.THEN)
-            then = self._parse_assignment()
+            then = self._parse_disjunction()
             ifs.append(self.expression(exp.If, this=this, true=then))
 
         if self._match(TokenType.ELSE):
-            default = self._parse_assignment()
+            default = self._parse_disjunction()
 
         if not self._match(TokenType.END):
             if isinstance(default, exp.Interval) and default.this.sql().upper() == "END":
@@ -6619,15 +6701,15 @@ class Parser(metaclass=_Parser):
             if self.NO_PAREN_IF_COMMANDS and index == 0:
                 return self._parse_as_command(self._prev)
 
-            condition = self._parse_assignment()
+            condition = self._parse_disjunction()
 
             if not condition:
                 self._retreat(index)
                 return None
 
             self._match(TokenType.THEN)
-            true = self._parse_assignment()
-            false = self._parse_assignment() if self._match(TokenType.ELSE) else None
+            true = self._parse_disjunction()
+            false = self._parse_disjunction() if self._match(TokenType.ELSE) else None
             self._match(TokenType.END)
             this = self.expression(exp.If, this=condition, true=true, false=false)
 
@@ -6666,7 +6748,7 @@ class Parser(metaclass=_Parser):
         return self.validate_expression(gap_fill, args)
 
     def _parse_cast(self, strict: bool, safe: t.Optional[bool] = None) -> exp.Expression:
-        this = self._parse_assignment()
+        this = self._parse_disjunction()
 
         if not self._match(TokenType.ALIAS):
             if self._match(TokenType.COMMA):
@@ -6726,12 +6808,12 @@ class Parser(metaclass=_Parser):
     def _parse_string_agg(self) -> exp.GroupConcat:
         if self._match(TokenType.DISTINCT):
             args: t.List[t.Optional[exp.Expression]] = [
-                self.expression(exp.Distinct, expressions=[self._parse_assignment()])
+                self.expression(exp.Distinct, expressions=[self._parse_disjunction()])
             ]
             if self._match(TokenType.COMMA):
-                args.extend(self._parse_csv(self._parse_assignment))
+                args.extend(self._parse_csv(self._parse_disjunction))
         else:
-            args = self._parse_csv(self._parse_assignment)  # type: ignore
+            args = self._parse_csv(self._parse_disjunction)  # type: ignore
 
         if self._match_text_seq("ON", "OVERFLOW"):
             # trino: LISTAGG(expression [, separator] [ON OVERFLOW overflow_behavior])
@@ -6836,7 +6918,7 @@ class Parser(metaclass=_Parser):
         return namespaces
 
     def _parse_decode(self) -> t.Optional[exp.Decode | exp.DecodeCase]:
-        args = self._parse_csv(self._parse_assignment)
+        args = self._parse_csv(self._parse_disjunction)
 
         if len(args) < 3:
             return self.expression(exp.Decode, this=seq_get(args, 0), charset=seq_get(args, 1))
@@ -7262,7 +7344,7 @@ class Parser(metaclass=_Parser):
             "value": (
                 (self._match_text_seq("UNBOUNDED") and "UNBOUNDED")
                 or (self._match_text_seq("CURRENT", "ROW") and "CURRENT ROW")
-                or self._parse_type()
+                or self._parse_bitwise()
             ),
             "side": self._match_texts(self.WINDOW_SIDES) and self._prev.text,
         }
@@ -7405,7 +7487,7 @@ class Parser(metaclass=_Parser):
         if self._match(TokenType.L_PAREN, advance=False):
             return self._parse_wrapped_csv(self._parse_expression)
 
-        expression = self._parse_alias(self._parse_assignment(), explicit=True)
+        expression = self._parse_alias(self._parse_disjunction(), explicit=True)
         return [expression] if expression else None
 
     def _parse_csv(
@@ -7514,9 +7596,19 @@ class Parser(metaclass=_Parser):
 
         return self.expression(exp.Commit, chain=chain)
 
-    def _parse_refresh(self) -> exp.Refresh:
-        self._match(TokenType.TABLE)
-        return self.expression(exp.Refresh, this=self._parse_string() or self._parse_table())
+    def _parse_refresh(self) -> exp.Refresh | exp.Command:
+        if self._match(TokenType.TABLE):
+            kind = "TABLE"
+        elif self._match_text_seq("MATERIALIZED", "VIEW"):
+            kind = "MATERIALIZED VIEW"
+        else:
+            kind = ""
+
+        this = self._parse_string() or self._parse_table()
+        if not kind and not isinstance(this, exp.Literal):
+            return self._parse_as_command(self._prev)
+
+        return self.expression(exp.Refresh, this=this, kind=kind)
 
     def _parse_column_def_with_exists(self):
         start = self._index
@@ -7613,7 +7705,7 @@ class Parser(metaclass=_Parser):
         if self._match_pair(TokenType.DROP, TokenType.DEFAULT):
             return self.expression(exp.AlterColumn, this=column, drop=True)
         if self._match_pair(TokenType.SET, TokenType.DEFAULT):
-            return self.expression(exp.AlterColumn, this=column, default=self._parse_assignment())
+            return self.expression(exp.AlterColumn, this=column, default=self._parse_disjunction())
         if self._match(TokenType.COMMENT):
             return self.expression(exp.AlterColumn, this=column, comment=self._parse_string())
         if self._match_text_seq("DROP", "NOT", "NULL"):
@@ -7642,7 +7734,7 @@ class Parser(metaclass=_Parser):
             this=column,
             dtype=self._parse_types(),
             collate=self._match(TokenType.COLLATE) and self._parse_term(),
-            using=self._match(TokenType.USING) and self._parse_assignment(),
+            using=self._match(TokenType.USING) and self._parse_disjunction(),
         )
 
     def _parse_alter_diststyle(self) -> exp.AlterDistStyle:
@@ -7973,7 +8065,7 @@ class Parser(metaclass=_Parser):
             exp.Merge,
             this=target,
             using=using,
-            on=self._match(TokenType.ON) and self._parse_assignment(),
+            on=self._match(TokenType.ON) and self._parse_disjunction(),
             using_cond=self._match(TokenType.USING) and self._parse_using_identifiers(),
             whens=self._parse_when_matched(),
             returning=self._parse_returning(),
@@ -7990,7 +8082,7 @@ class Parser(metaclass=_Parser):
                 if self._match_text_seq("BY", "TARGET")
                 else self._match_text_seq("BY", "SOURCE")
             )
-            condition = self._parse_assignment() if self._match(TokenType.AND) else None
+            condition = self._parse_disjunction() if self._match(TokenType.AND) else None
 
             self._match(TokenType.THEN)
 
@@ -8047,7 +8139,7 @@ class Parser(metaclass=_Parser):
             return self._parse_set_transaction(global_=kind == "GLOBAL")
 
         left = self._parse_primary() or self._parse_column()
-        assignment_delimiter = self._match_texts(("=", "TO"))
+        assignment_delimiter = self._match_texts(self.SET_ASSIGNMENT_DELIMITERS)
 
         if not left or (self.SET_REQUIRES_ASSIGNMENT_DELIMITER and not assignment_delimiter):
             self._retreat(index)
@@ -8069,7 +8161,7 @@ class Parser(metaclass=_Parser):
             exp.SetItem,
             expressions=characteristics,
             kind="TRANSACTION",
-            **{"global": global_},  # type: ignore
+            global_=global_,
         )
 
     def _parse_set_item(self) -> t.Optional[exp.Expression]:
@@ -8173,7 +8265,7 @@ class Parser(metaclass=_Parser):
             self._retreat(index - 1)
             return None
         iterator = self._parse_column()
-        condition = self._parse_assignment() if self._match_text_seq("IF") else None
+        condition = self._parse_disjunction() if self._match_text_seq("IF") else None
         return self.expression(
             exp.Comprehension,
             this=this,
@@ -8453,6 +8545,13 @@ class Parser(metaclass=_Parser):
             elif prev == "FILE_FORMAT":
                 # T-SQL's external file format case
                 param.set("expression", self._parse_field())
+            elif (
+                prev == "FORMAT"
+                and self._prev.token_type == TokenType.ALIAS
+                and self._match_texts(("AVRO", "JSON"))
+            ):
+                param.set("this", exp.var(f"FORMAT AS {self._prev.text.upper()}"))
+                param.set("expression", self._parse_field())
             else:
                 param.set("expression", self._parse_unquoted_field() or self._parse_bracket())
 
@@ -8475,7 +8574,10 @@ class Parser(metaclass=_Parser):
         if self._match_text_seq("ENCRYPTION"):
             expr.set("encryption", self._parse_wrapped_options())
         if self._match_text_seq("IAM_ROLE"):
-            expr.set("iam_role", self._parse_field())
+            expr.set(
+                "iam_role",
+                exp.var(self._prev.text) if self._match(TokenType.DEFAULT) else self._parse_field(),
+            )
         if self._match_text_seq("REGION"):
             expr.set("region", self._parse_field())
 
@@ -8552,11 +8654,9 @@ class Parser(metaclass=_Parser):
 
         return self.expression(
             exp.Star,
-            **{  # type: ignore
-                "except": self._parse_star_op("EXCEPT", "EXCLUDE"),
-                "replace": self._parse_star_op("REPLACE"),
-                "rename": self._parse_star_op("RENAME"),
-            },
+            except_=self._parse_star_op("EXCEPT", "EXCLUDE"),
+            replace=self._parse_star_op("REPLACE"),
+            rename=self._parse_star_op("RENAME"),
         ).update_positions(star_token)
 
     def _parse_grant_privilege(self) -> t.Optional[exp.GrantPrivilege]:
@@ -8654,14 +8754,17 @@ class Parser(metaclass=_Parser):
         )
 
     def _parse_overlay(self) -> exp.Overlay:
+        def _parse_overlay_arg(text: str) -> t.Optional[exp.Expression]:
+            return (
+                self._match(TokenType.COMMA) or self._match_text_seq(text)
+            ) and self._parse_bitwise()
+
         return self.expression(
             exp.Overlay,
-            **{  # type: ignore
-                "this": self._parse_bitwise(),
-                "expression": self._match_text_seq("PLACING") and self._parse_bitwise(),
-                "from": self._match_text_seq("FROM") and self._parse_bitwise(),
-                "for": self._match_text_seq("FOR") and self._parse_bitwise(),
-            },
+            this=self._parse_bitwise(),
+            expression=_parse_overlay_arg("PLACING"),
+            from_=_parse_overlay_arg("FROM"),
+            for_=_parse_overlay_arg("FOR"),
         )
 
     def _parse_format_name(self) -> exp.Property:
@@ -8689,10 +8792,7 @@ class Parser(metaclass=_Parser):
     def _identifier_expression(
         self, token: t.Optional[Token] = None, **kwargs: t.Any
     ) -> exp.Identifier:
-        token = token or self._prev
-        expression = self.expression(exp.Identifier, this=token.text, **kwargs)
-        expression.update_positions(token)
-        return expression
+        return self.expression(exp.Identifier, token=token or self._prev, **kwargs)
 
     def _build_pipe_cte(
         self,
@@ -8707,12 +8807,12 @@ class Parser(metaclass=_Parser):
             self._pipe_cte_counter += 1
             new_cte = f"__tmp{self._pipe_cte_counter}"
 
-        with_ = query.args.get("with")
+        with_ = query.args.get("with_")
         ctes = with_.pop() if with_ else None
 
         new_select = exp.select(*expressions, copy=False).from_(new_cte, copy=False)
         if ctes:
-            new_select.set("with", ctes)
+            new_select.set("with_", ctes)
 
         return new_select.with_(new_cte, as_=query, copy=False)
 
@@ -8740,7 +8840,7 @@ class Parser(metaclass=_Parser):
         return query
 
     def _parse_pipe_syntax_aggregate_fields(self) -> t.Optional[exp.Expression]:
-        this = self._parse_assignment()
+        this = self._parse_disjunction()
         if self._match_text_seq("GROUP", "AND", advance=False):
             return this
 
@@ -8807,7 +8907,7 @@ class Parser(metaclass=_Parser):
         ]
 
         query = self._build_pipe_cte(query=query, expressions=[exp.Star()])
-        with_ = query.args.get("with")
+        with_ = query.args.get("with_")
         ctes = with_.pop() if with_ else None
 
         if isinstance(first_setop, exp.Union):
@@ -8817,7 +8917,7 @@ class Parser(metaclass=_Parser):
         else:
             query = query.intersect(*setops, copy=False, **first_setop.args)
 
-        query.set("with", ctes)
+        query.set("with_", ctes)
 
         return self._build_pipe_cte(query=query, expressions=[exp.Star()])
 
@@ -8836,7 +8936,7 @@ class Parser(metaclass=_Parser):
         if not pivots:
             return query
 
-        from_ = query.args.get("from")
+        from_ = query.args.get("from_")
         if from_:
             from_.this.set("pivots", pivots)
 
@@ -8850,7 +8950,7 @@ class Parser(metaclass=_Parser):
     def _parse_pipe_syntax_tablesample(self, query: exp.Select) -> exp.Select:
         sample = self._parse_table_sample()
 
-        with_ = query.args.get("with")
+        with_ = query.args.get("with_")
         if with_:
             with_.expressions[-1].this.set("sample", sample)
         else:
@@ -8862,7 +8962,7 @@ class Parser(metaclass=_Parser):
         if isinstance(query, exp.Subquery):
             query = exp.select("*").from_(query, copy=False)
 
-        if not query.args.get("from"):
+        if not query.args.get("from_"):
             query = exp.select("*").from_(query.subquery(copy=False), copy=False)
 
         while self._match(TokenType.PIPE_GT):
@@ -8935,13 +9035,20 @@ class Parser(metaclass=_Parser):
         ) -> exp.Expression:
             if isinstance(node, exp.Distinct) and len(node.expressions) > 1:
                 concat_exprs = [
-                    self.expression(exp.Concat, expressions=node.expressions, safe=True)
+                    self.expression(
+                        exp.Concat,
+                        expressions=node.expressions,
+                        safe=True,
+                        coalesce=self.dialect.CONCAT_COALESCE,
+                    )
                 ]
                 node.set("expressions", concat_exprs)
                 return node
             if len(exprs) == 1:
                 return exprs[0]
-            return self.expression(exp.Concat, expressions=args, safe=True)
+            return self.expression(
+                exp.Concat, expressions=args, safe=True, coalesce=self.dialect.CONCAT_COALESCE
+            )
 
         args = self._parse_csv(self._parse_lambda)
 
@@ -8961,3 +9068,12 @@ class Parser(metaclass=_Parser):
         separator = self._parse_field() if self._match(TokenType.SEPARATOR) else None
 
         return self.expression(exp.GroupConcat, this=this, separator=separator)
+
+    def _parse_initcap(self) -> exp.Initcap:
+        expr = exp.Initcap.from_arg_list(self._parse_function_args())
+
+        # attach dialect's default delimiters
+        if expr.args.get("expression") is None:
+            expr.set("expression", exp.Literal.string(self.dialect.INITCAP_DEFAULT_DELIMITER_CHARS))
+
+        return expr