sqlglot.dialects.clickhouse
1from __future__ import annotations 2 3import typing as t 4 5from sqlglot import exp, generator, parser, tokens, transforms 6from sqlglot.dialects.dialect import ( 7 Dialect, 8 arg_max_or_min_no_count, 9 date_delta_sql, 10 inline_array_sql, 11 json_extract_segments, 12 json_path_key_only_name, 13 no_pivot_sql, 14 build_json_extract_path, 15 rename_func, 16 var_map_sql, 17) 18from sqlglot.helper import is_int, seq_get 19from sqlglot.tokens import Token, TokenType 20 21 22def _lower_func(sql: str) -> str: 23 index = sql.index("(") 24 return sql[:index].lower() + sql[index:] 25 26 27def _quantile_sql(self: ClickHouse.Generator, expression: exp.Quantile) -> str: 28 quantile = expression.args["quantile"] 29 args = f"({self.sql(expression, 'this')})" 30 31 if isinstance(quantile, exp.Array): 32 func = self.func("quantiles", *quantile) 33 else: 34 func = self.func("quantile", quantile) 35 36 return func + args 37 38 39def _build_count_if(args: t.List) -> exp.CountIf | exp.CombinedAggFunc: 40 if len(args) == 1: 41 return exp.CountIf(this=seq_get(args, 0)) 42 43 return exp.CombinedAggFunc(this="countIf", expressions=args, parts=("count", "If")) 44 45 46class ClickHouse(Dialect): 47 NORMALIZE_FUNCTIONS: bool | str = False 48 NULL_ORDERING = "nulls_are_last" 49 SUPPORTS_USER_DEFINED_TYPES = False 50 SAFE_DIVISION = True 51 LOG_BASE_FIRST: t.Optional[bool] = None 52 53 UNESCAPED_SEQUENCES = { 54 "\\0": "\0", 55 } 56 57 class Tokenizer(tokens.Tokenizer): 58 COMMENTS = ["--", "#", "#!", ("/*", "*/")] 59 IDENTIFIERS = ['"', "`"] 60 STRING_ESCAPES = ["'", "\\"] 61 BIT_STRINGS = [("0b", "")] 62 HEX_STRINGS = [("0x", ""), ("0X", "")] 63 HEREDOC_STRINGS = ["$"] 64 65 KEYWORDS = { 66 **tokens.Tokenizer.KEYWORDS, 67 "ATTACH": TokenType.COMMAND, 68 "DATE32": TokenType.DATE32, 69 "DATETIME64": TokenType.DATETIME64, 70 "DICTIONARY": TokenType.DICTIONARY, 71 "ENUM8": TokenType.ENUM8, 72 "ENUM16": TokenType.ENUM16, 73 "FINAL": TokenType.FINAL, 74 "FIXEDSTRING": TokenType.FIXEDSTRING, 75 "FLOAT32": TokenType.FLOAT, 76 "FLOAT64": TokenType.DOUBLE, 77 "GLOBAL": TokenType.GLOBAL, 78 "INT256": TokenType.INT256, 79 "LOWCARDINALITY": TokenType.LOWCARDINALITY, 80 "MAP": TokenType.MAP, 81 "NESTED": TokenType.NESTED, 82 "SAMPLE": TokenType.TABLE_SAMPLE, 83 "TUPLE": TokenType.STRUCT, 84 "UINT128": TokenType.UINT128, 85 "UINT16": TokenType.USMALLINT, 86 "UINT256": TokenType.UINT256, 87 "UINT32": TokenType.UINT, 88 "UINT64": TokenType.UBIGINT, 89 "UINT8": TokenType.UTINYINT, 90 "IPV4": TokenType.IPV4, 91 "IPV6": TokenType.IPV6, 92 "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION, 93 "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION, 94 "SYSTEM": TokenType.COMMAND, 95 "PREWHERE": TokenType.PREWHERE, 96 } 97 98 SINGLE_TOKENS = { 99 **tokens.Tokenizer.SINGLE_TOKENS, 100 "$": TokenType.HEREDOC_STRING, 101 } 102 103 class Parser(parser.Parser): 104 # Tested in ClickHouse's playground, it seems that the following two queries do the same thing 105 # * select x from t1 union all select x from t2 limit 1; 106 # * select x from t1 union all (select x from t2 limit 1); 107 MODIFIERS_ATTACHED_TO_UNION = False 108 INTERVAL_SPANS = False 109 110 FUNCTIONS = { 111 **parser.Parser.FUNCTIONS, 112 "ANY": exp.AnyValue.from_arg_list, 113 "ARRAYSUM": exp.ArraySum.from_arg_list, 114 "COUNTIF": _build_count_if, 115 "DATE_ADD": lambda args: exp.DateAdd( 116 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 117 ), 118 "DATEADD": lambda args: exp.DateAdd( 119 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 120 ), 121 "DATE_DIFF": lambda args: exp.DateDiff( 122 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 123 ), 124 "DATEDIFF": lambda args: exp.DateDiff( 125 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 126 ), 127 "JSONEXTRACTSTRING": build_json_extract_path( 128 exp.JSONExtractScalar, zero_based_indexing=False 129 ), 130 "MAP": parser.build_var_map, 131 "MATCH": exp.RegexpLike.from_arg_list, 132 "RANDCANONICAL": exp.Rand.from_arg_list, 133 "TUPLE": exp.Struct.from_arg_list, 134 "UNIQ": exp.ApproxDistinct.from_arg_list, 135 "XOR": lambda args: exp.Xor(expressions=args), 136 } 137 138 AGG_FUNCTIONS = { 139 "count", 140 "min", 141 "max", 142 "sum", 143 "avg", 144 "any", 145 "stddevPop", 146 "stddevSamp", 147 "varPop", 148 "varSamp", 149 "corr", 150 "covarPop", 151 "covarSamp", 152 "entropy", 153 "exponentialMovingAverage", 154 "intervalLengthSum", 155 "kolmogorovSmirnovTest", 156 "mannWhitneyUTest", 157 "median", 158 "rankCorr", 159 "sumKahan", 160 "studentTTest", 161 "welchTTest", 162 "anyHeavy", 163 "anyLast", 164 "boundingRatio", 165 "first_value", 166 "last_value", 167 "argMin", 168 "argMax", 169 "avgWeighted", 170 "topK", 171 "topKWeighted", 172 "deltaSum", 173 "deltaSumTimestamp", 174 "groupArray", 175 "groupArrayLast", 176 "groupUniqArray", 177 "groupArrayInsertAt", 178 "groupArrayMovingAvg", 179 "groupArrayMovingSum", 180 "groupArraySample", 181 "groupBitAnd", 182 "groupBitOr", 183 "groupBitXor", 184 "groupBitmap", 185 "groupBitmapAnd", 186 "groupBitmapOr", 187 "groupBitmapXor", 188 "sumWithOverflow", 189 "sumMap", 190 "minMap", 191 "maxMap", 192 "skewSamp", 193 "skewPop", 194 "kurtSamp", 195 "kurtPop", 196 "uniq", 197 "uniqExact", 198 "uniqCombined", 199 "uniqCombined64", 200 "uniqHLL12", 201 "uniqTheta", 202 "quantile", 203 "quantiles", 204 "quantileExact", 205 "quantilesExact", 206 "quantileExactLow", 207 "quantilesExactLow", 208 "quantileExactHigh", 209 "quantilesExactHigh", 210 "quantileExactWeighted", 211 "quantilesExactWeighted", 212 "quantileTiming", 213 "quantilesTiming", 214 "quantileTimingWeighted", 215 "quantilesTimingWeighted", 216 "quantileDeterministic", 217 "quantilesDeterministic", 218 "quantileTDigest", 219 "quantilesTDigest", 220 "quantileTDigestWeighted", 221 "quantilesTDigestWeighted", 222 "quantileBFloat16", 223 "quantilesBFloat16", 224 "quantileBFloat16Weighted", 225 "quantilesBFloat16Weighted", 226 "simpleLinearRegression", 227 "stochasticLinearRegression", 228 "stochasticLogisticRegression", 229 "categoricalInformationValue", 230 "contingency", 231 "cramersV", 232 "cramersVBiasCorrected", 233 "theilsU", 234 "maxIntersections", 235 "maxIntersectionsPosition", 236 "meanZTest", 237 "quantileInterpolatedWeighted", 238 "quantilesInterpolatedWeighted", 239 "quantileGK", 240 "quantilesGK", 241 "sparkBar", 242 "sumCount", 243 "largestTriangleThreeBuckets", 244 } 245 246 AGG_FUNCTIONS_SUFFIXES = [ 247 "If", 248 "Array", 249 "ArrayIf", 250 "Map", 251 "SimpleState", 252 "State", 253 "Merge", 254 "MergeState", 255 "ForEach", 256 "Distinct", 257 "OrDefault", 258 "OrNull", 259 "Resample", 260 "ArgMin", 261 "ArgMax", 262 ] 263 264 FUNC_TOKENS = { 265 *parser.Parser.FUNC_TOKENS, 266 TokenType.SET, 267 } 268 269 AGG_FUNC_MAPPING = ( 270 lambda functions, suffixes: { 271 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 272 } 273 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 274 275 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 276 277 FUNCTION_PARSERS = { 278 **parser.Parser.FUNCTION_PARSERS, 279 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 280 "QUANTILE": lambda self: self._parse_quantile(), 281 } 282 283 FUNCTION_PARSERS.pop("MATCH") 284 285 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 286 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 287 288 RANGE_PARSERS = { 289 **parser.Parser.RANGE_PARSERS, 290 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 291 and self._parse_in(this, is_global=True), 292 } 293 294 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 295 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 296 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 297 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 298 299 JOIN_KINDS = { 300 *parser.Parser.JOIN_KINDS, 301 TokenType.ANY, 302 TokenType.ASOF, 303 TokenType.ARRAY, 304 } 305 306 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 307 TokenType.ANY, 308 TokenType.ARRAY, 309 TokenType.FINAL, 310 TokenType.FORMAT, 311 TokenType.SETTINGS, 312 } 313 314 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 315 TokenType.FORMAT, 316 } 317 318 LOG_DEFAULTS_TO_LN = True 319 320 QUERY_MODIFIER_PARSERS = { 321 **parser.Parser.QUERY_MODIFIER_PARSERS, 322 TokenType.SETTINGS: lambda self: ( 323 "settings", 324 self._advance() or self._parse_csv(self._parse_conjunction), 325 ), 326 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 327 } 328 329 CONSTRAINT_PARSERS = { 330 **parser.Parser.CONSTRAINT_PARSERS, 331 "INDEX": lambda self: self._parse_index_constraint(), 332 "CODEC": lambda self: self._parse_compress(), 333 } 334 335 SCHEMA_UNNAMED_CONSTRAINTS = { 336 *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS, 337 "INDEX", 338 } 339 340 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 341 this = super()._parse_conjunction() 342 343 if self._match(TokenType.PLACEHOLDER): 344 return self.expression( 345 exp.If, 346 this=this, 347 true=self._parse_conjunction(), 348 false=self._match(TokenType.COLON) and self._parse_conjunction(), 349 ) 350 351 return this 352 353 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 354 """ 355 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 356 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 357 """ 358 if not self._match(TokenType.L_BRACE): 359 return None 360 361 this = self._parse_id_var() 362 self._match(TokenType.COLON) 363 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 364 self._match_text_seq("IDENTIFIER") and "Identifier" 365 ) 366 367 if not kind: 368 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 369 elif not self._match(TokenType.R_BRACE): 370 self.raise_error("Expecting }") 371 372 return self.expression(exp.Placeholder, this=this, kind=kind) 373 374 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 375 this = super()._parse_in(this) 376 this.set("is_global", is_global) 377 return this 378 379 def _parse_table( 380 self, 381 schema: bool = False, 382 joins: bool = False, 383 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 384 parse_bracket: bool = False, 385 is_db_reference: bool = False, 386 ) -> t.Optional[exp.Expression]: 387 this = super()._parse_table( 388 schema=schema, 389 joins=joins, 390 alias_tokens=alias_tokens, 391 parse_bracket=parse_bracket, 392 is_db_reference=is_db_reference, 393 ) 394 395 if self._match(TokenType.FINAL): 396 this = self.expression(exp.Final, this=this) 397 398 return this 399 400 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 401 return super()._parse_position(haystack_first=True) 402 403 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 404 def _parse_cte(self) -> exp.CTE: 405 # WITH <identifier> AS <subquery expression> 406 cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte) 407 408 if not cte: 409 # WITH <expression> AS <identifier> 410 cte = self.expression( 411 exp.CTE, 412 this=self._parse_conjunction(), 413 alias=self._parse_table_alias(), 414 scalar=True, 415 ) 416 417 return cte 418 419 def _parse_join_parts( 420 self, 421 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 422 is_global = self._match(TokenType.GLOBAL) and self._prev 423 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 424 425 if kind_pre: 426 kind = self._match_set(self.JOIN_KINDS) and self._prev 427 side = self._match_set(self.JOIN_SIDES) and self._prev 428 return is_global, side, kind 429 430 return ( 431 is_global, 432 self._match_set(self.JOIN_SIDES) and self._prev, 433 self._match_set(self.JOIN_KINDS) and self._prev, 434 ) 435 436 def _parse_join( 437 self, skip_join_token: bool = False, parse_bracket: bool = False 438 ) -> t.Optional[exp.Join]: 439 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 440 if join: 441 join.set("global", join.args.pop("method", None)) 442 443 return join 444 445 def _parse_function( 446 self, 447 functions: t.Optional[t.Dict[str, t.Callable]] = None, 448 anonymous: bool = False, 449 optional_parens: bool = True, 450 ) -> t.Optional[exp.Expression]: 451 func = super()._parse_function( 452 functions=functions, anonymous=anonymous, optional_parens=optional_parens 453 ) 454 455 if isinstance(func, exp.Anonymous): 456 parts = self.AGG_FUNC_MAPPING.get(func.this) 457 params = self._parse_func_params(func) 458 459 if params: 460 if parts and parts[1]: 461 return self.expression( 462 exp.CombinedParameterizedAgg, 463 this=func.this, 464 expressions=func.expressions, 465 params=params, 466 parts=parts, 467 ) 468 return self.expression( 469 exp.ParameterizedAgg, 470 this=func.this, 471 expressions=func.expressions, 472 params=params, 473 ) 474 475 if parts: 476 if parts[1]: 477 return self.expression( 478 exp.CombinedAggFunc, 479 this=func.this, 480 expressions=func.expressions, 481 parts=parts, 482 ) 483 return self.expression( 484 exp.AnonymousAggFunc, 485 this=func.this, 486 expressions=func.expressions, 487 ) 488 489 return func 490 491 def _parse_func_params( 492 self, this: t.Optional[exp.Func] = None 493 ) -> t.Optional[t.List[exp.Expression]]: 494 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 495 return self._parse_csv(self._parse_lambda) 496 497 if self._match(TokenType.L_PAREN): 498 params = self._parse_csv(self._parse_lambda) 499 self._match_r_paren(this) 500 return params 501 502 return None 503 504 def _parse_quantile(self) -> exp.Quantile: 505 this = self._parse_lambda() 506 params = self._parse_func_params() 507 if params: 508 return self.expression(exp.Quantile, this=params[0], quantile=this) 509 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 510 511 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 512 return super()._parse_wrapped_id_vars(optional=True) 513 514 def _parse_primary_key( 515 self, wrapped_optional: bool = False, in_props: bool = False 516 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 517 return super()._parse_primary_key( 518 wrapped_optional=wrapped_optional or in_props, in_props=in_props 519 ) 520 521 def _parse_on_property(self) -> t.Optional[exp.Expression]: 522 index = self._index 523 if self._match_text_seq("CLUSTER"): 524 this = self._parse_id_var() 525 if this: 526 return self.expression(exp.OnCluster, this=this) 527 else: 528 self._retreat(index) 529 return None 530 531 def _parse_index_constraint( 532 self, kind: t.Optional[str] = None 533 ) -> exp.IndexColumnConstraint: 534 # INDEX name1 expr TYPE type1(args) GRANULARITY value 535 this = self._parse_id_var() 536 expression = self._parse_conjunction() 537 538 index_type = self._match_text_seq("TYPE") and ( 539 self._parse_function() or self._parse_var() 540 ) 541 542 granularity = self._match_text_seq("GRANULARITY") and self._parse_term() 543 544 return self.expression( 545 exp.IndexColumnConstraint, 546 this=this, 547 expression=expression, 548 index_type=index_type, 549 granularity=granularity, 550 ) 551 552 class Generator(generator.Generator): 553 QUERY_HINTS = False 554 STRUCT_DELIMITER = ("(", ")") 555 NVL2_SUPPORTED = False 556 TABLESAMPLE_REQUIRES_PARENS = False 557 TABLESAMPLE_SIZE_IS_ROWS = False 558 TABLESAMPLE_KEYWORDS = "SAMPLE" 559 LAST_DAY_SUPPORTS_DATE_PART = False 560 CAN_IMPLEMENT_ARRAY_ANY = True 561 SUPPORTS_TO_NUMBER = False 562 563 STRING_TYPE_MAPPING = { 564 exp.DataType.Type.CHAR: "String", 565 exp.DataType.Type.LONGBLOB: "String", 566 exp.DataType.Type.LONGTEXT: "String", 567 exp.DataType.Type.MEDIUMBLOB: "String", 568 exp.DataType.Type.MEDIUMTEXT: "String", 569 exp.DataType.Type.TINYBLOB: "String", 570 exp.DataType.Type.TINYTEXT: "String", 571 exp.DataType.Type.TEXT: "String", 572 exp.DataType.Type.VARBINARY: "String", 573 exp.DataType.Type.VARCHAR: "String", 574 } 575 576 SUPPORTED_JSON_PATH_PARTS = { 577 exp.JSONPathKey, 578 exp.JSONPathRoot, 579 exp.JSONPathSubscript, 580 } 581 582 TYPE_MAPPING = { 583 **generator.Generator.TYPE_MAPPING, 584 **STRING_TYPE_MAPPING, 585 exp.DataType.Type.ARRAY: "Array", 586 exp.DataType.Type.BIGINT: "Int64", 587 exp.DataType.Type.DATE32: "Date32", 588 exp.DataType.Type.DATETIME64: "DateTime64", 589 exp.DataType.Type.DOUBLE: "Float64", 590 exp.DataType.Type.ENUM: "Enum", 591 exp.DataType.Type.ENUM8: "Enum8", 592 exp.DataType.Type.ENUM16: "Enum16", 593 exp.DataType.Type.FIXEDSTRING: "FixedString", 594 exp.DataType.Type.FLOAT: "Float32", 595 exp.DataType.Type.INT: "Int32", 596 exp.DataType.Type.MEDIUMINT: "Int32", 597 exp.DataType.Type.INT128: "Int128", 598 exp.DataType.Type.INT256: "Int256", 599 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 600 exp.DataType.Type.MAP: "Map", 601 exp.DataType.Type.NESTED: "Nested", 602 exp.DataType.Type.NULLABLE: "Nullable", 603 exp.DataType.Type.SMALLINT: "Int16", 604 exp.DataType.Type.STRUCT: "Tuple", 605 exp.DataType.Type.TINYINT: "Int8", 606 exp.DataType.Type.UBIGINT: "UInt64", 607 exp.DataType.Type.UINT: "UInt32", 608 exp.DataType.Type.UINT128: "UInt128", 609 exp.DataType.Type.UINT256: "UInt256", 610 exp.DataType.Type.USMALLINT: "UInt16", 611 exp.DataType.Type.UTINYINT: "UInt8", 612 exp.DataType.Type.IPV4: "IPv4", 613 exp.DataType.Type.IPV6: "IPv6", 614 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 615 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 616 } 617 618 TRANSFORMS = { 619 **generator.Generator.TRANSFORMS, 620 exp.AnyValue: rename_func("any"), 621 exp.ApproxDistinct: rename_func("uniq"), 622 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 623 exp.ArraySize: rename_func("LENGTH"), 624 exp.ArraySum: rename_func("arraySum"), 625 exp.ArgMax: arg_max_or_min_no_count("argMax"), 626 exp.ArgMin: arg_max_or_min_no_count("argMin"), 627 exp.Array: inline_array_sql, 628 exp.CastToStrType: rename_func("CAST"), 629 exp.CountIf: rename_func("countIf"), 630 exp.CompressColumnConstraint: lambda self, 631 e: f"CODEC({self.expressions(e, key='this', flat=True)})", 632 exp.ComputedColumnConstraint: lambda self, e: f"ALIAS {self.sql(e, 'this')}", 633 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 634 exp.DateAdd: date_delta_sql("DATE_ADD"), 635 exp.DateDiff: date_delta_sql("DATE_DIFF"), 636 exp.Explode: rename_func("arrayJoin"), 637 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 638 exp.IsNan: rename_func("isNaN"), 639 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 640 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 641 exp.JSONPathKey: json_path_key_only_name, 642 exp.JSONPathRoot: lambda *_: "", 643 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 644 exp.Nullif: rename_func("nullIf"), 645 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 646 exp.Pivot: no_pivot_sql, 647 exp.Quantile: _quantile_sql, 648 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 649 exp.Rand: rename_func("randCanonical"), 650 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 651 exp.StartsWith: rename_func("startsWith"), 652 exp.StrPosition: lambda self, e: self.func( 653 "position", e.this, e.args.get("substr"), e.args.get("position") 654 ), 655 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 656 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 657 } 658 659 PROPERTIES_LOCATION = { 660 **generator.Generator.PROPERTIES_LOCATION, 661 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 662 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 663 exp.OnCluster: exp.Properties.Location.POST_NAME, 664 } 665 666 JOIN_HINTS = False 667 TABLE_HINTS = False 668 EXPLICIT_UNION = True 669 GROUPINGS_SEP = "" 670 671 # there's no list in docs, but it can be found in Clickhouse code 672 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 673 ON_CLUSTER_TARGETS = { 674 "DATABASE", 675 "TABLE", 676 "VIEW", 677 "DICTIONARY", 678 "INDEX", 679 "FUNCTION", 680 "NAMED COLLECTION", 681 } 682 683 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 684 this = self.json_path_part(expression.this) 685 return str(int(this) + 1) if is_int(this) else this 686 687 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 688 return f"AS {self.sql(expression, 'this')}" 689 690 def _any_to_has( 691 self, 692 expression: exp.EQ | exp.NEQ, 693 default: t.Callable[[t.Any], str], 694 prefix: str = "", 695 ) -> str: 696 if isinstance(expression.left, exp.Any): 697 arr = expression.left 698 this = expression.right 699 elif isinstance(expression.right, exp.Any): 700 arr = expression.right 701 this = expression.left 702 else: 703 return default(expression) 704 705 return prefix + self.func("has", arr.this.unnest(), this) 706 707 def eq_sql(self, expression: exp.EQ) -> str: 708 return self._any_to_has(expression, super().eq_sql) 709 710 def neq_sql(self, expression: exp.NEQ) -> str: 711 return self._any_to_has(expression, super().neq_sql, "NOT ") 712 713 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 714 # Manually add a flag to make the search case-insensitive 715 regex = self.func("CONCAT", "'(?i)'", expression.expression) 716 return self.func("match", expression.this, regex) 717 718 def datatype_sql(self, expression: exp.DataType) -> str: 719 # String is the standard ClickHouse type, every other variant is just an alias. 720 # Additionally, any supplied length parameter will be ignored. 721 # 722 # https://clickhouse.com/docs/en/sql-reference/data-types/string 723 if expression.this in self.STRING_TYPE_MAPPING: 724 return "String" 725 726 return super().datatype_sql(expression) 727 728 def cte_sql(self, expression: exp.CTE) -> str: 729 if expression.args.get("scalar"): 730 this = self.sql(expression, "this") 731 alias = self.sql(expression, "alias") 732 return f"{this} AS {alias}" 733 734 return super().cte_sql(expression) 735 736 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 737 return super().after_limit_modifiers(expression) + [ 738 ( 739 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 740 if expression.args.get("settings") 741 else "" 742 ), 743 ( 744 self.seg("FORMAT ") + self.sql(expression, "format") 745 if expression.args.get("format") 746 else "" 747 ), 748 ] 749 750 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 751 params = self.expressions(expression, key="params", flat=True) 752 return self.func(expression.name, *expression.expressions) + f"({params})" 753 754 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 755 return self.func(expression.name, *expression.expressions) 756 757 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 758 return self.anonymousaggfunc_sql(expression) 759 760 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 761 return self.parameterizedagg_sql(expression) 762 763 def placeholder_sql(self, expression: exp.Placeholder) -> str: 764 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 765 766 def oncluster_sql(self, expression: exp.OnCluster) -> str: 767 return f"ON CLUSTER {self.sql(expression, 'this')}" 768 769 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 770 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 771 exp.Properties.Location.POST_NAME 772 ): 773 this_name = self.sql(expression.this, "this") 774 this_properties = " ".join( 775 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 776 ) 777 this_schema = self.schema_columns_sql(expression.this) 778 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 779 780 return super().createable_sql(expression, locations) 781 782 def prewhere_sql(self, expression: exp.PreWhere) -> str: 783 this = self.indent(self.sql(expression, "this")) 784 return f"{self.seg('PREWHERE')}{self.sep()}{this}" 785 786 def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str: 787 this = self.sql(expression, "this") 788 this = f" {this}" if this else "" 789 expr = self.sql(expression, "expression") 790 expr = f" {expr}" if expr else "" 791 index_type = self.sql(expression, "index_type") 792 index_type = f" TYPE {index_type}" if index_type else "" 793 granularity = self.sql(expression, "granularity") 794 granularity = f" GRANULARITY {granularity}" if granularity else "" 795 796 return f"INDEX{this}{expr}{index_type}{granularity}"
47class ClickHouse(Dialect): 48 NORMALIZE_FUNCTIONS: bool | str = False 49 NULL_ORDERING = "nulls_are_last" 50 SUPPORTS_USER_DEFINED_TYPES = False 51 SAFE_DIVISION = True 52 LOG_BASE_FIRST: t.Optional[bool] = None 53 54 UNESCAPED_SEQUENCES = { 55 "\\0": "\0", 56 } 57 58 class Tokenizer(tokens.Tokenizer): 59 COMMENTS = ["--", "#", "#!", ("/*", "*/")] 60 IDENTIFIERS = ['"', "`"] 61 STRING_ESCAPES = ["'", "\\"] 62 BIT_STRINGS = [("0b", "")] 63 HEX_STRINGS = [("0x", ""), ("0X", "")] 64 HEREDOC_STRINGS = ["$"] 65 66 KEYWORDS = { 67 **tokens.Tokenizer.KEYWORDS, 68 "ATTACH": TokenType.COMMAND, 69 "DATE32": TokenType.DATE32, 70 "DATETIME64": TokenType.DATETIME64, 71 "DICTIONARY": TokenType.DICTIONARY, 72 "ENUM8": TokenType.ENUM8, 73 "ENUM16": TokenType.ENUM16, 74 "FINAL": TokenType.FINAL, 75 "FIXEDSTRING": TokenType.FIXEDSTRING, 76 "FLOAT32": TokenType.FLOAT, 77 "FLOAT64": TokenType.DOUBLE, 78 "GLOBAL": TokenType.GLOBAL, 79 "INT256": TokenType.INT256, 80 "LOWCARDINALITY": TokenType.LOWCARDINALITY, 81 "MAP": TokenType.MAP, 82 "NESTED": TokenType.NESTED, 83 "SAMPLE": TokenType.TABLE_SAMPLE, 84 "TUPLE": TokenType.STRUCT, 85 "UINT128": TokenType.UINT128, 86 "UINT16": TokenType.USMALLINT, 87 "UINT256": TokenType.UINT256, 88 "UINT32": TokenType.UINT, 89 "UINT64": TokenType.UBIGINT, 90 "UINT8": TokenType.UTINYINT, 91 "IPV4": TokenType.IPV4, 92 "IPV6": TokenType.IPV6, 93 "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION, 94 "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION, 95 "SYSTEM": TokenType.COMMAND, 96 "PREWHERE": TokenType.PREWHERE, 97 } 98 99 SINGLE_TOKENS = { 100 **tokens.Tokenizer.SINGLE_TOKENS, 101 "$": TokenType.HEREDOC_STRING, 102 } 103 104 class Parser(parser.Parser): 105 # Tested in ClickHouse's playground, it seems that the following two queries do the same thing 106 # * select x from t1 union all select x from t2 limit 1; 107 # * select x from t1 union all (select x from t2 limit 1); 108 MODIFIERS_ATTACHED_TO_UNION = False 109 INTERVAL_SPANS = False 110 111 FUNCTIONS = { 112 **parser.Parser.FUNCTIONS, 113 "ANY": exp.AnyValue.from_arg_list, 114 "ARRAYSUM": exp.ArraySum.from_arg_list, 115 "COUNTIF": _build_count_if, 116 "DATE_ADD": lambda args: exp.DateAdd( 117 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 118 ), 119 "DATEADD": lambda args: exp.DateAdd( 120 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 121 ), 122 "DATE_DIFF": lambda args: exp.DateDiff( 123 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 124 ), 125 "DATEDIFF": lambda args: exp.DateDiff( 126 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 127 ), 128 "JSONEXTRACTSTRING": build_json_extract_path( 129 exp.JSONExtractScalar, zero_based_indexing=False 130 ), 131 "MAP": parser.build_var_map, 132 "MATCH": exp.RegexpLike.from_arg_list, 133 "RANDCANONICAL": exp.Rand.from_arg_list, 134 "TUPLE": exp.Struct.from_arg_list, 135 "UNIQ": exp.ApproxDistinct.from_arg_list, 136 "XOR": lambda args: exp.Xor(expressions=args), 137 } 138 139 AGG_FUNCTIONS = { 140 "count", 141 "min", 142 "max", 143 "sum", 144 "avg", 145 "any", 146 "stddevPop", 147 "stddevSamp", 148 "varPop", 149 "varSamp", 150 "corr", 151 "covarPop", 152 "covarSamp", 153 "entropy", 154 "exponentialMovingAverage", 155 "intervalLengthSum", 156 "kolmogorovSmirnovTest", 157 "mannWhitneyUTest", 158 "median", 159 "rankCorr", 160 "sumKahan", 161 "studentTTest", 162 "welchTTest", 163 "anyHeavy", 164 "anyLast", 165 "boundingRatio", 166 "first_value", 167 "last_value", 168 "argMin", 169 "argMax", 170 "avgWeighted", 171 "topK", 172 "topKWeighted", 173 "deltaSum", 174 "deltaSumTimestamp", 175 "groupArray", 176 "groupArrayLast", 177 "groupUniqArray", 178 "groupArrayInsertAt", 179 "groupArrayMovingAvg", 180 "groupArrayMovingSum", 181 "groupArraySample", 182 "groupBitAnd", 183 "groupBitOr", 184 "groupBitXor", 185 "groupBitmap", 186 "groupBitmapAnd", 187 "groupBitmapOr", 188 "groupBitmapXor", 189 "sumWithOverflow", 190 "sumMap", 191 "minMap", 192 "maxMap", 193 "skewSamp", 194 "skewPop", 195 "kurtSamp", 196 "kurtPop", 197 "uniq", 198 "uniqExact", 199 "uniqCombined", 200 "uniqCombined64", 201 "uniqHLL12", 202 "uniqTheta", 203 "quantile", 204 "quantiles", 205 "quantileExact", 206 "quantilesExact", 207 "quantileExactLow", 208 "quantilesExactLow", 209 "quantileExactHigh", 210 "quantilesExactHigh", 211 "quantileExactWeighted", 212 "quantilesExactWeighted", 213 "quantileTiming", 214 "quantilesTiming", 215 "quantileTimingWeighted", 216 "quantilesTimingWeighted", 217 "quantileDeterministic", 218 "quantilesDeterministic", 219 "quantileTDigest", 220 "quantilesTDigest", 221 "quantileTDigestWeighted", 222 "quantilesTDigestWeighted", 223 "quantileBFloat16", 224 "quantilesBFloat16", 225 "quantileBFloat16Weighted", 226 "quantilesBFloat16Weighted", 227 "simpleLinearRegression", 228 "stochasticLinearRegression", 229 "stochasticLogisticRegression", 230 "categoricalInformationValue", 231 "contingency", 232 "cramersV", 233 "cramersVBiasCorrected", 234 "theilsU", 235 "maxIntersections", 236 "maxIntersectionsPosition", 237 "meanZTest", 238 "quantileInterpolatedWeighted", 239 "quantilesInterpolatedWeighted", 240 "quantileGK", 241 "quantilesGK", 242 "sparkBar", 243 "sumCount", 244 "largestTriangleThreeBuckets", 245 } 246 247 AGG_FUNCTIONS_SUFFIXES = [ 248 "If", 249 "Array", 250 "ArrayIf", 251 "Map", 252 "SimpleState", 253 "State", 254 "Merge", 255 "MergeState", 256 "ForEach", 257 "Distinct", 258 "OrDefault", 259 "OrNull", 260 "Resample", 261 "ArgMin", 262 "ArgMax", 263 ] 264 265 FUNC_TOKENS = { 266 *parser.Parser.FUNC_TOKENS, 267 TokenType.SET, 268 } 269 270 AGG_FUNC_MAPPING = ( 271 lambda functions, suffixes: { 272 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 273 } 274 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 275 276 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 277 278 FUNCTION_PARSERS = { 279 **parser.Parser.FUNCTION_PARSERS, 280 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 281 "QUANTILE": lambda self: self._parse_quantile(), 282 } 283 284 FUNCTION_PARSERS.pop("MATCH") 285 286 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 287 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 288 289 RANGE_PARSERS = { 290 **parser.Parser.RANGE_PARSERS, 291 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 292 and self._parse_in(this, is_global=True), 293 } 294 295 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 296 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 297 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 298 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 299 300 JOIN_KINDS = { 301 *parser.Parser.JOIN_KINDS, 302 TokenType.ANY, 303 TokenType.ASOF, 304 TokenType.ARRAY, 305 } 306 307 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 308 TokenType.ANY, 309 TokenType.ARRAY, 310 TokenType.FINAL, 311 TokenType.FORMAT, 312 TokenType.SETTINGS, 313 } 314 315 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 316 TokenType.FORMAT, 317 } 318 319 LOG_DEFAULTS_TO_LN = True 320 321 QUERY_MODIFIER_PARSERS = { 322 **parser.Parser.QUERY_MODIFIER_PARSERS, 323 TokenType.SETTINGS: lambda self: ( 324 "settings", 325 self._advance() or self._parse_csv(self._parse_conjunction), 326 ), 327 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 328 } 329 330 CONSTRAINT_PARSERS = { 331 **parser.Parser.CONSTRAINT_PARSERS, 332 "INDEX": lambda self: self._parse_index_constraint(), 333 "CODEC": lambda self: self._parse_compress(), 334 } 335 336 SCHEMA_UNNAMED_CONSTRAINTS = { 337 *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS, 338 "INDEX", 339 } 340 341 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 342 this = super()._parse_conjunction() 343 344 if self._match(TokenType.PLACEHOLDER): 345 return self.expression( 346 exp.If, 347 this=this, 348 true=self._parse_conjunction(), 349 false=self._match(TokenType.COLON) and self._parse_conjunction(), 350 ) 351 352 return this 353 354 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 355 """ 356 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 357 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 358 """ 359 if not self._match(TokenType.L_BRACE): 360 return None 361 362 this = self._parse_id_var() 363 self._match(TokenType.COLON) 364 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 365 self._match_text_seq("IDENTIFIER") and "Identifier" 366 ) 367 368 if not kind: 369 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 370 elif not self._match(TokenType.R_BRACE): 371 self.raise_error("Expecting }") 372 373 return self.expression(exp.Placeholder, this=this, kind=kind) 374 375 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 376 this = super()._parse_in(this) 377 this.set("is_global", is_global) 378 return this 379 380 def _parse_table( 381 self, 382 schema: bool = False, 383 joins: bool = False, 384 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 385 parse_bracket: bool = False, 386 is_db_reference: bool = False, 387 ) -> t.Optional[exp.Expression]: 388 this = super()._parse_table( 389 schema=schema, 390 joins=joins, 391 alias_tokens=alias_tokens, 392 parse_bracket=parse_bracket, 393 is_db_reference=is_db_reference, 394 ) 395 396 if self._match(TokenType.FINAL): 397 this = self.expression(exp.Final, this=this) 398 399 return this 400 401 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 402 return super()._parse_position(haystack_first=True) 403 404 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 405 def _parse_cte(self) -> exp.CTE: 406 # WITH <identifier> AS <subquery expression> 407 cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte) 408 409 if not cte: 410 # WITH <expression> AS <identifier> 411 cte = self.expression( 412 exp.CTE, 413 this=self._parse_conjunction(), 414 alias=self._parse_table_alias(), 415 scalar=True, 416 ) 417 418 return cte 419 420 def _parse_join_parts( 421 self, 422 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 423 is_global = self._match(TokenType.GLOBAL) and self._prev 424 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 425 426 if kind_pre: 427 kind = self._match_set(self.JOIN_KINDS) and self._prev 428 side = self._match_set(self.JOIN_SIDES) and self._prev 429 return is_global, side, kind 430 431 return ( 432 is_global, 433 self._match_set(self.JOIN_SIDES) and self._prev, 434 self._match_set(self.JOIN_KINDS) and self._prev, 435 ) 436 437 def _parse_join( 438 self, skip_join_token: bool = False, parse_bracket: bool = False 439 ) -> t.Optional[exp.Join]: 440 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 441 if join: 442 join.set("global", join.args.pop("method", None)) 443 444 return join 445 446 def _parse_function( 447 self, 448 functions: t.Optional[t.Dict[str, t.Callable]] = None, 449 anonymous: bool = False, 450 optional_parens: bool = True, 451 ) -> t.Optional[exp.Expression]: 452 func = super()._parse_function( 453 functions=functions, anonymous=anonymous, optional_parens=optional_parens 454 ) 455 456 if isinstance(func, exp.Anonymous): 457 parts = self.AGG_FUNC_MAPPING.get(func.this) 458 params = self._parse_func_params(func) 459 460 if params: 461 if parts and parts[1]: 462 return self.expression( 463 exp.CombinedParameterizedAgg, 464 this=func.this, 465 expressions=func.expressions, 466 params=params, 467 parts=parts, 468 ) 469 return self.expression( 470 exp.ParameterizedAgg, 471 this=func.this, 472 expressions=func.expressions, 473 params=params, 474 ) 475 476 if parts: 477 if parts[1]: 478 return self.expression( 479 exp.CombinedAggFunc, 480 this=func.this, 481 expressions=func.expressions, 482 parts=parts, 483 ) 484 return self.expression( 485 exp.AnonymousAggFunc, 486 this=func.this, 487 expressions=func.expressions, 488 ) 489 490 return func 491 492 def _parse_func_params( 493 self, this: t.Optional[exp.Func] = None 494 ) -> t.Optional[t.List[exp.Expression]]: 495 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 496 return self._parse_csv(self._parse_lambda) 497 498 if self._match(TokenType.L_PAREN): 499 params = self._parse_csv(self._parse_lambda) 500 self._match_r_paren(this) 501 return params 502 503 return None 504 505 def _parse_quantile(self) -> exp.Quantile: 506 this = self._parse_lambda() 507 params = self._parse_func_params() 508 if params: 509 return self.expression(exp.Quantile, this=params[0], quantile=this) 510 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 511 512 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 513 return super()._parse_wrapped_id_vars(optional=True) 514 515 def _parse_primary_key( 516 self, wrapped_optional: bool = False, in_props: bool = False 517 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 518 return super()._parse_primary_key( 519 wrapped_optional=wrapped_optional or in_props, in_props=in_props 520 ) 521 522 def _parse_on_property(self) -> t.Optional[exp.Expression]: 523 index = self._index 524 if self._match_text_seq("CLUSTER"): 525 this = self._parse_id_var() 526 if this: 527 return self.expression(exp.OnCluster, this=this) 528 else: 529 self._retreat(index) 530 return None 531 532 def _parse_index_constraint( 533 self, kind: t.Optional[str] = None 534 ) -> exp.IndexColumnConstraint: 535 # INDEX name1 expr TYPE type1(args) GRANULARITY value 536 this = self._parse_id_var() 537 expression = self._parse_conjunction() 538 539 index_type = self._match_text_seq("TYPE") and ( 540 self._parse_function() or self._parse_var() 541 ) 542 543 granularity = self._match_text_seq("GRANULARITY") and self._parse_term() 544 545 return self.expression( 546 exp.IndexColumnConstraint, 547 this=this, 548 expression=expression, 549 index_type=index_type, 550 granularity=granularity, 551 ) 552 553 class Generator(generator.Generator): 554 QUERY_HINTS = False 555 STRUCT_DELIMITER = ("(", ")") 556 NVL2_SUPPORTED = False 557 TABLESAMPLE_REQUIRES_PARENS = False 558 TABLESAMPLE_SIZE_IS_ROWS = False 559 TABLESAMPLE_KEYWORDS = "SAMPLE" 560 LAST_DAY_SUPPORTS_DATE_PART = False 561 CAN_IMPLEMENT_ARRAY_ANY = True 562 SUPPORTS_TO_NUMBER = False 563 564 STRING_TYPE_MAPPING = { 565 exp.DataType.Type.CHAR: "String", 566 exp.DataType.Type.LONGBLOB: "String", 567 exp.DataType.Type.LONGTEXT: "String", 568 exp.DataType.Type.MEDIUMBLOB: "String", 569 exp.DataType.Type.MEDIUMTEXT: "String", 570 exp.DataType.Type.TINYBLOB: "String", 571 exp.DataType.Type.TINYTEXT: "String", 572 exp.DataType.Type.TEXT: "String", 573 exp.DataType.Type.VARBINARY: "String", 574 exp.DataType.Type.VARCHAR: "String", 575 } 576 577 SUPPORTED_JSON_PATH_PARTS = { 578 exp.JSONPathKey, 579 exp.JSONPathRoot, 580 exp.JSONPathSubscript, 581 } 582 583 TYPE_MAPPING = { 584 **generator.Generator.TYPE_MAPPING, 585 **STRING_TYPE_MAPPING, 586 exp.DataType.Type.ARRAY: "Array", 587 exp.DataType.Type.BIGINT: "Int64", 588 exp.DataType.Type.DATE32: "Date32", 589 exp.DataType.Type.DATETIME64: "DateTime64", 590 exp.DataType.Type.DOUBLE: "Float64", 591 exp.DataType.Type.ENUM: "Enum", 592 exp.DataType.Type.ENUM8: "Enum8", 593 exp.DataType.Type.ENUM16: "Enum16", 594 exp.DataType.Type.FIXEDSTRING: "FixedString", 595 exp.DataType.Type.FLOAT: "Float32", 596 exp.DataType.Type.INT: "Int32", 597 exp.DataType.Type.MEDIUMINT: "Int32", 598 exp.DataType.Type.INT128: "Int128", 599 exp.DataType.Type.INT256: "Int256", 600 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 601 exp.DataType.Type.MAP: "Map", 602 exp.DataType.Type.NESTED: "Nested", 603 exp.DataType.Type.NULLABLE: "Nullable", 604 exp.DataType.Type.SMALLINT: "Int16", 605 exp.DataType.Type.STRUCT: "Tuple", 606 exp.DataType.Type.TINYINT: "Int8", 607 exp.DataType.Type.UBIGINT: "UInt64", 608 exp.DataType.Type.UINT: "UInt32", 609 exp.DataType.Type.UINT128: "UInt128", 610 exp.DataType.Type.UINT256: "UInt256", 611 exp.DataType.Type.USMALLINT: "UInt16", 612 exp.DataType.Type.UTINYINT: "UInt8", 613 exp.DataType.Type.IPV4: "IPv4", 614 exp.DataType.Type.IPV6: "IPv6", 615 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 616 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 617 } 618 619 TRANSFORMS = { 620 **generator.Generator.TRANSFORMS, 621 exp.AnyValue: rename_func("any"), 622 exp.ApproxDistinct: rename_func("uniq"), 623 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 624 exp.ArraySize: rename_func("LENGTH"), 625 exp.ArraySum: rename_func("arraySum"), 626 exp.ArgMax: arg_max_or_min_no_count("argMax"), 627 exp.ArgMin: arg_max_or_min_no_count("argMin"), 628 exp.Array: inline_array_sql, 629 exp.CastToStrType: rename_func("CAST"), 630 exp.CountIf: rename_func("countIf"), 631 exp.CompressColumnConstraint: lambda self, 632 e: f"CODEC({self.expressions(e, key='this', flat=True)})", 633 exp.ComputedColumnConstraint: lambda self, e: f"ALIAS {self.sql(e, 'this')}", 634 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 635 exp.DateAdd: date_delta_sql("DATE_ADD"), 636 exp.DateDiff: date_delta_sql("DATE_DIFF"), 637 exp.Explode: rename_func("arrayJoin"), 638 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 639 exp.IsNan: rename_func("isNaN"), 640 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 641 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 642 exp.JSONPathKey: json_path_key_only_name, 643 exp.JSONPathRoot: lambda *_: "", 644 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 645 exp.Nullif: rename_func("nullIf"), 646 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 647 exp.Pivot: no_pivot_sql, 648 exp.Quantile: _quantile_sql, 649 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 650 exp.Rand: rename_func("randCanonical"), 651 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 652 exp.StartsWith: rename_func("startsWith"), 653 exp.StrPosition: lambda self, e: self.func( 654 "position", e.this, e.args.get("substr"), e.args.get("position") 655 ), 656 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 657 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 658 } 659 660 PROPERTIES_LOCATION = { 661 **generator.Generator.PROPERTIES_LOCATION, 662 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 663 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 664 exp.OnCluster: exp.Properties.Location.POST_NAME, 665 } 666 667 JOIN_HINTS = False 668 TABLE_HINTS = False 669 EXPLICIT_UNION = True 670 GROUPINGS_SEP = "" 671 672 # there's no list in docs, but it can be found in Clickhouse code 673 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 674 ON_CLUSTER_TARGETS = { 675 "DATABASE", 676 "TABLE", 677 "VIEW", 678 "DICTIONARY", 679 "INDEX", 680 "FUNCTION", 681 "NAMED COLLECTION", 682 } 683 684 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 685 this = self.json_path_part(expression.this) 686 return str(int(this) + 1) if is_int(this) else this 687 688 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 689 return f"AS {self.sql(expression, 'this')}" 690 691 def _any_to_has( 692 self, 693 expression: exp.EQ | exp.NEQ, 694 default: t.Callable[[t.Any], str], 695 prefix: str = "", 696 ) -> str: 697 if isinstance(expression.left, exp.Any): 698 arr = expression.left 699 this = expression.right 700 elif isinstance(expression.right, exp.Any): 701 arr = expression.right 702 this = expression.left 703 else: 704 return default(expression) 705 706 return prefix + self.func("has", arr.this.unnest(), this) 707 708 def eq_sql(self, expression: exp.EQ) -> str: 709 return self._any_to_has(expression, super().eq_sql) 710 711 def neq_sql(self, expression: exp.NEQ) -> str: 712 return self._any_to_has(expression, super().neq_sql, "NOT ") 713 714 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 715 # Manually add a flag to make the search case-insensitive 716 regex = self.func("CONCAT", "'(?i)'", expression.expression) 717 return self.func("match", expression.this, regex) 718 719 def datatype_sql(self, expression: exp.DataType) -> str: 720 # String is the standard ClickHouse type, every other variant is just an alias. 721 # Additionally, any supplied length parameter will be ignored. 722 # 723 # https://clickhouse.com/docs/en/sql-reference/data-types/string 724 if expression.this in self.STRING_TYPE_MAPPING: 725 return "String" 726 727 return super().datatype_sql(expression) 728 729 def cte_sql(self, expression: exp.CTE) -> str: 730 if expression.args.get("scalar"): 731 this = self.sql(expression, "this") 732 alias = self.sql(expression, "alias") 733 return f"{this} AS {alias}" 734 735 return super().cte_sql(expression) 736 737 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 738 return super().after_limit_modifiers(expression) + [ 739 ( 740 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 741 if expression.args.get("settings") 742 else "" 743 ), 744 ( 745 self.seg("FORMAT ") + self.sql(expression, "format") 746 if expression.args.get("format") 747 else "" 748 ), 749 ] 750 751 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 752 params = self.expressions(expression, key="params", flat=True) 753 return self.func(expression.name, *expression.expressions) + f"({params})" 754 755 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 756 return self.func(expression.name, *expression.expressions) 757 758 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 759 return self.anonymousaggfunc_sql(expression) 760 761 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 762 return self.parameterizedagg_sql(expression) 763 764 def placeholder_sql(self, expression: exp.Placeholder) -> str: 765 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 766 767 def oncluster_sql(self, expression: exp.OnCluster) -> str: 768 return f"ON CLUSTER {self.sql(expression, 'this')}" 769 770 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 771 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 772 exp.Properties.Location.POST_NAME 773 ): 774 this_name = self.sql(expression.this, "this") 775 this_properties = " ".join( 776 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 777 ) 778 this_schema = self.schema_columns_sql(expression.this) 779 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 780 781 return super().createable_sql(expression, locations) 782 783 def prewhere_sql(self, expression: exp.PreWhere) -> str: 784 this = self.indent(self.sql(expression, "this")) 785 return f"{self.seg('PREWHERE')}{self.sep()}{this}" 786 787 def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str: 788 this = self.sql(expression, "this") 789 this = f" {this}" if this else "" 790 expr = self.sql(expression, "expression") 791 expr = f" {expr}" if expr else "" 792 index_type = self.sql(expression, "index_type") 793 index_type = f" TYPE {index_type}" if index_type else "" 794 granularity = self.sql(expression, "granularity") 795 granularity = f" GRANULARITY {granularity}" if granularity else "" 796 797 return f"INDEX{this}{expr}{index_type}{granularity}"
NORMALIZE_FUNCTIONS: bool | str =
False
Determines how function names are going to be normalized.
Possible values:
"upper" or True: Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
NULL_ORDERING =
'nulls_are_last'
Default NULL
ordering method to use if not explicitly set.
Possible values: "nulls_are_small"
, "nulls_are_large"
, "nulls_are_last"
LOG_BASE_FIRST: Optional[bool] =
None
Whether the base comes first in the LOG
function.
Possible values: True
, False
, None
(two arguments are not supported by LOG
)
UNESCAPED_SEQUENCES =
{'\\a': '\x07', '\\b': '\x08', '\\f': '\x0c', '\\n': '\n', '\\r': '\r', '\\t': '\t', '\\v': '\x0b', '\\\\': '\\', '\\0': '\x00'}
Mapping of an escaped sequence (\n
) to its unescaped version (
).
tokenizer_class =
<class 'ClickHouse.Tokenizer'>
parser_class =
<class 'ClickHouse.Parser'>
generator_class =
<class 'ClickHouse.Generator'>
ESCAPED_SEQUENCES: Dict[str, str] =
{'\x07': '\\a', '\x08': '\\b', '\x0c': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\x0b': '\\v', '\\': '\\\\', '\x00': '\\0'}
Inherited Members
- sqlglot.dialects.dialect.Dialect
- Dialect
- INDEX_OFFSET
- WEEK_OFFSET
- UNNEST_COLUMN_ONLY
- ALIAS_POST_TABLESAMPLE
- TABLESAMPLE_SIZE_IS_PERCENT
- NORMALIZATION_STRATEGY
- IDENTIFIERS_CAN_START_WITH_DIGIT
- DPIPE_IS_STRING_CONCAT
- STRICT_STRING_CONCAT
- SUPPORTS_SEMI_ANTI_JOIN
- TYPED_DIVISION
- CONCAT_COALESCE
- DATE_FORMAT
- DATEINT_FORMAT
- TIME_FORMAT
- TIME_MAPPING
- FORMAT_MAPPING
- PSEUDOCOLUMNS
- PREFER_CTE_ALIAS_COLUMN
- get_or_raise
- format_time
- normalize_identifier
- case_sensitive
- can_identify
- quote_identifier
- to_json_path
- parse
- parse_into
- generate
- transpile
- tokenize
- tokenizer
- parser
- generator
58 class Tokenizer(tokens.Tokenizer): 59 COMMENTS = ["--", "#", "#!", ("/*", "*/")] 60 IDENTIFIERS = ['"', "`"] 61 STRING_ESCAPES = ["'", "\\"] 62 BIT_STRINGS = [("0b", "")] 63 HEX_STRINGS = [("0x", ""), ("0X", "")] 64 HEREDOC_STRINGS = ["$"] 65 66 KEYWORDS = { 67 **tokens.Tokenizer.KEYWORDS, 68 "ATTACH": TokenType.COMMAND, 69 "DATE32": TokenType.DATE32, 70 "DATETIME64": TokenType.DATETIME64, 71 "DICTIONARY": TokenType.DICTIONARY, 72 "ENUM8": TokenType.ENUM8, 73 "ENUM16": TokenType.ENUM16, 74 "FINAL": TokenType.FINAL, 75 "FIXEDSTRING": TokenType.FIXEDSTRING, 76 "FLOAT32": TokenType.FLOAT, 77 "FLOAT64": TokenType.DOUBLE, 78 "GLOBAL": TokenType.GLOBAL, 79 "INT256": TokenType.INT256, 80 "LOWCARDINALITY": TokenType.LOWCARDINALITY, 81 "MAP": TokenType.MAP, 82 "NESTED": TokenType.NESTED, 83 "SAMPLE": TokenType.TABLE_SAMPLE, 84 "TUPLE": TokenType.STRUCT, 85 "UINT128": TokenType.UINT128, 86 "UINT16": TokenType.USMALLINT, 87 "UINT256": TokenType.UINT256, 88 "UINT32": TokenType.UINT, 89 "UINT64": TokenType.UBIGINT, 90 "UINT8": TokenType.UTINYINT, 91 "IPV4": TokenType.IPV4, 92 "IPV6": TokenType.IPV6, 93 "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION, 94 "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION, 95 "SYSTEM": TokenType.COMMAND, 96 "PREWHERE": TokenType.PREWHERE, 97 } 98 99 SINGLE_TOKENS = { 100 **tokens.Tokenizer.SINGLE_TOKENS, 101 "$": TokenType.HEREDOC_STRING, 102 }
KEYWORDS =
{'{%': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{%-': <TokenType.BLOCK_START: 'BLOCK_START'>, '%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '+%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-%}': <TokenType.BLOCK_END: 'BLOCK_END'>, '{{+': <TokenType.BLOCK_START: 'BLOCK_START'>, '{{-': <TokenType.BLOCK_START: 'BLOCK_START'>, '+}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '-}}': <TokenType.BLOCK_END: 'BLOCK_END'>, '/*+': <TokenType.HINT: 'HINT'>, '==': <TokenType.EQ: 'EQ'>, '::': <TokenType.DCOLON: 'DCOLON'>, '||': <TokenType.DPIPE: 'DPIPE'>, '>=': <TokenType.GTE: 'GTE'>, '<=': <TokenType.LTE: 'LTE'>, '<>': <TokenType.NEQ: 'NEQ'>, '!=': <TokenType.NEQ: 'NEQ'>, ':=': <TokenType.COLON_EQ: 'COLON_EQ'>, '<=>': <TokenType.NULLSAFE_EQ: 'NULLSAFE_EQ'>, '->': <TokenType.ARROW: 'ARROW'>, '->>': <TokenType.DARROW: 'DARROW'>, '=>': <TokenType.FARROW: 'FARROW'>, '#>': <TokenType.HASH_ARROW: 'HASH_ARROW'>, '#>>': <TokenType.DHASH_ARROW: 'DHASH_ARROW'>, '<->': <TokenType.LR_ARROW: 'LR_ARROW'>, '&&': <TokenType.DAMP: 'DAMP'>, '??': <TokenType.DQMARK: 'DQMARK'>, 'ALL': <TokenType.ALL: 'ALL'>, 'ALWAYS': <TokenType.ALWAYS: 'ALWAYS'>, 'AND': <TokenType.AND: 'AND'>, 'ANTI': <TokenType.ANTI: 'ANTI'>, 'ANY': <TokenType.ANY: 'ANY'>, 'ASC': <TokenType.ASC: 'ASC'>, 'AS': <TokenType.ALIAS: 'ALIAS'>, 'ASOF': <TokenType.ASOF: 'ASOF'>, 'AUTOINCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'AUTO_INCREMENT': <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, 'BEGIN': <TokenType.BEGIN: 'BEGIN'>, 'BETWEEN': <TokenType.BETWEEN: 'BETWEEN'>, 'CACHE': <TokenType.CACHE: 'CACHE'>, 'UNCACHE': <TokenType.UNCACHE: 'UNCACHE'>, 'CASE': <TokenType.CASE: 'CASE'>, 'CHARACTER SET': <TokenType.CHARACTER_SET: 'CHARACTER_SET'>, 'CLUSTER BY': <TokenType.CLUSTER_BY: 'CLUSTER_BY'>, 'COLLATE': <TokenType.COLLATE: 'COLLATE'>, 'COLUMN': <TokenType.COLUMN: 'COLUMN'>, 'COMMIT': <TokenType.COMMIT: 'COMMIT'>, 'CONNECT BY': <TokenType.CONNECT_BY: 'CONNECT_BY'>, 'CONSTRAINT': <TokenType.CONSTRAINT: 'CONSTRAINT'>, 'CREATE': <TokenType.CREATE: 'CREATE'>, 'CROSS': <TokenType.CROSS: 'CROSS'>, 'CUBE': <TokenType.CUBE: 'CUBE'>, 'CURRENT_DATE': <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, 'CURRENT_TIME': <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, 'CURRENT_TIMESTAMP': <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, 'CURRENT_USER': <TokenType.CURRENT_USER: 'CURRENT_USER'>, 'DATABASE': <TokenType.DATABASE: 'DATABASE'>, 'DEFAULT': <TokenType.DEFAULT: 'DEFAULT'>, 'DELETE': <TokenType.DELETE: 'DELETE'>, 'DESC': <TokenType.DESC: 'DESC'>, 'DESCRIBE': <TokenType.DESCRIBE: 'DESCRIBE'>, 'DISTINCT': <TokenType.DISTINCT: 'DISTINCT'>, 'DISTRIBUTE BY': <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>, 'DIV': <TokenType.DIV: 'DIV'>, 'DROP': <TokenType.DROP: 'DROP'>, 'ELSE': <TokenType.ELSE: 'ELSE'>, 'END': <TokenType.END: 'END'>, 'ENUM': <TokenType.ENUM: 'ENUM'>, 'ESCAPE': <TokenType.ESCAPE: 'ESCAPE'>, 'EXCEPT': <TokenType.EXCEPT: 'EXCEPT'>, 'EXECUTE': <TokenType.EXECUTE: 'EXECUTE'>, 'EXISTS': <TokenType.EXISTS: 'EXISTS'>, 'FALSE': <TokenType.FALSE: 'FALSE'>, 'FETCH': <TokenType.FETCH: 'FETCH'>, 'FILTER': <TokenType.FILTER: 'FILTER'>, 'FIRST': <TokenType.FIRST: 'FIRST'>, 'FULL': <TokenType.FULL: 'FULL'>, 'FUNCTION': <TokenType.FUNCTION: 'FUNCTION'>, 'FOR': <TokenType.FOR: 'FOR'>, 'FOREIGN KEY': <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, 'FORMAT': <TokenType.FORMAT: 'FORMAT'>, 'FROM': <TokenType.FROM: 'FROM'>, 'GEOGRAPHY': <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, 'GEOMETRY': <TokenType.GEOMETRY: 'GEOMETRY'>, 'GLOB': <TokenType.GLOB: 'GLOB'>, 'GROUP BY': <TokenType.GROUP_BY: 'GROUP_BY'>, 'GROUPING SETS': <TokenType.GROUPING_SETS: 'GROUPING_SETS'>, 'HAVING': <TokenType.HAVING: 'HAVING'>, 'ILIKE': <TokenType.ILIKE: 'ILIKE'>, 'IN': <TokenType.IN: 'IN'>, 'INDEX': <TokenType.INDEX: 'INDEX'>, 'INET': <TokenType.INET: 'INET'>, 'INNER': <TokenType.INNER: 'INNER'>, 'INSERT': <TokenType.INSERT: 'INSERT'>, 'INTERVAL': <TokenType.INTERVAL: 'INTERVAL'>, 'INTERSECT': <TokenType.INTERSECT: 'INTERSECT'>, 'INTO': <TokenType.INTO: 'INTO'>, 'IS': <TokenType.IS: 'IS'>, 'ISNULL': <TokenType.ISNULL: 'ISNULL'>, 'JOIN': <TokenType.JOIN: 'JOIN'>, 'KEEP': <TokenType.KEEP: 'KEEP'>, 'KILL': <TokenType.KILL: 'KILL'>, 'LATERAL': <TokenType.LATERAL: 'LATERAL'>, 'LEFT': <TokenType.LEFT: 'LEFT'>, 'LIKE': <TokenType.LIKE: 'LIKE'>, 'LIMIT': <TokenType.LIMIT: 'LIMIT'>, 'LOAD': <TokenType.LOAD: 'LOAD'>, 'LOCK': <TokenType.LOCK: 'LOCK'>, 'MERGE': <TokenType.MERGE: 'MERGE'>, 'NATURAL': <TokenType.NATURAL: 'NATURAL'>, 'NEXT': <TokenType.NEXT: 'NEXT'>, 'NOT': <TokenType.NOT: 'NOT'>, 'NOTNULL': <TokenType.NOTNULL: 'NOTNULL'>, 'NULL': <TokenType.NULL: 'NULL'>, 'OBJECT': <TokenType.OBJECT: 'OBJECT'>, 'OFFSET': <TokenType.OFFSET: 'OFFSET'>, 'ON': <TokenType.ON: 'ON'>, 'OR': <TokenType.OR: 'OR'>, 'XOR': <TokenType.XOR: 'XOR'>, 'ORDER BY': <TokenType.ORDER_BY: 'ORDER_BY'>, 'ORDINALITY': <TokenType.ORDINALITY: 'ORDINALITY'>, 'OUTER': <TokenType.OUTER: 'OUTER'>, 'OVER': <TokenType.OVER: 'OVER'>, 'OVERLAPS': <TokenType.OVERLAPS: 'OVERLAPS'>, 'OVERWRITE': <TokenType.OVERWRITE: 'OVERWRITE'>, 'PARTITION': <TokenType.PARTITION: 'PARTITION'>, 'PARTITION BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PARTITIONED_BY': <TokenType.PARTITION_BY: 'PARTITION_BY'>, 'PERCENT': <TokenType.PERCENT: 'PERCENT'>, 'PIVOT': <TokenType.PIVOT: 'PIVOT'>, 'PRAGMA': <TokenType.PRAGMA: 'PRAGMA'>, 'PRIMARY KEY': <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, 'PROCEDURE': <TokenType.PROCEDURE: 'PROCEDURE'>, 'QUALIFY': <TokenType.QUALIFY: 'QUALIFY'>, 'RANGE': <TokenType.RANGE: 'RANGE'>, 'RECURSIVE': <TokenType.RECURSIVE: 'RECURSIVE'>, 'REGEXP': <TokenType.RLIKE: 'RLIKE'>, 'REPLACE': <TokenType.REPLACE: 'REPLACE'>, 'RETURNING': <TokenType.RETURNING: 'RETURNING'>, 'REFERENCES': <TokenType.REFERENCES: 'REFERENCES'>, 'RIGHT': <TokenType.RIGHT: 'RIGHT'>, 'RLIKE': <TokenType.RLIKE: 'RLIKE'>, 'ROLLBACK': <TokenType.ROLLBACK: 'ROLLBACK'>, 'ROLLUP': <TokenType.ROLLUP: 'ROLLUP'>, 'ROW': <TokenType.ROW: 'ROW'>, 'ROWS': <TokenType.ROWS: 'ROWS'>, 'SCHEMA': <TokenType.SCHEMA: 'SCHEMA'>, 'SELECT': <TokenType.SELECT: 'SELECT'>, 'SEMI': <TokenType.SEMI: 'SEMI'>, 'SET': <TokenType.SET: 'SET'>, 'SETTINGS': <TokenType.SETTINGS: 'SETTINGS'>, 'SHOW': <TokenType.SHOW: 'SHOW'>, 'SIMILAR TO': <TokenType.SIMILAR_TO: 'SIMILAR_TO'>, 'SOME': <TokenType.SOME: 'SOME'>, 'SORT BY': <TokenType.SORT_BY: 'SORT_BY'>, 'START WITH': <TokenType.START_WITH: 'START_WITH'>, 'TABLE': <TokenType.TABLE: 'TABLE'>, 'TABLESAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TEMP': <TokenType.TEMPORARY: 'TEMPORARY'>, 'TEMPORARY': <TokenType.TEMPORARY: 'TEMPORARY'>, 'THEN': <TokenType.THEN: 'THEN'>, 'TRUE': <TokenType.TRUE: 'TRUE'>, 'TRUNCATE': <TokenType.TRUNCATE: 'TRUNCATE'>, 'UNION': <TokenType.UNION: 'UNION'>, 'UNKNOWN': <TokenType.UNKNOWN: 'UNKNOWN'>, 'UNNEST': <TokenType.UNNEST: 'UNNEST'>, 'UNPIVOT': <TokenType.UNPIVOT: 'UNPIVOT'>, 'UPDATE': <TokenType.UPDATE: 'UPDATE'>, 'USE': <TokenType.USE: 'USE'>, 'USING': <TokenType.USING: 'USING'>, 'UUID': <TokenType.UUID: 'UUID'>, 'VALUES': <TokenType.VALUES: 'VALUES'>, 'VIEW': <TokenType.VIEW: 'VIEW'>, 'VOLATILE': <TokenType.VOLATILE: 'VOLATILE'>, 'WHEN': <TokenType.WHEN: 'WHEN'>, 'WHERE': <TokenType.WHERE: 'WHERE'>, 'WINDOW': <TokenType.WINDOW: 'WINDOW'>, 'WITH': <TokenType.WITH: 'WITH'>, 'APPLY': <TokenType.APPLY: 'APPLY'>, 'ARRAY': <TokenType.ARRAY: 'ARRAY'>, 'BIT': <TokenType.BIT: 'BIT'>, 'BOOL': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BOOLEAN': <TokenType.BOOLEAN: 'BOOLEAN'>, 'BYTE': <TokenType.TINYINT: 'TINYINT'>, 'MEDIUMINT': <TokenType.MEDIUMINT: 'MEDIUMINT'>, 'INT1': <TokenType.TINYINT: 'TINYINT'>, 'TINYINT': <TokenType.TINYINT: 'TINYINT'>, 'INT16': <TokenType.SMALLINT: 'SMALLINT'>, 'SHORT': <TokenType.SMALLINT: 'SMALLINT'>, 'SMALLINT': <TokenType.SMALLINT: 'SMALLINT'>, 'INT128': <TokenType.INT128: 'INT128'>, 'HUGEINT': <TokenType.INT128: 'INT128'>, 'INT2': <TokenType.SMALLINT: 'SMALLINT'>, 'INTEGER': <TokenType.INT: 'INT'>, 'INT': <TokenType.INT: 'INT'>, 'INT4': <TokenType.INT: 'INT'>, 'INT32': <TokenType.INT: 'INT'>, 'INT64': <TokenType.BIGINT: 'BIGINT'>, 'LONG': <TokenType.BIGINT: 'BIGINT'>, 'BIGINT': <TokenType.BIGINT: 'BIGINT'>, 'INT8': <TokenType.TINYINT: 'TINYINT'>, 'UINT': <TokenType.UINT: 'UINT'>, 'DEC': <TokenType.DECIMAL: 'DECIMAL'>, 'DECIMAL': <TokenType.DECIMAL: 'DECIMAL'>, 'BIGDECIMAL': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'BIGNUMERIC': <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, 'MAP': <TokenType.MAP: 'MAP'>, 'NULLABLE': <TokenType.NULLABLE: 'NULLABLE'>, 'NUMBER': <TokenType.DECIMAL: 'DECIMAL'>, 'NUMERIC': <TokenType.DECIMAL: 'DECIMAL'>, 'FIXED': <TokenType.DECIMAL: 'DECIMAL'>, 'REAL': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT4': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT8': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE': <TokenType.DOUBLE: 'DOUBLE'>, 'DOUBLE PRECISION': <TokenType.DOUBLE: 'DOUBLE'>, 'JSON': <TokenType.JSON: 'JSON'>, 'CHAR': <TokenType.CHAR: 'CHAR'>, 'CHARACTER': <TokenType.CHAR: 'CHAR'>, 'NCHAR': <TokenType.NCHAR: 'NCHAR'>, 'VARCHAR': <TokenType.VARCHAR: 'VARCHAR'>, 'VARCHAR2': <TokenType.VARCHAR: 'VARCHAR'>, 'NVARCHAR': <TokenType.NVARCHAR: 'NVARCHAR'>, 'NVARCHAR2': <TokenType.NVARCHAR: 'NVARCHAR'>, 'BPCHAR': <TokenType.BPCHAR: 'BPCHAR'>, 'STR': <TokenType.TEXT: 'TEXT'>, 'STRING': <TokenType.TEXT: 'TEXT'>, 'TEXT': <TokenType.TEXT: 'TEXT'>, 'LONGTEXT': <TokenType.LONGTEXT: 'LONGTEXT'>, 'MEDIUMTEXT': <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, 'TINYTEXT': <TokenType.TINYTEXT: 'TINYTEXT'>, 'CLOB': <TokenType.TEXT: 'TEXT'>, 'LONGVARCHAR': <TokenType.TEXT: 'TEXT'>, 'BINARY': <TokenType.BINARY: 'BINARY'>, 'BLOB': <TokenType.VARBINARY: 'VARBINARY'>, 'LONGBLOB': <TokenType.LONGBLOB: 'LONGBLOB'>, 'MEDIUMBLOB': <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, 'TINYBLOB': <TokenType.TINYBLOB: 'TINYBLOB'>, 'BYTEA': <TokenType.VARBINARY: 'VARBINARY'>, 'VARBINARY': <TokenType.VARBINARY: 'VARBINARY'>, 'TIME': <TokenType.TIME: 'TIME'>, 'TIMETZ': <TokenType.TIMETZ: 'TIMETZ'>, 'TIMESTAMP': <TokenType.TIMESTAMP: 'TIMESTAMP'>, 'TIMESTAMPTZ': <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, 'TIMESTAMPLTZ': <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, 'DATE': <TokenType.DATE: 'DATE'>, 'DATETIME': <TokenType.DATETIME: 'DATETIME'>, 'INT4RANGE': <TokenType.INT4RANGE: 'INT4RANGE'>, 'INT4MULTIRANGE': <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, 'INT8RANGE': <TokenType.INT8RANGE: 'INT8RANGE'>, 'INT8MULTIRANGE': <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, 'NUMRANGE': <TokenType.NUMRANGE: 'NUMRANGE'>, 'NUMMULTIRANGE': <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, 'TSRANGE': <TokenType.TSRANGE: 'TSRANGE'>, 'TSMULTIRANGE': <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, 'TSTZRANGE': <TokenType.TSTZRANGE: 'TSTZRANGE'>, 'TSTZMULTIRANGE': <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, 'DATERANGE': <TokenType.DATERANGE: 'DATERANGE'>, 'DATEMULTIRANGE': <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, 'UNIQUE': <TokenType.UNIQUE: 'UNIQUE'>, 'STRUCT': <TokenType.STRUCT: 'STRUCT'>, 'SEQUENCE': <TokenType.SEQUENCE: 'SEQUENCE'>, 'VARIANT': <TokenType.VARIANT: 'VARIANT'>, 'ALTER': <TokenType.ALTER: 'ALTER'>, 'ANALYZE': <TokenType.COMMAND: 'COMMAND'>, 'CALL': <TokenType.COMMAND: 'COMMAND'>, 'COMMENT': <TokenType.COMMENT: 'COMMENT'>, 'COPY': <TokenType.COMMAND: 'COMMAND'>, 'EXPLAIN': <TokenType.COMMAND: 'COMMAND'>, 'GRANT': <TokenType.COMMAND: 'COMMAND'>, 'OPTIMIZE': <TokenType.COMMAND: 'COMMAND'>, 'PREPARE': <TokenType.COMMAND: 'COMMAND'>, 'VACUUM': <TokenType.COMMAND: 'COMMAND'>, 'USER-DEFINED': <TokenType.USERDEFINED: 'USERDEFINED'>, 'FOR VERSION': <TokenType.VERSION_SNAPSHOT: 'VERSION_SNAPSHOT'>, 'FOR TIMESTAMP': <TokenType.TIMESTAMP_SNAPSHOT: 'TIMESTAMP_SNAPSHOT'>, 'ATTACH': <TokenType.COMMAND: 'COMMAND'>, 'DATE32': <TokenType.DATE32: 'DATE32'>, 'DATETIME64': <TokenType.DATETIME64: 'DATETIME64'>, 'DICTIONARY': <TokenType.DICTIONARY: 'DICTIONARY'>, 'ENUM8': <TokenType.ENUM8: 'ENUM8'>, 'ENUM16': <TokenType.ENUM16: 'ENUM16'>, 'FINAL': <TokenType.FINAL: 'FINAL'>, 'FIXEDSTRING': <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, 'FLOAT32': <TokenType.FLOAT: 'FLOAT'>, 'FLOAT64': <TokenType.DOUBLE: 'DOUBLE'>, 'GLOBAL': <TokenType.GLOBAL: 'GLOBAL'>, 'INT256': <TokenType.INT256: 'INT256'>, 'LOWCARDINALITY': <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, 'NESTED': <TokenType.NESTED: 'NESTED'>, 'SAMPLE': <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>, 'TUPLE': <TokenType.STRUCT: 'STRUCT'>, 'UINT128': <TokenType.UINT128: 'UINT128'>, 'UINT16': <TokenType.USMALLINT: 'USMALLINT'>, 'UINT256': <TokenType.UINT256: 'UINT256'>, 'UINT32': <TokenType.UINT: 'UINT'>, 'UINT64': <TokenType.UBIGINT: 'UBIGINT'>, 'UINT8': <TokenType.UTINYINT: 'UTINYINT'>, 'IPV4': <TokenType.IPV4: 'IPV4'>, 'IPV6': <TokenType.IPV6: 'IPV6'>, 'AGGREGATEFUNCTION': <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, 'SIMPLEAGGREGATEFUNCTION': <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, 'SYSTEM': <TokenType.COMMAND: 'COMMAND'>, 'PREWHERE': <TokenType.PREWHERE: 'PREWHERE'>}
SINGLE_TOKENS =
{'(': <TokenType.L_PAREN: 'L_PAREN'>, ')': <TokenType.R_PAREN: 'R_PAREN'>, '[': <TokenType.L_BRACKET: 'L_BRACKET'>, ']': <TokenType.R_BRACKET: 'R_BRACKET'>, '{': <TokenType.L_BRACE: 'L_BRACE'>, '}': <TokenType.R_BRACE: 'R_BRACE'>, '&': <TokenType.AMP: 'AMP'>, '^': <TokenType.CARET: 'CARET'>, ':': <TokenType.COLON: 'COLON'>, ',': <TokenType.COMMA: 'COMMA'>, '.': <TokenType.DOT: 'DOT'>, '-': <TokenType.DASH: 'DASH'>, '=': <TokenType.EQ: 'EQ'>, '>': <TokenType.GT: 'GT'>, '<': <TokenType.LT: 'LT'>, '%': <TokenType.MOD: 'MOD'>, '!': <TokenType.NOT: 'NOT'>, '|': <TokenType.PIPE: 'PIPE'>, '+': <TokenType.PLUS: 'PLUS'>, ';': <TokenType.SEMICOLON: 'SEMICOLON'>, '/': <TokenType.SLASH: 'SLASH'>, '\\': <TokenType.BACKSLASH: 'BACKSLASH'>, '*': <TokenType.STAR: 'STAR'>, '~': <TokenType.TILDA: 'TILDA'>, '?': <TokenType.PLACEHOLDER: 'PLACEHOLDER'>, '@': <TokenType.PARAMETER: 'PARAMETER'>, "'": <TokenType.QUOTE: 'QUOTE'>, '`': <TokenType.IDENTIFIER: 'IDENTIFIER'>, '"': <TokenType.IDENTIFIER: 'IDENTIFIER'>, '#': <TokenType.HASH: 'HASH'>, '$': <TokenType.HEREDOC_STRING: 'HEREDOC_STRING'>}
Inherited Members
104 class Parser(parser.Parser): 105 # Tested in ClickHouse's playground, it seems that the following two queries do the same thing 106 # * select x from t1 union all select x from t2 limit 1; 107 # * select x from t1 union all (select x from t2 limit 1); 108 MODIFIERS_ATTACHED_TO_UNION = False 109 INTERVAL_SPANS = False 110 111 FUNCTIONS = { 112 **parser.Parser.FUNCTIONS, 113 "ANY": exp.AnyValue.from_arg_list, 114 "ARRAYSUM": exp.ArraySum.from_arg_list, 115 "COUNTIF": _build_count_if, 116 "DATE_ADD": lambda args: exp.DateAdd( 117 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 118 ), 119 "DATEADD": lambda args: exp.DateAdd( 120 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 121 ), 122 "DATE_DIFF": lambda args: exp.DateDiff( 123 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 124 ), 125 "DATEDIFF": lambda args: exp.DateDiff( 126 this=seq_get(args, 2), expression=seq_get(args, 1), unit=seq_get(args, 0) 127 ), 128 "JSONEXTRACTSTRING": build_json_extract_path( 129 exp.JSONExtractScalar, zero_based_indexing=False 130 ), 131 "MAP": parser.build_var_map, 132 "MATCH": exp.RegexpLike.from_arg_list, 133 "RANDCANONICAL": exp.Rand.from_arg_list, 134 "TUPLE": exp.Struct.from_arg_list, 135 "UNIQ": exp.ApproxDistinct.from_arg_list, 136 "XOR": lambda args: exp.Xor(expressions=args), 137 } 138 139 AGG_FUNCTIONS = { 140 "count", 141 "min", 142 "max", 143 "sum", 144 "avg", 145 "any", 146 "stddevPop", 147 "stddevSamp", 148 "varPop", 149 "varSamp", 150 "corr", 151 "covarPop", 152 "covarSamp", 153 "entropy", 154 "exponentialMovingAverage", 155 "intervalLengthSum", 156 "kolmogorovSmirnovTest", 157 "mannWhitneyUTest", 158 "median", 159 "rankCorr", 160 "sumKahan", 161 "studentTTest", 162 "welchTTest", 163 "anyHeavy", 164 "anyLast", 165 "boundingRatio", 166 "first_value", 167 "last_value", 168 "argMin", 169 "argMax", 170 "avgWeighted", 171 "topK", 172 "topKWeighted", 173 "deltaSum", 174 "deltaSumTimestamp", 175 "groupArray", 176 "groupArrayLast", 177 "groupUniqArray", 178 "groupArrayInsertAt", 179 "groupArrayMovingAvg", 180 "groupArrayMovingSum", 181 "groupArraySample", 182 "groupBitAnd", 183 "groupBitOr", 184 "groupBitXor", 185 "groupBitmap", 186 "groupBitmapAnd", 187 "groupBitmapOr", 188 "groupBitmapXor", 189 "sumWithOverflow", 190 "sumMap", 191 "minMap", 192 "maxMap", 193 "skewSamp", 194 "skewPop", 195 "kurtSamp", 196 "kurtPop", 197 "uniq", 198 "uniqExact", 199 "uniqCombined", 200 "uniqCombined64", 201 "uniqHLL12", 202 "uniqTheta", 203 "quantile", 204 "quantiles", 205 "quantileExact", 206 "quantilesExact", 207 "quantileExactLow", 208 "quantilesExactLow", 209 "quantileExactHigh", 210 "quantilesExactHigh", 211 "quantileExactWeighted", 212 "quantilesExactWeighted", 213 "quantileTiming", 214 "quantilesTiming", 215 "quantileTimingWeighted", 216 "quantilesTimingWeighted", 217 "quantileDeterministic", 218 "quantilesDeterministic", 219 "quantileTDigest", 220 "quantilesTDigest", 221 "quantileTDigestWeighted", 222 "quantilesTDigestWeighted", 223 "quantileBFloat16", 224 "quantilesBFloat16", 225 "quantileBFloat16Weighted", 226 "quantilesBFloat16Weighted", 227 "simpleLinearRegression", 228 "stochasticLinearRegression", 229 "stochasticLogisticRegression", 230 "categoricalInformationValue", 231 "contingency", 232 "cramersV", 233 "cramersVBiasCorrected", 234 "theilsU", 235 "maxIntersections", 236 "maxIntersectionsPosition", 237 "meanZTest", 238 "quantileInterpolatedWeighted", 239 "quantilesInterpolatedWeighted", 240 "quantileGK", 241 "quantilesGK", 242 "sparkBar", 243 "sumCount", 244 "largestTriangleThreeBuckets", 245 } 246 247 AGG_FUNCTIONS_SUFFIXES = [ 248 "If", 249 "Array", 250 "ArrayIf", 251 "Map", 252 "SimpleState", 253 "State", 254 "Merge", 255 "MergeState", 256 "ForEach", 257 "Distinct", 258 "OrDefault", 259 "OrNull", 260 "Resample", 261 "ArgMin", 262 "ArgMax", 263 ] 264 265 FUNC_TOKENS = { 266 *parser.Parser.FUNC_TOKENS, 267 TokenType.SET, 268 } 269 270 AGG_FUNC_MAPPING = ( 271 lambda functions, suffixes: { 272 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 273 } 274 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 275 276 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 277 278 FUNCTION_PARSERS = { 279 **parser.Parser.FUNCTION_PARSERS, 280 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 281 "QUANTILE": lambda self: self._parse_quantile(), 282 } 283 284 FUNCTION_PARSERS.pop("MATCH") 285 286 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 287 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 288 289 RANGE_PARSERS = { 290 **parser.Parser.RANGE_PARSERS, 291 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 292 and self._parse_in(this, is_global=True), 293 } 294 295 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 296 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 297 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 298 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 299 300 JOIN_KINDS = { 301 *parser.Parser.JOIN_KINDS, 302 TokenType.ANY, 303 TokenType.ASOF, 304 TokenType.ARRAY, 305 } 306 307 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 308 TokenType.ANY, 309 TokenType.ARRAY, 310 TokenType.FINAL, 311 TokenType.FORMAT, 312 TokenType.SETTINGS, 313 } 314 315 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 316 TokenType.FORMAT, 317 } 318 319 LOG_DEFAULTS_TO_LN = True 320 321 QUERY_MODIFIER_PARSERS = { 322 **parser.Parser.QUERY_MODIFIER_PARSERS, 323 TokenType.SETTINGS: lambda self: ( 324 "settings", 325 self._advance() or self._parse_csv(self._parse_conjunction), 326 ), 327 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 328 } 329 330 CONSTRAINT_PARSERS = { 331 **parser.Parser.CONSTRAINT_PARSERS, 332 "INDEX": lambda self: self._parse_index_constraint(), 333 "CODEC": lambda self: self._parse_compress(), 334 } 335 336 SCHEMA_UNNAMED_CONSTRAINTS = { 337 *parser.Parser.SCHEMA_UNNAMED_CONSTRAINTS, 338 "INDEX", 339 } 340 341 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 342 this = super()._parse_conjunction() 343 344 if self._match(TokenType.PLACEHOLDER): 345 return self.expression( 346 exp.If, 347 this=this, 348 true=self._parse_conjunction(), 349 false=self._match(TokenType.COLON) and self._parse_conjunction(), 350 ) 351 352 return this 353 354 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 355 """ 356 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 357 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 358 """ 359 if not self._match(TokenType.L_BRACE): 360 return None 361 362 this = self._parse_id_var() 363 self._match(TokenType.COLON) 364 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 365 self._match_text_seq("IDENTIFIER") and "Identifier" 366 ) 367 368 if not kind: 369 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 370 elif not self._match(TokenType.R_BRACE): 371 self.raise_error("Expecting }") 372 373 return self.expression(exp.Placeholder, this=this, kind=kind) 374 375 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 376 this = super()._parse_in(this) 377 this.set("is_global", is_global) 378 return this 379 380 def _parse_table( 381 self, 382 schema: bool = False, 383 joins: bool = False, 384 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 385 parse_bracket: bool = False, 386 is_db_reference: bool = False, 387 ) -> t.Optional[exp.Expression]: 388 this = super()._parse_table( 389 schema=schema, 390 joins=joins, 391 alias_tokens=alias_tokens, 392 parse_bracket=parse_bracket, 393 is_db_reference=is_db_reference, 394 ) 395 396 if self._match(TokenType.FINAL): 397 this = self.expression(exp.Final, this=this) 398 399 return this 400 401 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 402 return super()._parse_position(haystack_first=True) 403 404 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 405 def _parse_cte(self) -> exp.CTE: 406 # WITH <identifier> AS <subquery expression> 407 cte: t.Optional[exp.CTE] = self._try_parse(super()._parse_cte) 408 409 if not cte: 410 # WITH <expression> AS <identifier> 411 cte = self.expression( 412 exp.CTE, 413 this=self._parse_conjunction(), 414 alias=self._parse_table_alias(), 415 scalar=True, 416 ) 417 418 return cte 419 420 def _parse_join_parts( 421 self, 422 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 423 is_global = self._match(TokenType.GLOBAL) and self._prev 424 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 425 426 if kind_pre: 427 kind = self._match_set(self.JOIN_KINDS) and self._prev 428 side = self._match_set(self.JOIN_SIDES) and self._prev 429 return is_global, side, kind 430 431 return ( 432 is_global, 433 self._match_set(self.JOIN_SIDES) and self._prev, 434 self._match_set(self.JOIN_KINDS) and self._prev, 435 ) 436 437 def _parse_join( 438 self, skip_join_token: bool = False, parse_bracket: bool = False 439 ) -> t.Optional[exp.Join]: 440 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 441 if join: 442 join.set("global", join.args.pop("method", None)) 443 444 return join 445 446 def _parse_function( 447 self, 448 functions: t.Optional[t.Dict[str, t.Callable]] = None, 449 anonymous: bool = False, 450 optional_parens: bool = True, 451 ) -> t.Optional[exp.Expression]: 452 func = super()._parse_function( 453 functions=functions, anonymous=anonymous, optional_parens=optional_parens 454 ) 455 456 if isinstance(func, exp.Anonymous): 457 parts = self.AGG_FUNC_MAPPING.get(func.this) 458 params = self._parse_func_params(func) 459 460 if params: 461 if parts and parts[1]: 462 return self.expression( 463 exp.CombinedParameterizedAgg, 464 this=func.this, 465 expressions=func.expressions, 466 params=params, 467 parts=parts, 468 ) 469 return self.expression( 470 exp.ParameterizedAgg, 471 this=func.this, 472 expressions=func.expressions, 473 params=params, 474 ) 475 476 if parts: 477 if parts[1]: 478 return self.expression( 479 exp.CombinedAggFunc, 480 this=func.this, 481 expressions=func.expressions, 482 parts=parts, 483 ) 484 return self.expression( 485 exp.AnonymousAggFunc, 486 this=func.this, 487 expressions=func.expressions, 488 ) 489 490 return func 491 492 def _parse_func_params( 493 self, this: t.Optional[exp.Func] = None 494 ) -> t.Optional[t.List[exp.Expression]]: 495 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 496 return self._parse_csv(self._parse_lambda) 497 498 if self._match(TokenType.L_PAREN): 499 params = self._parse_csv(self._parse_lambda) 500 self._match_r_paren(this) 501 return params 502 503 return None 504 505 def _parse_quantile(self) -> exp.Quantile: 506 this = self._parse_lambda() 507 params = self._parse_func_params() 508 if params: 509 return self.expression(exp.Quantile, this=params[0], quantile=this) 510 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 511 512 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 513 return super()._parse_wrapped_id_vars(optional=True) 514 515 def _parse_primary_key( 516 self, wrapped_optional: bool = False, in_props: bool = False 517 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 518 return super()._parse_primary_key( 519 wrapped_optional=wrapped_optional or in_props, in_props=in_props 520 ) 521 522 def _parse_on_property(self) -> t.Optional[exp.Expression]: 523 index = self._index 524 if self._match_text_seq("CLUSTER"): 525 this = self._parse_id_var() 526 if this: 527 return self.expression(exp.OnCluster, this=this) 528 else: 529 self._retreat(index) 530 return None 531 532 def _parse_index_constraint( 533 self, kind: t.Optional[str] = None 534 ) -> exp.IndexColumnConstraint: 535 # INDEX name1 expr TYPE type1(args) GRANULARITY value 536 this = self._parse_id_var() 537 expression = self._parse_conjunction() 538 539 index_type = self._match_text_seq("TYPE") and ( 540 self._parse_function() or self._parse_var() 541 ) 542 543 granularity = self._match_text_seq("GRANULARITY") and self._parse_term() 544 545 return self.expression( 546 exp.IndexColumnConstraint, 547 this=this, 548 expression=expression, 549 index_type=index_type, 550 granularity=granularity, 551 )
Parser consumes a list of tokens produced by the Tokenizer and produces a parsed syntax tree.
Arguments:
- error_level: The desired error level. Default: ErrorLevel.IMMEDIATE
- error_message_context: The amount of context to capture from a query string when displaying the error message (in number of characters). Default: 100
- max_errors: Maximum number of error messages to include in a raised ParseError. This is only relevant if error_level is ErrorLevel.RAISE. Default: 3
FUNCTIONS =
{'ABS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Abs'>>, 'ADD_MONTHS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AddMonths'>>, 'ANONYMOUS_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnonymousAggFunc'>>, 'ANY_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'APPROX_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_COUNT_DISTINCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>, 'APPROX_QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxQuantile'>>, 'APPROX_TOP_K': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxTopK'>>, 'ARG_MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARGMAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'MAX_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMax'>>, 'ARG_MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARGMIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'MIN_BY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArgMin'>>, 'ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Array'>>, 'ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAgg'>>, 'ARRAY_ALL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAll'>>, 'ARRAY_ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayAny'>>, 'ARRAY_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayConcat'>>, 'ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayContains'>>, 'FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_FILTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayFilter'>>, 'ARRAY_OVERLAPS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayOverlaps'>>, 'ARRAY_SIZE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySize'>>, 'ARRAY_SORT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySort'>>, 'ARRAY_SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'ARRAY_TO_STRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_JOIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayToString'>>, 'ARRAY_UNION_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUnionAgg'>>, 'ARRAY_UNIQUE_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArrayUniqueAgg'>>, 'AVG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Avg'>>, 'CASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Case'>>, 'CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cast'>>, 'CAST_TO_STR_TYPE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CastToStrType'>>, 'CBRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Cbrt'>>, 'CEIL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CEILING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ceil'>>, 'CHR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Chr'>>, 'COALESCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'IFNULL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'NVL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Coalesce'>>, 'COLLATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Collate'>>, 'COMBINED_AGG_FUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedAggFunc'>>, 'COMBINED_PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CombinedParameterizedAgg'>>, 'CONCAT': <function Parser.<lambda>>, 'CONCAT_WS': <function Parser.<lambda>>, 'CONNECT_BY_ROOT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ConnectByRoot'>>, 'CONVERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Convert'>>, 'CORR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Corr'>>, 'COUNT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Count'>>, 'COUNT_IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CountIf'>>, 'COUNTIF': <function _build_count_if>, 'COVAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarPop'>>, 'COVAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CovarSamp'>>, 'CURRENT_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDate'>>, 'CURRENT_DATETIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentDatetime'>>, 'CURRENT_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTime'>>, 'CURRENT_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentTimestamp'>>, 'CURRENT_USER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.CurrentUser'>>, 'DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Date'>>, 'DATE_ADD': <function ClickHouse.Parser.<lambda>>, 'DATEDIFF': <function ClickHouse.Parser.<lambda>>, 'DATE_DIFF': <function ClickHouse.Parser.<lambda>>, 'DATE_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateFromParts'>>, 'DATE_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateStrToDate'>>, 'DATE_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateSub'>>, 'DATE_TO_DATE_STR': <function Parser.<lambda>>, 'DATE_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateToDi'>>, 'DATE_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DateTrunc'>>, 'DATETIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeAdd'>>, 'DATETIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeDiff'>>, 'DATETIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeSub'>>, 'DATETIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DatetimeTrunc'>>, 'DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Day'>>, 'DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAYOFMONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfMonth'>>, 'DAY_OF_WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAYOFWEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfWeek'>>, 'DAY_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DAYOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DayOfYear'>>, 'DECODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Decode'>>, 'DI_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.DiToDate'>>, 'ENCODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Encode'>>, 'EXP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Exp'>>, 'EXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Explode'>>, 'EXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ExplodeOuter'>>, 'EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Extract'>>, 'FIRST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.First'>>, 'FIRST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FirstValue'>>, 'FLATTEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Flatten'>>, 'FLOOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Floor'>>, 'FROM_BASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase'>>, 'FROM_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.FromBase64'>>, 'GENERATE_DATE_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateDateArray'>>, 'GENERATE_SERIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GenerateSeries'>>, 'GREATEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Greatest'>>, 'GROUP_CONCAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.GroupConcat'>>, 'HEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hex'>>, 'HLL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Hll'>>, 'IF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'IIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.If'>>, 'INITCAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Initcap'>>, 'IS_INF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'ISINF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsInf'>>, 'IS_NAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'ISNAN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.IsNan'>>, 'J_S_O_N_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArray'>>, 'J_S_O_N_ARRAY_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayAgg'>>, 'JSON_ARRAY_CONTAINS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONArrayContains'>>, 'JSONB_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtract'>>, 'JSONB_EXTRACT_SCALAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONBExtractScalar'>>, 'JSON_EXTRACT': <function build_extract_json_with_path.<locals>._builder>, 'JSON_EXTRACT_SCALAR': <function build_extract_json_with_path.<locals>._builder>, 'JSON_FORMAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONFormat'>>, 'J_S_O_N_OBJECT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObject'>>, 'J_S_O_N_OBJECT_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONObjectAgg'>>, 'J_S_O_N_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.JSONTable'>>, 'LAG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lag'>>, 'LAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Last'>>, 'LAST_DAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_DAY_OF_MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastDay'>>, 'LAST_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LastValue'>>, 'LEAD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lead'>>, 'LEAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Least'>>, 'LEFT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Left'>>, 'LENGTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Length'>>, 'LEVENSHTEIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Levenshtein'>>, 'LN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Ln'>>, 'LOG': <function build_logarithm>, 'LOGICAL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOL_AND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'BOOLAND_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalAnd'>>, 'LOGICAL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOL_OR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'BOOLOR_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.LogicalOr'>>, 'LOWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'LCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Lower'>>, 'MD5': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5'>>, 'MD5_DIGEST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MD5Digest'>>, 'MAP': <function build_var_map>, 'MAP_FROM_ENTRIES': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MapFromEntries'>>, 'MATCH_AGAINST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MatchAgainst'>>, 'MAX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Max'>>, 'MIN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Min'>>, 'MONTH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Month'>>, 'MONTHS_BETWEEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.MonthsBetween'>>, 'NEXT_VALUE_FOR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NextValueFor'>>, 'NTH_VALUE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NthValue'>>, 'NULLIF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nullif'>>, 'NUMBER_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.NumberToStr'>>, 'NVL2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Nvl2'>>, 'OPEN_J_S_O_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.OpenJSON'>>, 'PARAMETERIZED_AGG': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParameterizedAgg'>>, 'PARSE_JSON': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'JSON_PARSE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ParseJSON'>>, 'PERCENTILE_CONT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileCont'>>, 'PERCENTILE_DISC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PercentileDisc'>>, 'POSEXPLODE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Posexplode'>>, 'POSEXPLODE_OUTER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.PosexplodeOuter'>>, 'POWER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'POW': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Pow'>>, 'PREDICT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Predict'>>, 'QUANTILE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Quantile'>>, 'RAND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDOM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'RANDN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Randn'>>, 'RANGE_N': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RangeN'>>, 'READ_CSV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ReadCSV'>>, 'REDUCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Reduce'>>, 'REGEXP_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpExtract'>>, 'REGEXP_I_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpILike'>>, 'REGEXP_LIKE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'REGEXP_REPLACE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpReplace'>>, 'REGEXP_SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpSplit'>>, 'REPEAT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Repeat'>>, 'RIGHT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Right'>>, 'ROUND': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Round'>>, 'ROW_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RowNumber'>>, 'SHA': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA1': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA'>>, 'SHA2': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SHA2'>>, 'SAFE_DIVIDE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SafeDivide'>>, 'SIGN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SIGNUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sign'>>, 'SORT_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.SortArray'>>, 'SPLIT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Split'>>, 'SQRT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sqrt'>>, 'STANDARD_HASH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StandardHash'>>, 'STAR_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StarMap'>>, 'STARTS_WITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STARTSWITH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StartsWith'>>, 'STDDEV': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stddev'>>, 'STDDEV_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevPop'>>, 'STDDEV_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StddevSamp'>>, 'STR_POSITION': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrPosition'>>, 'STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToDate'>>, 'STR_TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToMap'>>, 'STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToTime'>>, 'STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StrToUnix'>>, 'STRUCT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'STRUCT_EXTRACT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.StructExtract'>>, 'STUFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'INSERT': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Stuff'>>, 'SUBSTRING': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Substring'>>, 'SUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Sum'>>, 'TIME_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeAdd'>>, 'TIME_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeDiff'>>, 'TIME_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIMEFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeFromParts'>>, 'TIME_STR_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToDate'>>, 'TIME_STR_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToTime'>>, 'TIME_STR_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeStrToUnix'>>, 'TIME_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeSub'>>, 'TIME_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToStr'>>, 'TIME_TO_TIME_STR': <function Parser.<lambda>>, 'TIME_TO_UNIX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeToUnix'>>, 'TIME_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimeTrunc'>>, 'TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Timestamp'>>, 'TIMESTAMP_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampAdd'>>, 'TIMESTAMPDIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampDiff'>>, 'TIMESTAMP_FROM_PARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMPFROMPARTS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampFromParts'>>, 'TIMESTAMP_SUB': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampSub'>>, 'TIMESTAMP_TRUNC': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TimestampTrunc'>>, 'TO_ARRAY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToArray'>>, 'TO_BASE64': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToBase64'>>, 'TO_CHAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToChar'>>, 'TO_DAYS': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToDays'>>, 'TO_MAP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToMap'>>, 'TO_NUMBER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ToNumber'>>, 'TRANSFORM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Transform'>>, 'TRIM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Trim'>>, 'TRY_CAST': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TryCast'>>, 'TS_OR_DI_TO_DI': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDiToDi'>>, 'TS_OR_DS_ADD': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsAdd'>>, 'TS_OR_DS_DIFF': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsDiff'>>, 'TS_OR_DS_TO_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToDate'>>, 'TS_OR_DS_TO_DATE_STR': <function Parser.<lambda>>, 'TS_OR_DS_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTime'>>, 'TS_OR_DS_TO_TIMESTAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.TsOrDsToTimestamp'>>, 'UNHEX': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Unhex'>>, 'UNIX_DATE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixDate'>>, 'UNIX_TO_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToStr'>>, 'UNIX_TO_TIME': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTime'>>, 'UNIX_TO_TIME_STR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.UnixToTimeStr'>>, 'UPPER': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'UCASE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Upper'>>, 'VAR_MAP': <function build_var_map>, 'VARIANCE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VAR_SAMP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Variance'>>, 'VARIANCE_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'VAR_POP': <bound method Func.from_arg_list of <class 'sqlglot.expressions.VariancePop'>>, 'WEEK': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Week'>>, 'WEEK_OF_YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WEEKOFYEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.WeekOfYear'>>, 'WHEN': <bound method Func.from_arg_list of <class 'sqlglot.expressions.When'>>, 'X_M_L_TABLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.XMLTable'>>, 'XOR': <function ClickHouse.Parser.<lambda>>, 'YEAR': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Year'>>, 'GLOB': <function Parser.<lambda>>, 'JSON_EXTRACT_PATH_TEXT': <function build_extract_json_with_path.<locals>._builder>, 'LIKE': <function build_like>, 'LOG2': <function Parser.<lambda>>, 'LOG10': <function Parser.<lambda>>, 'MOD': <function Parser.<lambda>>, 'ANY': <bound method Func.from_arg_list of <class 'sqlglot.expressions.AnyValue'>>, 'ARRAYSUM': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ArraySum'>>, 'DATEADD': <function ClickHouse.Parser.<lambda>>, 'JSONEXTRACTSTRING': <function build_json_extract_path.<locals>._builder>, 'MATCH': <bound method Func.from_arg_list of <class 'sqlglot.expressions.RegexpLike'>>, 'RANDCANONICAL': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Rand'>>, 'TUPLE': <bound method Func.from_arg_list of <class 'sqlglot.expressions.Struct'>>, 'UNIQ': <bound method Func.from_arg_list of <class 'sqlglot.expressions.ApproxDistinct'>>}
AGG_FUNCTIONS =
{'contingency', 'quantileGK', 'quantilesTiming', 'groupBitmapOr', 'theilsU', 'quantilesExact', 'exponentialMovingAverage', 'topKWeighted', 'entropy', 'uniqCombined64', 'quantileBFloat16Weighted', 'simpleLinearRegression', 'kurtSamp', 'argMax', 'quantileDeterministic', 'uniqCombined', 'stochasticLinearRegression', 'varSamp', 'kurtPop', 'uniq', 'quantilesExactWeighted', 'sumKahan', 'groupUniqArray', 'quantileTimingWeighted', 'avg', 'varPop', 'sumMap', 'quantilesTimingWeighted', 'groupBitXor', 'quantilesGK', 'groupBitmapAnd', 'maxIntersectionsPosition', 'rankCorr', 'welchTTest', 'stddevPop', 'mannWhitneyUTest', 'quantileExact', 'median', 'any', 'avgWeighted', 'uniqTheta', 'quantiles', 'groupBitAnd', 'groupArraySample', 'groupArray', 'quantilesTDigestWeighted', 'maxMap', 'intervalLengthSum', 'quantileExactLow', 'quantileBFloat16', 'cramersVBiasCorrected', 'uniqExact', 'kolmogorovSmirnovTest', 'groupBitmap', 'groupArrayLast', 'sumWithOverflow', 'anyLast', 'deltaSumTimestamp', 'quantilesBFloat16', 'covarPop', 'quantilesBFloat16Weighted', 'quantilesDeterministic', 'studentTTest', 'quantileTDigestWeighted', 'meanZTest', 'quantileTDigest', 'quantileInterpolatedWeighted', 'min', 'quantileExactHigh', 'quantilesTDigest', 'quantilesInterpolatedWeighted', 'first_value', 'argMin', 'corr', 'quantileTiming', 'last_value', 'quantilesExactHigh', 'skewSamp', 'sumCount', 'count', 'groupBitmapXor', 'cramersV', 'largestTriangleThreeBuckets', 'uniqHLL12', 'quantileExactWeighted', 'groupBitOr', 'deltaSum', 'groupArrayMovingAvg', 'covarSamp', 'quantilesExactLow', 'groupArrayMovingSum', 'skewPop', 'stochasticLogisticRegression', 'anyHeavy', 'minMap', 'stddevSamp', 'boundingRatio', 'groupArrayInsertAt', 'max', 'topK', 'quantile', 'maxIntersections', 'categoricalInformationValue', 'sparkBar', 'sum'}
AGG_FUNCTIONS_SUFFIXES =
['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
FUNC_TOKENS =
{<TokenType.INT256: 'INT256'>, <TokenType.INET: 'INET'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.IPV6: 'IPV6'>, <TokenType.FORMAT: 'FORMAT'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.TEXT: 'TEXT'>, <TokenType.LIKE: 'LIKE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.ENUM: 'ENUM'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIME: 'TIME'>, <TokenType.IPV4: 'IPV4'>, <TokenType.UINT: 'UINT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.RLIKE: 'RLIKE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SET: 'SET'>, <TokenType.INT128: 'INT128'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.ILIKE: 'ILIKE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.UUID: 'UUID'>, <TokenType.NAME: 'NAME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.ROW: 'ROW'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.IDENTIFIER: 'IDENTIFIER'>, <TokenType.XOR: 'XOR'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TABLE: 'TABLE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.VAR: 'VAR'>, <TokenType.LEFT: 'LEFT'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.INDEX: 'INDEX'>, <TokenType.SUPER: 'SUPER'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.FIRST: 'FIRST'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.UNNEST: 'UNNEST'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.SOME: 'SOME'>, <TokenType.NESTED: 'NESTED'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.GLOB: 'GLOB'>, <TokenType.JSON: 'JSON'>, <TokenType.MAP: 'MAP'>, <TokenType.XML: 'XML'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATE: 'DATE'>, <TokenType.ALL: 'ALL'>, <TokenType.INSERT: 'INSERT'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.INT: 'INT'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.PRIMARY_KEY: 'PRIMARY_KEY'>, <TokenType.ANY: 'ANY'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.BIT: 'BIT'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.UINT128: 'UINT128'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>}
AGG_FUNC_MAPPING =
{'contingencyIf': ('contingency', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'theilsUIf': ('theilsU', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'entropyIf': ('entropy', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'argMaxIf': ('argMax', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'varSampIf': ('varSamp', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'uniqIf': ('uniq', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'avgIf': ('avg', 'If'), 'varPopIf': ('varPop', 'If'), 'sumMapIf': ('sumMap', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'medianIf': ('median', 'If'), 'anyIf': ('any', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'quantilesIf': ('quantiles', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'maxMapIf': ('maxMap', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'anyLastIf': ('anyLast', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'covarPopIf': ('covarPop', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'minIf': ('min', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'first_valueIf': ('first_value', 'If'), 'argMinIf': ('argMin', 'If'), 'corrIf': ('corr', 'If'), 'quantileTimingIf': ('quantileTiming', 'If'), 'last_valueIf': ('last_value', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'sumCountIf': ('sumCount', 'If'), 'countIf': ('count', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'cramersVIf': ('cramersV', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'skewPopIf': ('skewPop', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'minMapIf': ('minMap', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'maxIf': ('max', 'If'), 'topKIf': ('topK', 'If'), 'quantileIf': ('quantile', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'sumIf': ('sum', 'If'), 'contingencyArray': ('contingency', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'entropyArray': ('entropy', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'uniqArray': ('uniq', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'avgArray': ('avg', 'Array'), 'varPopArray': ('varPop', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'medianArray': ('median', 'Array'), 'anyArray': ('any', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'minArray': ('min', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'argMinArray': ('argMin', 'Array'), 'corrArray': ('corr', 'Array'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'countArray': ('count', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'minMapArray': ('minMap', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'maxArray': ('max', 'Array'), 'topKArray': ('topK', 'Array'), 'quantileArray': ('quantile', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'sumArray': ('sum', 'Array'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'contingencyMap': ('contingency', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'entropyMap': ('entropy', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'uniqMap': ('uniq', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'avgMap': ('avg', 'Map'), 'varPopMap': ('varPop', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'medianMap': ('median', 'Map'), 'anyMap': ('any', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'maxMapMap': ('maxMap', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'studentTTestMap': ('studentTTest', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'minMap': ('minMap', ''), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'argMinMap': ('argMin', 'Map'), 'corrMap': ('corr', 'Map'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'countMap': ('count', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'minMapMap': ('minMap', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'maxMap': ('maxMap', ''), 'topKMap': ('topK', 'Map'), 'quantileMap': ('quantile', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'sumMap': ('sumMap', ''), 'contingencySimpleState': ('contingency', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'contingencyState': ('contingency', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'theilsUState': ('theilsU', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'entropyState': ('entropy', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'argMaxState': ('argMax', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'varSampState': ('varSamp', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'uniqState': ('uniq', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'avgState': ('avg', 'State'), 'varPopState': ('varPop', 'State'), 'sumMapState': ('sumMap', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'medianState': ('median', 'State'), 'anyState': ('any', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'quantilesState': ('quantiles', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'groupArrayState': ('groupArray', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'maxMapState': ('maxMap', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'anyLastState': ('anyLast', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'covarPopState': ('covarPop', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'minState': ('min', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'first_valueState': ('first_value', 'State'), 'argMinState': ('argMin', 'State'), 'corrState': ('corr', 'State'), 'quantileTimingState': ('quantileTiming', 'State'), 'last_valueState': ('last_value', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'skewSampState': ('skewSamp', 'State'), 'sumCountState': ('sumCount', 'State'), 'countState': ('count', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'cramersVState': ('cramersV', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'covarSampState': ('covarSamp', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'skewPopState': ('skewPop', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'minMapState': ('minMap', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'maxState': ('max', 'State'), 'topKState': ('topK', 'State'), 'quantileState': ('quantile', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'sumState': ('sum', 'State'), 'contingencyMerge': ('contingency', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'medianMerge': ('median', 'Merge'), 'anyMerge': ('any', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'minMerge': ('min', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'countMerge': ('count', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'maxMerge': ('max', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'contingencyMergeState': ('contingency', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'contingencyForEach': ('contingency', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'contingencyDistinct': ('contingency', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'contingencyOrNull': ('contingency', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'contingencyResample': ('contingency', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'avgResample': ('avg', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'medianResample': ('median', 'Resample'), 'anyResample': ('any', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'minResample': ('min', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'corrResample': ('corr', 'Resample'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'countResample': ('count', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'maxResample': ('max', 'Resample'), 'topKResample': ('topK', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'sumResample': ('sum', 'Resample'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'contingency': ('contingency', ''), 'quantileGK': ('quantileGK', ''), 'quantilesTiming': ('quantilesTiming', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'theilsU': ('theilsU', ''), 'quantilesExact': ('quantilesExact', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'topKWeighted': ('topKWeighted', ''), 'entropy': ('entropy', ''), 'uniqCombined64': ('uniqCombined64', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'kurtSamp': ('kurtSamp', ''), 'argMax': ('argMax', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'uniqCombined': ('uniqCombined', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'varSamp': ('varSamp', ''), 'kurtPop': ('kurtPop', ''), 'uniq': ('uniq', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'sumKahan': ('sumKahan', ''), 'groupUniqArray': ('groupUniqArray', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'avg': ('avg', ''), 'varPop': ('varPop', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'groupBitXor': ('groupBitXor', ''), 'quantilesGK': ('quantilesGK', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'rankCorr': ('rankCorr', ''), 'welchTTest': ('welchTTest', ''), 'stddevPop': ('stddevPop', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'quantileExact': ('quantileExact', ''), 'median': ('median', ''), 'any': ('any', ''), 'avgWeighted': ('avgWeighted', ''), 'uniqTheta': ('uniqTheta', ''), 'quantiles': ('quantiles', ''), 'groupBitAnd': ('groupBitAnd', ''), 'groupArraySample': ('groupArraySample', ''), 'groupArray': ('groupArray', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'quantileExactLow': ('quantileExactLow', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'uniqExact': ('uniqExact', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'groupBitmap': ('groupBitmap', ''), 'groupArrayLast': ('groupArrayLast', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'anyLast': ('anyLast', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'covarPop': ('covarPop', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'studentTTest': ('studentTTest', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'meanZTest': ('meanZTest', ''), 'quantileTDigest': ('quantileTDigest', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'min': ('min', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'first_value': ('first_value', ''), 'argMin': ('argMin', ''), 'corr': ('corr', ''), 'quantileTiming': ('quantileTiming', ''), 'last_value': ('last_value', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'skewSamp': ('skewSamp', ''), 'sumCount': ('sumCount', ''), 'count': ('count', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'cramersV': ('cramersV', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'uniqHLL12': ('uniqHLL12', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'groupBitOr': ('groupBitOr', ''), 'deltaSum': ('deltaSum', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'covarSamp': ('covarSamp', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'skewPop': ('skewPop', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'anyHeavy': ('anyHeavy', ''), 'stddevSamp': ('stddevSamp', ''), 'boundingRatio': ('boundingRatio', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'max': ('max', ''), 'topK': ('topK', ''), 'quantile': ('quantile', ''), 'maxIntersections': ('maxIntersections', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'sparkBar': ('sparkBar', ''), 'sum': ('sum', '')}
FUNCTION_PARSERS =
{'CAST': <function Parser.<lambda>>, 'CONVERT': <function Parser.<lambda>>, 'DECODE': <function Parser.<lambda>>, 'EXTRACT': <function Parser.<lambda>>, 'JSON_OBJECT': <function Parser.<lambda>>, 'JSON_OBJECTAGG': <function Parser.<lambda>>, 'JSON_TABLE': <function Parser.<lambda>>, 'OPENJSON': <function Parser.<lambda>>, 'POSITION': <function Parser.<lambda>>, 'PREDICT': <function Parser.<lambda>>, 'SAFE_CAST': <function Parser.<lambda>>, 'STRING_AGG': <function Parser.<lambda>>, 'SUBSTRING': <function Parser.<lambda>>, 'TRIM': <function Parser.<lambda>>, 'TRY_CAST': <function Parser.<lambda>>, 'TRY_CONVERT': <function Parser.<lambda>>, 'ARRAYJOIN': <function ClickHouse.Parser.<lambda>>, 'QUANTILE': <function ClickHouse.Parser.<lambda>>}
NO_PAREN_FUNCTION_PARSERS =
{'CASE': <function Parser.<lambda>>, 'IF': <function Parser.<lambda>>, 'NEXT': <function Parser.<lambda>>}
RANGE_PARSERS =
{<TokenType.BETWEEN: 'BETWEEN'>: <function Parser.<lambda>>, <TokenType.GLOB: 'GLOB'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.ILIKE: 'ILIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IN: 'IN'>: <function Parser.<lambda>>, <TokenType.IRLIKE: 'IRLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.IS: 'IS'>: <function Parser.<lambda>>, <TokenType.LIKE: 'LIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.OVERLAPS: 'OVERLAPS'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.RLIKE: 'RLIKE'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.SIMILAR_TO: 'SIMILAR_TO'>: <function binary_range_parser.<locals>.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.GLOBAL: 'GLOBAL'>: <function ClickHouse.Parser.<lambda>>}
COLUMN_OPERATORS =
{<TokenType.DOT: 'DOT'>: None, <TokenType.DCOLON: 'DCOLON'>: <function Parser.<lambda>>, <TokenType.ARROW: 'ARROW'>: <function Parser.<lambda>>, <TokenType.DARROW: 'DARROW'>: <function Parser.<lambda>>, <TokenType.HASH_ARROW: 'HASH_ARROW'>: <function Parser.<lambda>>, <TokenType.DHASH_ARROW: 'DHASH_ARROW'>: <function Parser.<lambda>>}
JOIN_KINDS =
{<TokenType.ANY: 'ANY'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ASOF: 'ASOF'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.CROSS: 'CROSS'>, <TokenType.ANTI: 'ANTI'>, <TokenType.SEMI: 'SEMI'>, <TokenType.INNER: 'INNER'>}
TABLE_ALIAS_TOKENS =
{<TokenType.INT256: 'INT256'>, <TokenType.TOP: 'TOP'>, <TokenType.INET: 'INET'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.ASC: 'ASC'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FALSE: 'FALSE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.VIEW: 'VIEW'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIME: 'TIME'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.UINT: 'UINT'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SET: 'SET'>, <TokenType.INT128: 'INT128'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.UUID: 'UUID'>, <TokenType.NAME: 'NAME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.ROW: 'ROW'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TABLE: 'TABLE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.FILTER: 'FILTER'>, <TokenType.KILL: 'KILL'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.VAR: 'VAR'>, <TokenType.END: 'END'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.SUPER: 'SUPER'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DELETE: 'DELETE'>, <TokenType.CASE: 'CASE'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.FIRST: 'FIRST'>, <TokenType.TRUE: 'TRUE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.DIV: 'DIV'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.SOME: 'SOME'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.NESTED: 'NESTED'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.JSON: 'JSON'>, <TokenType.MAP: 'MAP'>, <TokenType.XML: 'XML'>, <TokenType.ROWS: 'ROWS'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.DESC: 'DESC'>, <TokenType.ALL: 'ALL'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATE: 'DATE'>, <TokenType.USE: 'USE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.MODEL: 'MODEL'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.INT: 'INT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.LOAD: 'LOAD'>, <TokenType.IS: 'IS'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.CACHE: 'CACHE'>, <TokenType.BIT: 'BIT'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.UINT128: 'UINT128'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.TINYTEXT: 'TINYTEXT'>}
ALIAS_TOKENS =
{<TokenType.INT256: 'INT256'>, <TokenType.ASOF: 'ASOF'>, <TokenType.TOP: 'TOP'>, <TokenType.INET: 'INET'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.ASC: 'ASC'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.SHOW: 'SHOW'>, <TokenType.FALSE: 'FALSE'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.IPV6: 'IPV6'>, <TokenType.VIEW: 'VIEW'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.TEXT: 'TEXT'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.ENUM: 'ENUM'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.DATE32: 'DATE32'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIME: 'TIME'>, <TokenType.APPLY: 'APPLY'>, <TokenType.IPV4: 'IPV4'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.UINT: 'UINT'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ANTI: 'ANTI'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SET: 'SET'>, <TokenType.INT128: 'INT128'>, <TokenType.SEMI: 'SEMI'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.RANGE: 'RANGE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.UUID: 'UUID'>, <TokenType.NAME: 'NAME'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.ROW: 'ROW'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.TABLE: 'TABLE'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.FILTER: 'FILTER'>, <TokenType.KILL: 'KILL'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.VAR: 'VAR'>, <TokenType.LEFT: 'LEFT'>, <TokenType.END: 'END'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.SUPER: 'SUPER'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.NEXT: 'NEXT'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.DELETE: 'DELETE'>, <TokenType.CASE: 'CASE'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.FULL: 'FULL'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.FIRST: 'FIRST'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TRUE: 'TRUE'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.DIV: 'DIV'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.CHAR: 'CHAR'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.MERGE: 'MERGE'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.KEEP: 'KEEP'>, <TokenType.MONEY: 'MONEY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.SOME: 'SOME'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.NESTED: 'NESTED'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.JSON: 'JSON'>, <TokenType.MAP: 'MAP'>, <TokenType.XML: 'XML'>, <TokenType.ROWS: 'ROWS'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.DESC: 'DESC'>, <TokenType.ALL: 'ALL'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.NULL: 'NULL'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.DATE: 'DATE'>, <TokenType.USE: 'USE'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.MODEL: 'MODEL'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.INT: 'INT'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.LOAD: 'LOAD'>, <TokenType.IS: 'IS'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.FINAL: 'FINAL'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.JSONB: 'JSONB'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.ANY: 'ANY'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.UINT256: 'UINT256'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.CACHE: 'CACHE'>, <TokenType.BIT: 'BIT'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.UINT128: 'UINT128'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.TINYTEXT: 'TINYTEXT'>}
QUERY_MODIFIER_PARSERS =
{<TokenType.MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'>: <function Parser.<lambda>>, <TokenType.PREWHERE: 'PREWHERE'>: <function Parser.<lambda>>, <TokenType.WHERE: 'WHERE'>: <function Parser.<lambda>>, <TokenType.GROUP_BY: 'GROUP_BY'>: <function Parser.<lambda>>, <TokenType.HAVING: 'HAVING'>: <function Parser.<lambda>>, <TokenType.QUALIFY: 'QUALIFY'>: <function Parser.<lambda>>, <TokenType.WINDOW: 'WINDOW'>: <function Parser.<lambda>>, <TokenType.ORDER_BY: 'ORDER_BY'>: <function Parser.<lambda>>, <TokenType.LIMIT: 'LIMIT'>: <function Parser.<lambda>>, <TokenType.FETCH: 'FETCH'>: <function Parser.<lambda>>, <TokenType.OFFSET: 'OFFSET'>: <function Parser.<lambda>>, <TokenType.FOR: 'FOR'>: <function Parser.<lambda>>, <TokenType.LOCK: 'LOCK'>: <function Parser.<lambda>>, <TokenType.TABLE_SAMPLE: 'TABLE_SAMPLE'>: <function Parser.<lambda>>, <TokenType.USING: 'USING'>: <function Parser.<lambda>>, <TokenType.CLUSTER_BY: 'CLUSTER_BY'>: <function Parser.<lambda>>, <TokenType.DISTRIBUTE_BY: 'DISTRIBUTE_BY'>: <function Parser.<lambda>>, <TokenType.SORT_BY: 'SORT_BY'>: <function Parser.<lambda>>, <TokenType.CONNECT_BY: 'CONNECT_BY'>: <function Parser.<lambda>>, <TokenType.START_WITH: 'START_WITH'>: <function Parser.<lambda>>, <TokenType.SETTINGS: 'SETTINGS'>: <function ClickHouse.Parser.<lambda>>, <TokenType.FORMAT: 'FORMAT'>: <function ClickHouse.Parser.<lambda>>}
CONSTRAINT_PARSERS =
{'AUTOINCREMENT': <function Parser.<lambda>>, 'AUTO_INCREMENT': <function Parser.<lambda>>, 'CASESPECIFIC': <function Parser.<lambda>>, 'CHARACTER SET': <function Parser.<lambda>>, 'CHECK': <function Parser.<lambda>>, 'COLLATE': <function Parser.<lambda>>, 'COMMENT': <function Parser.<lambda>>, 'COMPRESS': <function Parser.<lambda>>, 'CLUSTERED': <function Parser.<lambda>>, 'NONCLUSTERED': <function Parser.<lambda>>, 'DEFAULT': <function Parser.<lambda>>, 'ENCODE': <function Parser.<lambda>>, 'EXCLUDE': <function Parser.<lambda>>, 'FOREIGN KEY': <function Parser.<lambda>>, 'FORMAT': <function Parser.<lambda>>, 'GENERATED': <function Parser.<lambda>>, 'IDENTITY': <function Parser.<lambda>>, 'INLINE': <function Parser.<lambda>>, 'LIKE': <function Parser.<lambda>>, 'NOT': <function Parser.<lambda>>, 'NULL': <function Parser.<lambda>>, 'ON': <function Parser.<lambda>>, 'PATH': <function Parser.<lambda>>, 'PERIOD': <function Parser.<lambda>>, 'PRIMARY KEY': <function Parser.<lambda>>, 'REFERENCES': <function Parser.<lambda>>, 'TITLE': <function Parser.<lambda>>, 'TTL': <function Parser.<lambda>>, 'UNIQUE': <function Parser.<lambda>>, 'UPPERCASE': <function Parser.<lambda>>, 'WITH': <function Parser.<lambda>>, 'INDEX': <function ClickHouse.Parser.<lambda>>, 'CODEC': <function ClickHouse.Parser.<lambda>>}
SCHEMA_UNNAMED_CONSTRAINTS =
{'FOREIGN KEY', 'UNIQUE', 'EXCLUDE', 'LIKE', 'CHECK', 'PRIMARY KEY', 'PERIOD', 'INDEX'}
SET_TRIE: Dict =
{'GLOBAL': {0: True}, 'LOCAL': {0: True}, 'SESSION': {0: True}, 'TRANSACTION': {0: True}}
Inherited Members
- sqlglot.parser.Parser
- Parser
- NO_PAREN_FUNCTIONS
- STRUCT_TYPE_TOKENS
- NESTED_TYPE_TOKENS
- ENUM_TYPE_TOKENS
- AGGREGATE_TYPE_TOKENS
- TYPE_TOKENS
- SIGNED_TO_UNSIGNED_TYPE_TOKEN
- SUBQUERY_PREDICATES
- RESERVED_TOKENS
- DB_CREATABLES
- CREATABLES
- ID_VAR_TOKENS
- INTERVAL_VARS
- COMMENT_TABLE_ALIAS_TOKENS
- UPDATE_ALIAS_TOKENS
- TRIM_TYPES
- CONJUNCTION
- EQUALITY
- COMPARISON
- BITWISE
- TERM
- FACTOR
- EXPONENT
- TIMES
- TIMESTAMPS
- SET_OPERATIONS
- JOIN_METHODS
- JOIN_SIDES
- JOIN_HINTS
- LAMBDAS
- EXPRESSION_PARSERS
- STATEMENT_PARSERS
- UNARY_PARSERS
- STRING_PARSERS
- NUMERIC_PARSERS
- PRIMARY_PARSERS
- PLACEHOLDER_PARSERS
- PROPERTY_PARSERS
- ALTER_PARSERS
- INVALID_FUNC_NAME_TOKENS
- KEY_VALUE_DEFINITIONS
- SET_PARSERS
- SHOW_PARSERS
- TYPE_LITERAL_PARSERS
- DDL_SELECT_TOKENS
- PRE_VOLATILE_TOKENS
- TRANSACTION_KIND
- TRANSACTION_CHARACTERISTICS
- CONFLICT_ACTIONS
- CREATE_SEQUENCE
- ISOLATED_LOADING_OPTIONS
- USABLES
- CAST_ACTIONS
- INSERT_ALTERNATIVES
- CLONE_KEYWORDS
- HISTORICAL_DATA_KIND
- OPCLASS_FOLLOW_KEYWORDS
- OPTYPE_FOLLOW_TOKENS
- TABLE_INDEX_HINT_TOKENS
- VIEW_ATTRIBUTES
- WINDOW_ALIAS_TOKENS
- WINDOW_BEFORE_PAREN_TOKENS
- WINDOW_SIDES
- JSON_KEY_VALUE_SEPARATOR_TOKENS
- FETCH_TOKENS
- ADD_CONSTRAINT_TOKENS
- DISTINCT_TOKENS
- NULL_TOKENS
- UNNEST_OFFSET_ALIAS_TOKENS
- SELECT_START_TOKENS
- STRICT_CAST
- PREFIXED_PIVOT_COLUMNS
- IDENTIFY_PIVOT_STRINGS
- ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN
- TABLESAMPLE_CSV
- SET_REQUIRES_ASSIGNMENT_DELIMITER
- TRIM_PATTERN_FIRST
- STRING_ALIASES
- UNION_MODIFIERS
- NO_PAREN_IF_COMMANDS
- JSON_ARROWS_REQUIRE_JSON_TYPE
- VALUES_FOLLOWED_BY_PAREN
- SUPPORTS_IMPLICIT_UNNEST
- error_level
- error_message_context
- max_errors
- dialect
- reset
- parse
- parse_into
- check_errors
- raise_error
- expression
- validate_expression
- errors
- sql
553 class Generator(generator.Generator): 554 QUERY_HINTS = False 555 STRUCT_DELIMITER = ("(", ")") 556 NVL2_SUPPORTED = False 557 TABLESAMPLE_REQUIRES_PARENS = False 558 TABLESAMPLE_SIZE_IS_ROWS = False 559 TABLESAMPLE_KEYWORDS = "SAMPLE" 560 LAST_DAY_SUPPORTS_DATE_PART = False 561 CAN_IMPLEMENT_ARRAY_ANY = True 562 SUPPORTS_TO_NUMBER = False 563 564 STRING_TYPE_MAPPING = { 565 exp.DataType.Type.CHAR: "String", 566 exp.DataType.Type.LONGBLOB: "String", 567 exp.DataType.Type.LONGTEXT: "String", 568 exp.DataType.Type.MEDIUMBLOB: "String", 569 exp.DataType.Type.MEDIUMTEXT: "String", 570 exp.DataType.Type.TINYBLOB: "String", 571 exp.DataType.Type.TINYTEXT: "String", 572 exp.DataType.Type.TEXT: "String", 573 exp.DataType.Type.VARBINARY: "String", 574 exp.DataType.Type.VARCHAR: "String", 575 } 576 577 SUPPORTED_JSON_PATH_PARTS = { 578 exp.JSONPathKey, 579 exp.JSONPathRoot, 580 exp.JSONPathSubscript, 581 } 582 583 TYPE_MAPPING = { 584 **generator.Generator.TYPE_MAPPING, 585 **STRING_TYPE_MAPPING, 586 exp.DataType.Type.ARRAY: "Array", 587 exp.DataType.Type.BIGINT: "Int64", 588 exp.DataType.Type.DATE32: "Date32", 589 exp.DataType.Type.DATETIME64: "DateTime64", 590 exp.DataType.Type.DOUBLE: "Float64", 591 exp.DataType.Type.ENUM: "Enum", 592 exp.DataType.Type.ENUM8: "Enum8", 593 exp.DataType.Type.ENUM16: "Enum16", 594 exp.DataType.Type.FIXEDSTRING: "FixedString", 595 exp.DataType.Type.FLOAT: "Float32", 596 exp.DataType.Type.INT: "Int32", 597 exp.DataType.Type.MEDIUMINT: "Int32", 598 exp.DataType.Type.INT128: "Int128", 599 exp.DataType.Type.INT256: "Int256", 600 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 601 exp.DataType.Type.MAP: "Map", 602 exp.DataType.Type.NESTED: "Nested", 603 exp.DataType.Type.NULLABLE: "Nullable", 604 exp.DataType.Type.SMALLINT: "Int16", 605 exp.DataType.Type.STRUCT: "Tuple", 606 exp.DataType.Type.TINYINT: "Int8", 607 exp.DataType.Type.UBIGINT: "UInt64", 608 exp.DataType.Type.UINT: "UInt32", 609 exp.DataType.Type.UINT128: "UInt128", 610 exp.DataType.Type.UINT256: "UInt256", 611 exp.DataType.Type.USMALLINT: "UInt16", 612 exp.DataType.Type.UTINYINT: "UInt8", 613 exp.DataType.Type.IPV4: "IPv4", 614 exp.DataType.Type.IPV6: "IPv6", 615 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 616 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 617 } 618 619 TRANSFORMS = { 620 **generator.Generator.TRANSFORMS, 621 exp.AnyValue: rename_func("any"), 622 exp.ApproxDistinct: rename_func("uniq"), 623 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 624 exp.ArraySize: rename_func("LENGTH"), 625 exp.ArraySum: rename_func("arraySum"), 626 exp.ArgMax: arg_max_or_min_no_count("argMax"), 627 exp.ArgMin: arg_max_or_min_no_count("argMin"), 628 exp.Array: inline_array_sql, 629 exp.CastToStrType: rename_func("CAST"), 630 exp.CountIf: rename_func("countIf"), 631 exp.CompressColumnConstraint: lambda self, 632 e: f"CODEC({self.expressions(e, key='this', flat=True)})", 633 exp.ComputedColumnConstraint: lambda self, e: f"ALIAS {self.sql(e, 'this')}", 634 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 635 exp.DateAdd: date_delta_sql("DATE_ADD"), 636 exp.DateDiff: date_delta_sql("DATE_DIFF"), 637 exp.Explode: rename_func("arrayJoin"), 638 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 639 exp.IsNan: rename_func("isNaN"), 640 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 641 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 642 exp.JSONPathKey: json_path_key_only_name, 643 exp.JSONPathRoot: lambda *_: "", 644 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 645 exp.Nullif: rename_func("nullIf"), 646 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 647 exp.Pivot: no_pivot_sql, 648 exp.Quantile: _quantile_sql, 649 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 650 exp.Rand: rename_func("randCanonical"), 651 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 652 exp.StartsWith: rename_func("startsWith"), 653 exp.StrPosition: lambda self, e: self.func( 654 "position", e.this, e.args.get("substr"), e.args.get("position") 655 ), 656 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 657 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 658 } 659 660 PROPERTIES_LOCATION = { 661 **generator.Generator.PROPERTIES_LOCATION, 662 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 663 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 664 exp.OnCluster: exp.Properties.Location.POST_NAME, 665 } 666 667 JOIN_HINTS = False 668 TABLE_HINTS = False 669 EXPLICIT_UNION = True 670 GROUPINGS_SEP = "" 671 672 # there's no list in docs, but it can be found in Clickhouse code 673 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 674 ON_CLUSTER_TARGETS = { 675 "DATABASE", 676 "TABLE", 677 "VIEW", 678 "DICTIONARY", 679 "INDEX", 680 "FUNCTION", 681 "NAMED COLLECTION", 682 } 683 684 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 685 this = self.json_path_part(expression.this) 686 return str(int(this) + 1) if is_int(this) else this 687 688 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 689 return f"AS {self.sql(expression, 'this')}" 690 691 def _any_to_has( 692 self, 693 expression: exp.EQ | exp.NEQ, 694 default: t.Callable[[t.Any], str], 695 prefix: str = "", 696 ) -> str: 697 if isinstance(expression.left, exp.Any): 698 arr = expression.left 699 this = expression.right 700 elif isinstance(expression.right, exp.Any): 701 arr = expression.right 702 this = expression.left 703 else: 704 return default(expression) 705 706 return prefix + self.func("has", arr.this.unnest(), this) 707 708 def eq_sql(self, expression: exp.EQ) -> str: 709 return self._any_to_has(expression, super().eq_sql) 710 711 def neq_sql(self, expression: exp.NEQ) -> str: 712 return self._any_to_has(expression, super().neq_sql, "NOT ") 713 714 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 715 # Manually add a flag to make the search case-insensitive 716 regex = self.func("CONCAT", "'(?i)'", expression.expression) 717 return self.func("match", expression.this, regex) 718 719 def datatype_sql(self, expression: exp.DataType) -> str: 720 # String is the standard ClickHouse type, every other variant is just an alias. 721 # Additionally, any supplied length parameter will be ignored. 722 # 723 # https://clickhouse.com/docs/en/sql-reference/data-types/string 724 if expression.this in self.STRING_TYPE_MAPPING: 725 return "String" 726 727 return super().datatype_sql(expression) 728 729 def cte_sql(self, expression: exp.CTE) -> str: 730 if expression.args.get("scalar"): 731 this = self.sql(expression, "this") 732 alias = self.sql(expression, "alias") 733 return f"{this} AS {alias}" 734 735 return super().cte_sql(expression) 736 737 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 738 return super().after_limit_modifiers(expression) + [ 739 ( 740 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 741 if expression.args.get("settings") 742 else "" 743 ), 744 ( 745 self.seg("FORMAT ") + self.sql(expression, "format") 746 if expression.args.get("format") 747 else "" 748 ), 749 ] 750 751 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 752 params = self.expressions(expression, key="params", flat=True) 753 return self.func(expression.name, *expression.expressions) + f"({params})" 754 755 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 756 return self.func(expression.name, *expression.expressions) 757 758 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 759 return self.anonymousaggfunc_sql(expression) 760 761 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 762 return self.parameterizedagg_sql(expression) 763 764 def placeholder_sql(self, expression: exp.Placeholder) -> str: 765 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 766 767 def oncluster_sql(self, expression: exp.OnCluster) -> str: 768 return f"ON CLUSTER {self.sql(expression, 'this')}" 769 770 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 771 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 772 exp.Properties.Location.POST_NAME 773 ): 774 this_name = self.sql(expression.this, "this") 775 this_properties = " ".join( 776 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 777 ) 778 this_schema = self.schema_columns_sql(expression.this) 779 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 780 781 return super().createable_sql(expression, locations) 782 783 def prewhere_sql(self, expression: exp.PreWhere) -> str: 784 this = self.indent(self.sql(expression, "this")) 785 return f"{self.seg('PREWHERE')}{self.sep()}{this}" 786 787 def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str: 788 this = self.sql(expression, "this") 789 this = f" {this}" if this else "" 790 expr = self.sql(expression, "expression") 791 expr = f" {expr}" if expr else "" 792 index_type = self.sql(expression, "index_type") 793 index_type = f" TYPE {index_type}" if index_type else "" 794 granularity = self.sql(expression, "granularity") 795 granularity = f" GRANULARITY {granularity}" if granularity else "" 796 797 return f"INDEX{this}{expr}{index_type}{granularity}"
Generator converts a given syntax tree to the corresponding SQL string.
Arguments:
- pretty: Whether to format the produced SQL string. Default: False.
- identify: Determines when an identifier should be quoted. Possible values are: False (default): Never quote, except in cases where it's mandatory by the dialect. True or 'always': Always quote. 'safe': Only quote identifiers that are case insensitive.
- normalize: Whether to normalize identifiers to lowercase. Default: False.
- pad: The pad size in a formatted string. For example, this affects the indentation of a projection in a query, relative to its nesting level. Default: 2.
- indent: The indentation size in a formatted string. For example, this affects the
indentation of subqueries and filters under a
WHERE
clause. Default: 2. - normalize_functions: How to normalize function names. Possible values are: "upper" or True (default): Convert names to uppercase. "lower": Convert names to lowercase. False: Disables function name normalization.
- unsupported_level: Determines the generator's behavior when it encounters unsupported expressions. Default ErrorLevel.WARN.
- max_unsupported: Maximum number of unsupported messages to include in a raised UnsupportedError. This is only relevant if unsupported_level is ErrorLevel.RAISE. Default: 3
- leading_comma: Whether the comma is leading or trailing in select expressions. This is only relevant when generating in pretty mode. Default: False
- max_text_width: The max number of characters in a segment before creating new lines in pretty mode. The default is on the smaller end because the length only represents a segment and not the true line length. Default: 80
- comments: Whether to preserve comments in the output SQL code. Default: True
STRING_TYPE_MAPPING =
{<Type.CHAR: 'CHAR'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String'}
SUPPORTED_JSON_PATH_PARTS =
{<class 'sqlglot.expressions.JSONPathSubscript'>, <class 'sqlglot.expressions.JSONPathRoot'>, <class 'sqlglot.expressions.JSONPathKey'>}
TYPE_MAPPING =
{<Type.NCHAR: 'NCHAR'>: 'CHAR', <Type.NVARCHAR: 'NVARCHAR'>: 'VARCHAR', <Type.MEDIUMTEXT: 'MEDIUMTEXT'>: 'String', <Type.LONGTEXT: 'LONGTEXT'>: 'String', <Type.TINYTEXT: 'TINYTEXT'>: 'String', <Type.MEDIUMBLOB: 'MEDIUMBLOB'>: 'String', <Type.LONGBLOB: 'LONGBLOB'>: 'String', <Type.TINYBLOB: 'TINYBLOB'>: 'String', <Type.INET: 'INET'>: 'INET', <Type.CHAR: 'CHAR'>: 'String', <Type.TEXT: 'TEXT'>: 'String', <Type.VARBINARY: 'VARBINARY'>: 'String', <Type.VARCHAR: 'VARCHAR'>: 'String', <Type.ARRAY: 'ARRAY'>: 'Array', <Type.BIGINT: 'BIGINT'>: 'Int64', <Type.DATE32: 'DATE32'>: 'Date32', <Type.DATETIME64: 'DATETIME64'>: 'DateTime64', <Type.DOUBLE: 'DOUBLE'>: 'Float64', <Type.ENUM: 'ENUM'>: 'Enum', <Type.ENUM8: 'ENUM8'>: 'Enum8', <Type.ENUM16: 'ENUM16'>: 'Enum16', <Type.FIXEDSTRING: 'FIXEDSTRING'>: 'FixedString', <Type.FLOAT: 'FLOAT'>: 'Float32', <Type.INT: 'INT'>: 'Int32', <Type.MEDIUMINT: 'MEDIUMINT'>: 'Int32', <Type.INT128: 'INT128'>: 'Int128', <Type.INT256: 'INT256'>: 'Int256', <Type.LOWCARDINALITY: 'LOWCARDINALITY'>: 'LowCardinality', <Type.MAP: 'MAP'>: 'Map', <Type.NESTED: 'NESTED'>: 'Nested', <Type.NULLABLE: 'NULLABLE'>: 'Nullable', <Type.SMALLINT: 'SMALLINT'>: 'Int16', <Type.STRUCT: 'STRUCT'>: 'Tuple', <Type.TINYINT: 'TINYINT'>: 'Int8', <Type.UBIGINT: 'UBIGINT'>: 'UInt64', <Type.UINT: 'UINT'>: 'UInt32', <Type.UINT128: 'UINT128'>: 'UInt128', <Type.UINT256: 'UINT256'>: 'UInt256', <Type.USMALLINT: 'USMALLINT'>: 'UInt16', <Type.UTINYINT: 'UTINYINT'>: 'UInt8', <Type.IPV4: 'IPV4'>: 'IPv4', <Type.IPV6: 'IPV6'>: 'IPv6', <Type.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>: 'AggregateFunction', <Type.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>: 'SimpleAggregateFunction'}
TRANSFORMS =
{<class 'sqlglot.expressions.JSONPathKey'>: <function json_path_key_only_name>, <class 'sqlglot.expressions.JSONPathRoot'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.JSONPathSubscript'>: <function <lambda>>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.BackupProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CaseSpecificColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CharacterSetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CollateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CommentColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DateAdd'>: <function date_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.DateFormatColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.DefaultColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.EncodeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExcludeColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ExternalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.GlobalProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.HeapProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IcebergProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InheritsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InlineLengthColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.InputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.IntervalSpan'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.JSONExtract'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.JSONExtractScalar'>: <function json_extract_segments.<locals>._json_extract_segments>, <class 'sqlglot.expressions.LanguageProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LocationProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.LogProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.MaterializedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NonClusteredColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.NotForReplicationColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnCommitProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OnUpdateColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.OutputModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.PathColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ReturnsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SampleProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetConfigProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SetProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SettingsProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SharingProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.StabilityProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TemporaryProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TitleColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.Timestamp'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToMap'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.ToTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransformModelProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.TransientProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UppercaseColumnConstraint'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.UnloggedProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VarMap'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.VolatileProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.WithOperator'>: <function Generator.<lambda>>, <class 'sqlglot.expressions.AnyValue'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ApproxDistinct'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArrayFilter'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ArraySize'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArraySum'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.ArgMax'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.ArgMin'>: <function arg_max_or_min_no_count.<locals>._arg_max_or_min_sql>, <class 'sqlglot.expressions.Array'>: <function inline_array_sql>, <class 'sqlglot.expressions.CastToStrType'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CountIf'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.CompressColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.ComputedColumnConstraint'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.CurrentDate'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.DateDiff'>: <function date_delta_sql.<locals>._delta_sql>, <class 'sqlglot.expressions.Explode'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Final'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.IsNan'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Map'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Nullif'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.PartitionedByProperty'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Pivot'>: <function no_pivot_sql>, <class 'sqlglot.expressions.Quantile'>: <function _quantile_sql>, <class 'sqlglot.expressions.RegexpLike'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Rand'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.Select'>: <function preprocess.<locals>._to_sql>, <class 'sqlglot.expressions.StartsWith'>: <function rename_func.<locals>.<lambda>>, <class 'sqlglot.expressions.StrPosition'>: <function ClickHouse.Generator.<lambda>>, <class 'sqlglot.expressions.Xor'>: <function ClickHouse.Generator.<lambda>>}
PROPERTIES_LOCATION =
{<class 'sqlglot.expressions.AlgorithmProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.AutoIncrementProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.AutoRefreshProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BackupProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.BlockCompressionProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CharacterSetProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ChecksumProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.CollateProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.CopyGrantsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Cluster'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ClusteredByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DataBlocksizeProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.DefinerProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.DictRange'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DictProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.DistStyleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.EngineProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExecuteAsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ExternalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.FallbackProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.FileFormatProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.FreespaceProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.GlobalProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.HeapProperty'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.InheritsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IcebergProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.InputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.IsolatedLoadingProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.JournalProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.LanguageProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LikeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LocationProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.LockingProperty'>: <Location.POST_ALIAS: 'POST_ALIAS'>, <class 'sqlglot.expressions.LogProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.MaterializedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.MergeBlockRatioProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.NoPrimaryIndexProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.OnProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCommitProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.Order'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OutputModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedByProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PartitionedOfProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.PrimaryKey'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Property'>: <Location.POST_WITH: 'POST_WITH'>, <class 'sqlglot.expressions.RemoteWithConnectionModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.ReturnsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatDelimitedProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.RowFormatSerdeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SampleProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SchemaCommentProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SerdeProperties'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.Set'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SettingsProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SetProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.SetConfigProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SharingProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SequenceProperties'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.SortKeyProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlReadWriteProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.SqlSecurityProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.StabilityProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TemporaryProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ToTableProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.TransientProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.TransformModelProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.MergeTreeTTL'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.UnloggedProperty'>: <Location.POST_CREATE: 'POST_CREATE'>, <class 'sqlglot.expressions.ViewAttributeProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.VolatileProperty'>: <Location.UNSUPPORTED: 'UNSUPPORTED'>, <class 'sqlglot.expressions.WithDataProperty'>: <Location.POST_EXPRESSION: 'POST_EXPRESSION'>, <class 'sqlglot.expressions.WithJournalTableProperty'>: <Location.POST_NAME: 'POST_NAME'>, <class 'sqlglot.expressions.WithSystemVersioningProperty'>: <Location.POST_SCHEMA: 'POST_SCHEMA'>, <class 'sqlglot.expressions.OnCluster'>: <Location.POST_NAME: 'POST_NAME'>}
ON_CLUSTER_TARGETS =
{'DICTIONARY', 'VIEW', 'FUNCTION', 'NAMED COLLECTION', 'DATABASE', 'INDEX', 'TABLE'}
719 def datatype_sql(self, expression: exp.DataType) -> str: 720 # String is the standard ClickHouse type, every other variant is just an alias. 721 # Additionally, any supplied length parameter will be ignored. 722 # 723 # https://clickhouse.com/docs/en/sql-reference/data-types/string 724 if expression.this in self.STRING_TYPE_MAPPING: 725 return "String" 726 727 return super().datatype_sql(expression)
737 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 738 return super().after_limit_modifiers(expression) + [ 739 ( 740 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 741 if expression.args.get("settings") 742 else "" 743 ), 744 ( 745 self.seg("FORMAT ") + self.sql(expression, "format") 746 if expression.args.get("format") 747 else "" 748 ), 749 ]
def
combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
770 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 771 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 772 exp.Properties.Location.POST_NAME 773 ): 774 this_name = self.sql(expression.this, "this") 775 this_properties = " ".join( 776 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 777 ) 778 this_schema = self.schema_columns_sql(expression.this) 779 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 780 781 return super().createable_sql(expression, locations)
787 def indexcolumnconstraint_sql(self, expression: exp.IndexColumnConstraint) -> str: 788 this = self.sql(expression, "this") 789 this = f" {this}" if this else "" 790 expr = self.sql(expression, "expression") 791 expr = f" {expr}" if expr else "" 792 index_type = self.sql(expression, "index_type") 793 index_type = f" TYPE {index_type}" if index_type else "" 794 granularity = self.sql(expression, "granularity") 795 granularity = f" GRANULARITY {granularity}" if granularity else "" 796 797 return f"INDEX{this}{expr}{index_type}{granularity}"
AFTER_HAVING_MODIFIER_TRANSFORMS =
{'qualify': <function Generator.<lambda>>, 'windows': <function Generator.<lambda>>}
Inherited Members
- sqlglot.generator.Generator
- Generator
- NULL_ORDERING_SUPPORTED
- IGNORE_NULLS_IN_FUNC
- LOCKING_READS_SUPPORTED
- WRAP_DERIVED_VALUES
- CREATE_FUNCTION_RETURN_AS
- MATCHED_BY_SOURCE
- SINGLE_STRING_INTERVAL
- INTERVAL_ALLOWS_PLURAL_FORM
- LIMIT_FETCH
- LIMIT_ONLY_LITERALS
- RENAME_TABLE_WITH_DB
- INDEX_ON
- QUERY_HINT_SEP
- IS_BOOL_ALLOWED
- DUPLICATE_KEY_UPDATE_WITH_SET
- LIMIT_IS_TOP
- RETURNING_END
- COLUMN_JOIN_MARKS_SUPPORTED
- EXTRACT_ALLOWS_QUOTES
- TZ_TO_WITH_TIME_ZONE
- VALUES_AS_TABLE
- ALTER_TABLE_INCLUDE_COLUMN_KEYWORD
- UNNEST_WITH_ORDINALITY
- AGGREGATE_FILTER_SUPPORTED
- SEMI_ANTI_JOIN_WITH_SIDE
- COMPUTED_COLUMN_WITH_TYPE
- SUPPORTS_TABLE_COPY
- TABLESAMPLE_WITH_METHOD
- TABLESAMPLE_SEED_KEYWORD
- COLLATE_IS_FUNC
- DATA_TYPE_SPECIFIERS_ALLOWED
- ENSURE_BOOLS
- CTE_RECURSIVE_KEYWORD_REQUIRED
- SUPPORTS_SINGLE_ARG_CONCAT
- SUPPORTS_TABLE_ALIAS_COLUMNS
- UNPIVOT_ALIASES_ARE_IDENTIFIERS
- JSON_KEY_VALUE_PAIR_SEP
- INSERT_OVERWRITE
- SUPPORTS_SELECT_INTO
- SUPPORTS_UNLOGGED_TABLES
- SUPPORTS_CREATE_TABLE_LIKE
- LIKE_PROPERTY_INSIDE_SCHEMA
- MULTI_ARG_DISTINCT
- JSON_TYPE_REQUIRED_FOR_EXTRACTION
- JSON_PATH_BRACKETED_KEY_SUPPORTED
- JSON_PATH_SINGLE_QUOTE_ESCAPE
- STAR_MAPPING
- TIME_PART_SINGULARS
- TOKEN_MAPPING
- PARAMETER_TOKEN
- NAMED_PLACEHOLDER_TOKEN
- RESERVED_KEYWORDS
- WITH_SEPARATED_COMMENTS
- EXCLUDE_COMMENTS
- UNWRAPPED_INTERVAL_VALUES
- PARAMETERIZABLE_TEXT_TYPES
- EXPRESSIONS_WITHOUT_NESTED_CTES
- SENTINEL_LINE_BREAK
- pretty
- identify
- normalize
- pad
- unsupported_level
- max_unsupported
- leading_comma
- max_text_width
- comments
- dialect
- normalize_functions
- unsupported_messages
- generate
- preprocess
- unsupported
- sep
- seg
- pad_comment
- maybe_comment
- wrap
- no_identify
- normalize_func
- indent
- sql
- uncache_sql
- cache_sql
- characterset_sql
- column_sql
- columnposition_sql
- columndef_sql
- columnconstraint_sql
- computedcolumnconstraint_sql
- autoincrementcolumnconstraint_sql
- compresscolumnconstraint_sql
- generatedasidentitycolumnconstraint_sql
- generatedasrowcolumnconstraint_sql
- periodforsystemtimeconstraint_sql
- notnullcolumnconstraint_sql
- transformcolumnconstraint_sql
- primarykeycolumnconstraint_sql
- uniquecolumnconstraint_sql
- create_sql
- sequenceproperties_sql
- clone_sql
- describe_sql
- heredoc_sql
- prepend_ctes
- with_sql
- tablealias_sql
- bitstring_sql
- hexstring_sql
- bytestring_sql
- unicodestring_sql
- rawstring_sql
- datatypeparam_sql
- directory_sql
- delete_sql
- drop_sql
- except_sql
- except_op
- fetch_sql
- filter_sql
- hint_sql
- indexparameters_sql
- index_sql
- identifier_sql
- inputoutputformat_sql
- national_sql
- partition_sql
- properties_sql
- root_properties
- properties
- with_properties
- locate_properties
- property_name
- property_sql
- fallbackproperty_sql
- journalproperty_sql
- freespaceproperty_sql
- checksumproperty_sql
- mergeblockratioproperty_sql
- datablocksizeproperty_sql
- blockcompressionproperty_sql
- isolatedloadingproperty_sql
- partitionboundspec_sql
- partitionedofproperty_sql
- lockingproperty_sql
- withdataproperty_sql
- withsystemversioningproperty_sql
- insert_sql
- intersect_sql
- intersect_op
- introducer_sql
- kill_sql
- pseudotype_sql
- objectidentifier_sql
- onconflict_sql
- returning_sql
- rowformatdelimitedproperty_sql
- withtablehint_sql
- indextablehint_sql
- historicaldata_sql
- table_parts
- table_sql
- tablesample_sql
- pivot_sql
- version_sql
- tuple_sql
- update_sql
- values_sql
- var_sql
- into_sql
- from_sql
- group_sql
- having_sql
- connect_sql
- prior_sql
- join_sql
- lambda_sql
- lateral_op
- lateral_sql
- limit_sql
- offset_sql
- setitem_sql
- set_sql
- pragma_sql
- lock_sql
- literal_sql
- escape_str
- loaddata_sql
- null_sql
- boolean_sql
- order_sql
- withfill_sql
- cluster_sql
- distribute_sql
- sort_sql
- ordered_sql
- matchrecognize_sql
- query_modifiers
- queryoption_sql
- offset_limit_modifiers
- select_sql
- schema_sql
- schema_columns_sql
- star_sql
- parameter_sql
- sessionparameter_sql
- subquery_sql
- qualify_sql
- set_operations
- union_sql
- union_op
- unnest_sql
- where_sql
- window_sql
- partition_by_sql
- windowspec_sql
- withingroup_sql
- between_sql
- bracket_sql
- all_sql
- any_sql
- exists_sql
- case_sql
- constraint_sql
- nextvaluefor_sql
- extract_sql
- trim_sql
- convert_concat_args
- concat_sql
- concatws_sql
- check_sql
- foreignkey_sql
- primarykey_sql
- if_sql
- matchagainst_sql
- jsonkeyvalue_sql
- jsonpath_sql
- json_path_part
- formatjson_sql
- jsonobject_sql
- jsonobjectagg_sql
- jsonarray_sql
- jsonarrayagg_sql
- jsoncolumndef_sql
- jsonschema_sql
- jsontable_sql
- openjsoncolumndef_sql
- openjson_sql
- in_sql
- in_unnest_op
- interval_sql
- return_sql
- reference_sql
- anonymous_sql
- paren_sql
- neg_sql
- not_sql
- alias_sql
- pivotalias_sql
- aliases_sql
- atindex_sql
- attimezone_sql
- fromtimezone_sql
- add_sql
- and_sql
- or_sql
- xor_sql
- connector_sql
- bitwiseand_sql
- bitwiseleftshift_sql
- bitwisenot_sql
- bitwiseor_sql
- bitwiserightshift_sql
- bitwisexor_sql
- cast_sql
- currentdate_sql
- currenttimestamp_sql
- collate_sql
- command_sql
- comment_sql
- mergetreettlaction_sql
- mergetreettl_sql
- transaction_sql
- commit_sql
- rollback_sql
- altercolumn_sql
- renametable_sql
- renamecolumn_sql
- altertable_sql
- add_column_sql
- droppartition_sql
- addconstraint_sql
- distinct_sql
- ignorenulls_sql
- respectnulls_sql
- havingmax_sql
- intdiv_sql
- dpipe_sql
- div_sql
- overlaps_sql
- distance_sql
- dot_sql
- propertyeq_sql
- escape_sql
- glob_sql
- gt_sql
- gte_sql
- ilike_sql
- ilikeany_sql
- is_sql
- like_sql
- likeany_sql
- similarto_sql
- lt_sql
- lte_sql
- mod_sql
- mul_sql
- nullsafeeq_sql
- nullsafeneq_sql
- slice_sql
- sub_sql
- trycast_sql
- log_sql
- use_sql
- binary
- function_fallback_sql
- func
- format_args
- text_width
- format_time
- expressions
- op_expressions
- naked_property
- tag_sql
- token_sql
- userdefinedfunction_sql
- joinhint_sql
- kwarg_sql
- when_sql
- merge_sql
- tochar_sql
- tonumber_sql
- dictproperty_sql
- dictrange_sql
- dictsubproperty_sql
- clusteredbyproperty_sql
- anyvalue_sql
- querytransform_sql
- indexconstraintoption_sql
- checkcolumnconstraint_sql
- nvl2_sql
- comprehension_sql
- columnprefix_sql
- opclass_sql
- predict_sql
- forin_sql
- refresh_sql
- operator_sql
- toarray_sql
- tsordstotime_sql
- tsordstotimestamp_sql
- tsordstodate_sql
- unixdate_sql
- lastday_sql
- arrayany_sql
- generateseries_sql
- struct_sql
- partitionrange_sql
- truncatetable_sql
- convert_sql