We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
error in optimizer.qualify with mixed identifier quotation.
**Fully reproducible code snippet**:
```
from sqlglot import parse_one
from sqlglot.dialects.oracle import Oracle
from sqlglot.lineage import lineage
from sqlglot.optimizer.qualify import qualify

parser = Oracle()

sql = """
with base as
(

    select x.dummy as COL_1
    from dual x
)
select b."COL_1"
from base b
"""

ast = parse_one(sql, read=parser)
qualified = qualify(
        ast,
        dialect=parser,
        schema=None,
    )

```
error:
```
Exception has occurred: OptimizeError
Unknown column: COL_1
  File "C:\Users\itay5\Desktop\work\sql\main.py", line 20, in <module>
    qualified = qualify(
                ^^^^^^^^
sqlglot.errors.OptimizeError: Unknown column: COL_1
```
I get the same error while trying to use identify=False, and still no luck.



--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `sqlglot/dialects/oracle.py`
Content:
```
1 from __future__ import annotations
2 
3 import typing as t
4 
5 from sqlglot import exp, generator, parser, tokens, transforms
6 from sqlglot.dialects.dialect import Dialect, no_ilike_sql, rename_func, trim_sql
7 from sqlglot.helper import seq_get
8 from sqlglot.tokens import TokenType
9 
10 
11 def _parse_xml_table(self: parser.Parser) -> exp.XMLTable:
12     this = self._parse_string()
13 
14     passing = None
15     columns = None
16 
17     if self._match_text_seq("PASSING"):
18         # The BY VALUE keywords are optional and are provided for semantic clarity
19         self._match_text_seq("BY", "VALUE")
20         passing = self._parse_csv(self._parse_column)
21 
22     by_ref = self._match_text_seq("RETURNING", "SEQUENCE", "BY", "REF")
23 
24     if self._match_text_seq("COLUMNS"):
25         columns = self._parse_csv(lambda: self._parse_column_def(self._parse_field(any_token=True)))
26 
27     return self.expression(exp.XMLTable, this=this, passing=passing, columns=columns, by_ref=by_ref)
28 
29 
30 class Oracle(Dialect):
31     ALIAS_POST_TABLESAMPLE = True
32 
33     # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212
34     # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
35     TIME_MAPPING = {
36         "AM": "%p",  # Meridian indicator with or without periods
37         "A.M.": "%p",  # Meridian indicator with or without periods
38         "PM": "%p",  # Meridian indicator with or without periods
39         "P.M.": "%p",  # Meridian indicator with or without periods
40         "D": "%u",  # Day of week (1-7)
41         "DAY": "%A",  # name of day
42         "DD": "%d",  # day of month (1-31)
43         "DDD": "%j",  # day of year (1-366)
44         "DY": "%a",  # abbreviated name of day
45         "HH": "%I",  # Hour of day (1-12)
46         "HH12": "%I",  # alias for HH
47         "HH24": "%H",  # Hour of day (0-23)
48         "IW": "%V",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard
49         "MI": "%M",  # Minute (0-59)
50         "MM": "%m",  # Month (01-12; January = 01)
51         "MON": "%b",  # Abbreviated name of month
52         "MONTH": "%B",  # Name of month
53         "SS": "%S",  # Second (0-59)
54         "WW": "%W",  # Week of year (1-53)
55         "YY": "%y",  # 15
56         "YYYY": "%Y",  # 2015
57     }
58 
59     class Parser(parser.Parser):
60         WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER, TokenType.KEEP}
61 
62         FUNCTIONS = {
63             **parser.Parser.FUNCTIONS,
64             "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
65         }
66 
67         FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
68             **parser.Parser.FUNCTION_PARSERS,
69             "XMLTABLE": _parse_xml_table,
70         }
71 
72         TYPE_LITERAL_PARSERS = {
73             exp.DataType.Type.DATE: lambda self, this, _: self.expression(
74                 exp.DateStrToDate, this=this
75             )
76         }
77 
78         def _parse_column(self) -> t.Optional[exp.Expression]:
79             column = super()._parse_column()
80             if column:
81                 column.set("join_mark", self._match(TokenType.JOIN_MARKER))
82             return column
83 
84         def _parse_hint(self) -> t.Optional[exp.Hint]:
85             if self._match(TokenType.HINT):
86                 start = self._curr
87                 while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH):
88                     self._advance()
89 
90                 if not self._curr:
91                     self.raise_error("Expected */ after HINT")
92 
93                 end = self._tokens[self._index - 3]
94                 return exp.Hint(expressions=[self._find_sql(start, end)])
95 
96             return None
97 
98     class Generator(generator.Generator):
99         LOCKING_READS_SUPPORTED = True
100         JOIN_HINTS = False
101         TABLE_HINTS = False
102         COLUMN_JOIN_MARKS_SUPPORTED = True
103 
104         LIMIT_FETCH = "FETCH"
105 
106         TYPE_MAPPING = {
107             **generator.Generator.TYPE_MAPPING,
108             exp.DataType.Type.TINYINT: "NUMBER",
109             exp.DataType.Type.SMALLINT: "NUMBER",
110             exp.DataType.Type.INT: "NUMBER",
111             exp.DataType.Type.BIGINT: "NUMBER",
112             exp.DataType.Type.DECIMAL: "NUMBER",
113             exp.DataType.Type.DOUBLE: "DOUBLE PRECISION",
114             exp.DataType.Type.VARCHAR: "VARCHAR2",
115             exp.DataType.Type.NVARCHAR: "NVARCHAR2",
116             exp.DataType.Type.NCHAR: "NCHAR",
117             exp.DataType.Type.TEXT: "CLOB",
118             exp.DataType.Type.BINARY: "BLOB",
119             exp.DataType.Type.VARBINARY: "BLOB",
120         }
121 
122         TRANSFORMS = {
123             **generator.Generator.TRANSFORMS,
124             exp.DateStrToDate: lambda self, e: self.func(
125                 "TO_DATE", e.this, exp.Literal.string("YYYY-MM-DD")
126             ),
127             exp.Group: transforms.preprocess([transforms.unalias_group]),
128             exp.ILike: no_ilike_sql,
129             exp.Coalesce: rename_func("NVL"),
130             exp.Select: transforms.preprocess([transforms.eliminate_distinct_on]),
131             exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})",
132             exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
133             exp.Substring: rename_func("SUBSTR"),
134             exp.Table: lambda self, e: self.table_sql(e, sep=" "),
135             exp.TableSample: lambda self, e: self.tablesample_sql(e, sep=" "),
136             exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})",
137             exp.ToChar: lambda self, e: self.function_fallback_sql(e),
138             exp.Trim: trim_sql,
139             exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)",
140         }
141 
142         PROPERTIES_LOCATION = {
143             **generator.Generator.PROPERTIES_LOCATION,
144             exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
145         }
146 
147         def offset_sql(self, expression: exp.Offset) -> str:
148             return f"{super().offset_sql(expression)} ROWS"
149 
150         def xmltable_sql(self, expression: exp.XMLTable) -> str:
151             this = self.sql(expression, "this")
152             passing = self.expressions(expression, key="passing")
153             passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
154             columns = self.expressions(expression, key="columns")
155             columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
156             by_ref = (
157                 f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
158             )
159             return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}"
160 
161     class Tokenizer(tokens.Tokenizer):
162         VAR_SINGLE_TOKENS = {"@"}
163 
164         KEYWORDS = {
165             **tokens.Tokenizer.KEYWORDS,
166             "(+)": TokenType.JOIN_MARKER,
167             "BINARY_DOUBLE": TokenType.DOUBLE,
168             "BINARY_FLOAT": TokenType.FLOAT,
169             "COLUMNS": TokenType.COLUMN,
170             "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
171             "MINUS": TokenType.EXCEPT,
172             "NVARCHAR2": TokenType.NVARCHAR,
173             "SAMPLE": TokenType.TABLE_SAMPLE,
174             "START": TokenType.BEGIN,
175             "TOP": TokenType.TOP,
176             "VARCHAR2": TokenType.VARCHAR,
177         }
178
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/sqlglot/dialects/oracle.py b/sqlglot/dialects/oracle.py
--- a/sqlglot/dialects/oracle.py
+++ b/sqlglot/dialects/oracle.py
@@ -30,6 +30,9 @@
 class Oracle(Dialect):
     ALIAS_POST_TABLESAMPLE = True
 
+    # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm
+    RESOLVES_IDENTIFIERS_AS_UPPERCASE = True
+
     # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212
     # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes
     TIME_MAPPING = {

{"golden_diff": "diff --git a/sqlglot/dialects/oracle.py b/sqlglot/dialects/oracle.py\n--- a/sqlglot/dialects/oracle.py\n+++ b/sqlglot/dialects/oracle.py\n@@ -30,6 +30,9 @@\n class Oracle(Dialect):\n     ALIAS_POST_TABLESAMPLE = True\n \n+    # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm\n+    RESOLVES_IDENTIFIERS_AS_UPPERCASE = True\n+\n     # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212\n     # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes\n     TIME_MAPPING = {\n", "issue": "error in optimizer.qualify with mixed identifier quotation.\n**Fully reproducible code snippet**:\r\n```\r\nfrom sqlglot import parse_one\r\nfrom sqlglot.dialects.oracle import Oracle\r\nfrom sqlglot.lineage import lineage\r\nfrom sqlglot.optimizer.qualify import qualify\r\n\r\nparser = Oracle()\r\n\r\nsql = \"\"\"\r\nwith base as\r\n(\r\n\r\n    select x.dummy as COL_1\r\n    from dual x\r\n)\r\nselect b.\"COL_1\"\r\nfrom base b\r\n\"\"\"\r\n\r\nast = parse_one(sql, read=parser)\r\nqualified = qualify(\r\n        ast,\r\n        dialect=parser,\r\n        schema=None,\r\n    )\r\n\r\n```\r\nerror:\r\n```\r\nException has occurred: OptimizeError\r\nUnknown column: COL_1\r\n  File \"C:\\Users\\itay5\\Desktop\\work\\sql\\main.py\", line 20, in <module>\r\n    qualified = qualify(\r\n                ^^^^^^^^\r\nsqlglot.errors.OptimizeError: Unknown column: COL_1\r\n```\r\nI get the same error while trying to use identify=False, and still no luck.\r\n\r\n\n", "before_files": [{"content": "from __future__ import annotations\n\nimport typing as t\n\nfrom sqlglot import exp, generator, parser, tokens, transforms\nfrom sqlglot.dialects.dialect import Dialect, no_ilike_sql, rename_func, trim_sql\nfrom sqlglot.helper import seq_get\nfrom sqlglot.tokens import TokenType\n\n\ndef _parse_xml_table(self: parser.Parser) -> exp.XMLTable:\n    this = self._parse_string()\n\n    passing = None\n    columns = None\n\n    if self._match_text_seq(\"PASSING\"):\n        # The BY VALUE keywords are optional and are provided for semantic clarity\n        self._match_text_seq(\"BY\", \"VALUE\")\n        passing = self._parse_csv(self._parse_column)\n\n    by_ref = self._match_text_seq(\"RETURNING\", \"SEQUENCE\", \"BY\", \"REF\")\n\n    if self._match_text_seq(\"COLUMNS\"):\n        columns = self._parse_csv(lambda: self._parse_column_def(self._parse_field(any_token=True)))\n\n    return self.expression(exp.XMLTable, this=this, passing=passing, columns=columns, by_ref=by_ref)\n\n\nclass Oracle(Dialect):\n    ALIAS_POST_TABLESAMPLE = True\n\n    # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212\n    # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes\n    TIME_MAPPING = {\n        \"AM\": \"%p\",  # Meridian indicator with or without periods\n        \"A.M.\": \"%p\",  # Meridian indicator with or without periods\n        \"PM\": \"%p\",  # Meridian indicator with or without periods\n        \"P.M.\": \"%p\",  # Meridian indicator with or without periods\n        \"D\": \"%u\",  # Day of week (1-7)\n        \"DAY\": \"%A\",  # name of day\n        \"DD\": \"%d\",  # day of month (1-31)\n        \"DDD\": \"%j\",  # day of year (1-366)\n        \"DY\": \"%a\",  # abbreviated name of day\n        \"HH\": \"%I\",  # Hour of day (1-12)\n        \"HH12\": \"%I\",  # alias for HH\n        \"HH24\": \"%H\",  # Hour of day (0-23)\n        \"IW\": \"%V\",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard\n        \"MI\": \"%M\",  # Minute (0-59)\n        \"MM\": \"%m\",  # Month (01-12; January = 01)\n        \"MON\": \"%b\",  # Abbreviated name of month\n        \"MONTH\": \"%B\",  # Name of month\n        \"SS\": \"%S\",  # Second (0-59)\n        \"WW\": \"%W\",  # Week of year (1-53)\n        \"YY\": \"%y\",  # 15\n        \"YYYY\": \"%Y\",  # 2015\n    }\n\n    class Parser(parser.Parser):\n        WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER, TokenType.KEEP}\n\n        FUNCTIONS = {\n            **parser.Parser.FUNCTIONS,\n            \"SQUARE\": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),\n        }\n\n        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {\n            **parser.Parser.FUNCTION_PARSERS,\n            \"XMLTABLE\": _parse_xml_table,\n        }\n\n        TYPE_LITERAL_PARSERS = {\n            exp.DataType.Type.DATE: lambda self, this, _: self.expression(\n                exp.DateStrToDate, this=this\n            )\n        }\n\n        def _parse_column(self) -> t.Optional[exp.Expression]:\n            column = super()._parse_column()\n            if column:\n                column.set(\"join_mark\", self._match(TokenType.JOIN_MARKER))\n            return column\n\n        def _parse_hint(self) -> t.Optional[exp.Hint]:\n            if self._match(TokenType.HINT):\n                start = self._curr\n                while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH):\n                    self._advance()\n\n                if not self._curr:\n                    self.raise_error(\"Expected */ after HINT\")\n\n                end = self._tokens[self._index - 3]\n                return exp.Hint(expressions=[self._find_sql(start, end)])\n\n            return None\n\n    class Generator(generator.Generator):\n        LOCKING_READS_SUPPORTED = True\n        JOIN_HINTS = False\n        TABLE_HINTS = False\n        COLUMN_JOIN_MARKS_SUPPORTED = True\n\n        LIMIT_FETCH = \"FETCH\"\n\n        TYPE_MAPPING = {\n            **generator.Generator.TYPE_MAPPING,\n            exp.DataType.Type.TINYINT: \"NUMBER\",\n            exp.DataType.Type.SMALLINT: \"NUMBER\",\n            exp.DataType.Type.INT: \"NUMBER\",\n            exp.DataType.Type.BIGINT: \"NUMBER\",\n            exp.DataType.Type.DECIMAL: \"NUMBER\",\n            exp.DataType.Type.DOUBLE: \"DOUBLE PRECISION\",\n            exp.DataType.Type.VARCHAR: \"VARCHAR2\",\n            exp.DataType.Type.NVARCHAR: \"NVARCHAR2\",\n            exp.DataType.Type.NCHAR: \"NCHAR\",\n            exp.DataType.Type.TEXT: \"CLOB\",\n            exp.DataType.Type.BINARY: \"BLOB\",\n            exp.DataType.Type.VARBINARY: \"BLOB\",\n        }\n\n        TRANSFORMS = {\n            **generator.Generator.TRANSFORMS,\n            exp.DateStrToDate: lambda self, e: self.func(\n                \"TO_DATE\", e.this, exp.Literal.string(\"YYYY-MM-DD\")\n            ),\n            exp.Group: transforms.preprocess([transforms.unalias_group]),\n            exp.ILike: no_ilike_sql,\n            exp.Coalesce: rename_func(\"NVL\"),\n            exp.Select: transforms.preprocess([transforms.eliminate_distinct_on]),\n            exp.StrToTime: lambda self, e: f\"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})\",\n            exp.Subquery: lambda self, e: self.subquery_sql(e, sep=\" \"),\n            exp.Substring: rename_func(\"SUBSTR\"),\n            exp.Table: lambda self, e: self.table_sql(e, sep=\" \"),\n            exp.TableSample: lambda self, e: self.tablesample_sql(e, sep=\" \"),\n            exp.TimeToStr: lambda self, e: f\"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})\",\n            exp.ToChar: lambda self, e: self.function_fallback_sql(e),\n            exp.Trim: trim_sql,\n            exp.UnixToTime: lambda self, e: f\"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)\",\n        }\n\n        PROPERTIES_LOCATION = {\n            **generator.Generator.PROPERTIES_LOCATION,\n            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,\n        }\n\n        def offset_sql(self, expression: exp.Offset) -> str:\n            return f\"{super().offset_sql(expression)} ROWS\"\n\n        def xmltable_sql(self, expression: exp.XMLTable) -> str:\n            this = self.sql(expression, \"this\")\n            passing = self.expressions(expression, key=\"passing\")\n            passing = f\"{self.sep()}PASSING{self.seg(passing)}\" if passing else \"\"\n            columns = self.expressions(expression, key=\"columns\")\n            columns = f\"{self.sep()}COLUMNS{self.seg(columns)}\" if columns else \"\"\n            by_ref = (\n                f\"{self.sep()}RETURNING SEQUENCE BY REF\" if expression.args.get(\"by_ref\") else \"\"\n            )\n            return f\"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}\"\n\n    class Tokenizer(tokens.Tokenizer):\n        VAR_SINGLE_TOKENS = {\"@\"}\n\n        KEYWORDS = {\n            **tokens.Tokenizer.KEYWORDS,\n            \"(+)\": TokenType.JOIN_MARKER,\n            \"BINARY_DOUBLE\": TokenType.DOUBLE,\n            \"BINARY_FLOAT\": TokenType.FLOAT,\n            \"COLUMNS\": TokenType.COLUMN,\n            \"MATCH_RECOGNIZE\": TokenType.MATCH_RECOGNIZE,\n            \"MINUS\": TokenType.EXCEPT,\n            \"NVARCHAR2\": TokenType.NVARCHAR,\n            \"SAMPLE\": TokenType.TABLE_SAMPLE,\n            \"START\": TokenType.BEGIN,\n            \"TOP\": TokenType.TOP,\n            \"VARCHAR2\": TokenType.VARCHAR,\n        }\n", "path": "sqlglot/dialects/oracle.py"}], "after_files": [{"content": "from __future__ import annotations\n\nimport typing as t\n\nfrom sqlglot import exp, generator, parser, tokens, transforms\nfrom sqlglot.dialects.dialect import Dialect, no_ilike_sql, rename_func, trim_sql\nfrom sqlglot.helper import seq_get\nfrom sqlglot.tokens import TokenType\n\n\ndef _parse_xml_table(self: parser.Parser) -> exp.XMLTable:\n    this = self._parse_string()\n\n    passing = None\n    columns = None\n\n    if self._match_text_seq(\"PASSING\"):\n        # The BY VALUE keywords are optional and are provided for semantic clarity\n        self._match_text_seq(\"BY\", \"VALUE\")\n        passing = self._parse_csv(self._parse_column)\n\n    by_ref = self._match_text_seq(\"RETURNING\", \"SEQUENCE\", \"BY\", \"REF\")\n\n    if self._match_text_seq(\"COLUMNS\"):\n        columns = self._parse_csv(lambda: self._parse_column_def(self._parse_field(any_token=True)))\n\n    return self.expression(exp.XMLTable, this=this, passing=passing, columns=columns, by_ref=by_ref)\n\n\nclass Oracle(Dialect):\n    ALIAS_POST_TABLESAMPLE = True\n\n    # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm\n    RESOLVES_IDENTIFIERS_AS_UPPERCASE = True\n\n    # https://docs.oracle.com/database/121/SQLRF/sql_elements004.htm#SQLRF00212\n    # https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes\n    TIME_MAPPING = {\n        \"AM\": \"%p\",  # Meridian indicator with or without periods\n        \"A.M.\": \"%p\",  # Meridian indicator with or without periods\n        \"PM\": \"%p\",  # Meridian indicator with or without periods\n        \"P.M.\": \"%p\",  # Meridian indicator with or without periods\n        \"D\": \"%u\",  # Day of week (1-7)\n        \"DAY\": \"%A\",  # name of day\n        \"DD\": \"%d\",  # day of month (1-31)\n        \"DDD\": \"%j\",  # day of year (1-366)\n        \"DY\": \"%a\",  # abbreviated name of day\n        \"HH\": \"%I\",  # Hour of day (1-12)\n        \"HH12\": \"%I\",  # alias for HH\n        \"HH24\": \"%H\",  # Hour of day (0-23)\n        \"IW\": \"%V\",  # Calendar week of year (1-52 or 1-53), as defined by the ISO 8601 standard\n        \"MI\": \"%M\",  # Minute (0-59)\n        \"MM\": \"%m\",  # Month (01-12; January = 01)\n        \"MON\": \"%b\",  # Abbreviated name of month\n        \"MONTH\": \"%B\",  # Name of month\n        \"SS\": \"%S\",  # Second (0-59)\n        \"WW\": \"%W\",  # Week of year (1-53)\n        \"YY\": \"%y\",  # 15\n        \"YYYY\": \"%Y\",  # 2015\n    }\n\n    class Parser(parser.Parser):\n        WINDOW_BEFORE_PAREN_TOKENS = {TokenType.OVER, TokenType.KEEP}\n\n        FUNCTIONS = {\n            **parser.Parser.FUNCTIONS,\n            \"SQUARE\": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),\n        }\n\n        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {\n            **parser.Parser.FUNCTION_PARSERS,\n            \"XMLTABLE\": _parse_xml_table,\n        }\n\n        TYPE_LITERAL_PARSERS = {\n            exp.DataType.Type.DATE: lambda self, this, _: self.expression(\n                exp.DateStrToDate, this=this\n            )\n        }\n\n        def _parse_column(self) -> t.Optional[exp.Expression]:\n            column = super()._parse_column()\n            if column:\n                column.set(\"join_mark\", self._match(TokenType.JOIN_MARKER))\n            return column\n\n        def _parse_hint(self) -> t.Optional[exp.Hint]:\n            if self._match(TokenType.HINT):\n                start = self._curr\n                while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH):\n                    self._advance()\n\n                if not self._curr:\n                    self.raise_error(\"Expected */ after HINT\")\n\n                end = self._tokens[self._index - 3]\n                return exp.Hint(expressions=[self._find_sql(start, end)])\n\n            return None\n\n    class Generator(generator.Generator):\n        LOCKING_READS_SUPPORTED = True\n        JOIN_HINTS = False\n        TABLE_HINTS = False\n        COLUMN_JOIN_MARKS_SUPPORTED = True\n\n        LIMIT_FETCH = \"FETCH\"\n\n        TYPE_MAPPING = {\n            **generator.Generator.TYPE_MAPPING,\n            exp.DataType.Type.TINYINT: \"NUMBER\",\n            exp.DataType.Type.SMALLINT: \"NUMBER\",\n            exp.DataType.Type.INT: \"NUMBER\",\n            exp.DataType.Type.BIGINT: \"NUMBER\",\n            exp.DataType.Type.DECIMAL: \"NUMBER\",\n            exp.DataType.Type.DOUBLE: \"DOUBLE PRECISION\",\n            exp.DataType.Type.VARCHAR: \"VARCHAR2\",\n            exp.DataType.Type.NVARCHAR: \"NVARCHAR2\",\n            exp.DataType.Type.NCHAR: \"NCHAR\",\n            exp.DataType.Type.TEXT: \"CLOB\",\n            exp.DataType.Type.BINARY: \"BLOB\",\n            exp.DataType.Type.VARBINARY: \"BLOB\",\n        }\n\n        TRANSFORMS = {\n            **generator.Generator.TRANSFORMS,\n            exp.DateStrToDate: lambda self, e: self.func(\n                \"TO_DATE\", e.this, exp.Literal.string(\"YYYY-MM-DD\")\n            ),\n            exp.Group: transforms.preprocess([transforms.unalias_group]),\n            exp.ILike: no_ilike_sql,\n            exp.Coalesce: rename_func(\"NVL\"),\n            exp.Select: transforms.preprocess([transforms.eliminate_distinct_on]),\n            exp.StrToTime: lambda self, e: f\"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})\",\n            exp.Subquery: lambda self, e: self.subquery_sql(e, sep=\" \"),\n            exp.Substring: rename_func(\"SUBSTR\"),\n            exp.Table: lambda self, e: self.table_sql(e, sep=\" \"),\n            exp.TableSample: lambda self, e: self.tablesample_sql(e, sep=\" \"),\n            exp.TimeToStr: lambda self, e: f\"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})\",\n            exp.ToChar: lambda self, e: self.function_fallback_sql(e),\n            exp.Trim: trim_sql,\n            exp.UnixToTime: lambda self, e: f\"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)\",\n        }\n\n        PROPERTIES_LOCATION = {\n            **generator.Generator.PROPERTIES_LOCATION,\n            exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,\n        }\n\n        def offset_sql(self, expression: exp.Offset) -> str:\n            return f\"{super().offset_sql(expression)} ROWS\"\n\n        def xmltable_sql(self, expression: exp.XMLTable) -> str:\n            this = self.sql(expression, \"this\")\n            passing = self.expressions(expression, key=\"passing\")\n            passing = f\"{self.sep()}PASSING{self.seg(passing)}\" if passing else \"\"\n            columns = self.expressions(expression, key=\"columns\")\n            columns = f\"{self.sep()}COLUMNS{self.seg(columns)}\" if columns else \"\"\n            by_ref = (\n                f\"{self.sep()}RETURNING SEQUENCE BY REF\" if expression.args.get(\"by_ref\") else \"\"\n            )\n            return f\"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}\"\n\n    class Tokenizer(tokens.Tokenizer):\n        VAR_SINGLE_TOKENS = {\"@\"}\n\n        KEYWORDS = {\n            **tokens.Tokenizer.KEYWORDS,\n            \"(+)\": TokenType.JOIN_MARKER,\n            \"BINARY_DOUBLE\": TokenType.DOUBLE,\n            \"BINARY_FLOAT\": TokenType.FLOAT,\n            \"COLUMNS\": TokenType.COLUMN,\n            \"MATCH_RECOGNIZE\": TokenType.MATCH_RECOGNIZE,\n            \"MINUS\": TokenType.EXCEPT,\n            \"NVARCHAR2\": TokenType.NVARCHAR,\n            \"SAMPLE\": TokenType.TABLE_SAMPLE,\n            \"START\": TokenType.BEGIN,\n            \"TOP\": TokenType.TOP,\n            \"VARCHAR2\": TokenType.VARCHAR,\n        }\n", "path": "sqlglot/dialects/oracle.py"}]}