From fb7e79eb4c8d6e22b7324de4bb1ea9cd11b8da7c Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 7 Apr 2023 14:35:04 +0200 Subject: Merging upstream version 11.5.2. Signed-off-by: Daniel Baumann --- docs/sqlglot/dialects/oracle.html | 596 +++++++++++++++++++------------------- 1 file changed, 297 insertions(+), 299 deletions(-) (limited to 'docs/sqlglot/dialects/oracle.html') diff --git a/docs/sqlglot/dialects/oracle.html b/docs/sqlglot/dialects/oracle.html index c1d00d2..dcf8bf6 100644 --- a/docs/sqlglot/dialects/oracle.html +++ b/docs/sqlglot/dialects/oracle.html @@ -3,7 +3,7 @@ - + sqlglot.dialects.oracle API documentation @@ -158,102 +158,100 @@ 70 class Parser(parser.Parser): 71 FUNCTIONS = { 72 **parser.Parser.FUNCTIONS, # type: ignore - 73 "DECODE": exp.Matches.from_arg_list, - 74 "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), - 75 } - 76 - 77 FUNCTION_PARSERS: t.Dict[str, t.Callable] = { - 78 **parser.Parser.FUNCTION_PARSERS, - 79 "XMLTABLE": _parse_xml_table, - 80 } - 81 - 82 def _parse_column(self) -> t.Optional[exp.Expression]: - 83 column = super()._parse_column() - 84 if column: - 85 column.set("join_mark", self._match(TokenType.JOIN_MARKER)) - 86 return column - 87 - 88 def _parse_hint(self) -> t.Optional[exp.Expression]: - 89 if self._match(TokenType.HINT): - 90 start = self._curr - 91 while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH): - 92 self._advance() - 93 - 94 if not self._curr: - 95 self.raise_error("Expected */ after HINT") - 96 - 97 end = self._tokens[self._index - 3] - 98 return exp.Hint(expressions=[self._find_sql(start, end)]) - 99 -100 return None -101 -102 class Generator(generator.Generator): -103 LOCKING_READS_SUPPORTED = True -104 -105 TYPE_MAPPING = { -106 **generator.Generator.TYPE_MAPPING, # type: ignore -107 exp.DataType.Type.TINYINT: "NUMBER", -108 exp.DataType.Type.SMALLINT: "NUMBER", -109 exp.DataType.Type.INT: "NUMBER", -110 exp.DataType.Type.BIGINT: "NUMBER", -111 exp.DataType.Type.DECIMAL: "NUMBER", -112 exp.DataType.Type.DOUBLE: "DOUBLE PRECISION", -113 exp.DataType.Type.VARCHAR: "VARCHAR2", -114 exp.DataType.Type.NVARCHAR: "NVARCHAR2", -115 exp.DataType.Type.TEXT: "CLOB", -116 exp.DataType.Type.BINARY: "BLOB", -117 exp.DataType.Type.VARBINARY: "BLOB", -118 } -119 -120 TRANSFORMS = { -121 **generator.Generator.TRANSFORMS, # type: ignore -122 **transforms.UNALIAS_GROUP, # type: ignore -123 exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */", -124 exp.ILike: no_ilike_sql, -125 exp.Matches: rename_func("DECODE"), -126 exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", -127 exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "), -128 exp.Substring: rename_func("SUBSTR"), -129 exp.Table: lambda self, e: self.table_sql(e, sep=" "), -130 exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})", -131 exp.ToChar: lambda self, e: self.function_fallback_sql(e), -132 exp.Trim: trim_sql, -133 exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)", -134 } + 73 "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), + 74 } + 75 + 76 FUNCTION_PARSERS: t.Dict[str, t.Callable] = { + 77 **parser.Parser.FUNCTION_PARSERS, + 78 "XMLTABLE": _parse_xml_table, + 79 } + 80 + 81 def _parse_column(self) -> t.Optional[exp.Expression]: + 82 column = super()._parse_column() + 83 if column: + 84 column.set("join_mark", self._match(TokenType.JOIN_MARKER)) + 85 return column + 86 + 87 def _parse_hint(self) -> t.Optional[exp.Expression]: + 88 if self._match(TokenType.HINT): + 89 start = self._curr + 90 while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH): + 91 self._advance() + 92 + 93 if not self._curr: + 94 self.raise_error("Expected */ after HINT") + 95 + 96 end = self._tokens[self._index - 3] + 97 return exp.Hint(expressions=[self._find_sql(start, end)]) + 98 + 99 return None +100 +101 class Generator(generator.Generator): +102 LOCKING_READS_SUPPORTED = True +103 +104 TYPE_MAPPING = { +105 **generator.Generator.TYPE_MAPPING, # type: ignore +106 exp.DataType.Type.TINYINT: "NUMBER", +107 exp.DataType.Type.SMALLINT: "NUMBER", +108 exp.DataType.Type.INT: "NUMBER", +109 exp.DataType.Type.BIGINT: "NUMBER", +110 exp.DataType.Type.DECIMAL: "NUMBER", +111 exp.DataType.Type.DOUBLE: "DOUBLE PRECISION", +112 exp.DataType.Type.VARCHAR: "VARCHAR2", +113 exp.DataType.Type.NVARCHAR: "NVARCHAR2", +114 exp.DataType.Type.TEXT: "CLOB", +115 exp.DataType.Type.BINARY: "BLOB", +116 exp.DataType.Type.VARBINARY: "BLOB", +117 } +118 +119 TRANSFORMS = { +120 **generator.Generator.TRANSFORMS, # type: ignore +121 **transforms.UNALIAS_GROUP, # type: ignore +122 exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */", +123 exp.ILike: no_ilike_sql, +124 exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", +125 exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "), +126 exp.Substring: rename_func("SUBSTR"), +127 exp.Table: lambda self, e: self.table_sql(e, sep=" "), +128 exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})", +129 exp.ToChar: lambda self, e: self.function_fallback_sql(e), +130 exp.Trim: trim_sql, +131 exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)", +132 } +133 +134 LIMIT_FETCH = "FETCH" 135 -136 LIMIT_FETCH = "FETCH" -137 -138 def offset_sql(self, expression: exp.Offset) -> str: -139 return f"{super().offset_sql(expression)} ROWS" -140 -141 def column_sql(self, expression: exp.Column) -> str: -142 column = super().column_sql(expression) -143 return f"{column} (+)" if expression.args.get("join_mark") else column -144 -145 def xmltable_sql(self, expression: exp.XMLTable) -> str: -146 this = self.sql(expression, "this") -147 passing = self.expressions(expression, "passing") -148 passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else "" -149 columns = self.expressions(expression, "columns") -150 columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else "" -151 by_ref = ( -152 f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else "" -153 ) -154 return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}" -155 -156 class Tokenizer(tokens.Tokenizer): -157 KEYWORDS = { -158 **tokens.Tokenizer.KEYWORDS, -159 "(+)": TokenType.JOIN_MARKER, -160 "COLUMNS": TokenType.COLUMN, -161 "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE, -162 "MINUS": TokenType.EXCEPT, -163 "NVARCHAR2": TokenType.NVARCHAR, -164 "RETURNING": TokenType.RETURNING, -165 "START": TokenType.BEGIN, -166 "TOP": TokenType.TOP, -167 "VARCHAR2": TokenType.VARCHAR, -168 } +136 def offset_sql(self, expression: exp.Offset) -> str: +137 return f"{super().offset_sql(expression)} ROWS" +138 +139 def column_sql(self, expression: exp.Column) -> str: +140 column = super().column_sql(expression) +141 return f"{column} (+)" if expression.args.get("join_mark") else column +142 +143 def xmltable_sql(self, expression: exp.XMLTable) -> str: +144 this = self.sql(expression, "this") +145 passing = self.expressions(expression, "passing") +146 passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else "" +147 columns = self.expressions(expression, "columns") +148 columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else "" +149 by_ref = ( +150 f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else "" +151 ) +152 return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}" +153 +154 class Tokenizer(tokens.Tokenizer): +155 KEYWORDS = { +156 **tokens.Tokenizer.KEYWORDS, +157 "(+)": TokenType.JOIN_MARKER, +158 "COLUMNS": TokenType.COLUMN, +159 "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE, +160 "MINUS": TokenType.EXCEPT, +161 "NVARCHAR2": TokenType.NVARCHAR, +162 "RETURNING": TokenType.RETURNING, +163 "START": TokenType.BEGIN, +164 "TOP": TokenType.TOP, +165 "VARCHAR2": TokenType.VARCHAR, +166 } @@ -299,102 +297,100 @@ 71 class Parser(parser.Parser): 72 FUNCTIONS = { 73 **parser.Parser.FUNCTIONS, # type: ignore - 74 "DECODE": exp.Matches.from_arg_list, - 75 "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), - 76 } - 77 - 78 FUNCTION_PARSERS: t.Dict[str, t.Callable] = { - 79 **parser.Parser.FUNCTION_PARSERS, - 80 "XMLTABLE": _parse_xml_table, - 81 } - 82 - 83 def _parse_column(self) -> t.Optional[exp.Expression]: - 84 column = super()._parse_column() - 85 if column: - 86 column.set("join_mark", self._match(TokenType.JOIN_MARKER)) - 87 return column - 88 - 89 def _parse_hint(self) -> t.Optional[exp.Expression]: - 90 if self._match(TokenType.HINT): - 91 start = self._curr - 92 while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH): - 93 self._advance() - 94 - 95 if not self._curr: - 96 self.raise_error("Expected */ after HINT") - 97 - 98 end = self._tokens[self._index - 3] - 99 return exp.Hint(expressions=[self._find_sql(start, end)]) -100 -101 return None -102 -103 class Generator(generator.Generator): -104 LOCKING_READS_SUPPORTED = True -105 -106 TYPE_MAPPING = { -107 **generator.Generator.TYPE_MAPPING, # type: ignore -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.TEXT: "CLOB", -117 exp.DataType.Type.BINARY: "BLOB", -118 exp.DataType.Type.VARBINARY: "BLOB", -119 } -120 -121 TRANSFORMS = { -122 **generator.Generator.TRANSFORMS, # type: ignore -123 **transforms.UNALIAS_GROUP, # type: ignore -124 exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */", -125 exp.ILike: no_ilike_sql, -126 exp.Matches: rename_func("DECODE"), -127 exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", -128 exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "), -129 exp.Substring: rename_func("SUBSTR"), -130 exp.Table: lambda self, e: self.table_sql(e, sep=" "), -131 exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})", -132 exp.ToChar: lambda self, e: self.function_fallback_sql(e), -133 exp.Trim: trim_sql, -134 exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)", -135 } + 74 "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)), + 75 } + 76 + 77 FUNCTION_PARSERS: t.Dict[str, t.Callable] = { + 78 **parser.Parser.FUNCTION_PARSERS, + 79 "XMLTABLE": _parse_xml_table, + 80 } + 81 + 82 def _parse_column(self) -> t.Optional[exp.Expression]: + 83 column = super()._parse_column() + 84 if column: + 85 column.set("join_mark", self._match(TokenType.JOIN_MARKER)) + 86 return column + 87 + 88 def _parse_hint(self) -> t.Optional[exp.Expression]: + 89 if self._match(TokenType.HINT): + 90 start = self._curr + 91 while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH): + 92 self._advance() + 93 + 94 if not self._curr: + 95 self.raise_error("Expected */ after HINT") + 96 + 97 end = self._tokens[self._index - 3] + 98 return exp.Hint(expressions=[self._find_sql(start, end)]) + 99 +100 return None +101 +102 class Generator(generator.Generator): +103 LOCKING_READS_SUPPORTED = True +104 +105 TYPE_MAPPING = { +106 **generator.Generator.TYPE_MAPPING, # type: ignore +107 exp.DataType.Type.TINYINT: "NUMBER", +108 exp.DataType.Type.SMALLINT: "NUMBER", +109 exp.DataType.Type.INT: "NUMBER", +110 exp.DataType.Type.BIGINT: "NUMBER", +111 exp.DataType.Type.DECIMAL: "NUMBER", +112 exp.DataType.Type.DOUBLE: "DOUBLE PRECISION", +113 exp.DataType.Type.VARCHAR: "VARCHAR2", +114 exp.DataType.Type.NVARCHAR: "NVARCHAR2", +115 exp.DataType.Type.TEXT: "CLOB", +116 exp.DataType.Type.BINARY: "BLOB", +117 exp.DataType.Type.VARBINARY: "BLOB", +118 } +119 +120 TRANSFORMS = { +121 **generator.Generator.TRANSFORMS, # type: ignore +122 **transforms.UNALIAS_GROUP, # type: ignore +123 exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */", +124 exp.ILike: no_ilike_sql, +125 exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})", +126 exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "), +127 exp.Substring: rename_func("SUBSTR"), +128 exp.Table: lambda self, e: self.table_sql(e, sep=" "), +129 exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})", +130 exp.ToChar: lambda self, e: self.function_fallback_sql(e), +131 exp.Trim: trim_sql, +132 exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)", +133 } +134 +135 LIMIT_FETCH = "FETCH" 136 -137 LIMIT_FETCH = "FETCH" -138 -139 def offset_sql(self, expression: exp.Offset) -> str: -140 return f"{super().offset_sql(expression)} ROWS" -141 -142 def column_sql(self, expression: exp.Column) -> str: -143 column = super().column_sql(expression) -144 return f"{column} (+)" if expression.args.get("join_mark") else column -145 -146 def xmltable_sql(self, expression: exp.XMLTable) -> str: -147 this = self.sql(expression, "this") -148 passing = self.expressions(expression, "passing") -149 passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else "" -150 columns = self.expressions(expression, "columns") -151 columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else "" -152 by_ref = ( -153 f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else "" -154 ) -155 return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}" -156 -157 class Tokenizer(tokens.Tokenizer): -158 KEYWORDS = { -159 **tokens.Tokenizer.KEYWORDS, -160 "(+)": TokenType.JOIN_MARKER, -161 "COLUMNS": TokenType.COLUMN, -162 "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE, -163 "MINUS": TokenType.EXCEPT, -164 "NVARCHAR2": TokenType.NVARCHAR, -165 "RETURNING": TokenType.RETURNING, -166 "START": TokenType.BEGIN, -167 "TOP": TokenType.TOP, -168 "VARCHAR2": TokenType.VARCHAR, -169 } +137 def offset_sql(self, expression: exp.Offset) -> str: +138 return f"{super().offset_sql(expression)} ROWS" +139 +140 def column_sql(self, expression: exp.Column) -> str: +141 column = super().column_sql(expression) +142 return f"{column} (+)" if expression.args.get("join_mark") else column +143 +144 def xmltable_sql(self, expression: exp.XMLTable) -> str: +145 this = self.sql(expression, "this") +146 passing = self.expressions(expression, "passing") +147 passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else "" +148 columns = self.expressions(expression, "columns") +149 columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else "" +150 by_ref = ( +151 f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else "" +152 ) +153 return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}" +154 +155 class Tokenizer(tokens.Tokenizer): +156 KEYWORDS = { +157 **tokens.Tokenizer.KEYWORDS, +158 "(+)": TokenType.JOIN_MARKER, +159 "COLUMNS": TokenType.COLUMN, +160 "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE, +161 "MINUS": TokenType.EXCEPT, +162 "NVARCHAR2": TokenType.NVARCHAR, +163 "RETURNING": TokenType.RETURNING, +164 "START": TokenType.BEGIN, +165 "TOP": TokenType.TOP, +166 "VARCHAR2": TokenType.VARCHAR, +167 } @@ -432,34 +428,33 @@ 
 71    class Parser(parser.Parser):
  72        FUNCTIONS = {
  73            **parser.Parser.FUNCTIONS,  # type: ignore
- 74            "DECODE": exp.Matches.from_arg_list,
- 75            "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
- 76        }
- 77
- 78        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
- 79            **parser.Parser.FUNCTION_PARSERS,
- 80            "XMLTABLE": _parse_xml_table,
- 81        }
- 82
- 83        def _parse_column(self) -> t.Optional[exp.Expression]:
- 84            column = super()._parse_column()
- 85            if column:
- 86                column.set("join_mark", self._match(TokenType.JOIN_MARKER))
- 87            return column
- 88
- 89        def _parse_hint(self) -> t.Optional[exp.Expression]:
- 90            if self._match(TokenType.HINT):
- 91                start = self._curr
- 92                while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH):
- 93                    self._advance()
- 94
- 95                if not self._curr:
- 96                    self.raise_error("Expected */ after HINT")
- 97
- 98                end = self._tokens[self._index - 3]
- 99                return exp.Hint(expressions=[self._find_sql(start, end)])
-100
-101            return None
+ 74            "SQUARE": lambda args: exp.Pow(this=seq_get(args, 0), expression=exp.Literal.number(2)),
+ 75        }
+ 76
+ 77        FUNCTION_PARSERS: t.Dict[str, t.Callable] = {
+ 78            **parser.Parser.FUNCTION_PARSERS,
+ 79            "XMLTABLE": _parse_xml_table,
+ 80        }
+ 81
+ 82        def _parse_column(self) -> t.Optional[exp.Expression]:
+ 83            column = super()._parse_column()
+ 84            if column:
+ 85                column.set("join_mark", self._match(TokenType.JOIN_MARKER))
+ 86            return column
+ 87
+ 88        def _parse_hint(self) -> t.Optional[exp.Expression]:
+ 89            if self._match(TokenType.HINT):
+ 90                start = self._curr
+ 91                while self._curr and not self._match_pair(TokenType.STAR, TokenType.SLASH):
+ 92                    self._advance()
+ 93
+ 94                if not self._curr:
+ 95                    self.raise_error("Expected */ after HINT")
+ 96
+ 97                end = self._tokens[self._index - 3]
+ 98                return exp.Hint(expressions=[self._find_sql(start, end)])
+ 99
+100            return None
@@ -516,59 +511,58 @@ Default: "nulls_are_small" - 
103    class Generator(generator.Generator):
-104        LOCKING_READS_SUPPORTED = True
-105
-106        TYPE_MAPPING = {
-107            **generator.Generator.TYPE_MAPPING,  # type: ignore
-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.TEXT: "CLOB",
-117            exp.DataType.Type.BINARY: "BLOB",
-118            exp.DataType.Type.VARBINARY: "BLOB",
-119        }
-120
-121        TRANSFORMS = {
-122            **generator.Generator.TRANSFORMS,  # type: ignore
-123            **transforms.UNALIAS_GROUP,  # type: ignore
-124            exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */",
-125            exp.ILike: no_ilike_sql,
-126            exp.Matches: rename_func("DECODE"),
-127            exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})",
-128            exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
-129            exp.Substring: rename_func("SUBSTR"),
-130            exp.Table: lambda self, e: self.table_sql(e, sep=" "),
-131            exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})",
-132            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
-133            exp.Trim: trim_sql,
-134            exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)",
-135        }
+            
102    class Generator(generator.Generator):
+103        LOCKING_READS_SUPPORTED = True
+104
+105        TYPE_MAPPING = {
+106            **generator.Generator.TYPE_MAPPING,  # type: ignore
+107            exp.DataType.Type.TINYINT: "NUMBER",
+108            exp.DataType.Type.SMALLINT: "NUMBER",
+109            exp.DataType.Type.INT: "NUMBER",
+110            exp.DataType.Type.BIGINT: "NUMBER",
+111            exp.DataType.Type.DECIMAL: "NUMBER",
+112            exp.DataType.Type.DOUBLE: "DOUBLE PRECISION",
+113            exp.DataType.Type.VARCHAR: "VARCHAR2",
+114            exp.DataType.Type.NVARCHAR: "NVARCHAR2",
+115            exp.DataType.Type.TEXT: "CLOB",
+116            exp.DataType.Type.BINARY: "BLOB",
+117            exp.DataType.Type.VARBINARY: "BLOB",
+118        }
+119
+120        TRANSFORMS = {
+121            **generator.Generator.TRANSFORMS,  # type: ignore
+122            **transforms.UNALIAS_GROUP,  # type: ignore
+123            exp.Hint: lambda self, e: f" /*+ {self.expressions(e).strip()} */",
+124            exp.ILike: no_ilike_sql,
+125            exp.StrToTime: lambda self, e: f"TO_TIMESTAMP({self.sql(e, 'this')}, {self.format_time(e)})",
+126            exp.Subquery: lambda self, e: self.subquery_sql(e, sep=" "),
+127            exp.Substring: rename_func("SUBSTR"),
+128            exp.Table: lambda self, e: self.table_sql(e, sep=" "),
+129            exp.TimeToStr: lambda self, e: f"TO_CHAR({self.sql(e, 'this')}, {self.format_time(e)})",
+130            exp.ToChar: lambda self, e: self.function_fallback_sql(e),
+131            exp.Trim: trim_sql,
+132            exp.UnixToTime: lambda self, e: f"TO_DATE('1970-01-01','YYYY-MM-DD') + ({self.sql(e, 'this')} / 86400)",
+133        }
+134
+135        LIMIT_FETCH = "FETCH"
 136
-137        LIMIT_FETCH = "FETCH"
-138
-139        def offset_sql(self, expression: exp.Offset) -> str:
-140            return f"{super().offset_sql(expression)} ROWS"
-141
-142        def column_sql(self, expression: exp.Column) -> str:
-143            column = super().column_sql(expression)
-144            return f"{column} (+)" if expression.args.get("join_mark") else column
-145
-146        def xmltable_sql(self, expression: exp.XMLTable) -> str:
-147            this = self.sql(expression, "this")
-148            passing = self.expressions(expression, "passing")
-149            passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
-150            columns = self.expressions(expression, "columns")
-151            columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
-152            by_ref = (
-153                f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
-154            )
-155            return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}"
+137        def offset_sql(self, expression: exp.Offset) -> str:
+138            return f"{super().offset_sql(expression)} ROWS"
+139
+140        def column_sql(self, expression: exp.Column) -> str:
+141            column = super().column_sql(expression)
+142            return f"{column} (+)" if expression.args.get("join_mark") else column
+143
+144        def xmltable_sql(self, expression: exp.XMLTable) -> str:
+145            this = self.sql(expression, "this")
+146            passing = self.expressions(expression, "passing")
+147            passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
+148            columns = self.expressions(expression, "columns")
+149            columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
+150            by_ref = (
+151                f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
+152            )
+153            return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}"
 

 
 
@@ -627,8 +621,8 @@ Default: True
- 
139        def offset_sql(self, expression: exp.Offset) -> str:
-140            return f"{super().offset_sql(expression)} ROWS"
+            
137        def offset_sql(self, expression: exp.Offset) -> str:
+138            return f"{super().offset_sql(expression)} ROWS"
 

 
 
@@ -646,9 +640,9 @@ Default: True
- 
142        def column_sql(self, expression: exp.Column) -> str:
-143            column = super().column_sql(expression)
-144            return f"{column} (+)" if expression.args.get("join_mark") else column
+            
140        def column_sql(self, expression: exp.Column) -> str:
+141            column = super().column_sql(expression)
+142            return f"{column} (+)" if expression.args.get("join_mark") else column
 

 
 
@@ -666,16 +660,16 @@ Default: True
- 
146        def xmltable_sql(self, expression: exp.XMLTable) -> str:
-147            this = self.sql(expression, "this")
-148            passing = self.expressions(expression, "passing")
-149            passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
-150            columns = self.expressions(expression, "columns")
-151            columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
-152            by_ref = (
-153                f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
-154            )
-155            return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}"
+            
144        def xmltable_sql(self, expression: exp.XMLTable) -> str:
+145            this = self.sql(expression, "this")
+146            passing = self.expressions(expression, "passing")
+147            passing = f"{self.sep()}PASSING{self.seg(passing)}" if passing else ""
+148            columns = self.expressions(expression, "columns")
+149            columns = f"{self.sep()}COLUMNS{self.seg(columns)}" if columns else ""
+150            by_ref = (
+151                f"{self.sep()}RETURNING SEQUENCE BY REF" if expression.args.get("by_ref") else ""
+152            )
+153            return f"XMLTABLE({self.sep('')}{self.indent(this + passing + by_ref + columns)}{self.seg(')', sep='')}"
 

 
 
@@ -701,6 +695,7 @@ Default: True
                 
uncache_sql

                 
cache_sql

                 
characterset_sql

+                
columnposition_sql

                 
columndef_sql

                 
columnconstraint_sql

                 
autoincrementcolumnconstraint_sql

@@ -817,6 +812,7 @@ Default: True
                 
primarykey_sql

                 
unique_sql

                 
if_sql

+                
matchagainst_sql

                 
jsonkeyvalue_sql

                 
jsonobject_sql

                 
in_sql

@@ -868,8 +864,10 @@ Default: True
                 
gt_sql

                 
gte_sql

                 
ilike_sql

+                
ilikeany_sql

                 
is_sql

                 
like_sql

+                
likeany_sql

                 
similarto_sql

                 
lt_sql

                 
lte_sql

@@ -917,19 +915,19 @@ Default: True
- 
157    class Tokenizer(tokens.Tokenizer):
-158        KEYWORDS = {
-159            **tokens.Tokenizer.KEYWORDS,
-160            "(+)": TokenType.JOIN_MARKER,
-161            "COLUMNS": TokenType.COLUMN,
-162            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
-163            "MINUS": TokenType.EXCEPT,
-164            "NVARCHAR2": TokenType.NVARCHAR,
-165            "RETURNING": TokenType.RETURNING,
-166            "START": TokenType.BEGIN,
-167            "TOP": TokenType.TOP,
-168            "VARCHAR2": TokenType.VARCHAR,
-169        }
+            
155    class Tokenizer(tokens.Tokenizer):
+156        KEYWORDS = {
+157            **tokens.Tokenizer.KEYWORDS,
+158            "(+)": TokenType.JOIN_MARKER,
+159            "COLUMNS": TokenType.COLUMN,
+160            "MATCH_RECOGNIZE": TokenType.MATCH_RECOGNIZE,
+161            "MINUS": TokenType.EXCEPT,
+162            "NVARCHAR2": TokenType.NVARCHAR,
+163            "RETURNING": TokenType.RETURNING,
+164            "START": TokenType.BEGIN,
+165            "TOP": TokenType.TOP,
+166            "VARCHAR2": TokenType.VARCHAR,
+167        }
 

 
 
-- 
cgit v1.2.3