We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Unable to parse the oracle query when "#" is present in the column names
Hello,

Parser is throwing an error when there is "#" character is present in the column name.

**Code for your reference -**

```
import sqlglot.expressions as exp

query ="""
SELECT A.COL#, B.COL2 FROM SCHEMA1.TABLE1 A
"""

expressions = sqlglot.parse_one(query, read='oracle')
x = list(expressions.find_all(exp.Table))

for i in x:
  listTables = str(i).split(' ')[0]
  print(listTables)
```


Above code fails as it cannot process '#' and throws the error.
Request you to add support for '#' for query parsing.

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

{"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@@ -166,7 +166,7 @@\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+        VAR_SINGLE_TOKENS = {\"@\", \"$\", \"#\"}\n \n         KEYWORDS = {\n             **tokens.Tokenizer.KEYWORDS,\n", "issue": "Unable to parse the oracle query when \"#\" is present in the column names\nHello,\r\n\r\nParser is throwing an error when there is \"#\" character is present in the column name.\r\n\r\n**Code for your reference -**\r\n\r\n```\r\nimport sqlglot.expressions as exp\r\n\r\nquery =\"\"\"\r\nSELECT A.COL#, B.COL2 FROM SCHEMA1.TABLE1 A\r\n\"\"\"\r\n\r\nexpressions = sqlglot.parse_one(query, read='oracle')\r\nx = list(expressions.find_all(exp.Table))\r\n\r\nfor i in x:\r\n  listTables = str(i).split(' ')[0]\r\n  print(listTables)\r\n```\r\n\r\n\r\nAbove code fails as it cannot process '#' and throws the error.\r\nRequest you to add support for '#' for query parsing.\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(self._parse_field_def)\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        # SELECT UNIQUE .. is old-style Oracle syntax for SELECT DISTINCT ..\n        # Reference: https://stackoverflow.com/a/336455\n        DISTINCT_TOKENS = {TokenType.DISTINCT, TokenType.UNIQUE}\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(self._parse_field_def)\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        # SELECT UNIQUE .. is old-style Oracle syntax for SELECT DISTINCT ..\n        # Reference: https://stackoverflow.com/a/336455\n        DISTINCT_TOKENS = {TokenType.DISTINCT, TokenType.UNIQUE}\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"}]}