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.errors import ParseError 19from sqlglot.helper import is_int, seq_get 20from sqlglot.tokens import Token, TokenType 21 22 23def _lower_func(sql: str) -> str: 24 index = sql.index("(") 25 return sql[:index].lower() + sql[index:] 26 27 28def _quantile_sql(self: ClickHouse.Generator, expression: exp.Quantile) -> str: 29 quantile = expression.args["quantile"] 30 args = f"({self.sql(expression, 'this')})" 31 32 if isinstance(quantile, exp.Array): 33 func = self.func("quantiles", *quantile) 34 else: 35 func = self.func("quantile", quantile) 36 37 return func + args 38 39 40def _build_count_if(args: t.List) -> exp.CountIf | exp.CombinedAggFunc: 41 if len(args) == 1: 42 return exp.CountIf(this=seq_get(args, 0)) 43 44 return exp.CombinedAggFunc(this="countIf", expressions=args, parts=("count", "If")) 45 46 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 ESCAPE_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 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 AGG_FUNC_MAPPING = ( 265 lambda functions, suffixes: { 266 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 267 } 268 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 269 270 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 271 272 FUNCTION_PARSERS = { 273 **parser.Parser.FUNCTION_PARSERS, 274 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 275 "QUANTILE": lambda self: self._parse_quantile(), 276 } 277 278 FUNCTION_PARSERS.pop("MATCH") 279 280 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 281 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 282 283 RANGE_PARSERS = { 284 **parser.Parser.RANGE_PARSERS, 285 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 286 and self._parse_in(this, is_global=True), 287 } 288 289 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 290 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 291 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 292 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 293 294 JOIN_KINDS = { 295 *parser.Parser.JOIN_KINDS, 296 TokenType.ANY, 297 TokenType.ASOF, 298 TokenType.ARRAY, 299 } 300 301 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 302 TokenType.ANY, 303 TokenType.ARRAY, 304 TokenType.FINAL, 305 TokenType.FORMAT, 306 TokenType.SETTINGS, 307 } 308 309 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 310 TokenType.FORMAT, 311 } 312 313 LOG_DEFAULTS_TO_LN = True 314 315 QUERY_MODIFIER_PARSERS = { 316 **parser.Parser.QUERY_MODIFIER_PARSERS, 317 TokenType.SETTINGS: lambda self: ( 318 "settings", 319 self._advance() or self._parse_csv(self._parse_conjunction), 320 ), 321 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 322 } 323 324 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 325 this = super()._parse_conjunction() 326 327 if self._match(TokenType.PLACEHOLDER): 328 return self.expression( 329 exp.If, 330 this=this, 331 true=self._parse_conjunction(), 332 false=self._match(TokenType.COLON) and self._parse_conjunction(), 333 ) 334 335 return this 336 337 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 338 """ 339 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 340 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 341 """ 342 if not self._match(TokenType.L_BRACE): 343 return None 344 345 this = self._parse_id_var() 346 self._match(TokenType.COLON) 347 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 348 self._match_text_seq("IDENTIFIER") and "Identifier" 349 ) 350 351 if not kind: 352 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 353 elif not self._match(TokenType.R_BRACE): 354 self.raise_error("Expecting }") 355 356 return self.expression(exp.Placeholder, this=this, kind=kind) 357 358 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 359 this = super()._parse_in(this) 360 this.set("is_global", is_global) 361 return this 362 363 def _parse_table( 364 self, 365 schema: bool = False, 366 joins: bool = False, 367 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 368 parse_bracket: bool = False, 369 is_db_reference: bool = False, 370 ) -> t.Optional[exp.Expression]: 371 this = super()._parse_table( 372 schema=schema, 373 joins=joins, 374 alias_tokens=alias_tokens, 375 parse_bracket=parse_bracket, 376 is_db_reference=is_db_reference, 377 ) 378 379 if self._match(TokenType.FINAL): 380 this = self.expression(exp.Final, this=this) 381 382 return this 383 384 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 385 return super()._parse_position(haystack_first=True) 386 387 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 388 def _parse_cte(self) -> exp.CTE: 389 index = self._index 390 try: 391 # WITH <identifier> AS <subquery expression> 392 return super()._parse_cte() 393 except ParseError: 394 # WITH <expression> AS <identifier> 395 self._retreat(index) 396 397 return self.expression( 398 exp.CTE, 399 this=self._parse_conjunction(), 400 alias=self._parse_table_alias(), 401 scalar=True, 402 ) 403 404 def _parse_join_parts( 405 self, 406 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 407 is_global = self._match(TokenType.GLOBAL) and self._prev 408 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 409 410 if kind_pre: 411 kind = self._match_set(self.JOIN_KINDS) and self._prev 412 side = self._match_set(self.JOIN_SIDES) and self._prev 413 return is_global, side, kind 414 415 return ( 416 is_global, 417 self._match_set(self.JOIN_SIDES) and self._prev, 418 self._match_set(self.JOIN_KINDS) and self._prev, 419 ) 420 421 def _parse_join( 422 self, skip_join_token: bool = False, parse_bracket: bool = False 423 ) -> t.Optional[exp.Join]: 424 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 425 if join: 426 join.set("global", join.args.pop("method", None)) 427 428 return join 429 430 def _parse_function( 431 self, 432 functions: t.Optional[t.Dict[str, t.Callable]] = None, 433 anonymous: bool = False, 434 optional_parens: bool = True, 435 ) -> t.Optional[exp.Expression]: 436 func = super()._parse_function( 437 functions=functions, anonymous=anonymous, optional_parens=optional_parens 438 ) 439 440 if isinstance(func, exp.Anonymous): 441 parts = self.AGG_FUNC_MAPPING.get(func.this) 442 params = self._parse_func_params(func) 443 444 if params: 445 if parts and parts[1]: 446 return self.expression( 447 exp.CombinedParameterizedAgg, 448 this=func.this, 449 expressions=func.expressions, 450 params=params, 451 parts=parts, 452 ) 453 return self.expression( 454 exp.ParameterizedAgg, 455 this=func.this, 456 expressions=func.expressions, 457 params=params, 458 ) 459 460 if parts: 461 if parts[1]: 462 return self.expression( 463 exp.CombinedAggFunc, 464 this=func.this, 465 expressions=func.expressions, 466 parts=parts, 467 ) 468 return self.expression( 469 exp.AnonymousAggFunc, 470 this=func.this, 471 expressions=func.expressions, 472 ) 473 474 return func 475 476 def _parse_func_params( 477 self, this: t.Optional[exp.Func] = None 478 ) -> t.Optional[t.List[exp.Expression]]: 479 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 480 return self._parse_csv(self._parse_lambda) 481 482 if self._match(TokenType.L_PAREN): 483 params = self._parse_csv(self._parse_lambda) 484 self._match_r_paren(this) 485 return params 486 487 return None 488 489 def _parse_quantile(self) -> exp.Quantile: 490 this = self._parse_lambda() 491 params = self._parse_func_params() 492 if params: 493 return self.expression(exp.Quantile, this=params[0], quantile=this) 494 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 495 496 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 497 return super()._parse_wrapped_id_vars(optional=True) 498 499 def _parse_primary_key( 500 self, wrapped_optional: bool = False, in_props: bool = False 501 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 502 return super()._parse_primary_key( 503 wrapped_optional=wrapped_optional or in_props, in_props=in_props 504 ) 505 506 def _parse_on_property(self) -> t.Optional[exp.Expression]: 507 index = self._index 508 if self._match_text_seq("CLUSTER"): 509 this = self._parse_id_var() 510 if this: 511 return self.expression(exp.OnCluster, this=this) 512 else: 513 self._retreat(index) 514 return None 515 516 class Generator(generator.Generator): 517 QUERY_HINTS = False 518 STRUCT_DELIMITER = ("(", ")") 519 NVL2_SUPPORTED = False 520 TABLESAMPLE_REQUIRES_PARENS = False 521 TABLESAMPLE_SIZE_IS_ROWS = False 522 TABLESAMPLE_KEYWORDS = "SAMPLE" 523 LAST_DAY_SUPPORTS_DATE_PART = False 524 CAN_IMPLEMENT_ARRAY_ANY = True 525 SUPPORTS_TO_NUMBER = False 526 527 STRING_TYPE_MAPPING = { 528 exp.DataType.Type.CHAR: "String", 529 exp.DataType.Type.LONGBLOB: "String", 530 exp.DataType.Type.LONGTEXT: "String", 531 exp.DataType.Type.MEDIUMBLOB: "String", 532 exp.DataType.Type.MEDIUMTEXT: "String", 533 exp.DataType.Type.TINYBLOB: "String", 534 exp.DataType.Type.TINYTEXT: "String", 535 exp.DataType.Type.TEXT: "String", 536 exp.DataType.Type.VARBINARY: "String", 537 exp.DataType.Type.VARCHAR: "String", 538 } 539 540 SUPPORTED_JSON_PATH_PARTS = { 541 exp.JSONPathKey, 542 exp.JSONPathRoot, 543 exp.JSONPathSubscript, 544 } 545 546 TYPE_MAPPING = { 547 **generator.Generator.TYPE_MAPPING, 548 **STRING_TYPE_MAPPING, 549 exp.DataType.Type.ARRAY: "Array", 550 exp.DataType.Type.BIGINT: "Int64", 551 exp.DataType.Type.DATE32: "Date32", 552 exp.DataType.Type.DATETIME64: "DateTime64", 553 exp.DataType.Type.DOUBLE: "Float64", 554 exp.DataType.Type.ENUM: "Enum", 555 exp.DataType.Type.ENUM8: "Enum8", 556 exp.DataType.Type.ENUM16: "Enum16", 557 exp.DataType.Type.FIXEDSTRING: "FixedString", 558 exp.DataType.Type.FLOAT: "Float32", 559 exp.DataType.Type.INT: "Int32", 560 exp.DataType.Type.MEDIUMINT: "Int32", 561 exp.DataType.Type.INT128: "Int128", 562 exp.DataType.Type.INT256: "Int256", 563 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 564 exp.DataType.Type.MAP: "Map", 565 exp.DataType.Type.NESTED: "Nested", 566 exp.DataType.Type.NULLABLE: "Nullable", 567 exp.DataType.Type.SMALLINT: "Int16", 568 exp.DataType.Type.STRUCT: "Tuple", 569 exp.DataType.Type.TINYINT: "Int8", 570 exp.DataType.Type.UBIGINT: "UInt64", 571 exp.DataType.Type.UINT: "UInt32", 572 exp.DataType.Type.UINT128: "UInt128", 573 exp.DataType.Type.UINT256: "UInt256", 574 exp.DataType.Type.USMALLINT: "UInt16", 575 exp.DataType.Type.UTINYINT: "UInt8", 576 exp.DataType.Type.IPV4: "IPv4", 577 exp.DataType.Type.IPV6: "IPv6", 578 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 579 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 580 } 581 582 TRANSFORMS = { 583 **generator.Generator.TRANSFORMS, 584 exp.AnyValue: rename_func("any"), 585 exp.ApproxDistinct: rename_func("uniq"), 586 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 587 exp.ArraySize: rename_func("LENGTH"), 588 exp.ArraySum: rename_func("arraySum"), 589 exp.ArgMax: arg_max_or_min_no_count("argMax"), 590 exp.ArgMin: arg_max_or_min_no_count("argMin"), 591 exp.Array: inline_array_sql, 592 exp.CastToStrType: rename_func("CAST"), 593 exp.CountIf: rename_func("countIf"), 594 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 595 exp.DateAdd: date_delta_sql("DATE_ADD"), 596 exp.DateDiff: date_delta_sql("DATE_DIFF"), 597 exp.Explode: rename_func("arrayJoin"), 598 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 599 exp.IsNan: rename_func("isNaN"), 600 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 601 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 602 exp.JSONPathKey: json_path_key_only_name, 603 exp.JSONPathRoot: lambda *_: "", 604 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 605 exp.Nullif: rename_func("nullIf"), 606 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 607 exp.Pivot: no_pivot_sql, 608 exp.Quantile: _quantile_sql, 609 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 610 exp.Rand: rename_func("randCanonical"), 611 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 612 exp.StartsWith: rename_func("startsWith"), 613 exp.StrPosition: lambda self, e: self.func( 614 "position", e.this, e.args.get("substr"), e.args.get("position") 615 ), 616 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 617 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 618 } 619 620 PROPERTIES_LOCATION = { 621 **generator.Generator.PROPERTIES_LOCATION, 622 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 623 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 624 exp.OnCluster: exp.Properties.Location.POST_NAME, 625 } 626 627 JOIN_HINTS = False 628 TABLE_HINTS = False 629 EXPLICIT_UNION = True 630 GROUPINGS_SEP = "" 631 632 # there's no list in docs, but it can be found in Clickhouse code 633 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 634 ON_CLUSTER_TARGETS = { 635 "DATABASE", 636 "TABLE", 637 "VIEW", 638 "DICTIONARY", 639 "INDEX", 640 "FUNCTION", 641 "NAMED COLLECTION", 642 } 643 644 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 645 this = self.json_path_part(expression.this) 646 return str(int(this) + 1) if is_int(this) else this 647 648 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 649 return f"AS {self.sql(expression, 'this')}" 650 651 def _any_to_has( 652 self, 653 expression: exp.EQ | exp.NEQ, 654 default: t.Callable[[t.Any], str], 655 prefix: str = "", 656 ) -> str: 657 if isinstance(expression.left, exp.Any): 658 arr = expression.left 659 this = expression.right 660 elif isinstance(expression.right, exp.Any): 661 arr = expression.right 662 this = expression.left 663 else: 664 return default(expression) 665 666 return prefix + self.func("has", arr.this.unnest(), this) 667 668 def eq_sql(self, expression: exp.EQ) -> str: 669 return self._any_to_has(expression, super().eq_sql) 670 671 def neq_sql(self, expression: exp.NEQ) -> str: 672 return self._any_to_has(expression, super().neq_sql, "NOT ") 673 674 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 675 # Manually add a flag to make the search case-insensitive 676 regex = self.func("CONCAT", "'(?i)'", expression.expression) 677 return self.func("match", expression.this, regex) 678 679 def datatype_sql(self, expression: exp.DataType) -> str: 680 # String is the standard ClickHouse type, every other variant is just an alias. 681 # Additionally, any supplied length parameter will be ignored. 682 # 683 # https://clickhouse.com/docs/en/sql-reference/data-types/string 684 if expression.this in self.STRING_TYPE_MAPPING: 685 return "String" 686 687 return super().datatype_sql(expression) 688 689 def cte_sql(self, expression: exp.CTE) -> str: 690 if expression.args.get("scalar"): 691 this = self.sql(expression, "this") 692 alias = self.sql(expression, "alias") 693 return f"{this} AS {alias}" 694 695 return super().cte_sql(expression) 696 697 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 698 return super().after_limit_modifiers(expression) + [ 699 ( 700 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 701 if expression.args.get("settings") 702 else "" 703 ), 704 ( 705 self.seg("FORMAT ") + self.sql(expression, "format") 706 if expression.args.get("format") 707 else "" 708 ), 709 ] 710 711 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 712 params = self.expressions(expression, key="params", flat=True) 713 return self.func(expression.name, *expression.expressions) + f"({params})" 714 715 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 716 return self.func(expression.name, *expression.expressions) 717 718 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 719 return self.anonymousaggfunc_sql(expression) 720 721 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 722 return self.parameterizedagg_sql(expression) 723 724 def placeholder_sql(self, expression: exp.Placeholder) -> str: 725 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 726 727 def oncluster_sql(self, expression: exp.OnCluster) -> str: 728 return f"ON CLUSTER {self.sql(expression, 'this')}" 729 730 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 731 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 732 exp.Properties.Location.POST_NAME 733 ): 734 this_name = self.sql(expression.this, "this") 735 this_properties = " ".join( 736 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 737 ) 738 this_schema = self.schema_columns_sql(expression.this) 739 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 740 741 return super().createable_sql(expression, locations) 742 743 def prewhere_sql(self, expression: exp.PreWhere) -> str: 744 this = self.indent(self.sql(expression, "this")) 745 return f"{self.seg('PREWHERE')}{self.sep()}{this}"
48class ClickHouse(Dialect): 49 NORMALIZE_FUNCTIONS: bool | str = False 50 NULL_ORDERING = "nulls_are_last" 51 SUPPORTS_USER_DEFINED_TYPES = False 52 SAFE_DIVISION = True 53 LOG_BASE_FIRST: t.Optional[bool] = None 54 55 ESCAPE_SEQUENCES = { 56 "\\0": "\0", 57 } 58 59 class Tokenizer(tokens.Tokenizer): 60 COMMENTS = ["--", "#", "#!", ("/*", "*/")] 61 IDENTIFIERS = ['"', "`"] 62 STRING_ESCAPES = ["'", "\\"] 63 BIT_STRINGS = [("0b", "")] 64 HEX_STRINGS = [("0x", ""), ("0X", "")] 65 HEREDOC_STRINGS = ["$"] 66 67 KEYWORDS = { 68 **tokens.Tokenizer.KEYWORDS, 69 "ATTACH": TokenType.COMMAND, 70 "DATE32": TokenType.DATE32, 71 "DATETIME64": TokenType.DATETIME64, 72 "DICTIONARY": TokenType.DICTIONARY, 73 "ENUM8": TokenType.ENUM8, 74 "ENUM16": TokenType.ENUM16, 75 "FINAL": TokenType.FINAL, 76 "FIXEDSTRING": TokenType.FIXEDSTRING, 77 "FLOAT32": TokenType.FLOAT, 78 "FLOAT64": TokenType.DOUBLE, 79 "GLOBAL": TokenType.GLOBAL, 80 "INT256": TokenType.INT256, 81 "LOWCARDINALITY": TokenType.LOWCARDINALITY, 82 "MAP": TokenType.MAP, 83 "NESTED": TokenType.NESTED, 84 "SAMPLE": TokenType.TABLE_SAMPLE, 85 "TUPLE": TokenType.STRUCT, 86 "UINT128": TokenType.UINT128, 87 "UINT16": TokenType.USMALLINT, 88 "UINT256": TokenType.UINT256, 89 "UINT32": TokenType.UINT, 90 "UINT64": TokenType.UBIGINT, 91 "UINT8": TokenType.UTINYINT, 92 "IPV4": TokenType.IPV4, 93 "IPV6": TokenType.IPV6, 94 "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION, 95 "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION, 96 "SYSTEM": TokenType.COMMAND, 97 "PREWHERE": TokenType.PREWHERE, 98 } 99 100 SINGLE_TOKENS = { 101 **tokens.Tokenizer.SINGLE_TOKENS, 102 "$": TokenType.HEREDOC_STRING, 103 } 104 105 class Parser(parser.Parser): 106 # Tested in ClickHouse's playground, it seems that the following two queries do the same thing 107 # * select x from t1 union all select x from t2 limit 1; 108 # * select x from t1 union all (select x from t2 limit 1); 109 MODIFIERS_ATTACHED_TO_UNION = 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 AGG_FUNC_MAPPING = ( 266 lambda functions, suffixes: { 267 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 268 } 269 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 270 271 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 272 273 FUNCTION_PARSERS = { 274 **parser.Parser.FUNCTION_PARSERS, 275 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 276 "QUANTILE": lambda self: self._parse_quantile(), 277 } 278 279 FUNCTION_PARSERS.pop("MATCH") 280 281 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 282 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 283 284 RANGE_PARSERS = { 285 **parser.Parser.RANGE_PARSERS, 286 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 287 and self._parse_in(this, is_global=True), 288 } 289 290 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 291 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 292 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 293 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 294 295 JOIN_KINDS = { 296 *parser.Parser.JOIN_KINDS, 297 TokenType.ANY, 298 TokenType.ASOF, 299 TokenType.ARRAY, 300 } 301 302 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 303 TokenType.ANY, 304 TokenType.ARRAY, 305 TokenType.FINAL, 306 TokenType.FORMAT, 307 TokenType.SETTINGS, 308 } 309 310 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 311 TokenType.FORMAT, 312 } 313 314 LOG_DEFAULTS_TO_LN = True 315 316 QUERY_MODIFIER_PARSERS = { 317 **parser.Parser.QUERY_MODIFIER_PARSERS, 318 TokenType.SETTINGS: lambda self: ( 319 "settings", 320 self._advance() or self._parse_csv(self._parse_conjunction), 321 ), 322 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 323 } 324 325 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 326 this = super()._parse_conjunction() 327 328 if self._match(TokenType.PLACEHOLDER): 329 return self.expression( 330 exp.If, 331 this=this, 332 true=self._parse_conjunction(), 333 false=self._match(TokenType.COLON) and self._parse_conjunction(), 334 ) 335 336 return this 337 338 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 339 """ 340 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 341 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 342 """ 343 if not self._match(TokenType.L_BRACE): 344 return None 345 346 this = self._parse_id_var() 347 self._match(TokenType.COLON) 348 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 349 self._match_text_seq("IDENTIFIER") and "Identifier" 350 ) 351 352 if not kind: 353 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 354 elif not self._match(TokenType.R_BRACE): 355 self.raise_error("Expecting }") 356 357 return self.expression(exp.Placeholder, this=this, kind=kind) 358 359 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 360 this = super()._parse_in(this) 361 this.set("is_global", is_global) 362 return this 363 364 def _parse_table( 365 self, 366 schema: bool = False, 367 joins: bool = False, 368 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 369 parse_bracket: bool = False, 370 is_db_reference: bool = False, 371 ) -> t.Optional[exp.Expression]: 372 this = super()._parse_table( 373 schema=schema, 374 joins=joins, 375 alias_tokens=alias_tokens, 376 parse_bracket=parse_bracket, 377 is_db_reference=is_db_reference, 378 ) 379 380 if self._match(TokenType.FINAL): 381 this = self.expression(exp.Final, this=this) 382 383 return this 384 385 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 386 return super()._parse_position(haystack_first=True) 387 388 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 389 def _parse_cte(self) -> exp.CTE: 390 index = self._index 391 try: 392 # WITH <identifier> AS <subquery expression> 393 return super()._parse_cte() 394 except ParseError: 395 # WITH <expression> AS <identifier> 396 self._retreat(index) 397 398 return self.expression( 399 exp.CTE, 400 this=self._parse_conjunction(), 401 alias=self._parse_table_alias(), 402 scalar=True, 403 ) 404 405 def _parse_join_parts( 406 self, 407 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 408 is_global = self._match(TokenType.GLOBAL) and self._prev 409 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 410 411 if kind_pre: 412 kind = self._match_set(self.JOIN_KINDS) and self._prev 413 side = self._match_set(self.JOIN_SIDES) and self._prev 414 return is_global, side, kind 415 416 return ( 417 is_global, 418 self._match_set(self.JOIN_SIDES) and self._prev, 419 self._match_set(self.JOIN_KINDS) and self._prev, 420 ) 421 422 def _parse_join( 423 self, skip_join_token: bool = False, parse_bracket: bool = False 424 ) -> t.Optional[exp.Join]: 425 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 426 if join: 427 join.set("global", join.args.pop("method", None)) 428 429 return join 430 431 def _parse_function( 432 self, 433 functions: t.Optional[t.Dict[str, t.Callable]] = None, 434 anonymous: bool = False, 435 optional_parens: bool = True, 436 ) -> t.Optional[exp.Expression]: 437 func = super()._parse_function( 438 functions=functions, anonymous=anonymous, optional_parens=optional_parens 439 ) 440 441 if isinstance(func, exp.Anonymous): 442 parts = self.AGG_FUNC_MAPPING.get(func.this) 443 params = self._parse_func_params(func) 444 445 if params: 446 if parts and parts[1]: 447 return self.expression( 448 exp.CombinedParameterizedAgg, 449 this=func.this, 450 expressions=func.expressions, 451 params=params, 452 parts=parts, 453 ) 454 return self.expression( 455 exp.ParameterizedAgg, 456 this=func.this, 457 expressions=func.expressions, 458 params=params, 459 ) 460 461 if parts: 462 if parts[1]: 463 return self.expression( 464 exp.CombinedAggFunc, 465 this=func.this, 466 expressions=func.expressions, 467 parts=parts, 468 ) 469 return self.expression( 470 exp.AnonymousAggFunc, 471 this=func.this, 472 expressions=func.expressions, 473 ) 474 475 return func 476 477 def _parse_func_params( 478 self, this: t.Optional[exp.Func] = None 479 ) -> t.Optional[t.List[exp.Expression]]: 480 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 481 return self._parse_csv(self._parse_lambda) 482 483 if self._match(TokenType.L_PAREN): 484 params = self._parse_csv(self._parse_lambda) 485 self._match_r_paren(this) 486 return params 487 488 return None 489 490 def _parse_quantile(self) -> exp.Quantile: 491 this = self._parse_lambda() 492 params = self._parse_func_params() 493 if params: 494 return self.expression(exp.Quantile, this=params[0], quantile=this) 495 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 496 497 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 498 return super()._parse_wrapped_id_vars(optional=True) 499 500 def _parse_primary_key( 501 self, wrapped_optional: bool = False, in_props: bool = False 502 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 503 return super()._parse_primary_key( 504 wrapped_optional=wrapped_optional or in_props, in_props=in_props 505 ) 506 507 def _parse_on_property(self) -> t.Optional[exp.Expression]: 508 index = self._index 509 if self._match_text_seq("CLUSTER"): 510 this = self._parse_id_var() 511 if this: 512 return self.expression(exp.OnCluster, this=this) 513 else: 514 self._retreat(index) 515 return None 516 517 class Generator(generator.Generator): 518 QUERY_HINTS = False 519 STRUCT_DELIMITER = ("(", ")") 520 NVL2_SUPPORTED = False 521 TABLESAMPLE_REQUIRES_PARENS = False 522 TABLESAMPLE_SIZE_IS_ROWS = False 523 TABLESAMPLE_KEYWORDS = "SAMPLE" 524 LAST_DAY_SUPPORTS_DATE_PART = False 525 CAN_IMPLEMENT_ARRAY_ANY = True 526 SUPPORTS_TO_NUMBER = False 527 528 STRING_TYPE_MAPPING = { 529 exp.DataType.Type.CHAR: "String", 530 exp.DataType.Type.LONGBLOB: "String", 531 exp.DataType.Type.LONGTEXT: "String", 532 exp.DataType.Type.MEDIUMBLOB: "String", 533 exp.DataType.Type.MEDIUMTEXT: "String", 534 exp.DataType.Type.TINYBLOB: "String", 535 exp.DataType.Type.TINYTEXT: "String", 536 exp.DataType.Type.TEXT: "String", 537 exp.DataType.Type.VARBINARY: "String", 538 exp.DataType.Type.VARCHAR: "String", 539 } 540 541 SUPPORTED_JSON_PATH_PARTS = { 542 exp.JSONPathKey, 543 exp.JSONPathRoot, 544 exp.JSONPathSubscript, 545 } 546 547 TYPE_MAPPING = { 548 **generator.Generator.TYPE_MAPPING, 549 **STRING_TYPE_MAPPING, 550 exp.DataType.Type.ARRAY: "Array", 551 exp.DataType.Type.BIGINT: "Int64", 552 exp.DataType.Type.DATE32: "Date32", 553 exp.DataType.Type.DATETIME64: "DateTime64", 554 exp.DataType.Type.DOUBLE: "Float64", 555 exp.DataType.Type.ENUM: "Enum", 556 exp.DataType.Type.ENUM8: "Enum8", 557 exp.DataType.Type.ENUM16: "Enum16", 558 exp.DataType.Type.FIXEDSTRING: "FixedString", 559 exp.DataType.Type.FLOAT: "Float32", 560 exp.DataType.Type.INT: "Int32", 561 exp.DataType.Type.MEDIUMINT: "Int32", 562 exp.DataType.Type.INT128: "Int128", 563 exp.DataType.Type.INT256: "Int256", 564 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 565 exp.DataType.Type.MAP: "Map", 566 exp.DataType.Type.NESTED: "Nested", 567 exp.DataType.Type.NULLABLE: "Nullable", 568 exp.DataType.Type.SMALLINT: "Int16", 569 exp.DataType.Type.STRUCT: "Tuple", 570 exp.DataType.Type.TINYINT: "Int8", 571 exp.DataType.Type.UBIGINT: "UInt64", 572 exp.DataType.Type.UINT: "UInt32", 573 exp.DataType.Type.UINT128: "UInt128", 574 exp.DataType.Type.UINT256: "UInt256", 575 exp.DataType.Type.USMALLINT: "UInt16", 576 exp.DataType.Type.UTINYINT: "UInt8", 577 exp.DataType.Type.IPV4: "IPv4", 578 exp.DataType.Type.IPV6: "IPv6", 579 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 580 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 581 } 582 583 TRANSFORMS = { 584 **generator.Generator.TRANSFORMS, 585 exp.AnyValue: rename_func("any"), 586 exp.ApproxDistinct: rename_func("uniq"), 587 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 588 exp.ArraySize: rename_func("LENGTH"), 589 exp.ArraySum: rename_func("arraySum"), 590 exp.ArgMax: arg_max_or_min_no_count("argMax"), 591 exp.ArgMin: arg_max_or_min_no_count("argMin"), 592 exp.Array: inline_array_sql, 593 exp.CastToStrType: rename_func("CAST"), 594 exp.CountIf: rename_func("countIf"), 595 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 596 exp.DateAdd: date_delta_sql("DATE_ADD"), 597 exp.DateDiff: date_delta_sql("DATE_DIFF"), 598 exp.Explode: rename_func("arrayJoin"), 599 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 600 exp.IsNan: rename_func("isNaN"), 601 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 602 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 603 exp.JSONPathKey: json_path_key_only_name, 604 exp.JSONPathRoot: lambda *_: "", 605 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 606 exp.Nullif: rename_func("nullIf"), 607 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 608 exp.Pivot: no_pivot_sql, 609 exp.Quantile: _quantile_sql, 610 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 611 exp.Rand: rename_func("randCanonical"), 612 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 613 exp.StartsWith: rename_func("startsWith"), 614 exp.StrPosition: lambda self, e: self.func( 615 "position", e.this, e.args.get("substr"), e.args.get("position") 616 ), 617 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 618 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 619 } 620 621 PROPERTIES_LOCATION = { 622 **generator.Generator.PROPERTIES_LOCATION, 623 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 624 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 625 exp.OnCluster: exp.Properties.Location.POST_NAME, 626 } 627 628 JOIN_HINTS = False 629 TABLE_HINTS = False 630 EXPLICIT_UNION = True 631 GROUPINGS_SEP = "" 632 633 # there's no list in docs, but it can be found in Clickhouse code 634 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 635 ON_CLUSTER_TARGETS = { 636 "DATABASE", 637 "TABLE", 638 "VIEW", 639 "DICTIONARY", 640 "INDEX", 641 "FUNCTION", 642 "NAMED COLLECTION", 643 } 644 645 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 646 this = self.json_path_part(expression.this) 647 return str(int(this) + 1) if is_int(this) else this 648 649 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 650 return f"AS {self.sql(expression, 'this')}" 651 652 def _any_to_has( 653 self, 654 expression: exp.EQ | exp.NEQ, 655 default: t.Callable[[t.Any], str], 656 prefix: str = "", 657 ) -> str: 658 if isinstance(expression.left, exp.Any): 659 arr = expression.left 660 this = expression.right 661 elif isinstance(expression.right, exp.Any): 662 arr = expression.right 663 this = expression.left 664 else: 665 return default(expression) 666 667 return prefix + self.func("has", arr.this.unnest(), this) 668 669 def eq_sql(self, expression: exp.EQ) -> str: 670 return self._any_to_has(expression, super().eq_sql) 671 672 def neq_sql(self, expression: exp.NEQ) -> str: 673 return self._any_to_has(expression, super().neq_sql, "NOT ") 674 675 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 676 # Manually add a flag to make the search case-insensitive 677 regex = self.func("CONCAT", "'(?i)'", expression.expression) 678 return self.func("match", expression.this, regex) 679 680 def datatype_sql(self, expression: exp.DataType) -> str: 681 # String is the standard ClickHouse type, every other variant is just an alias. 682 # Additionally, any supplied length parameter will be ignored. 683 # 684 # https://clickhouse.com/docs/en/sql-reference/data-types/string 685 if expression.this in self.STRING_TYPE_MAPPING: 686 return "String" 687 688 return super().datatype_sql(expression) 689 690 def cte_sql(self, expression: exp.CTE) -> str: 691 if expression.args.get("scalar"): 692 this = self.sql(expression, "this") 693 alias = self.sql(expression, "alias") 694 return f"{this} AS {alias}" 695 696 return super().cte_sql(expression) 697 698 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 699 return super().after_limit_modifiers(expression) + [ 700 ( 701 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 702 if expression.args.get("settings") 703 else "" 704 ), 705 ( 706 self.seg("FORMAT ") + self.sql(expression, "format") 707 if expression.args.get("format") 708 else "" 709 ), 710 ] 711 712 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 713 params = self.expressions(expression, key="params", flat=True) 714 return self.func(expression.name, *expression.expressions) + f"({params})" 715 716 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 717 return self.func(expression.name, *expression.expressions) 718 719 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 720 return self.anonymousaggfunc_sql(expression) 721 722 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 723 return self.parameterizedagg_sql(expression) 724 725 def placeholder_sql(self, expression: exp.Placeholder) -> str: 726 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 727 728 def oncluster_sql(self, expression: exp.OnCluster) -> str: 729 return f"ON CLUSTER {self.sql(expression, 'this')}" 730 731 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 732 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 733 exp.Properties.Location.POST_NAME 734 ): 735 this_name = self.sql(expression.this, "this") 736 this_properties = " ".join( 737 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 738 ) 739 this_schema = self.schema_columns_sql(expression.this) 740 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 741 742 return super().createable_sql(expression, locations) 743 744 def prewhere_sql(self, expression: exp.PreWhere) -> str: 745 this = self.indent(self.sql(expression, "this")) 746 return f"{self.seg('PREWHERE')}{self.sep()}{this}"
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
)
ESCAPE_SEQUENCES =
{'\\0': '\x00'}
Mapping of an unescaped escape sequence to the corresponding character.
tokenizer_class =
<class 'ClickHouse.Tokenizer'>
parser_class =
<class 'ClickHouse.Parser'>
generator_class =
<class 'ClickHouse.Generator'>
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
59 class Tokenizer(tokens.Tokenizer): 60 COMMENTS = ["--", "#", "#!", ("/*", "*/")] 61 IDENTIFIERS = ['"', "`"] 62 STRING_ESCAPES = ["'", "\\"] 63 BIT_STRINGS = [("0b", "")] 64 HEX_STRINGS = [("0x", ""), ("0X", "")] 65 HEREDOC_STRINGS = ["$"] 66 67 KEYWORDS = { 68 **tokens.Tokenizer.KEYWORDS, 69 "ATTACH": TokenType.COMMAND, 70 "DATE32": TokenType.DATE32, 71 "DATETIME64": TokenType.DATETIME64, 72 "DICTIONARY": TokenType.DICTIONARY, 73 "ENUM8": TokenType.ENUM8, 74 "ENUM16": TokenType.ENUM16, 75 "FINAL": TokenType.FINAL, 76 "FIXEDSTRING": TokenType.FIXEDSTRING, 77 "FLOAT32": TokenType.FLOAT, 78 "FLOAT64": TokenType.DOUBLE, 79 "GLOBAL": TokenType.GLOBAL, 80 "INT256": TokenType.INT256, 81 "LOWCARDINALITY": TokenType.LOWCARDINALITY, 82 "MAP": TokenType.MAP, 83 "NESTED": TokenType.NESTED, 84 "SAMPLE": TokenType.TABLE_SAMPLE, 85 "TUPLE": TokenType.STRUCT, 86 "UINT128": TokenType.UINT128, 87 "UINT16": TokenType.USMALLINT, 88 "UINT256": TokenType.UINT256, 89 "UINT32": TokenType.UINT, 90 "UINT64": TokenType.UBIGINT, 91 "UINT8": TokenType.UTINYINT, 92 "IPV4": TokenType.IPV4, 93 "IPV6": TokenType.IPV6, 94 "AGGREGATEFUNCTION": TokenType.AGGREGATEFUNCTION, 95 "SIMPLEAGGREGATEFUNCTION": TokenType.SIMPLEAGGREGATEFUNCTION, 96 "SYSTEM": TokenType.COMMAND, 97 "PREWHERE": TokenType.PREWHERE, 98 } 99 100 SINGLE_TOKENS = { 101 **tokens.Tokenizer.SINGLE_TOKENS, 102 "$": TokenType.HEREDOC_STRING, 103 }
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'>, '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
105 class Parser(parser.Parser): 106 # Tested in ClickHouse's playground, it seems that the following two queries do the same thing 107 # * select x from t1 union all select x from t2 limit 1; 108 # * select x from t1 union all (select x from t2 limit 1); 109 MODIFIERS_ATTACHED_TO_UNION = 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 AGG_FUNC_MAPPING = ( 266 lambda functions, suffixes: { 267 f"{f}{sfx}": (f, sfx) for sfx in (suffixes + [""]) for f in functions 268 } 269 )(AGG_FUNCTIONS, AGG_FUNCTIONS_SUFFIXES) 270 271 FUNCTIONS_WITH_ALIASED_ARGS = {*parser.Parser.FUNCTIONS_WITH_ALIASED_ARGS, "TUPLE"} 272 273 FUNCTION_PARSERS = { 274 **parser.Parser.FUNCTION_PARSERS, 275 "ARRAYJOIN": lambda self: self.expression(exp.Explode, this=self._parse_expression()), 276 "QUANTILE": lambda self: self._parse_quantile(), 277 } 278 279 FUNCTION_PARSERS.pop("MATCH") 280 281 NO_PAREN_FUNCTION_PARSERS = parser.Parser.NO_PAREN_FUNCTION_PARSERS.copy() 282 NO_PAREN_FUNCTION_PARSERS.pop("ANY") 283 284 RANGE_PARSERS = { 285 **parser.Parser.RANGE_PARSERS, 286 TokenType.GLOBAL: lambda self, this: self._match(TokenType.IN) 287 and self._parse_in(this, is_global=True), 288 } 289 290 # The PLACEHOLDER entry is popped because 1) it doesn't affect Clickhouse (it corresponds to 291 # the postgres-specific JSONBContains parser) and 2) it makes parsing the ternary op simpler. 292 COLUMN_OPERATORS = parser.Parser.COLUMN_OPERATORS.copy() 293 COLUMN_OPERATORS.pop(TokenType.PLACEHOLDER) 294 295 JOIN_KINDS = { 296 *parser.Parser.JOIN_KINDS, 297 TokenType.ANY, 298 TokenType.ASOF, 299 TokenType.ARRAY, 300 } 301 302 TABLE_ALIAS_TOKENS = parser.Parser.TABLE_ALIAS_TOKENS - { 303 TokenType.ANY, 304 TokenType.ARRAY, 305 TokenType.FINAL, 306 TokenType.FORMAT, 307 TokenType.SETTINGS, 308 } 309 310 ALIAS_TOKENS = parser.Parser.ALIAS_TOKENS - { 311 TokenType.FORMAT, 312 } 313 314 LOG_DEFAULTS_TO_LN = True 315 316 QUERY_MODIFIER_PARSERS = { 317 **parser.Parser.QUERY_MODIFIER_PARSERS, 318 TokenType.SETTINGS: lambda self: ( 319 "settings", 320 self._advance() or self._parse_csv(self._parse_conjunction), 321 ), 322 TokenType.FORMAT: lambda self: ("format", self._advance() or self._parse_id_var()), 323 } 324 325 def _parse_conjunction(self) -> t.Optional[exp.Expression]: 326 this = super()._parse_conjunction() 327 328 if self._match(TokenType.PLACEHOLDER): 329 return self.expression( 330 exp.If, 331 this=this, 332 true=self._parse_conjunction(), 333 false=self._match(TokenType.COLON) and self._parse_conjunction(), 334 ) 335 336 return this 337 338 def _parse_placeholder(self) -> t.Optional[exp.Expression]: 339 """ 340 Parse a placeholder expression like SELECT {abc: UInt32} or FROM {table: Identifier} 341 https://clickhouse.com/docs/en/sql-reference/syntax#defining-and-using-query-parameters 342 """ 343 if not self._match(TokenType.L_BRACE): 344 return None 345 346 this = self._parse_id_var() 347 self._match(TokenType.COLON) 348 kind = self._parse_types(check_func=False, allow_identifiers=False) or ( 349 self._match_text_seq("IDENTIFIER") and "Identifier" 350 ) 351 352 if not kind: 353 self.raise_error("Expecting a placeholder type or 'Identifier' for tables") 354 elif not self._match(TokenType.R_BRACE): 355 self.raise_error("Expecting }") 356 357 return self.expression(exp.Placeholder, this=this, kind=kind) 358 359 def _parse_in(self, this: t.Optional[exp.Expression], is_global: bool = False) -> exp.In: 360 this = super()._parse_in(this) 361 this.set("is_global", is_global) 362 return this 363 364 def _parse_table( 365 self, 366 schema: bool = False, 367 joins: bool = False, 368 alias_tokens: t.Optional[t.Collection[TokenType]] = None, 369 parse_bracket: bool = False, 370 is_db_reference: bool = False, 371 ) -> t.Optional[exp.Expression]: 372 this = super()._parse_table( 373 schema=schema, 374 joins=joins, 375 alias_tokens=alias_tokens, 376 parse_bracket=parse_bracket, 377 is_db_reference=is_db_reference, 378 ) 379 380 if self._match(TokenType.FINAL): 381 this = self.expression(exp.Final, this=this) 382 383 return this 384 385 def _parse_position(self, haystack_first: bool = False) -> exp.StrPosition: 386 return super()._parse_position(haystack_first=True) 387 388 # https://clickhouse.com/docs/en/sql-reference/statements/select/with/ 389 def _parse_cte(self) -> exp.CTE: 390 index = self._index 391 try: 392 # WITH <identifier> AS <subquery expression> 393 return super()._parse_cte() 394 except ParseError: 395 # WITH <expression> AS <identifier> 396 self._retreat(index) 397 398 return self.expression( 399 exp.CTE, 400 this=self._parse_conjunction(), 401 alias=self._parse_table_alias(), 402 scalar=True, 403 ) 404 405 def _parse_join_parts( 406 self, 407 ) -> t.Tuple[t.Optional[Token], t.Optional[Token], t.Optional[Token]]: 408 is_global = self._match(TokenType.GLOBAL) and self._prev 409 kind_pre = self._match_set(self.JOIN_KINDS, advance=False) and self._prev 410 411 if kind_pre: 412 kind = self._match_set(self.JOIN_KINDS) and self._prev 413 side = self._match_set(self.JOIN_SIDES) and self._prev 414 return is_global, side, kind 415 416 return ( 417 is_global, 418 self._match_set(self.JOIN_SIDES) and self._prev, 419 self._match_set(self.JOIN_KINDS) and self._prev, 420 ) 421 422 def _parse_join( 423 self, skip_join_token: bool = False, parse_bracket: bool = False 424 ) -> t.Optional[exp.Join]: 425 join = super()._parse_join(skip_join_token=skip_join_token, parse_bracket=True) 426 if join: 427 join.set("global", join.args.pop("method", None)) 428 429 return join 430 431 def _parse_function( 432 self, 433 functions: t.Optional[t.Dict[str, t.Callable]] = None, 434 anonymous: bool = False, 435 optional_parens: bool = True, 436 ) -> t.Optional[exp.Expression]: 437 func = super()._parse_function( 438 functions=functions, anonymous=anonymous, optional_parens=optional_parens 439 ) 440 441 if isinstance(func, exp.Anonymous): 442 parts = self.AGG_FUNC_MAPPING.get(func.this) 443 params = self._parse_func_params(func) 444 445 if params: 446 if parts and parts[1]: 447 return self.expression( 448 exp.CombinedParameterizedAgg, 449 this=func.this, 450 expressions=func.expressions, 451 params=params, 452 parts=parts, 453 ) 454 return self.expression( 455 exp.ParameterizedAgg, 456 this=func.this, 457 expressions=func.expressions, 458 params=params, 459 ) 460 461 if parts: 462 if parts[1]: 463 return self.expression( 464 exp.CombinedAggFunc, 465 this=func.this, 466 expressions=func.expressions, 467 parts=parts, 468 ) 469 return self.expression( 470 exp.AnonymousAggFunc, 471 this=func.this, 472 expressions=func.expressions, 473 ) 474 475 return func 476 477 def _parse_func_params( 478 self, this: t.Optional[exp.Func] = None 479 ) -> t.Optional[t.List[exp.Expression]]: 480 if self._match_pair(TokenType.R_PAREN, TokenType.L_PAREN): 481 return self._parse_csv(self._parse_lambda) 482 483 if self._match(TokenType.L_PAREN): 484 params = self._parse_csv(self._parse_lambda) 485 self._match_r_paren(this) 486 return params 487 488 return None 489 490 def _parse_quantile(self) -> exp.Quantile: 491 this = self._parse_lambda() 492 params = self._parse_func_params() 493 if params: 494 return self.expression(exp.Quantile, this=params[0], quantile=this) 495 return self.expression(exp.Quantile, this=this, quantile=exp.Literal.number(0.5)) 496 497 def _parse_wrapped_id_vars(self, optional: bool = False) -> t.List[exp.Expression]: 498 return super()._parse_wrapped_id_vars(optional=True) 499 500 def _parse_primary_key( 501 self, wrapped_optional: bool = False, in_props: bool = False 502 ) -> exp.PrimaryKeyColumnConstraint | exp.PrimaryKey: 503 return super()._parse_primary_key( 504 wrapped_optional=wrapped_optional or in_props, in_props=in_props 505 ) 506 507 def _parse_on_property(self) -> t.Optional[exp.Expression]: 508 index = self._index 509 if self._match_text_seq("CLUSTER"): 510 this = self._parse_id_var() 511 if this: 512 return self.expression(exp.OnCluster, this=this) 513 else: 514 self._retreat(index) 515 return None
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'>>, '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>, '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_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'>>, '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 =
{'quantileTiming', 'anyHeavy', 'uniq', 'groupBitmapAnd', 'argMin', 'rankCorr', 'kolmogorovSmirnovTest', 'covarPop', 'quantilesTiming', 'quantileExact', 'median', 'quantileBFloat16', 'avgWeighted', 'topKWeighted', 'largestTriangleThreeBuckets', 'sumKahan', 'stochasticLinearRegression', 'groupBitOr', 'varPop', 'quantilesExactWeighted', 'quantilesTDigest', 'boundingRatio', 'groupArrayInsertAt', 'quantilesBFloat16', 'exponentialMovingAverage', 'quantilesExact', 'groupBitmap', 'covarSamp', 'kurtSamp', 'quantilesTimingWeighted', 'avg', 'quantilesBFloat16Weighted', 'groupArrayMovingAvg', 'stddevPop', 'maxIntersectionsPosition', 'groupBitAnd', 'theilsU', 'quantileDeterministic', 'corr', 'stddevSamp', 'uniqTheta', 'groupArraySample', 'quantile', 'last_value', 'quantilesDeterministic', 'maxIntersections', 'sumCount', 'uniqHLL12', 'sum', 'quantileBFloat16Weighted', 'groupArrayLast', 'quantileTimingWeighted', 'sumWithOverflow', 'skewSamp', 'entropy', 'kurtPop', 'sparkBar', 'quantileExactWeighted', 'quantileInterpolatedWeighted', 'groupUniqArray', 'first_value', 'uniqCombined', 'groupBitmapXor', 'varSamp', 'minMap', 'argMax', 'sumMap', 'min', 'maxMap', 'quantilesGK', 'any', 'groupBitXor', 'quantilesInterpolatedWeighted', 'intervalLengthSum', 'deltaSum', 'quantileTDigest', 'stochasticLogisticRegression', 'anyLast', 'topK', 'quantilesExactHigh', 'welchTTest', 'quantiles', 'cramersVBiasCorrected', 'quantilesExactLow', 'cramersV', 'quantileTDigestWeighted', 'meanZTest', 'uniqCombined64', 'categoricalInformationValue', 'groupBitmapOr', 'quantilesTDigestWeighted', 'quantileGK', 'quantileExactHigh', 'count', 'quantileExactLow', 'simpleLinearRegression', 'deltaSumTimestamp', 'skewPop', 'contingency', 'max', 'studentTTest', 'mannWhitneyUTest', 'groupArrayMovingSum', 'groupArray', 'uniqExact'}
AGG_FUNCTIONS_SUFFIXES =
['If', 'Array', 'ArrayIf', 'Map', 'SimpleState', 'State', 'Merge', 'MergeState', 'ForEach', 'Distinct', 'OrDefault', 'OrNull', 'Resample', 'ArgMin', 'ArgMax']
AGG_FUNC_MAPPING =
{'quantileTimingIf': ('quantileTiming', 'If'), 'anyHeavyIf': ('anyHeavy', 'If'), 'uniqIf': ('uniq', 'If'), 'groupBitmapAndIf': ('groupBitmapAnd', 'If'), 'argMinIf': ('argMin', 'If'), 'rankCorrIf': ('rankCorr', 'If'), 'kolmogorovSmirnovTestIf': ('kolmogorovSmirnovTest', 'If'), 'covarPopIf': ('covarPop', 'If'), 'quantilesTimingIf': ('quantilesTiming', 'If'), 'quantileExactIf': ('quantileExact', 'If'), 'medianIf': ('median', 'If'), 'quantileBFloat16If': ('quantileBFloat16', 'If'), 'avgWeightedIf': ('avgWeighted', 'If'), 'topKWeightedIf': ('topKWeighted', 'If'), 'largestTriangleThreeBucketsIf': ('largestTriangleThreeBuckets', 'If'), 'sumKahanIf': ('sumKahan', 'If'), 'stochasticLinearRegressionIf': ('stochasticLinearRegression', 'If'), 'groupBitOrIf': ('groupBitOr', 'If'), 'varPopIf': ('varPop', 'If'), 'quantilesExactWeightedIf': ('quantilesExactWeighted', 'If'), 'quantilesTDigestIf': ('quantilesTDigest', 'If'), 'boundingRatioIf': ('boundingRatio', 'If'), 'groupArrayInsertAtIf': ('groupArrayInsertAt', 'If'), 'quantilesBFloat16If': ('quantilesBFloat16', 'If'), 'exponentialMovingAverageIf': ('exponentialMovingAverage', 'If'), 'quantilesExactIf': ('quantilesExact', 'If'), 'groupBitmapIf': ('groupBitmap', 'If'), 'covarSampIf': ('covarSamp', 'If'), 'kurtSampIf': ('kurtSamp', 'If'), 'quantilesTimingWeightedIf': ('quantilesTimingWeighted', 'If'), 'avgIf': ('avg', 'If'), 'quantilesBFloat16WeightedIf': ('quantilesBFloat16Weighted', 'If'), 'groupArrayMovingAvgIf': ('groupArrayMovingAvg', 'If'), 'stddevPopIf': ('stddevPop', 'If'), 'maxIntersectionsPositionIf': ('maxIntersectionsPosition', 'If'), 'groupBitAndIf': ('groupBitAnd', 'If'), 'theilsUIf': ('theilsU', 'If'), 'quantileDeterministicIf': ('quantileDeterministic', 'If'), 'corrIf': ('corr', 'If'), 'stddevSampIf': ('stddevSamp', 'If'), 'uniqThetaIf': ('uniqTheta', 'If'), 'groupArraySampleIf': ('groupArraySample', 'If'), 'quantileIf': ('quantile', 'If'), 'last_valueIf': ('last_value', 'If'), 'quantilesDeterministicIf': ('quantilesDeterministic', 'If'), 'maxIntersectionsIf': ('maxIntersections', 'If'), 'sumCountIf': ('sumCount', 'If'), 'uniqHLL12If': ('uniqHLL12', 'If'), 'sumIf': ('sum', 'If'), 'quantileBFloat16WeightedIf': ('quantileBFloat16Weighted', 'If'), 'groupArrayLastIf': ('groupArrayLast', 'If'), 'quantileTimingWeightedIf': ('quantileTimingWeighted', 'If'), 'sumWithOverflowIf': ('sumWithOverflow', 'If'), 'skewSampIf': ('skewSamp', 'If'), 'entropyIf': ('entropy', 'If'), 'kurtPopIf': ('kurtPop', 'If'), 'sparkBarIf': ('sparkBar', 'If'), 'quantileExactWeightedIf': ('quantileExactWeighted', 'If'), 'quantileInterpolatedWeightedIf': ('quantileInterpolatedWeighted', 'If'), 'groupUniqArrayIf': ('groupUniqArray', 'If'), 'first_valueIf': ('first_value', 'If'), 'uniqCombinedIf': ('uniqCombined', 'If'), 'groupBitmapXorIf': ('groupBitmapXor', 'If'), 'varSampIf': ('varSamp', 'If'), 'minMapIf': ('minMap', 'If'), 'argMaxIf': ('argMax', 'If'), 'sumMapIf': ('sumMap', 'If'), 'minIf': ('min', 'If'), 'maxMapIf': ('maxMap', 'If'), 'quantilesGKIf': ('quantilesGK', 'If'), 'anyIf': ('any', 'If'), 'groupBitXorIf': ('groupBitXor', 'If'), 'quantilesInterpolatedWeightedIf': ('quantilesInterpolatedWeighted', 'If'), 'intervalLengthSumIf': ('intervalLengthSum', 'If'), 'deltaSumIf': ('deltaSum', 'If'), 'quantileTDigestIf': ('quantileTDigest', 'If'), 'stochasticLogisticRegressionIf': ('stochasticLogisticRegression', 'If'), 'anyLastIf': ('anyLast', 'If'), 'topKIf': ('topK', 'If'), 'quantilesExactHighIf': ('quantilesExactHigh', 'If'), 'welchTTestIf': ('welchTTest', 'If'), 'quantilesIf': ('quantiles', 'If'), 'cramersVBiasCorrectedIf': ('cramersVBiasCorrected', 'If'), 'quantilesExactLowIf': ('quantilesExactLow', 'If'), 'cramersVIf': ('cramersV', 'If'), 'quantileTDigestWeightedIf': ('quantileTDigestWeighted', 'If'), 'meanZTestIf': ('meanZTest', 'If'), 'uniqCombined64If': ('uniqCombined64', 'If'), 'categoricalInformationValueIf': ('categoricalInformationValue', 'If'), 'groupBitmapOrIf': ('groupBitmapOr', 'If'), 'quantilesTDigestWeightedIf': ('quantilesTDigestWeighted', 'If'), 'quantileGKIf': ('quantileGK', 'If'), 'quantileExactHighIf': ('quantileExactHigh', 'If'), 'countIf': ('count', 'If'), 'quantileExactLowIf': ('quantileExactLow', 'If'), 'simpleLinearRegressionIf': ('simpleLinearRegression', 'If'), 'deltaSumTimestampIf': ('deltaSumTimestamp', 'If'), 'skewPopIf': ('skewPop', 'If'), 'contingencyIf': ('contingency', 'If'), 'maxIf': ('max', 'If'), 'studentTTestIf': ('studentTTest', 'If'), 'mannWhitneyUTestIf': ('mannWhitneyUTest', 'If'), 'groupArrayMovingSumIf': ('groupArrayMovingSum', 'If'), 'groupArrayIf': ('groupArray', 'If'), 'uniqExactIf': ('uniqExact', 'If'), 'quantileTimingArray': ('quantileTiming', 'Array'), 'anyHeavyArray': ('anyHeavy', 'Array'), 'uniqArray': ('uniq', 'Array'), 'groupBitmapAndArray': ('groupBitmapAnd', 'Array'), 'argMinArray': ('argMin', 'Array'), 'rankCorrArray': ('rankCorr', 'Array'), 'kolmogorovSmirnovTestArray': ('kolmogorovSmirnovTest', 'Array'), 'covarPopArray': ('covarPop', 'Array'), 'quantilesTimingArray': ('quantilesTiming', 'Array'), 'quantileExactArray': ('quantileExact', 'Array'), 'medianArray': ('median', 'Array'), 'quantileBFloat16Array': ('quantileBFloat16', 'Array'), 'avgWeightedArray': ('avgWeighted', 'Array'), 'topKWeightedArray': ('topKWeighted', 'Array'), 'largestTriangleThreeBucketsArray': ('largestTriangleThreeBuckets', 'Array'), 'sumKahanArray': ('sumKahan', 'Array'), 'stochasticLinearRegressionArray': ('stochasticLinearRegression', 'Array'), 'groupBitOrArray': ('groupBitOr', 'Array'), 'varPopArray': ('varPop', 'Array'), 'quantilesExactWeightedArray': ('quantilesExactWeighted', 'Array'), 'quantilesTDigestArray': ('quantilesTDigest', 'Array'), 'boundingRatioArray': ('boundingRatio', 'Array'), 'groupArrayInsertAtArray': ('groupArrayInsertAt', 'Array'), 'quantilesBFloat16Array': ('quantilesBFloat16', 'Array'), 'exponentialMovingAverageArray': ('exponentialMovingAverage', 'Array'), 'quantilesExactArray': ('quantilesExact', 'Array'), 'groupBitmapArray': ('groupBitmap', 'Array'), 'covarSampArray': ('covarSamp', 'Array'), 'kurtSampArray': ('kurtSamp', 'Array'), 'quantilesTimingWeightedArray': ('quantilesTimingWeighted', 'Array'), 'avgArray': ('avg', 'Array'), 'quantilesBFloat16WeightedArray': ('quantilesBFloat16Weighted', 'Array'), 'groupArrayMovingAvgArray': ('groupArrayMovingAvg', 'Array'), 'stddevPopArray': ('stddevPop', 'Array'), 'maxIntersectionsPositionArray': ('maxIntersectionsPosition', 'Array'), 'groupBitAndArray': ('groupBitAnd', 'Array'), 'theilsUArray': ('theilsU', 'Array'), 'quantileDeterministicArray': ('quantileDeterministic', 'Array'), 'corrArray': ('corr', 'Array'), 'stddevSampArray': ('stddevSamp', 'Array'), 'uniqThetaArray': ('uniqTheta', 'Array'), 'groupArraySampleArray': ('groupArraySample', 'Array'), 'quantileArray': ('quantile', 'Array'), 'last_valueArray': ('last_value', 'Array'), 'quantilesDeterministicArray': ('quantilesDeterministic', 'Array'), 'maxIntersectionsArray': ('maxIntersections', 'Array'), 'sumCountArray': ('sumCount', 'Array'), 'uniqHLL12Array': ('uniqHLL12', 'Array'), 'sumArray': ('sum', 'Array'), 'quantileBFloat16WeightedArray': ('quantileBFloat16Weighted', 'Array'), 'groupArrayLastArray': ('groupArrayLast', 'Array'), 'quantileTimingWeightedArray': ('quantileTimingWeighted', 'Array'), 'sumWithOverflowArray': ('sumWithOverflow', 'Array'), 'skewSampArray': ('skewSamp', 'Array'), 'entropyArray': ('entropy', 'Array'), 'kurtPopArray': ('kurtPop', 'Array'), 'sparkBarArray': ('sparkBar', 'Array'), 'quantileExactWeightedArray': ('quantileExactWeighted', 'Array'), 'quantileInterpolatedWeightedArray': ('quantileInterpolatedWeighted', 'Array'), 'groupUniqArrayArray': ('groupUniqArray', 'Array'), 'first_valueArray': ('first_value', 'Array'), 'uniqCombinedArray': ('uniqCombined', 'Array'), 'groupBitmapXorArray': ('groupBitmapXor', 'Array'), 'varSampArray': ('varSamp', 'Array'), 'minMapArray': ('minMap', 'Array'), 'argMaxArray': ('argMax', 'Array'), 'sumMapArray': ('sumMap', 'Array'), 'minArray': ('min', 'Array'), 'maxMapArray': ('maxMap', 'Array'), 'quantilesGKArray': ('quantilesGK', 'Array'), 'anyArray': ('any', 'Array'), 'groupBitXorArray': ('groupBitXor', 'Array'), 'quantilesInterpolatedWeightedArray': ('quantilesInterpolatedWeighted', 'Array'), 'intervalLengthSumArray': ('intervalLengthSum', 'Array'), 'deltaSumArray': ('deltaSum', 'Array'), 'quantileTDigestArray': ('quantileTDigest', 'Array'), 'stochasticLogisticRegressionArray': ('stochasticLogisticRegression', 'Array'), 'anyLastArray': ('anyLast', 'Array'), 'topKArray': ('topK', 'Array'), 'quantilesExactHighArray': ('quantilesExactHigh', 'Array'), 'welchTTestArray': ('welchTTest', 'Array'), 'quantilesArray': ('quantiles', 'Array'), 'cramersVBiasCorrectedArray': ('cramersVBiasCorrected', 'Array'), 'quantilesExactLowArray': ('quantilesExactLow', 'Array'), 'cramersVArray': ('cramersV', 'Array'), 'quantileTDigestWeightedArray': ('quantileTDigestWeighted', 'Array'), 'meanZTestArray': ('meanZTest', 'Array'), 'uniqCombined64Array': ('uniqCombined64', 'Array'), 'categoricalInformationValueArray': ('categoricalInformationValue', 'Array'), 'groupBitmapOrArray': ('groupBitmapOr', 'Array'), 'quantilesTDigestWeightedArray': ('quantilesTDigestWeighted', 'Array'), 'quantileGKArray': ('quantileGK', 'Array'), 'quantileExactHighArray': ('quantileExactHigh', 'Array'), 'countArray': ('count', 'Array'), 'quantileExactLowArray': ('quantileExactLow', 'Array'), 'simpleLinearRegressionArray': ('simpleLinearRegression', 'Array'), 'deltaSumTimestampArray': ('deltaSumTimestamp', 'Array'), 'skewPopArray': ('skewPop', 'Array'), 'contingencyArray': ('contingency', 'Array'), 'maxArray': ('max', 'Array'), 'studentTTestArray': ('studentTTest', 'Array'), 'mannWhitneyUTestArray': ('mannWhitneyUTest', 'Array'), 'groupArrayMovingSumArray': ('groupArrayMovingSum', 'Array'), 'groupArrayArray': ('groupArray', 'Array'), 'uniqExactArray': ('uniqExact', 'Array'), 'quantileTimingArrayIf': ('quantileTiming', 'ArrayIf'), 'anyHeavyArrayIf': ('anyHeavy', 'ArrayIf'), 'uniqArrayIf': ('uniq', 'ArrayIf'), 'groupBitmapAndArrayIf': ('groupBitmapAnd', 'ArrayIf'), 'argMinArrayIf': ('argMin', 'ArrayIf'), 'rankCorrArrayIf': ('rankCorr', 'ArrayIf'), 'kolmogorovSmirnovTestArrayIf': ('kolmogorovSmirnovTest', 'ArrayIf'), 'covarPopArrayIf': ('covarPop', 'ArrayIf'), 'quantilesTimingArrayIf': ('quantilesTiming', 'ArrayIf'), 'quantileExactArrayIf': ('quantileExact', 'ArrayIf'), 'medianArrayIf': ('median', 'ArrayIf'), 'quantileBFloat16ArrayIf': ('quantileBFloat16', 'ArrayIf'), 'avgWeightedArrayIf': ('avgWeighted', 'ArrayIf'), 'topKWeightedArrayIf': ('topKWeighted', 'ArrayIf'), 'largestTriangleThreeBucketsArrayIf': ('largestTriangleThreeBuckets', 'ArrayIf'), 'sumKahanArrayIf': ('sumKahan', 'ArrayIf'), 'stochasticLinearRegressionArrayIf': ('stochasticLinearRegression', 'ArrayIf'), 'groupBitOrArrayIf': ('groupBitOr', 'ArrayIf'), 'varPopArrayIf': ('varPop', 'ArrayIf'), 'quantilesExactWeightedArrayIf': ('quantilesExactWeighted', 'ArrayIf'), 'quantilesTDigestArrayIf': ('quantilesTDigest', 'ArrayIf'), 'boundingRatioArrayIf': ('boundingRatio', 'ArrayIf'), 'groupArrayInsertAtArrayIf': ('groupArrayInsertAt', 'ArrayIf'), 'quantilesBFloat16ArrayIf': ('quantilesBFloat16', 'ArrayIf'), 'exponentialMovingAverageArrayIf': ('exponentialMovingAverage', 'ArrayIf'), 'quantilesExactArrayIf': ('quantilesExact', 'ArrayIf'), 'groupBitmapArrayIf': ('groupBitmap', 'ArrayIf'), 'covarSampArrayIf': ('covarSamp', 'ArrayIf'), 'kurtSampArrayIf': ('kurtSamp', 'ArrayIf'), 'quantilesTimingWeightedArrayIf': ('quantilesTimingWeighted', 'ArrayIf'), 'avgArrayIf': ('avg', 'ArrayIf'), 'quantilesBFloat16WeightedArrayIf': ('quantilesBFloat16Weighted', 'ArrayIf'), 'groupArrayMovingAvgArrayIf': ('groupArrayMovingAvg', 'ArrayIf'), 'stddevPopArrayIf': ('stddevPop', 'ArrayIf'), 'maxIntersectionsPositionArrayIf': ('maxIntersectionsPosition', 'ArrayIf'), 'groupBitAndArrayIf': ('groupBitAnd', 'ArrayIf'), 'theilsUArrayIf': ('theilsU', 'ArrayIf'), 'quantileDeterministicArrayIf': ('quantileDeterministic', 'ArrayIf'), 'corrArrayIf': ('corr', 'ArrayIf'), 'stddevSampArrayIf': ('stddevSamp', 'ArrayIf'), 'uniqThetaArrayIf': ('uniqTheta', 'ArrayIf'), 'groupArraySampleArrayIf': ('groupArraySample', 'ArrayIf'), 'quantileArrayIf': ('quantile', 'ArrayIf'), 'last_valueArrayIf': ('last_value', 'ArrayIf'), 'quantilesDeterministicArrayIf': ('quantilesDeterministic', 'ArrayIf'), 'maxIntersectionsArrayIf': ('maxIntersections', 'ArrayIf'), 'sumCountArrayIf': ('sumCount', 'ArrayIf'), 'uniqHLL12ArrayIf': ('uniqHLL12', 'ArrayIf'), 'sumArrayIf': ('sum', 'ArrayIf'), 'quantileBFloat16WeightedArrayIf': ('quantileBFloat16Weighted', 'ArrayIf'), 'groupArrayLastArrayIf': ('groupArrayLast', 'ArrayIf'), 'quantileTimingWeightedArrayIf': ('quantileTimingWeighted', 'ArrayIf'), 'sumWithOverflowArrayIf': ('sumWithOverflow', 'ArrayIf'), 'skewSampArrayIf': ('skewSamp', 'ArrayIf'), 'entropyArrayIf': ('entropy', 'ArrayIf'), 'kurtPopArrayIf': ('kurtPop', 'ArrayIf'), 'sparkBarArrayIf': ('sparkBar', 'ArrayIf'), 'quantileExactWeightedArrayIf': ('quantileExactWeighted', 'ArrayIf'), 'quantileInterpolatedWeightedArrayIf': ('quantileInterpolatedWeighted', 'ArrayIf'), 'groupUniqArrayArrayIf': ('groupUniqArray', 'ArrayIf'), 'first_valueArrayIf': ('first_value', 'ArrayIf'), 'uniqCombinedArrayIf': ('uniqCombined', 'ArrayIf'), 'groupBitmapXorArrayIf': ('groupBitmapXor', 'ArrayIf'), 'varSampArrayIf': ('varSamp', 'ArrayIf'), 'minMapArrayIf': ('minMap', 'ArrayIf'), 'argMaxArrayIf': ('argMax', 'ArrayIf'), 'sumMapArrayIf': ('sumMap', 'ArrayIf'), 'minArrayIf': ('min', 'ArrayIf'), 'maxMapArrayIf': ('maxMap', 'ArrayIf'), 'quantilesGKArrayIf': ('quantilesGK', 'ArrayIf'), 'anyArrayIf': ('any', 'ArrayIf'), 'groupBitXorArrayIf': ('groupBitXor', 'ArrayIf'), 'quantilesInterpolatedWeightedArrayIf': ('quantilesInterpolatedWeighted', 'ArrayIf'), 'intervalLengthSumArrayIf': ('intervalLengthSum', 'ArrayIf'), 'deltaSumArrayIf': ('deltaSum', 'ArrayIf'), 'quantileTDigestArrayIf': ('quantileTDigest', 'ArrayIf'), 'stochasticLogisticRegressionArrayIf': ('stochasticLogisticRegression', 'ArrayIf'), 'anyLastArrayIf': ('anyLast', 'ArrayIf'), 'topKArrayIf': ('topK', 'ArrayIf'), 'quantilesExactHighArrayIf': ('quantilesExactHigh', 'ArrayIf'), 'welchTTestArrayIf': ('welchTTest', 'ArrayIf'), 'quantilesArrayIf': ('quantiles', 'ArrayIf'), 'cramersVBiasCorrectedArrayIf': ('cramersVBiasCorrected', 'ArrayIf'), 'quantilesExactLowArrayIf': ('quantilesExactLow', 'ArrayIf'), 'cramersVArrayIf': ('cramersV', 'ArrayIf'), 'quantileTDigestWeightedArrayIf': ('quantileTDigestWeighted', 'ArrayIf'), 'meanZTestArrayIf': ('meanZTest', 'ArrayIf'), 'uniqCombined64ArrayIf': ('uniqCombined64', 'ArrayIf'), 'categoricalInformationValueArrayIf': ('categoricalInformationValue', 'ArrayIf'), 'groupBitmapOrArrayIf': ('groupBitmapOr', 'ArrayIf'), 'quantilesTDigestWeightedArrayIf': ('quantilesTDigestWeighted', 'ArrayIf'), 'quantileGKArrayIf': ('quantileGK', 'ArrayIf'), 'quantileExactHighArrayIf': ('quantileExactHigh', 'ArrayIf'), 'countArrayIf': ('count', 'ArrayIf'), 'quantileExactLowArrayIf': ('quantileExactLow', 'ArrayIf'), 'simpleLinearRegressionArrayIf': ('simpleLinearRegression', 'ArrayIf'), 'deltaSumTimestampArrayIf': ('deltaSumTimestamp', 'ArrayIf'), 'skewPopArrayIf': ('skewPop', 'ArrayIf'), 'contingencyArrayIf': ('contingency', 'ArrayIf'), 'maxArrayIf': ('max', 'ArrayIf'), 'studentTTestArrayIf': ('studentTTest', 'ArrayIf'), 'mannWhitneyUTestArrayIf': ('mannWhitneyUTest', 'ArrayIf'), 'groupArrayMovingSumArrayIf': ('groupArrayMovingSum', 'ArrayIf'), 'groupArrayArrayIf': ('groupArray', 'ArrayIf'), 'uniqExactArrayIf': ('uniqExact', 'ArrayIf'), 'quantileTimingMap': ('quantileTiming', 'Map'), 'anyHeavyMap': ('anyHeavy', 'Map'), 'uniqMap': ('uniq', 'Map'), 'groupBitmapAndMap': ('groupBitmapAnd', 'Map'), 'argMinMap': ('argMin', 'Map'), 'rankCorrMap': ('rankCorr', 'Map'), 'kolmogorovSmirnovTestMap': ('kolmogorovSmirnovTest', 'Map'), 'covarPopMap': ('covarPop', 'Map'), 'quantilesTimingMap': ('quantilesTiming', 'Map'), 'quantileExactMap': ('quantileExact', 'Map'), 'medianMap': ('median', 'Map'), 'quantileBFloat16Map': ('quantileBFloat16', 'Map'), 'avgWeightedMap': ('avgWeighted', 'Map'), 'topKWeightedMap': ('topKWeighted', 'Map'), 'largestTriangleThreeBucketsMap': ('largestTriangleThreeBuckets', 'Map'), 'sumKahanMap': ('sumKahan', 'Map'), 'stochasticLinearRegressionMap': ('stochasticLinearRegression', 'Map'), 'groupBitOrMap': ('groupBitOr', 'Map'), 'varPopMap': ('varPop', 'Map'), 'quantilesExactWeightedMap': ('quantilesExactWeighted', 'Map'), 'quantilesTDigestMap': ('quantilesTDigest', 'Map'), 'boundingRatioMap': ('boundingRatio', 'Map'), 'groupArrayInsertAtMap': ('groupArrayInsertAt', 'Map'), 'quantilesBFloat16Map': ('quantilesBFloat16', 'Map'), 'exponentialMovingAverageMap': ('exponentialMovingAverage', 'Map'), 'quantilesExactMap': ('quantilesExact', 'Map'), 'groupBitmapMap': ('groupBitmap', 'Map'), 'covarSampMap': ('covarSamp', 'Map'), 'kurtSampMap': ('kurtSamp', 'Map'), 'quantilesTimingWeightedMap': ('quantilesTimingWeighted', 'Map'), 'avgMap': ('avg', 'Map'), 'quantilesBFloat16WeightedMap': ('quantilesBFloat16Weighted', 'Map'), 'groupArrayMovingAvgMap': ('groupArrayMovingAvg', 'Map'), 'stddevPopMap': ('stddevPop', 'Map'), 'maxIntersectionsPositionMap': ('maxIntersectionsPosition', 'Map'), 'groupBitAndMap': ('groupBitAnd', 'Map'), 'theilsUMap': ('theilsU', 'Map'), 'quantileDeterministicMap': ('quantileDeterministic', 'Map'), 'corrMap': ('corr', 'Map'), 'stddevSampMap': ('stddevSamp', 'Map'), 'uniqThetaMap': ('uniqTheta', 'Map'), 'groupArraySampleMap': ('groupArraySample', 'Map'), 'quantileMap': ('quantile', 'Map'), 'last_valueMap': ('last_value', 'Map'), 'quantilesDeterministicMap': ('quantilesDeterministic', 'Map'), 'maxIntersectionsMap': ('maxIntersections', 'Map'), 'sumCountMap': ('sumCount', 'Map'), 'uniqHLL12Map': ('uniqHLL12', 'Map'), 'sumMap': ('sumMap', ''), 'quantileBFloat16WeightedMap': ('quantileBFloat16Weighted', 'Map'), 'groupArrayLastMap': ('groupArrayLast', 'Map'), 'quantileTimingWeightedMap': ('quantileTimingWeighted', 'Map'), 'sumWithOverflowMap': ('sumWithOverflow', 'Map'), 'skewSampMap': ('skewSamp', 'Map'), 'entropyMap': ('entropy', 'Map'), 'kurtPopMap': ('kurtPop', 'Map'), 'sparkBarMap': ('sparkBar', 'Map'), 'quantileExactWeightedMap': ('quantileExactWeighted', 'Map'), 'quantileInterpolatedWeightedMap': ('quantileInterpolatedWeighted', 'Map'), 'groupUniqArrayMap': ('groupUniqArray', 'Map'), 'first_valueMap': ('first_value', 'Map'), 'uniqCombinedMap': ('uniqCombined', 'Map'), 'groupBitmapXorMap': ('groupBitmapXor', 'Map'), 'varSampMap': ('varSamp', 'Map'), 'minMapMap': ('minMap', 'Map'), 'argMaxMap': ('argMax', 'Map'), 'sumMapMap': ('sumMap', 'Map'), 'minMap': ('minMap', ''), 'maxMapMap': ('maxMap', 'Map'), 'quantilesGKMap': ('quantilesGK', 'Map'), 'anyMap': ('any', 'Map'), 'groupBitXorMap': ('groupBitXor', 'Map'), 'quantilesInterpolatedWeightedMap': ('quantilesInterpolatedWeighted', 'Map'), 'intervalLengthSumMap': ('intervalLengthSum', 'Map'), 'deltaSumMap': ('deltaSum', 'Map'), 'quantileTDigestMap': ('quantileTDigest', 'Map'), 'stochasticLogisticRegressionMap': ('stochasticLogisticRegression', 'Map'), 'anyLastMap': ('anyLast', 'Map'), 'topKMap': ('topK', 'Map'), 'quantilesExactHighMap': ('quantilesExactHigh', 'Map'), 'welchTTestMap': ('welchTTest', 'Map'), 'quantilesMap': ('quantiles', 'Map'), 'cramersVBiasCorrectedMap': ('cramersVBiasCorrected', 'Map'), 'quantilesExactLowMap': ('quantilesExactLow', 'Map'), 'cramersVMap': ('cramersV', 'Map'), 'quantileTDigestWeightedMap': ('quantileTDigestWeighted', 'Map'), 'meanZTestMap': ('meanZTest', 'Map'), 'uniqCombined64Map': ('uniqCombined64', 'Map'), 'categoricalInformationValueMap': ('categoricalInformationValue', 'Map'), 'groupBitmapOrMap': ('groupBitmapOr', 'Map'), 'quantilesTDigestWeightedMap': ('quantilesTDigestWeighted', 'Map'), 'quantileGKMap': ('quantileGK', 'Map'), 'quantileExactHighMap': ('quantileExactHigh', 'Map'), 'countMap': ('count', 'Map'), 'quantileExactLowMap': ('quantileExactLow', 'Map'), 'simpleLinearRegressionMap': ('simpleLinearRegression', 'Map'), 'deltaSumTimestampMap': ('deltaSumTimestamp', 'Map'), 'skewPopMap': ('skewPop', 'Map'), 'contingencyMap': ('contingency', 'Map'), 'maxMap': ('maxMap', ''), 'studentTTestMap': ('studentTTest', 'Map'), 'mannWhitneyUTestMap': ('mannWhitneyUTest', 'Map'), 'groupArrayMovingSumMap': ('groupArrayMovingSum', 'Map'), 'groupArrayMap': ('groupArray', 'Map'), 'uniqExactMap': ('uniqExact', 'Map'), 'quantileTimingSimpleState': ('quantileTiming', 'SimpleState'), 'anyHeavySimpleState': ('anyHeavy', 'SimpleState'), 'uniqSimpleState': ('uniq', 'SimpleState'), 'groupBitmapAndSimpleState': ('groupBitmapAnd', 'SimpleState'), 'argMinSimpleState': ('argMin', 'SimpleState'), 'rankCorrSimpleState': ('rankCorr', 'SimpleState'), 'kolmogorovSmirnovTestSimpleState': ('kolmogorovSmirnovTest', 'SimpleState'), 'covarPopSimpleState': ('covarPop', 'SimpleState'), 'quantilesTimingSimpleState': ('quantilesTiming', 'SimpleState'), 'quantileExactSimpleState': ('quantileExact', 'SimpleState'), 'medianSimpleState': ('median', 'SimpleState'), 'quantileBFloat16SimpleState': ('quantileBFloat16', 'SimpleState'), 'avgWeightedSimpleState': ('avgWeighted', 'SimpleState'), 'topKWeightedSimpleState': ('topKWeighted', 'SimpleState'), 'largestTriangleThreeBucketsSimpleState': ('largestTriangleThreeBuckets', 'SimpleState'), 'sumKahanSimpleState': ('sumKahan', 'SimpleState'), 'stochasticLinearRegressionSimpleState': ('stochasticLinearRegression', 'SimpleState'), 'groupBitOrSimpleState': ('groupBitOr', 'SimpleState'), 'varPopSimpleState': ('varPop', 'SimpleState'), 'quantilesExactWeightedSimpleState': ('quantilesExactWeighted', 'SimpleState'), 'quantilesTDigestSimpleState': ('quantilesTDigest', 'SimpleState'), 'boundingRatioSimpleState': ('boundingRatio', 'SimpleState'), 'groupArrayInsertAtSimpleState': ('groupArrayInsertAt', 'SimpleState'), 'quantilesBFloat16SimpleState': ('quantilesBFloat16', 'SimpleState'), 'exponentialMovingAverageSimpleState': ('exponentialMovingAverage', 'SimpleState'), 'quantilesExactSimpleState': ('quantilesExact', 'SimpleState'), 'groupBitmapSimpleState': ('groupBitmap', 'SimpleState'), 'covarSampSimpleState': ('covarSamp', 'SimpleState'), 'kurtSampSimpleState': ('kurtSamp', 'SimpleState'), 'quantilesTimingWeightedSimpleState': ('quantilesTimingWeighted', 'SimpleState'), 'avgSimpleState': ('avg', 'SimpleState'), 'quantilesBFloat16WeightedSimpleState': ('quantilesBFloat16Weighted', 'SimpleState'), 'groupArrayMovingAvgSimpleState': ('groupArrayMovingAvg', 'SimpleState'), 'stddevPopSimpleState': ('stddevPop', 'SimpleState'), 'maxIntersectionsPositionSimpleState': ('maxIntersectionsPosition', 'SimpleState'), 'groupBitAndSimpleState': ('groupBitAnd', 'SimpleState'), 'theilsUSimpleState': ('theilsU', 'SimpleState'), 'quantileDeterministicSimpleState': ('quantileDeterministic', 'SimpleState'), 'corrSimpleState': ('corr', 'SimpleState'), 'stddevSampSimpleState': ('stddevSamp', 'SimpleState'), 'uniqThetaSimpleState': ('uniqTheta', 'SimpleState'), 'groupArraySampleSimpleState': ('groupArraySample', 'SimpleState'), 'quantileSimpleState': ('quantile', 'SimpleState'), 'last_valueSimpleState': ('last_value', 'SimpleState'), 'quantilesDeterministicSimpleState': ('quantilesDeterministic', 'SimpleState'), 'maxIntersectionsSimpleState': ('maxIntersections', 'SimpleState'), 'sumCountSimpleState': ('sumCount', 'SimpleState'), 'uniqHLL12SimpleState': ('uniqHLL12', 'SimpleState'), 'sumSimpleState': ('sum', 'SimpleState'), 'quantileBFloat16WeightedSimpleState': ('quantileBFloat16Weighted', 'SimpleState'), 'groupArrayLastSimpleState': ('groupArrayLast', 'SimpleState'), 'quantileTimingWeightedSimpleState': ('quantileTimingWeighted', 'SimpleState'), 'sumWithOverflowSimpleState': ('sumWithOverflow', 'SimpleState'), 'skewSampSimpleState': ('skewSamp', 'SimpleState'), 'entropySimpleState': ('entropy', 'SimpleState'), 'kurtPopSimpleState': ('kurtPop', 'SimpleState'), 'sparkBarSimpleState': ('sparkBar', 'SimpleState'), 'quantileExactWeightedSimpleState': ('quantileExactWeighted', 'SimpleState'), 'quantileInterpolatedWeightedSimpleState': ('quantileInterpolatedWeighted', 'SimpleState'), 'groupUniqArraySimpleState': ('groupUniqArray', 'SimpleState'), 'first_valueSimpleState': ('first_value', 'SimpleState'), 'uniqCombinedSimpleState': ('uniqCombined', 'SimpleState'), 'groupBitmapXorSimpleState': ('groupBitmapXor', 'SimpleState'), 'varSampSimpleState': ('varSamp', 'SimpleState'), 'minMapSimpleState': ('minMap', 'SimpleState'), 'argMaxSimpleState': ('argMax', 'SimpleState'), 'sumMapSimpleState': ('sumMap', 'SimpleState'), 'minSimpleState': ('min', 'SimpleState'), 'maxMapSimpleState': ('maxMap', 'SimpleState'), 'quantilesGKSimpleState': ('quantilesGK', 'SimpleState'), 'anySimpleState': ('any', 'SimpleState'), 'groupBitXorSimpleState': ('groupBitXor', 'SimpleState'), 'quantilesInterpolatedWeightedSimpleState': ('quantilesInterpolatedWeighted', 'SimpleState'), 'intervalLengthSumSimpleState': ('intervalLengthSum', 'SimpleState'), 'deltaSumSimpleState': ('deltaSum', 'SimpleState'), 'quantileTDigestSimpleState': ('quantileTDigest', 'SimpleState'), 'stochasticLogisticRegressionSimpleState': ('stochasticLogisticRegression', 'SimpleState'), 'anyLastSimpleState': ('anyLast', 'SimpleState'), 'topKSimpleState': ('topK', 'SimpleState'), 'quantilesExactHighSimpleState': ('quantilesExactHigh', 'SimpleState'), 'welchTTestSimpleState': ('welchTTest', 'SimpleState'), 'quantilesSimpleState': ('quantiles', 'SimpleState'), 'cramersVBiasCorrectedSimpleState': ('cramersVBiasCorrected', 'SimpleState'), 'quantilesExactLowSimpleState': ('quantilesExactLow', 'SimpleState'), 'cramersVSimpleState': ('cramersV', 'SimpleState'), 'quantileTDigestWeightedSimpleState': ('quantileTDigestWeighted', 'SimpleState'), 'meanZTestSimpleState': ('meanZTest', 'SimpleState'), 'uniqCombined64SimpleState': ('uniqCombined64', 'SimpleState'), 'categoricalInformationValueSimpleState': ('categoricalInformationValue', 'SimpleState'), 'groupBitmapOrSimpleState': ('groupBitmapOr', 'SimpleState'), 'quantilesTDigestWeightedSimpleState': ('quantilesTDigestWeighted', 'SimpleState'), 'quantileGKSimpleState': ('quantileGK', 'SimpleState'), 'quantileExactHighSimpleState': ('quantileExactHigh', 'SimpleState'), 'countSimpleState': ('count', 'SimpleState'), 'quantileExactLowSimpleState': ('quantileExactLow', 'SimpleState'), 'simpleLinearRegressionSimpleState': ('simpleLinearRegression', 'SimpleState'), 'deltaSumTimestampSimpleState': ('deltaSumTimestamp', 'SimpleState'), 'skewPopSimpleState': ('skewPop', 'SimpleState'), 'contingencySimpleState': ('contingency', 'SimpleState'), 'maxSimpleState': ('max', 'SimpleState'), 'studentTTestSimpleState': ('studentTTest', 'SimpleState'), 'mannWhitneyUTestSimpleState': ('mannWhitneyUTest', 'SimpleState'), 'groupArrayMovingSumSimpleState': ('groupArrayMovingSum', 'SimpleState'), 'groupArraySimpleState': ('groupArray', 'SimpleState'), 'uniqExactSimpleState': ('uniqExact', 'SimpleState'), 'quantileTimingState': ('quantileTiming', 'State'), 'anyHeavyState': ('anyHeavy', 'State'), 'uniqState': ('uniq', 'State'), 'groupBitmapAndState': ('groupBitmapAnd', 'State'), 'argMinState': ('argMin', 'State'), 'rankCorrState': ('rankCorr', 'State'), 'kolmogorovSmirnovTestState': ('kolmogorovSmirnovTest', 'State'), 'covarPopState': ('covarPop', 'State'), 'quantilesTimingState': ('quantilesTiming', 'State'), 'quantileExactState': ('quantileExact', 'State'), 'medianState': ('median', 'State'), 'quantileBFloat16State': ('quantileBFloat16', 'State'), 'avgWeightedState': ('avgWeighted', 'State'), 'topKWeightedState': ('topKWeighted', 'State'), 'largestTriangleThreeBucketsState': ('largestTriangleThreeBuckets', 'State'), 'sumKahanState': ('sumKahan', 'State'), 'stochasticLinearRegressionState': ('stochasticLinearRegression', 'State'), 'groupBitOrState': ('groupBitOr', 'State'), 'varPopState': ('varPop', 'State'), 'quantilesExactWeightedState': ('quantilesExactWeighted', 'State'), 'quantilesTDigestState': ('quantilesTDigest', 'State'), 'boundingRatioState': ('boundingRatio', 'State'), 'groupArrayInsertAtState': ('groupArrayInsertAt', 'State'), 'quantilesBFloat16State': ('quantilesBFloat16', 'State'), 'exponentialMovingAverageState': ('exponentialMovingAverage', 'State'), 'quantilesExactState': ('quantilesExact', 'State'), 'groupBitmapState': ('groupBitmap', 'State'), 'covarSampState': ('covarSamp', 'State'), 'kurtSampState': ('kurtSamp', 'State'), 'quantilesTimingWeightedState': ('quantilesTimingWeighted', 'State'), 'avgState': ('avg', 'State'), 'quantilesBFloat16WeightedState': ('quantilesBFloat16Weighted', 'State'), 'groupArrayMovingAvgState': ('groupArrayMovingAvg', 'State'), 'stddevPopState': ('stddevPop', 'State'), 'maxIntersectionsPositionState': ('maxIntersectionsPosition', 'State'), 'groupBitAndState': ('groupBitAnd', 'State'), 'theilsUState': ('theilsU', 'State'), 'quantileDeterministicState': ('quantileDeterministic', 'State'), 'corrState': ('corr', 'State'), 'stddevSampState': ('stddevSamp', 'State'), 'uniqThetaState': ('uniqTheta', 'State'), 'groupArraySampleState': ('groupArraySample', 'State'), 'quantileState': ('quantile', 'State'), 'last_valueState': ('last_value', 'State'), 'quantilesDeterministicState': ('quantilesDeterministic', 'State'), 'maxIntersectionsState': ('maxIntersections', 'State'), 'sumCountState': ('sumCount', 'State'), 'uniqHLL12State': ('uniqHLL12', 'State'), 'sumState': ('sum', 'State'), 'quantileBFloat16WeightedState': ('quantileBFloat16Weighted', 'State'), 'groupArrayLastState': ('groupArrayLast', 'State'), 'quantileTimingWeightedState': ('quantileTimingWeighted', 'State'), 'sumWithOverflowState': ('sumWithOverflow', 'State'), 'skewSampState': ('skewSamp', 'State'), 'entropyState': ('entropy', 'State'), 'kurtPopState': ('kurtPop', 'State'), 'sparkBarState': ('sparkBar', 'State'), 'quantileExactWeightedState': ('quantileExactWeighted', 'State'), 'quantileInterpolatedWeightedState': ('quantileInterpolatedWeighted', 'State'), 'groupUniqArrayState': ('groupUniqArray', 'State'), 'first_valueState': ('first_value', 'State'), 'uniqCombinedState': ('uniqCombined', 'State'), 'groupBitmapXorState': ('groupBitmapXor', 'State'), 'varSampState': ('varSamp', 'State'), 'minMapState': ('minMap', 'State'), 'argMaxState': ('argMax', 'State'), 'sumMapState': ('sumMap', 'State'), 'minState': ('min', 'State'), 'maxMapState': ('maxMap', 'State'), 'quantilesGKState': ('quantilesGK', 'State'), 'anyState': ('any', 'State'), 'groupBitXorState': ('groupBitXor', 'State'), 'quantilesInterpolatedWeightedState': ('quantilesInterpolatedWeighted', 'State'), 'intervalLengthSumState': ('intervalLengthSum', 'State'), 'deltaSumState': ('deltaSum', 'State'), 'quantileTDigestState': ('quantileTDigest', 'State'), 'stochasticLogisticRegressionState': ('stochasticLogisticRegression', 'State'), 'anyLastState': ('anyLast', 'State'), 'topKState': ('topK', 'State'), 'quantilesExactHighState': ('quantilesExactHigh', 'State'), 'welchTTestState': ('welchTTest', 'State'), 'quantilesState': ('quantiles', 'State'), 'cramersVBiasCorrectedState': ('cramersVBiasCorrected', 'State'), 'quantilesExactLowState': ('quantilesExactLow', 'State'), 'cramersVState': ('cramersV', 'State'), 'quantileTDigestWeightedState': ('quantileTDigestWeighted', 'State'), 'meanZTestState': ('meanZTest', 'State'), 'uniqCombined64State': ('uniqCombined64', 'State'), 'categoricalInformationValueState': ('categoricalInformationValue', 'State'), 'groupBitmapOrState': ('groupBitmapOr', 'State'), 'quantilesTDigestWeightedState': ('quantilesTDigestWeighted', 'State'), 'quantileGKState': ('quantileGK', 'State'), 'quantileExactHighState': ('quantileExactHigh', 'State'), 'countState': ('count', 'State'), 'quantileExactLowState': ('quantileExactLow', 'State'), 'simpleLinearRegressionState': ('simpleLinearRegression', 'State'), 'deltaSumTimestampState': ('deltaSumTimestamp', 'State'), 'skewPopState': ('skewPop', 'State'), 'contingencyState': ('contingency', 'State'), 'maxState': ('max', 'State'), 'studentTTestState': ('studentTTest', 'State'), 'mannWhitneyUTestState': ('mannWhitneyUTest', 'State'), 'groupArrayMovingSumState': ('groupArrayMovingSum', 'State'), 'groupArrayState': ('groupArray', 'State'), 'uniqExactState': ('uniqExact', 'State'), 'quantileTimingMerge': ('quantileTiming', 'Merge'), 'anyHeavyMerge': ('anyHeavy', 'Merge'), 'uniqMerge': ('uniq', 'Merge'), 'groupBitmapAndMerge': ('groupBitmapAnd', 'Merge'), 'argMinMerge': ('argMin', 'Merge'), 'rankCorrMerge': ('rankCorr', 'Merge'), 'kolmogorovSmirnovTestMerge': ('kolmogorovSmirnovTest', 'Merge'), 'covarPopMerge': ('covarPop', 'Merge'), 'quantilesTimingMerge': ('quantilesTiming', 'Merge'), 'quantileExactMerge': ('quantileExact', 'Merge'), 'medianMerge': ('median', 'Merge'), 'quantileBFloat16Merge': ('quantileBFloat16', 'Merge'), 'avgWeightedMerge': ('avgWeighted', 'Merge'), 'topKWeightedMerge': ('topKWeighted', 'Merge'), 'largestTriangleThreeBucketsMerge': ('largestTriangleThreeBuckets', 'Merge'), 'sumKahanMerge': ('sumKahan', 'Merge'), 'stochasticLinearRegressionMerge': ('stochasticLinearRegression', 'Merge'), 'groupBitOrMerge': ('groupBitOr', 'Merge'), 'varPopMerge': ('varPop', 'Merge'), 'quantilesExactWeightedMerge': ('quantilesExactWeighted', 'Merge'), 'quantilesTDigestMerge': ('quantilesTDigest', 'Merge'), 'boundingRatioMerge': ('boundingRatio', 'Merge'), 'groupArrayInsertAtMerge': ('groupArrayInsertAt', 'Merge'), 'quantilesBFloat16Merge': ('quantilesBFloat16', 'Merge'), 'exponentialMovingAverageMerge': ('exponentialMovingAverage', 'Merge'), 'quantilesExactMerge': ('quantilesExact', 'Merge'), 'groupBitmapMerge': ('groupBitmap', 'Merge'), 'covarSampMerge': ('covarSamp', 'Merge'), 'kurtSampMerge': ('kurtSamp', 'Merge'), 'quantilesTimingWeightedMerge': ('quantilesTimingWeighted', 'Merge'), 'avgMerge': ('avg', 'Merge'), 'quantilesBFloat16WeightedMerge': ('quantilesBFloat16Weighted', 'Merge'), 'groupArrayMovingAvgMerge': ('groupArrayMovingAvg', 'Merge'), 'stddevPopMerge': ('stddevPop', 'Merge'), 'maxIntersectionsPositionMerge': ('maxIntersectionsPosition', 'Merge'), 'groupBitAndMerge': ('groupBitAnd', 'Merge'), 'theilsUMerge': ('theilsU', 'Merge'), 'quantileDeterministicMerge': ('quantileDeterministic', 'Merge'), 'corrMerge': ('corr', 'Merge'), 'stddevSampMerge': ('stddevSamp', 'Merge'), 'uniqThetaMerge': ('uniqTheta', 'Merge'), 'groupArraySampleMerge': ('groupArraySample', 'Merge'), 'quantileMerge': ('quantile', 'Merge'), 'last_valueMerge': ('last_value', 'Merge'), 'quantilesDeterministicMerge': ('quantilesDeterministic', 'Merge'), 'maxIntersectionsMerge': ('maxIntersections', 'Merge'), 'sumCountMerge': ('sumCount', 'Merge'), 'uniqHLL12Merge': ('uniqHLL12', 'Merge'), 'sumMerge': ('sum', 'Merge'), 'quantileBFloat16WeightedMerge': ('quantileBFloat16Weighted', 'Merge'), 'groupArrayLastMerge': ('groupArrayLast', 'Merge'), 'quantileTimingWeightedMerge': ('quantileTimingWeighted', 'Merge'), 'sumWithOverflowMerge': ('sumWithOverflow', 'Merge'), 'skewSampMerge': ('skewSamp', 'Merge'), 'entropyMerge': ('entropy', 'Merge'), 'kurtPopMerge': ('kurtPop', 'Merge'), 'sparkBarMerge': ('sparkBar', 'Merge'), 'quantileExactWeightedMerge': ('quantileExactWeighted', 'Merge'), 'quantileInterpolatedWeightedMerge': ('quantileInterpolatedWeighted', 'Merge'), 'groupUniqArrayMerge': ('groupUniqArray', 'Merge'), 'first_valueMerge': ('first_value', 'Merge'), 'uniqCombinedMerge': ('uniqCombined', 'Merge'), 'groupBitmapXorMerge': ('groupBitmapXor', 'Merge'), 'varSampMerge': ('varSamp', 'Merge'), 'minMapMerge': ('minMap', 'Merge'), 'argMaxMerge': ('argMax', 'Merge'), 'sumMapMerge': ('sumMap', 'Merge'), 'minMerge': ('min', 'Merge'), 'maxMapMerge': ('maxMap', 'Merge'), 'quantilesGKMerge': ('quantilesGK', 'Merge'), 'anyMerge': ('any', 'Merge'), 'groupBitXorMerge': ('groupBitXor', 'Merge'), 'quantilesInterpolatedWeightedMerge': ('quantilesInterpolatedWeighted', 'Merge'), 'intervalLengthSumMerge': ('intervalLengthSum', 'Merge'), 'deltaSumMerge': ('deltaSum', 'Merge'), 'quantileTDigestMerge': ('quantileTDigest', 'Merge'), 'stochasticLogisticRegressionMerge': ('stochasticLogisticRegression', 'Merge'), 'anyLastMerge': ('anyLast', 'Merge'), 'topKMerge': ('topK', 'Merge'), 'quantilesExactHighMerge': ('quantilesExactHigh', 'Merge'), 'welchTTestMerge': ('welchTTest', 'Merge'), 'quantilesMerge': ('quantiles', 'Merge'), 'cramersVBiasCorrectedMerge': ('cramersVBiasCorrected', 'Merge'), 'quantilesExactLowMerge': ('quantilesExactLow', 'Merge'), 'cramersVMerge': ('cramersV', 'Merge'), 'quantileTDigestWeightedMerge': ('quantileTDigestWeighted', 'Merge'), 'meanZTestMerge': ('meanZTest', 'Merge'), 'uniqCombined64Merge': ('uniqCombined64', 'Merge'), 'categoricalInformationValueMerge': ('categoricalInformationValue', 'Merge'), 'groupBitmapOrMerge': ('groupBitmapOr', 'Merge'), 'quantilesTDigestWeightedMerge': ('quantilesTDigestWeighted', 'Merge'), 'quantileGKMerge': ('quantileGK', 'Merge'), 'quantileExactHighMerge': ('quantileExactHigh', 'Merge'), 'countMerge': ('count', 'Merge'), 'quantileExactLowMerge': ('quantileExactLow', 'Merge'), 'simpleLinearRegressionMerge': ('simpleLinearRegression', 'Merge'), 'deltaSumTimestampMerge': ('deltaSumTimestamp', 'Merge'), 'skewPopMerge': ('skewPop', 'Merge'), 'contingencyMerge': ('contingency', 'Merge'), 'maxMerge': ('max', 'Merge'), 'studentTTestMerge': ('studentTTest', 'Merge'), 'mannWhitneyUTestMerge': ('mannWhitneyUTest', 'Merge'), 'groupArrayMovingSumMerge': ('groupArrayMovingSum', 'Merge'), 'groupArrayMerge': ('groupArray', 'Merge'), 'uniqExactMerge': ('uniqExact', 'Merge'), 'quantileTimingMergeState': ('quantileTiming', 'MergeState'), 'anyHeavyMergeState': ('anyHeavy', 'MergeState'), 'uniqMergeState': ('uniq', 'MergeState'), 'groupBitmapAndMergeState': ('groupBitmapAnd', 'MergeState'), 'argMinMergeState': ('argMin', 'MergeState'), 'rankCorrMergeState': ('rankCorr', 'MergeState'), 'kolmogorovSmirnovTestMergeState': ('kolmogorovSmirnovTest', 'MergeState'), 'covarPopMergeState': ('covarPop', 'MergeState'), 'quantilesTimingMergeState': ('quantilesTiming', 'MergeState'), 'quantileExactMergeState': ('quantileExact', 'MergeState'), 'medianMergeState': ('median', 'MergeState'), 'quantileBFloat16MergeState': ('quantileBFloat16', 'MergeState'), 'avgWeightedMergeState': ('avgWeighted', 'MergeState'), 'topKWeightedMergeState': ('topKWeighted', 'MergeState'), 'largestTriangleThreeBucketsMergeState': ('largestTriangleThreeBuckets', 'MergeState'), 'sumKahanMergeState': ('sumKahan', 'MergeState'), 'stochasticLinearRegressionMergeState': ('stochasticLinearRegression', 'MergeState'), 'groupBitOrMergeState': ('groupBitOr', 'MergeState'), 'varPopMergeState': ('varPop', 'MergeState'), 'quantilesExactWeightedMergeState': ('quantilesExactWeighted', 'MergeState'), 'quantilesTDigestMergeState': ('quantilesTDigest', 'MergeState'), 'boundingRatioMergeState': ('boundingRatio', 'MergeState'), 'groupArrayInsertAtMergeState': ('groupArrayInsertAt', 'MergeState'), 'quantilesBFloat16MergeState': ('quantilesBFloat16', 'MergeState'), 'exponentialMovingAverageMergeState': ('exponentialMovingAverage', 'MergeState'), 'quantilesExactMergeState': ('quantilesExact', 'MergeState'), 'groupBitmapMergeState': ('groupBitmap', 'MergeState'), 'covarSampMergeState': ('covarSamp', 'MergeState'), 'kurtSampMergeState': ('kurtSamp', 'MergeState'), 'quantilesTimingWeightedMergeState': ('quantilesTimingWeighted', 'MergeState'), 'avgMergeState': ('avg', 'MergeState'), 'quantilesBFloat16WeightedMergeState': ('quantilesBFloat16Weighted', 'MergeState'), 'groupArrayMovingAvgMergeState': ('groupArrayMovingAvg', 'MergeState'), 'stddevPopMergeState': ('stddevPop', 'MergeState'), 'maxIntersectionsPositionMergeState': ('maxIntersectionsPosition', 'MergeState'), 'groupBitAndMergeState': ('groupBitAnd', 'MergeState'), 'theilsUMergeState': ('theilsU', 'MergeState'), 'quantileDeterministicMergeState': ('quantileDeterministic', 'MergeState'), 'corrMergeState': ('corr', 'MergeState'), 'stddevSampMergeState': ('stddevSamp', 'MergeState'), 'uniqThetaMergeState': ('uniqTheta', 'MergeState'), 'groupArraySampleMergeState': ('groupArraySample', 'MergeState'), 'quantileMergeState': ('quantile', 'MergeState'), 'last_valueMergeState': ('last_value', 'MergeState'), 'quantilesDeterministicMergeState': ('quantilesDeterministic', 'MergeState'), 'maxIntersectionsMergeState': ('maxIntersections', 'MergeState'), 'sumCountMergeState': ('sumCount', 'MergeState'), 'uniqHLL12MergeState': ('uniqHLL12', 'MergeState'), 'sumMergeState': ('sum', 'MergeState'), 'quantileBFloat16WeightedMergeState': ('quantileBFloat16Weighted', 'MergeState'), 'groupArrayLastMergeState': ('groupArrayLast', 'MergeState'), 'quantileTimingWeightedMergeState': ('quantileTimingWeighted', 'MergeState'), 'sumWithOverflowMergeState': ('sumWithOverflow', 'MergeState'), 'skewSampMergeState': ('skewSamp', 'MergeState'), 'entropyMergeState': ('entropy', 'MergeState'), 'kurtPopMergeState': ('kurtPop', 'MergeState'), 'sparkBarMergeState': ('sparkBar', 'MergeState'), 'quantileExactWeightedMergeState': ('quantileExactWeighted', 'MergeState'), 'quantileInterpolatedWeightedMergeState': ('quantileInterpolatedWeighted', 'MergeState'), 'groupUniqArrayMergeState': ('groupUniqArray', 'MergeState'), 'first_valueMergeState': ('first_value', 'MergeState'), 'uniqCombinedMergeState': ('uniqCombined', 'MergeState'), 'groupBitmapXorMergeState': ('groupBitmapXor', 'MergeState'), 'varSampMergeState': ('varSamp', 'MergeState'), 'minMapMergeState': ('minMap', 'MergeState'), 'argMaxMergeState': ('argMax', 'MergeState'), 'sumMapMergeState': ('sumMap', 'MergeState'), 'minMergeState': ('min', 'MergeState'), 'maxMapMergeState': ('maxMap', 'MergeState'), 'quantilesGKMergeState': ('quantilesGK', 'MergeState'), 'anyMergeState': ('any', 'MergeState'), 'groupBitXorMergeState': ('groupBitXor', 'MergeState'), 'quantilesInterpolatedWeightedMergeState': ('quantilesInterpolatedWeighted', 'MergeState'), 'intervalLengthSumMergeState': ('intervalLengthSum', 'MergeState'), 'deltaSumMergeState': ('deltaSum', 'MergeState'), 'quantileTDigestMergeState': ('quantileTDigest', 'MergeState'), 'stochasticLogisticRegressionMergeState': ('stochasticLogisticRegression', 'MergeState'), 'anyLastMergeState': ('anyLast', 'MergeState'), 'topKMergeState': ('topK', 'MergeState'), 'quantilesExactHighMergeState': ('quantilesExactHigh', 'MergeState'), 'welchTTestMergeState': ('welchTTest', 'MergeState'), 'quantilesMergeState': ('quantiles', 'MergeState'), 'cramersVBiasCorrectedMergeState': ('cramersVBiasCorrected', 'MergeState'), 'quantilesExactLowMergeState': ('quantilesExactLow', 'MergeState'), 'cramersVMergeState': ('cramersV', 'MergeState'), 'quantileTDigestWeightedMergeState': ('quantileTDigestWeighted', 'MergeState'), 'meanZTestMergeState': ('meanZTest', 'MergeState'), 'uniqCombined64MergeState': ('uniqCombined64', 'MergeState'), 'categoricalInformationValueMergeState': ('categoricalInformationValue', 'MergeState'), 'groupBitmapOrMergeState': ('groupBitmapOr', 'MergeState'), 'quantilesTDigestWeightedMergeState': ('quantilesTDigestWeighted', 'MergeState'), 'quantileGKMergeState': ('quantileGK', 'MergeState'), 'quantileExactHighMergeState': ('quantileExactHigh', 'MergeState'), 'countMergeState': ('count', 'MergeState'), 'quantileExactLowMergeState': ('quantileExactLow', 'MergeState'), 'simpleLinearRegressionMergeState': ('simpleLinearRegression', 'MergeState'), 'deltaSumTimestampMergeState': ('deltaSumTimestamp', 'MergeState'), 'skewPopMergeState': ('skewPop', 'MergeState'), 'contingencyMergeState': ('contingency', 'MergeState'), 'maxMergeState': ('max', 'MergeState'), 'studentTTestMergeState': ('studentTTest', 'MergeState'), 'mannWhitneyUTestMergeState': ('mannWhitneyUTest', 'MergeState'), 'groupArrayMovingSumMergeState': ('groupArrayMovingSum', 'MergeState'), 'groupArrayMergeState': ('groupArray', 'MergeState'), 'uniqExactMergeState': ('uniqExact', 'MergeState'), 'quantileTimingForEach': ('quantileTiming', 'ForEach'), 'anyHeavyForEach': ('anyHeavy', 'ForEach'), 'uniqForEach': ('uniq', 'ForEach'), 'groupBitmapAndForEach': ('groupBitmapAnd', 'ForEach'), 'argMinForEach': ('argMin', 'ForEach'), 'rankCorrForEach': ('rankCorr', 'ForEach'), 'kolmogorovSmirnovTestForEach': ('kolmogorovSmirnovTest', 'ForEach'), 'covarPopForEach': ('covarPop', 'ForEach'), 'quantilesTimingForEach': ('quantilesTiming', 'ForEach'), 'quantileExactForEach': ('quantileExact', 'ForEach'), 'medianForEach': ('median', 'ForEach'), 'quantileBFloat16ForEach': ('quantileBFloat16', 'ForEach'), 'avgWeightedForEach': ('avgWeighted', 'ForEach'), 'topKWeightedForEach': ('topKWeighted', 'ForEach'), 'largestTriangleThreeBucketsForEach': ('largestTriangleThreeBuckets', 'ForEach'), 'sumKahanForEach': ('sumKahan', 'ForEach'), 'stochasticLinearRegressionForEach': ('stochasticLinearRegression', 'ForEach'), 'groupBitOrForEach': ('groupBitOr', 'ForEach'), 'varPopForEach': ('varPop', 'ForEach'), 'quantilesExactWeightedForEach': ('quantilesExactWeighted', 'ForEach'), 'quantilesTDigestForEach': ('quantilesTDigest', 'ForEach'), 'boundingRatioForEach': ('boundingRatio', 'ForEach'), 'groupArrayInsertAtForEach': ('groupArrayInsertAt', 'ForEach'), 'quantilesBFloat16ForEach': ('quantilesBFloat16', 'ForEach'), 'exponentialMovingAverageForEach': ('exponentialMovingAverage', 'ForEach'), 'quantilesExactForEach': ('quantilesExact', 'ForEach'), 'groupBitmapForEach': ('groupBitmap', 'ForEach'), 'covarSampForEach': ('covarSamp', 'ForEach'), 'kurtSampForEach': ('kurtSamp', 'ForEach'), 'quantilesTimingWeightedForEach': ('quantilesTimingWeighted', 'ForEach'), 'avgForEach': ('avg', 'ForEach'), 'quantilesBFloat16WeightedForEach': ('quantilesBFloat16Weighted', 'ForEach'), 'groupArrayMovingAvgForEach': ('groupArrayMovingAvg', 'ForEach'), 'stddevPopForEach': ('stddevPop', 'ForEach'), 'maxIntersectionsPositionForEach': ('maxIntersectionsPosition', 'ForEach'), 'groupBitAndForEach': ('groupBitAnd', 'ForEach'), 'theilsUForEach': ('theilsU', 'ForEach'), 'quantileDeterministicForEach': ('quantileDeterministic', 'ForEach'), 'corrForEach': ('corr', 'ForEach'), 'stddevSampForEach': ('stddevSamp', 'ForEach'), 'uniqThetaForEach': ('uniqTheta', 'ForEach'), 'groupArraySampleForEach': ('groupArraySample', 'ForEach'), 'quantileForEach': ('quantile', 'ForEach'), 'last_valueForEach': ('last_value', 'ForEach'), 'quantilesDeterministicForEach': ('quantilesDeterministic', 'ForEach'), 'maxIntersectionsForEach': ('maxIntersections', 'ForEach'), 'sumCountForEach': ('sumCount', 'ForEach'), 'uniqHLL12ForEach': ('uniqHLL12', 'ForEach'), 'sumForEach': ('sum', 'ForEach'), 'quantileBFloat16WeightedForEach': ('quantileBFloat16Weighted', 'ForEach'), 'groupArrayLastForEach': ('groupArrayLast', 'ForEach'), 'quantileTimingWeightedForEach': ('quantileTimingWeighted', 'ForEach'), 'sumWithOverflowForEach': ('sumWithOverflow', 'ForEach'), 'skewSampForEach': ('skewSamp', 'ForEach'), 'entropyForEach': ('entropy', 'ForEach'), 'kurtPopForEach': ('kurtPop', 'ForEach'), 'sparkBarForEach': ('sparkBar', 'ForEach'), 'quantileExactWeightedForEach': ('quantileExactWeighted', 'ForEach'), 'quantileInterpolatedWeightedForEach': ('quantileInterpolatedWeighted', 'ForEach'), 'groupUniqArrayForEach': ('groupUniqArray', 'ForEach'), 'first_valueForEach': ('first_value', 'ForEach'), 'uniqCombinedForEach': ('uniqCombined', 'ForEach'), 'groupBitmapXorForEach': ('groupBitmapXor', 'ForEach'), 'varSampForEach': ('varSamp', 'ForEach'), 'minMapForEach': ('minMap', 'ForEach'), 'argMaxForEach': ('argMax', 'ForEach'), 'sumMapForEach': ('sumMap', 'ForEach'), 'minForEach': ('min', 'ForEach'), 'maxMapForEach': ('maxMap', 'ForEach'), 'quantilesGKForEach': ('quantilesGK', 'ForEach'), 'anyForEach': ('any', 'ForEach'), 'groupBitXorForEach': ('groupBitXor', 'ForEach'), 'quantilesInterpolatedWeightedForEach': ('quantilesInterpolatedWeighted', 'ForEach'), 'intervalLengthSumForEach': ('intervalLengthSum', 'ForEach'), 'deltaSumForEach': ('deltaSum', 'ForEach'), 'quantileTDigestForEach': ('quantileTDigest', 'ForEach'), 'stochasticLogisticRegressionForEach': ('stochasticLogisticRegression', 'ForEach'), 'anyLastForEach': ('anyLast', 'ForEach'), 'topKForEach': ('topK', 'ForEach'), 'quantilesExactHighForEach': ('quantilesExactHigh', 'ForEach'), 'welchTTestForEach': ('welchTTest', 'ForEach'), 'quantilesForEach': ('quantiles', 'ForEach'), 'cramersVBiasCorrectedForEach': ('cramersVBiasCorrected', 'ForEach'), 'quantilesExactLowForEach': ('quantilesExactLow', 'ForEach'), 'cramersVForEach': ('cramersV', 'ForEach'), 'quantileTDigestWeightedForEach': ('quantileTDigestWeighted', 'ForEach'), 'meanZTestForEach': ('meanZTest', 'ForEach'), 'uniqCombined64ForEach': ('uniqCombined64', 'ForEach'), 'categoricalInformationValueForEach': ('categoricalInformationValue', 'ForEach'), 'groupBitmapOrForEach': ('groupBitmapOr', 'ForEach'), 'quantilesTDigestWeightedForEach': ('quantilesTDigestWeighted', 'ForEach'), 'quantileGKForEach': ('quantileGK', 'ForEach'), 'quantileExactHighForEach': ('quantileExactHigh', 'ForEach'), 'countForEach': ('count', 'ForEach'), 'quantileExactLowForEach': ('quantileExactLow', 'ForEach'), 'simpleLinearRegressionForEach': ('simpleLinearRegression', 'ForEach'), 'deltaSumTimestampForEach': ('deltaSumTimestamp', 'ForEach'), 'skewPopForEach': ('skewPop', 'ForEach'), 'contingencyForEach': ('contingency', 'ForEach'), 'maxForEach': ('max', 'ForEach'), 'studentTTestForEach': ('studentTTest', 'ForEach'), 'mannWhitneyUTestForEach': ('mannWhitneyUTest', 'ForEach'), 'groupArrayMovingSumForEach': ('groupArrayMovingSum', 'ForEach'), 'groupArrayForEach': ('groupArray', 'ForEach'), 'uniqExactForEach': ('uniqExact', 'ForEach'), 'quantileTimingDistinct': ('quantileTiming', 'Distinct'), 'anyHeavyDistinct': ('anyHeavy', 'Distinct'), 'uniqDistinct': ('uniq', 'Distinct'), 'groupBitmapAndDistinct': ('groupBitmapAnd', 'Distinct'), 'argMinDistinct': ('argMin', 'Distinct'), 'rankCorrDistinct': ('rankCorr', 'Distinct'), 'kolmogorovSmirnovTestDistinct': ('kolmogorovSmirnovTest', 'Distinct'), 'covarPopDistinct': ('covarPop', 'Distinct'), 'quantilesTimingDistinct': ('quantilesTiming', 'Distinct'), 'quantileExactDistinct': ('quantileExact', 'Distinct'), 'medianDistinct': ('median', 'Distinct'), 'quantileBFloat16Distinct': ('quantileBFloat16', 'Distinct'), 'avgWeightedDistinct': ('avgWeighted', 'Distinct'), 'topKWeightedDistinct': ('topKWeighted', 'Distinct'), 'largestTriangleThreeBucketsDistinct': ('largestTriangleThreeBuckets', 'Distinct'), 'sumKahanDistinct': ('sumKahan', 'Distinct'), 'stochasticLinearRegressionDistinct': ('stochasticLinearRegression', 'Distinct'), 'groupBitOrDistinct': ('groupBitOr', 'Distinct'), 'varPopDistinct': ('varPop', 'Distinct'), 'quantilesExactWeightedDistinct': ('quantilesExactWeighted', 'Distinct'), 'quantilesTDigestDistinct': ('quantilesTDigest', 'Distinct'), 'boundingRatioDistinct': ('boundingRatio', 'Distinct'), 'groupArrayInsertAtDistinct': ('groupArrayInsertAt', 'Distinct'), 'quantilesBFloat16Distinct': ('quantilesBFloat16', 'Distinct'), 'exponentialMovingAverageDistinct': ('exponentialMovingAverage', 'Distinct'), 'quantilesExactDistinct': ('quantilesExact', 'Distinct'), 'groupBitmapDistinct': ('groupBitmap', 'Distinct'), 'covarSampDistinct': ('covarSamp', 'Distinct'), 'kurtSampDistinct': ('kurtSamp', 'Distinct'), 'quantilesTimingWeightedDistinct': ('quantilesTimingWeighted', 'Distinct'), 'avgDistinct': ('avg', 'Distinct'), 'quantilesBFloat16WeightedDistinct': ('quantilesBFloat16Weighted', 'Distinct'), 'groupArrayMovingAvgDistinct': ('groupArrayMovingAvg', 'Distinct'), 'stddevPopDistinct': ('stddevPop', 'Distinct'), 'maxIntersectionsPositionDistinct': ('maxIntersectionsPosition', 'Distinct'), 'groupBitAndDistinct': ('groupBitAnd', 'Distinct'), 'theilsUDistinct': ('theilsU', 'Distinct'), 'quantileDeterministicDistinct': ('quantileDeterministic', 'Distinct'), 'corrDistinct': ('corr', 'Distinct'), 'stddevSampDistinct': ('stddevSamp', 'Distinct'), 'uniqThetaDistinct': ('uniqTheta', 'Distinct'), 'groupArraySampleDistinct': ('groupArraySample', 'Distinct'), 'quantileDistinct': ('quantile', 'Distinct'), 'last_valueDistinct': ('last_value', 'Distinct'), 'quantilesDeterministicDistinct': ('quantilesDeterministic', 'Distinct'), 'maxIntersectionsDistinct': ('maxIntersections', 'Distinct'), 'sumCountDistinct': ('sumCount', 'Distinct'), 'uniqHLL12Distinct': ('uniqHLL12', 'Distinct'), 'sumDistinct': ('sum', 'Distinct'), 'quantileBFloat16WeightedDistinct': ('quantileBFloat16Weighted', 'Distinct'), 'groupArrayLastDistinct': ('groupArrayLast', 'Distinct'), 'quantileTimingWeightedDistinct': ('quantileTimingWeighted', 'Distinct'), 'sumWithOverflowDistinct': ('sumWithOverflow', 'Distinct'), 'skewSampDistinct': ('skewSamp', 'Distinct'), 'entropyDistinct': ('entropy', 'Distinct'), 'kurtPopDistinct': ('kurtPop', 'Distinct'), 'sparkBarDistinct': ('sparkBar', 'Distinct'), 'quantileExactWeightedDistinct': ('quantileExactWeighted', 'Distinct'), 'quantileInterpolatedWeightedDistinct': ('quantileInterpolatedWeighted', 'Distinct'), 'groupUniqArrayDistinct': ('groupUniqArray', 'Distinct'), 'first_valueDistinct': ('first_value', 'Distinct'), 'uniqCombinedDistinct': ('uniqCombined', 'Distinct'), 'groupBitmapXorDistinct': ('groupBitmapXor', 'Distinct'), 'varSampDistinct': ('varSamp', 'Distinct'), 'minMapDistinct': ('minMap', 'Distinct'), 'argMaxDistinct': ('argMax', 'Distinct'), 'sumMapDistinct': ('sumMap', 'Distinct'), 'minDistinct': ('min', 'Distinct'), 'maxMapDistinct': ('maxMap', 'Distinct'), 'quantilesGKDistinct': ('quantilesGK', 'Distinct'), 'anyDistinct': ('any', 'Distinct'), 'groupBitXorDistinct': ('groupBitXor', 'Distinct'), 'quantilesInterpolatedWeightedDistinct': ('quantilesInterpolatedWeighted', 'Distinct'), 'intervalLengthSumDistinct': ('intervalLengthSum', 'Distinct'), 'deltaSumDistinct': ('deltaSum', 'Distinct'), 'quantileTDigestDistinct': ('quantileTDigest', 'Distinct'), 'stochasticLogisticRegressionDistinct': ('stochasticLogisticRegression', 'Distinct'), 'anyLastDistinct': ('anyLast', 'Distinct'), 'topKDistinct': ('topK', 'Distinct'), 'quantilesExactHighDistinct': ('quantilesExactHigh', 'Distinct'), 'welchTTestDistinct': ('welchTTest', 'Distinct'), 'quantilesDistinct': ('quantiles', 'Distinct'), 'cramersVBiasCorrectedDistinct': ('cramersVBiasCorrected', 'Distinct'), 'quantilesExactLowDistinct': ('quantilesExactLow', 'Distinct'), 'cramersVDistinct': ('cramersV', 'Distinct'), 'quantileTDigestWeightedDistinct': ('quantileTDigestWeighted', 'Distinct'), 'meanZTestDistinct': ('meanZTest', 'Distinct'), 'uniqCombined64Distinct': ('uniqCombined64', 'Distinct'), 'categoricalInformationValueDistinct': ('categoricalInformationValue', 'Distinct'), 'groupBitmapOrDistinct': ('groupBitmapOr', 'Distinct'), 'quantilesTDigestWeightedDistinct': ('quantilesTDigestWeighted', 'Distinct'), 'quantileGKDistinct': ('quantileGK', 'Distinct'), 'quantileExactHighDistinct': ('quantileExactHigh', 'Distinct'), 'countDistinct': ('count', 'Distinct'), 'quantileExactLowDistinct': ('quantileExactLow', 'Distinct'), 'simpleLinearRegressionDistinct': ('simpleLinearRegression', 'Distinct'), 'deltaSumTimestampDistinct': ('deltaSumTimestamp', 'Distinct'), 'skewPopDistinct': ('skewPop', 'Distinct'), 'contingencyDistinct': ('contingency', 'Distinct'), 'maxDistinct': ('max', 'Distinct'), 'studentTTestDistinct': ('studentTTest', 'Distinct'), 'mannWhitneyUTestDistinct': ('mannWhitneyUTest', 'Distinct'), 'groupArrayMovingSumDistinct': ('groupArrayMovingSum', 'Distinct'), 'groupArrayDistinct': ('groupArray', 'Distinct'), 'uniqExactDistinct': ('uniqExact', 'Distinct'), 'quantileTimingOrDefault': ('quantileTiming', 'OrDefault'), 'anyHeavyOrDefault': ('anyHeavy', 'OrDefault'), 'uniqOrDefault': ('uniq', 'OrDefault'), 'groupBitmapAndOrDefault': ('groupBitmapAnd', 'OrDefault'), 'argMinOrDefault': ('argMin', 'OrDefault'), 'rankCorrOrDefault': ('rankCorr', 'OrDefault'), 'kolmogorovSmirnovTestOrDefault': ('kolmogorovSmirnovTest', 'OrDefault'), 'covarPopOrDefault': ('covarPop', 'OrDefault'), 'quantilesTimingOrDefault': ('quantilesTiming', 'OrDefault'), 'quantileExactOrDefault': ('quantileExact', 'OrDefault'), 'medianOrDefault': ('median', 'OrDefault'), 'quantileBFloat16OrDefault': ('quantileBFloat16', 'OrDefault'), 'avgWeightedOrDefault': ('avgWeighted', 'OrDefault'), 'topKWeightedOrDefault': ('topKWeighted', 'OrDefault'), 'largestTriangleThreeBucketsOrDefault': ('largestTriangleThreeBuckets', 'OrDefault'), 'sumKahanOrDefault': ('sumKahan', 'OrDefault'), 'stochasticLinearRegressionOrDefault': ('stochasticLinearRegression', 'OrDefault'), 'groupBitOrOrDefault': ('groupBitOr', 'OrDefault'), 'varPopOrDefault': ('varPop', 'OrDefault'), 'quantilesExactWeightedOrDefault': ('quantilesExactWeighted', 'OrDefault'), 'quantilesTDigestOrDefault': ('quantilesTDigest', 'OrDefault'), 'boundingRatioOrDefault': ('boundingRatio', 'OrDefault'), 'groupArrayInsertAtOrDefault': ('groupArrayInsertAt', 'OrDefault'), 'quantilesBFloat16OrDefault': ('quantilesBFloat16', 'OrDefault'), 'exponentialMovingAverageOrDefault': ('exponentialMovingAverage', 'OrDefault'), 'quantilesExactOrDefault': ('quantilesExact', 'OrDefault'), 'groupBitmapOrDefault': ('groupBitmap', 'OrDefault'), 'covarSampOrDefault': ('covarSamp', 'OrDefault'), 'kurtSampOrDefault': ('kurtSamp', 'OrDefault'), 'quantilesTimingWeightedOrDefault': ('quantilesTimingWeighted', 'OrDefault'), 'avgOrDefault': ('avg', 'OrDefault'), 'quantilesBFloat16WeightedOrDefault': ('quantilesBFloat16Weighted', 'OrDefault'), 'groupArrayMovingAvgOrDefault': ('groupArrayMovingAvg', 'OrDefault'), 'stddevPopOrDefault': ('stddevPop', 'OrDefault'), 'maxIntersectionsPositionOrDefault': ('maxIntersectionsPosition', 'OrDefault'), 'groupBitAndOrDefault': ('groupBitAnd', 'OrDefault'), 'theilsUOrDefault': ('theilsU', 'OrDefault'), 'quantileDeterministicOrDefault': ('quantileDeterministic', 'OrDefault'), 'corrOrDefault': ('corr', 'OrDefault'), 'stddevSampOrDefault': ('stddevSamp', 'OrDefault'), 'uniqThetaOrDefault': ('uniqTheta', 'OrDefault'), 'groupArraySampleOrDefault': ('groupArraySample', 'OrDefault'), 'quantileOrDefault': ('quantile', 'OrDefault'), 'last_valueOrDefault': ('last_value', 'OrDefault'), 'quantilesDeterministicOrDefault': ('quantilesDeterministic', 'OrDefault'), 'maxIntersectionsOrDefault': ('maxIntersections', 'OrDefault'), 'sumCountOrDefault': ('sumCount', 'OrDefault'), 'uniqHLL12OrDefault': ('uniqHLL12', 'OrDefault'), 'sumOrDefault': ('sum', 'OrDefault'), 'quantileBFloat16WeightedOrDefault': ('quantileBFloat16Weighted', 'OrDefault'), 'groupArrayLastOrDefault': ('groupArrayLast', 'OrDefault'), 'quantileTimingWeightedOrDefault': ('quantileTimingWeighted', 'OrDefault'), 'sumWithOverflowOrDefault': ('sumWithOverflow', 'OrDefault'), 'skewSampOrDefault': ('skewSamp', 'OrDefault'), 'entropyOrDefault': ('entropy', 'OrDefault'), 'kurtPopOrDefault': ('kurtPop', 'OrDefault'), 'sparkBarOrDefault': ('sparkBar', 'OrDefault'), 'quantileExactWeightedOrDefault': ('quantileExactWeighted', 'OrDefault'), 'quantileInterpolatedWeightedOrDefault': ('quantileInterpolatedWeighted', 'OrDefault'), 'groupUniqArrayOrDefault': ('groupUniqArray', 'OrDefault'), 'first_valueOrDefault': ('first_value', 'OrDefault'), 'uniqCombinedOrDefault': ('uniqCombined', 'OrDefault'), 'groupBitmapXorOrDefault': ('groupBitmapXor', 'OrDefault'), 'varSampOrDefault': ('varSamp', 'OrDefault'), 'minMapOrDefault': ('minMap', 'OrDefault'), 'argMaxOrDefault': ('argMax', 'OrDefault'), 'sumMapOrDefault': ('sumMap', 'OrDefault'), 'minOrDefault': ('min', 'OrDefault'), 'maxMapOrDefault': ('maxMap', 'OrDefault'), 'quantilesGKOrDefault': ('quantilesGK', 'OrDefault'), 'anyOrDefault': ('any', 'OrDefault'), 'groupBitXorOrDefault': ('groupBitXor', 'OrDefault'), 'quantilesInterpolatedWeightedOrDefault': ('quantilesInterpolatedWeighted', 'OrDefault'), 'intervalLengthSumOrDefault': ('intervalLengthSum', 'OrDefault'), 'deltaSumOrDefault': ('deltaSum', 'OrDefault'), 'quantileTDigestOrDefault': ('quantileTDigest', 'OrDefault'), 'stochasticLogisticRegressionOrDefault': ('stochasticLogisticRegression', 'OrDefault'), 'anyLastOrDefault': ('anyLast', 'OrDefault'), 'topKOrDefault': ('topK', 'OrDefault'), 'quantilesExactHighOrDefault': ('quantilesExactHigh', 'OrDefault'), 'welchTTestOrDefault': ('welchTTest', 'OrDefault'), 'quantilesOrDefault': ('quantiles', 'OrDefault'), 'cramersVBiasCorrectedOrDefault': ('cramersVBiasCorrected', 'OrDefault'), 'quantilesExactLowOrDefault': ('quantilesExactLow', 'OrDefault'), 'cramersVOrDefault': ('cramersV', 'OrDefault'), 'quantileTDigestWeightedOrDefault': ('quantileTDigestWeighted', 'OrDefault'), 'meanZTestOrDefault': ('meanZTest', 'OrDefault'), 'uniqCombined64OrDefault': ('uniqCombined64', 'OrDefault'), 'categoricalInformationValueOrDefault': ('categoricalInformationValue', 'OrDefault'), 'groupBitmapOrOrDefault': ('groupBitmapOr', 'OrDefault'), 'quantilesTDigestWeightedOrDefault': ('quantilesTDigestWeighted', 'OrDefault'), 'quantileGKOrDefault': ('quantileGK', 'OrDefault'), 'quantileExactHighOrDefault': ('quantileExactHigh', 'OrDefault'), 'countOrDefault': ('count', 'OrDefault'), 'quantileExactLowOrDefault': ('quantileExactLow', 'OrDefault'), 'simpleLinearRegressionOrDefault': ('simpleLinearRegression', 'OrDefault'), 'deltaSumTimestampOrDefault': ('deltaSumTimestamp', 'OrDefault'), 'skewPopOrDefault': ('skewPop', 'OrDefault'), 'contingencyOrDefault': ('contingency', 'OrDefault'), 'maxOrDefault': ('max', 'OrDefault'), 'studentTTestOrDefault': ('studentTTest', 'OrDefault'), 'mannWhitneyUTestOrDefault': ('mannWhitneyUTest', 'OrDefault'), 'groupArrayMovingSumOrDefault': ('groupArrayMovingSum', 'OrDefault'), 'groupArrayOrDefault': ('groupArray', 'OrDefault'), 'uniqExactOrDefault': ('uniqExact', 'OrDefault'), 'quantileTimingOrNull': ('quantileTiming', 'OrNull'), 'anyHeavyOrNull': ('anyHeavy', 'OrNull'), 'uniqOrNull': ('uniq', 'OrNull'), 'groupBitmapAndOrNull': ('groupBitmapAnd', 'OrNull'), 'argMinOrNull': ('argMin', 'OrNull'), 'rankCorrOrNull': ('rankCorr', 'OrNull'), 'kolmogorovSmirnovTestOrNull': ('kolmogorovSmirnovTest', 'OrNull'), 'covarPopOrNull': ('covarPop', 'OrNull'), 'quantilesTimingOrNull': ('quantilesTiming', 'OrNull'), 'quantileExactOrNull': ('quantileExact', 'OrNull'), 'medianOrNull': ('median', 'OrNull'), 'quantileBFloat16OrNull': ('quantileBFloat16', 'OrNull'), 'avgWeightedOrNull': ('avgWeighted', 'OrNull'), 'topKWeightedOrNull': ('topKWeighted', 'OrNull'), 'largestTriangleThreeBucketsOrNull': ('largestTriangleThreeBuckets', 'OrNull'), 'sumKahanOrNull': ('sumKahan', 'OrNull'), 'stochasticLinearRegressionOrNull': ('stochasticLinearRegression', 'OrNull'), 'groupBitOrOrNull': ('groupBitOr', 'OrNull'), 'varPopOrNull': ('varPop', 'OrNull'), 'quantilesExactWeightedOrNull': ('quantilesExactWeighted', 'OrNull'), 'quantilesTDigestOrNull': ('quantilesTDigest', 'OrNull'), 'boundingRatioOrNull': ('boundingRatio', 'OrNull'), 'groupArrayInsertAtOrNull': ('groupArrayInsertAt', 'OrNull'), 'quantilesBFloat16OrNull': ('quantilesBFloat16', 'OrNull'), 'exponentialMovingAverageOrNull': ('exponentialMovingAverage', 'OrNull'), 'quantilesExactOrNull': ('quantilesExact', 'OrNull'), 'groupBitmapOrNull': ('groupBitmap', 'OrNull'), 'covarSampOrNull': ('covarSamp', 'OrNull'), 'kurtSampOrNull': ('kurtSamp', 'OrNull'), 'quantilesTimingWeightedOrNull': ('quantilesTimingWeighted', 'OrNull'), 'avgOrNull': ('avg', 'OrNull'), 'quantilesBFloat16WeightedOrNull': ('quantilesBFloat16Weighted', 'OrNull'), 'groupArrayMovingAvgOrNull': ('groupArrayMovingAvg', 'OrNull'), 'stddevPopOrNull': ('stddevPop', 'OrNull'), 'maxIntersectionsPositionOrNull': ('maxIntersectionsPosition', 'OrNull'), 'groupBitAndOrNull': ('groupBitAnd', 'OrNull'), 'theilsUOrNull': ('theilsU', 'OrNull'), 'quantileDeterministicOrNull': ('quantileDeterministic', 'OrNull'), 'corrOrNull': ('corr', 'OrNull'), 'stddevSampOrNull': ('stddevSamp', 'OrNull'), 'uniqThetaOrNull': ('uniqTheta', 'OrNull'), 'groupArraySampleOrNull': ('groupArraySample', 'OrNull'), 'quantileOrNull': ('quantile', 'OrNull'), 'last_valueOrNull': ('last_value', 'OrNull'), 'quantilesDeterministicOrNull': ('quantilesDeterministic', 'OrNull'), 'maxIntersectionsOrNull': ('maxIntersections', 'OrNull'), 'sumCountOrNull': ('sumCount', 'OrNull'), 'uniqHLL12OrNull': ('uniqHLL12', 'OrNull'), 'sumOrNull': ('sum', 'OrNull'), 'quantileBFloat16WeightedOrNull': ('quantileBFloat16Weighted', 'OrNull'), 'groupArrayLastOrNull': ('groupArrayLast', 'OrNull'), 'quantileTimingWeightedOrNull': ('quantileTimingWeighted', 'OrNull'), 'sumWithOverflowOrNull': ('sumWithOverflow', 'OrNull'), 'skewSampOrNull': ('skewSamp', 'OrNull'), 'entropyOrNull': ('entropy', 'OrNull'), 'kurtPopOrNull': ('kurtPop', 'OrNull'), 'sparkBarOrNull': ('sparkBar', 'OrNull'), 'quantileExactWeightedOrNull': ('quantileExactWeighted', 'OrNull'), 'quantileInterpolatedWeightedOrNull': ('quantileInterpolatedWeighted', 'OrNull'), 'groupUniqArrayOrNull': ('groupUniqArray', 'OrNull'), 'first_valueOrNull': ('first_value', 'OrNull'), 'uniqCombinedOrNull': ('uniqCombined', 'OrNull'), 'groupBitmapXorOrNull': ('groupBitmapXor', 'OrNull'), 'varSampOrNull': ('varSamp', 'OrNull'), 'minMapOrNull': ('minMap', 'OrNull'), 'argMaxOrNull': ('argMax', 'OrNull'), 'sumMapOrNull': ('sumMap', 'OrNull'), 'minOrNull': ('min', 'OrNull'), 'maxMapOrNull': ('maxMap', 'OrNull'), 'quantilesGKOrNull': ('quantilesGK', 'OrNull'), 'anyOrNull': ('any', 'OrNull'), 'groupBitXorOrNull': ('groupBitXor', 'OrNull'), 'quantilesInterpolatedWeightedOrNull': ('quantilesInterpolatedWeighted', 'OrNull'), 'intervalLengthSumOrNull': ('intervalLengthSum', 'OrNull'), 'deltaSumOrNull': ('deltaSum', 'OrNull'), 'quantileTDigestOrNull': ('quantileTDigest', 'OrNull'), 'stochasticLogisticRegressionOrNull': ('stochasticLogisticRegression', 'OrNull'), 'anyLastOrNull': ('anyLast', 'OrNull'), 'topKOrNull': ('topK', 'OrNull'), 'quantilesExactHighOrNull': ('quantilesExactHigh', 'OrNull'), 'welchTTestOrNull': ('welchTTest', 'OrNull'), 'quantilesOrNull': ('quantiles', 'OrNull'), 'cramersVBiasCorrectedOrNull': ('cramersVBiasCorrected', 'OrNull'), 'quantilesExactLowOrNull': ('quantilesExactLow', 'OrNull'), 'cramersVOrNull': ('cramersV', 'OrNull'), 'quantileTDigestWeightedOrNull': ('quantileTDigestWeighted', 'OrNull'), 'meanZTestOrNull': ('meanZTest', 'OrNull'), 'uniqCombined64OrNull': ('uniqCombined64', 'OrNull'), 'categoricalInformationValueOrNull': ('categoricalInformationValue', 'OrNull'), 'groupBitmapOrOrNull': ('groupBitmapOr', 'OrNull'), 'quantilesTDigestWeightedOrNull': ('quantilesTDigestWeighted', 'OrNull'), 'quantileGKOrNull': ('quantileGK', 'OrNull'), 'quantileExactHighOrNull': ('quantileExactHigh', 'OrNull'), 'countOrNull': ('count', 'OrNull'), 'quantileExactLowOrNull': ('quantileExactLow', 'OrNull'), 'simpleLinearRegressionOrNull': ('simpleLinearRegression', 'OrNull'), 'deltaSumTimestampOrNull': ('deltaSumTimestamp', 'OrNull'), 'skewPopOrNull': ('skewPop', 'OrNull'), 'contingencyOrNull': ('contingency', 'OrNull'), 'maxOrNull': ('max', 'OrNull'), 'studentTTestOrNull': ('studentTTest', 'OrNull'), 'mannWhitneyUTestOrNull': ('mannWhitneyUTest', 'OrNull'), 'groupArrayMovingSumOrNull': ('groupArrayMovingSum', 'OrNull'), 'groupArrayOrNull': ('groupArray', 'OrNull'), 'uniqExactOrNull': ('uniqExact', 'OrNull'), 'quantileTimingResample': ('quantileTiming', 'Resample'), 'anyHeavyResample': ('anyHeavy', 'Resample'), 'uniqResample': ('uniq', 'Resample'), 'groupBitmapAndResample': ('groupBitmapAnd', 'Resample'), 'argMinResample': ('argMin', 'Resample'), 'rankCorrResample': ('rankCorr', 'Resample'), 'kolmogorovSmirnovTestResample': ('kolmogorovSmirnovTest', 'Resample'), 'covarPopResample': ('covarPop', 'Resample'), 'quantilesTimingResample': ('quantilesTiming', 'Resample'), 'quantileExactResample': ('quantileExact', 'Resample'), 'medianResample': ('median', 'Resample'), 'quantileBFloat16Resample': ('quantileBFloat16', 'Resample'), 'avgWeightedResample': ('avgWeighted', 'Resample'), 'topKWeightedResample': ('topKWeighted', 'Resample'), 'largestTriangleThreeBucketsResample': ('largestTriangleThreeBuckets', 'Resample'), 'sumKahanResample': ('sumKahan', 'Resample'), 'stochasticLinearRegressionResample': ('stochasticLinearRegression', 'Resample'), 'groupBitOrResample': ('groupBitOr', 'Resample'), 'varPopResample': ('varPop', 'Resample'), 'quantilesExactWeightedResample': ('quantilesExactWeighted', 'Resample'), 'quantilesTDigestResample': ('quantilesTDigest', 'Resample'), 'boundingRatioResample': ('boundingRatio', 'Resample'), 'groupArrayInsertAtResample': ('groupArrayInsertAt', 'Resample'), 'quantilesBFloat16Resample': ('quantilesBFloat16', 'Resample'), 'exponentialMovingAverageResample': ('exponentialMovingAverage', 'Resample'), 'quantilesExactResample': ('quantilesExact', 'Resample'), 'groupBitmapResample': ('groupBitmap', 'Resample'), 'covarSampResample': ('covarSamp', 'Resample'), 'kurtSampResample': ('kurtSamp', 'Resample'), 'quantilesTimingWeightedResample': ('quantilesTimingWeighted', 'Resample'), 'avgResample': ('avg', 'Resample'), 'quantilesBFloat16WeightedResample': ('quantilesBFloat16Weighted', 'Resample'), 'groupArrayMovingAvgResample': ('groupArrayMovingAvg', 'Resample'), 'stddevPopResample': ('stddevPop', 'Resample'), 'maxIntersectionsPositionResample': ('maxIntersectionsPosition', 'Resample'), 'groupBitAndResample': ('groupBitAnd', 'Resample'), 'theilsUResample': ('theilsU', 'Resample'), 'quantileDeterministicResample': ('quantileDeterministic', 'Resample'), 'corrResample': ('corr', 'Resample'), 'stddevSampResample': ('stddevSamp', 'Resample'), 'uniqThetaResample': ('uniqTheta', 'Resample'), 'groupArraySampleResample': ('groupArraySample', 'Resample'), 'quantileResample': ('quantile', 'Resample'), 'last_valueResample': ('last_value', 'Resample'), 'quantilesDeterministicResample': ('quantilesDeterministic', 'Resample'), 'maxIntersectionsResample': ('maxIntersections', 'Resample'), 'sumCountResample': ('sumCount', 'Resample'), 'uniqHLL12Resample': ('uniqHLL12', 'Resample'), 'sumResample': ('sum', 'Resample'), 'quantileBFloat16WeightedResample': ('quantileBFloat16Weighted', 'Resample'), 'groupArrayLastResample': ('groupArrayLast', 'Resample'), 'quantileTimingWeightedResample': ('quantileTimingWeighted', 'Resample'), 'sumWithOverflowResample': ('sumWithOverflow', 'Resample'), 'skewSampResample': ('skewSamp', 'Resample'), 'entropyResample': ('entropy', 'Resample'), 'kurtPopResample': ('kurtPop', 'Resample'), 'sparkBarResample': ('sparkBar', 'Resample'), 'quantileExactWeightedResample': ('quantileExactWeighted', 'Resample'), 'quantileInterpolatedWeightedResample': ('quantileInterpolatedWeighted', 'Resample'), 'groupUniqArrayResample': ('groupUniqArray', 'Resample'), 'first_valueResample': ('first_value', 'Resample'), 'uniqCombinedResample': ('uniqCombined', 'Resample'), 'groupBitmapXorResample': ('groupBitmapXor', 'Resample'), 'varSampResample': ('varSamp', 'Resample'), 'minMapResample': ('minMap', 'Resample'), 'argMaxResample': ('argMax', 'Resample'), 'sumMapResample': ('sumMap', 'Resample'), 'minResample': ('min', 'Resample'), 'maxMapResample': ('maxMap', 'Resample'), 'quantilesGKResample': ('quantilesGK', 'Resample'), 'anyResample': ('any', 'Resample'), 'groupBitXorResample': ('groupBitXor', 'Resample'), 'quantilesInterpolatedWeightedResample': ('quantilesInterpolatedWeighted', 'Resample'), 'intervalLengthSumResample': ('intervalLengthSum', 'Resample'), 'deltaSumResample': ('deltaSum', 'Resample'), 'quantileTDigestResample': ('quantileTDigest', 'Resample'), 'stochasticLogisticRegressionResample': ('stochasticLogisticRegression', 'Resample'), 'anyLastResample': ('anyLast', 'Resample'), 'topKResample': ('topK', 'Resample'), 'quantilesExactHighResample': ('quantilesExactHigh', 'Resample'), 'welchTTestResample': ('welchTTest', 'Resample'), 'quantilesResample': ('quantiles', 'Resample'), 'cramersVBiasCorrectedResample': ('cramersVBiasCorrected', 'Resample'), 'quantilesExactLowResample': ('quantilesExactLow', 'Resample'), 'cramersVResample': ('cramersV', 'Resample'), 'quantileTDigestWeightedResample': ('quantileTDigestWeighted', 'Resample'), 'meanZTestResample': ('meanZTest', 'Resample'), 'uniqCombined64Resample': ('uniqCombined64', 'Resample'), 'categoricalInformationValueResample': ('categoricalInformationValue', 'Resample'), 'groupBitmapOrResample': ('groupBitmapOr', 'Resample'), 'quantilesTDigestWeightedResample': ('quantilesTDigestWeighted', 'Resample'), 'quantileGKResample': ('quantileGK', 'Resample'), 'quantileExactHighResample': ('quantileExactHigh', 'Resample'), 'countResample': ('count', 'Resample'), 'quantileExactLowResample': ('quantileExactLow', 'Resample'), 'simpleLinearRegressionResample': ('simpleLinearRegression', 'Resample'), 'deltaSumTimestampResample': ('deltaSumTimestamp', 'Resample'), 'skewPopResample': ('skewPop', 'Resample'), 'contingencyResample': ('contingency', 'Resample'), 'maxResample': ('max', 'Resample'), 'studentTTestResample': ('studentTTest', 'Resample'), 'mannWhitneyUTestResample': ('mannWhitneyUTest', 'Resample'), 'groupArrayMovingSumResample': ('groupArrayMovingSum', 'Resample'), 'groupArrayResample': ('groupArray', 'Resample'), 'uniqExactResample': ('uniqExact', 'Resample'), 'quantileTimingArgMin': ('quantileTiming', 'ArgMin'), 'anyHeavyArgMin': ('anyHeavy', 'ArgMin'), 'uniqArgMin': ('uniq', 'ArgMin'), 'groupBitmapAndArgMin': ('groupBitmapAnd', 'ArgMin'), 'argMinArgMin': ('argMin', 'ArgMin'), 'rankCorrArgMin': ('rankCorr', 'ArgMin'), 'kolmogorovSmirnovTestArgMin': ('kolmogorovSmirnovTest', 'ArgMin'), 'covarPopArgMin': ('covarPop', 'ArgMin'), 'quantilesTimingArgMin': ('quantilesTiming', 'ArgMin'), 'quantileExactArgMin': ('quantileExact', 'ArgMin'), 'medianArgMin': ('median', 'ArgMin'), 'quantileBFloat16ArgMin': ('quantileBFloat16', 'ArgMin'), 'avgWeightedArgMin': ('avgWeighted', 'ArgMin'), 'topKWeightedArgMin': ('topKWeighted', 'ArgMin'), 'largestTriangleThreeBucketsArgMin': ('largestTriangleThreeBuckets', 'ArgMin'), 'sumKahanArgMin': ('sumKahan', 'ArgMin'), 'stochasticLinearRegressionArgMin': ('stochasticLinearRegression', 'ArgMin'), 'groupBitOrArgMin': ('groupBitOr', 'ArgMin'), 'varPopArgMin': ('varPop', 'ArgMin'), 'quantilesExactWeightedArgMin': ('quantilesExactWeighted', 'ArgMin'), 'quantilesTDigestArgMin': ('quantilesTDigest', 'ArgMin'), 'boundingRatioArgMin': ('boundingRatio', 'ArgMin'), 'groupArrayInsertAtArgMin': ('groupArrayInsertAt', 'ArgMin'), 'quantilesBFloat16ArgMin': ('quantilesBFloat16', 'ArgMin'), 'exponentialMovingAverageArgMin': ('exponentialMovingAverage', 'ArgMin'), 'quantilesExactArgMin': ('quantilesExact', 'ArgMin'), 'groupBitmapArgMin': ('groupBitmap', 'ArgMin'), 'covarSampArgMin': ('covarSamp', 'ArgMin'), 'kurtSampArgMin': ('kurtSamp', 'ArgMin'), 'quantilesTimingWeightedArgMin': ('quantilesTimingWeighted', 'ArgMin'), 'avgArgMin': ('avg', 'ArgMin'), 'quantilesBFloat16WeightedArgMin': ('quantilesBFloat16Weighted', 'ArgMin'), 'groupArrayMovingAvgArgMin': ('groupArrayMovingAvg', 'ArgMin'), 'stddevPopArgMin': ('stddevPop', 'ArgMin'), 'maxIntersectionsPositionArgMin': ('maxIntersectionsPosition', 'ArgMin'), 'groupBitAndArgMin': ('groupBitAnd', 'ArgMin'), 'theilsUArgMin': ('theilsU', 'ArgMin'), 'quantileDeterministicArgMin': ('quantileDeterministic', 'ArgMin'), 'corrArgMin': ('corr', 'ArgMin'), 'stddevSampArgMin': ('stddevSamp', 'ArgMin'), 'uniqThetaArgMin': ('uniqTheta', 'ArgMin'), 'groupArraySampleArgMin': ('groupArraySample', 'ArgMin'), 'quantileArgMin': ('quantile', 'ArgMin'), 'last_valueArgMin': ('last_value', 'ArgMin'), 'quantilesDeterministicArgMin': ('quantilesDeterministic', 'ArgMin'), 'maxIntersectionsArgMin': ('maxIntersections', 'ArgMin'), 'sumCountArgMin': ('sumCount', 'ArgMin'), 'uniqHLL12ArgMin': ('uniqHLL12', 'ArgMin'), 'sumArgMin': ('sum', 'ArgMin'), 'quantileBFloat16WeightedArgMin': ('quantileBFloat16Weighted', 'ArgMin'), 'groupArrayLastArgMin': ('groupArrayLast', 'ArgMin'), 'quantileTimingWeightedArgMin': ('quantileTimingWeighted', 'ArgMin'), 'sumWithOverflowArgMin': ('sumWithOverflow', 'ArgMin'), 'skewSampArgMin': ('skewSamp', 'ArgMin'), 'entropyArgMin': ('entropy', 'ArgMin'), 'kurtPopArgMin': ('kurtPop', 'ArgMin'), 'sparkBarArgMin': ('sparkBar', 'ArgMin'), 'quantileExactWeightedArgMin': ('quantileExactWeighted', 'ArgMin'), 'quantileInterpolatedWeightedArgMin': ('quantileInterpolatedWeighted', 'ArgMin'), 'groupUniqArrayArgMin': ('groupUniqArray', 'ArgMin'), 'first_valueArgMin': ('first_value', 'ArgMin'), 'uniqCombinedArgMin': ('uniqCombined', 'ArgMin'), 'groupBitmapXorArgMin': ('groupBitmapXor', 'ArgMin'), 'varSampArgMin': ('varSamp', 'ArgMin'), 'minMapArgMin': ('minMap', 'ArgMin'), 'argMaxArgMin': ('argMax', 'ArgMin'), 'sumMapArgMin': ('sumMap', 'ArgMin'), 'minArgMin': ('min', 'ArgMin'), 'maxMapArgMin': ('maxMap', 'ArgMin'), 'quantilesGKArgMin': ('quantilesGK', 'ArgMin'), 'anyArgMin': ('any', 'ArgMin'), 'groupBitXorArgMin': ('groupBitXor', 'ArgMin'), 'quantilesInterpolatedWeightedArgMin': ('quantilesInterpolatedWeighted', 'ArgMin'), 'intervalLengthSumArgMin': ('intervalLengthSum', 'ArgMin'), 'deltaSumArgMin': ('deltaSum', 'ArgMin'), 'quantileTDigestArgMin': ('quantileTDigest', 'ArgMin'), 'stochasticLogisticRegressionArgMin': ('stochasticLogisticRegression', 'ArgMin'), 'anyLastArgMin': ('anyLast', 'ArgMin'), 'topKArgMin': ('topK', 'ArgMin'), 'quantilesExactHighArgMin': ('quantilesExactHigh', 'ArgMin'), 'welchTTestArgMin': ('welchTTest', 'ArgMin'), 'quantilesArgMin': ('quantiles', 'ArgMin'), 'cramersVBiasCorrectedArgMin': ('cramersVBiasCorrected', 'ArgMin'), 'quantilesExactLowArgMin': ('quantilesExactLow', 'ArgMin'), 'cramersVArgMin': ('cramersV', 'ArgMin'), 'quantileTDigestWeightedArgMin': ('quantileTDigestWeighted', 'ArgMin'), 'meanZTestArgMin': ('meanZTest', 'ArgMin'), 'uniqCombined64ArgMin': ('uniqCombined64', 'ArgMin'), 'categoricalInformationValueArgMin': ('categoricalInformationValue', 'ArgMin'), 'groupBitmapOrArgMin': ('groupBitmapOr', 'ArgMin'), 'quantilesTDigestWeightedArgMin': ('quantilesTDigestWeighted', 'ArgMin'), 'quantileGKArgMin': ('quantileGK', 'ArgMin'), 'quantileExactHighArgMin': ('quantileExactHigh', 'ArgMin'), 'countArgMin': ('count', 'ArgMin'), 'quantileExactLowArgMin': ('quantileExactLow', 'ArgMin'), 'simpleLinearRegressionArgMin': ('simpleLinearRegression', 'ArgMin'), 'deltaSumTimestampArgMin': ('deltaSumTimestamp', 'ArgMin'), 'skewPopArgMin': ('skewPop', 'ArgMin'), 'contingencyArgMin': ('contingency', 'ArgMin'), 'maxArgMin': ('max', 'ArgMin'), 'studentTTestArgMin': ('studentTTest', 'ArgMin'), 'mannWhitneyUTestArgMin': ('mannWhitneyUTest', 'ArgMin'), 'groupArrayMovingSumArgMin': ('groupArrayMovingSum', 'ArgMin'), 'groupArrayArgMin': ('groupArray', 'ArgMin'), 'uniqExactArgMin': ('uniqExact', 'ArgMin'), 'quantileTimingArgMax': ('quantileTiming', 'ArgMax'), 'anyHeavyArgMax': ('anyHeavy', 'ArgMax'), 'uniqArgMax': ('uniq', 'ArgMax'), 'groupBitmapAndArgMax': ('groupBitmapAnd', 'ArgMax'), 'argMinArgMax': ('argMin', 'ArgMax'), 'rankCorrArgMax': ('rankCorr', 'ArgMax'), 'kolmogorovSmirnovTestArgMax': ('kolmogorovSmirnovTest', 'ArgMax'), 'covarPopArgMax': ('covarPop', 'ArgMax'), 'quantilesTimingArgMax': ('quantilesTiming', 'ArgMax'), 'quantileExactArgMax': ('quantileExact', 'ArgMax'), 'medianArgMax': ('median', 'ArgMax'), 'quantileBFloat16ArgMax': ('quantileBFloat16', 'ArgMax'), 'avgWeightedArgMax': ('avgWeighted', 'ArgMax'), 'topKWeightedArgMax': ('topKWeighted', 'ArgMax'), 'largestTriangleThreeBucketsArgMax': ('largestTriangleThreeBuckets', 'ArgMax'), 'sumKahanArgMax': ('sumKahan', 'ArgMax'), 'stochasticLinearRegressionArgMax': ('stochasticLinearRegression', 'ArgMax'), 'groupBitOrArgMax': ('groupBitOr', 'ArgMax'), 'varPopArgMax': ('varPop', 'ArgMax'), 'quantilesExactWeightedArgMax': ('quantilesExactWeighted', 'ArgMax'), 'quantilesTDigestArgMax': ('quantilesTDigest', 'ArgMax'), 'boundingRatioArgMax': ('boundingRatio', 'ArgMax'), 'groupArrayInsertAtArgMax': ('groupArrayInsertAt', 'ArgMax'), 'quantilesBFloat16ArgMax': ('quantilesBFloat16', 'ArgMax'), 'exponentialMovingAverageArgMax': ('exponentialMovingAverage', 'ArgMax'), 'quantilesExactArgMax': ('quantilesExact', 'ArgMax'), 'groupBitmapArgMax': ('groupBitmap', 'ArgMax'), 'covarSampArgMax': ('covarSamp', 'ArgMax'), 'kurtSampArgMax': ('kurtSamp', 'ArgMax'), 'quantilesTimingWeightedArgMax': ('quantilesTimingWeighted', 'ArgMax'), 'avgArgMax': ('avg', 'ArgMax'), 'quantilesBFloat16WeightedArgMax': ('quantilesBFloat16Weighted', 'ArgMax'), 'groupArrayMovingAvgArgMax': ('groupArrayMovingAvg', 'ArgMax'), 'stddevPopArgMax': ('stddevPop', 'ArgMax'), 'maxIntersectionsPositionArgMax': ('maxIntersectionsPosition', 'ArgMax'), 'groupBitAndArgMax': ('groupBitAnd', 'ArgMax'), 'theilsUArgMax': ('theilsU', 'ArgMax'), 'quantileDeterministicArgMax': ('quantileDeterministic', 'ArgMax'), 'corrArgMax': ('corr', 'ArgMax'), 'stddevSampArgMax': ('stddevSamp', 'ArgMax'), 'uniqThetaArgMax': ('uniqTheta', 'ArgMax'), 'groupArraySampleArgMax': ('groupArraySample', 'ArgMax'), 'quantileArgMax': ('quantile', 'ArgMax'), 'last_valueArgMax': ('last_value', 'ArgMax'), 'quantilesDeterministicArgMax': ('quantilesDeterministic', 'ArgMax'), 'maxIntersectionsArgMax': ('maxIntersections', 'ArgMax'), 'sumCountArgMax': ('sumCount', 'ArgMax'), 'uniqHLL12ArgMax': ('uniqHLL12', 'ArgMax'), 'sumArgMax': ('sum', 'ArgMax'), 'quantileBFloat16WeightedArgMax': ('quantileBFloat16Weighted', 'ArgMax'), 'groupArrayLastArgMax': ('groupArrayLast', 'ArgMax'), 'quantileTimingWeightedArgMax': ('quantileTimingWeighted', 'ArgMax'), 'sumWithOverflowArgMax': ('sumWithOverflow', 'ArgMax'), 'skewSampArgMax': ('skewSamp', 'ArgMax'), 'entropyArgMax': ('entropy', 'ArgMax'), 'kurtPopArgMax': ('kurtPop', 'ArgMax'), 'sparkBarArgMax': ('sparkBar', 'ArgMax'), 'quantileExactWeightedArgMax': ('quantileExactWeighted', 'ArgMax'), 'quantileInterpolatedWeightedArgMax': ('quantileInterpolatedWeighted', 'ArgMax'), 'groupUniqArrayArgMax': ('groupUniqArray', 'ArgMax'), 'first_valueArgMax': ('first_value', 'ArgMax'), 'uniqCombinedArgMax': ('uniqCombined', 'ArgMax'), 'groupBitmapXorArgMax': ('groupBitmapXor', 'ArgMax'), 'varSampArgMax': ('varSamp', 'ArgMax'), 'minMapArgMax': ('minMap', 'ArgMax'), 'argMaxArgMax': ('argMax', 'ArgMax'), 'sumMapArgMax': ('sumMap', 'ArgMax'), 'minArgMax': ('min', 'ArgMax'), 'maxMapArgMax': ('maxMap', 'ArgMax'), 'quantilesGKArgMax': ('quantilesGK', 'ArgMax'), 'anyArgMax': ('any', 'ArgMax'), 'groupBitXorArgMax': ('groupBitXor', 'ArgMax'), 'quantilesInterpolatedWeightedArgMax': ('quantilesInterpolatedWeighted', 'ArgMax'), 'intervalLengthSumArgMax': ('intervalLengthSum', 'ArgMax'), 'deltaSumArgMax': ('deltaSum', 'ArgMax'), 'quantileTDigestArgMax': ('quantileTDigest', 'ArgMax'), 'stochasticLogisticRegressionArgMax': ('stochasticLogisticRegression', 'ArgMax'), 'anyLastArgMax': ('anyLast', 'ArgMax'), 'topKArgMax': ('topK', 'ArgMax'), 'quantilesExactHighArgMax': ('quantilesExactHigh', 'ArgMax'), 'welchTTestArgMax': ('welchTTest', 'ArgMax'), 'quantilesArgMax': ('quantiles', 'ArgMax'), 'cramersVBiasCorrectedArgMax': ('cramersVBiasCorrected', 'ArgMax'), 'quantilesExactLowArgMax': ('quantilesExactLow', 'ArgMax'), 'cramersVArgMax': ('cramersV', 'ArgMax'), 'quantileTDigestWeightedArgMax': ('quantileTDigestWeighted', 'ArgMax'), 'meanZTestArgMax': ('meanZTest', 'ArgMax'), 'uniqCombined64ArgMax': ('uniqCombined64', 'ArgMax'), 'categoricalInformationValueArgMax': ('categoricalInformationValue', 'ArgMax'), 'groupBitmapOrArgMax': ('groupBitmapOr', 'ArgMax'), 'quantilesTDigestWeightedArgMax': ('quantilesTDigestWeighted', 'ArgMax'), 'quantileGKArgMax': ('quantileGK', 'ArgMax'), 'quantileExactHighArgMax': ('quantileExactHigh', 'ArgMax'), 'countArgMax': ('count', 'ArgMax'), 'quantileExactLowArgMax': ('quantileExactLow', 'ArgMax'), 'simpleLinearRegressionArgMax': ('simpleLinearRegression', 'ArgMax'), 'deltaSumTimestampArgMax': ('deltaSumTimestamp', 'ArgMax'), 'skewPopArgMax': ('skewPop', 'ArgMax'), 'contingencyArgMax': ('contingency', 'ArgMax'), 'maxArgMax': ('max', 'ArgMax'), 'studentTTestArgMax': ('studentTTest', 'ArgMax'), 'mannWhitneyUTestArgMax': ('mannWhitneyUTest', 'ArgMax'), 'groupArrayMovingSumArgMax': ('groupArrayMovingSum', 'ArgMax'), 'groupArrayArgMax': ('groupArray', 'ArgMax'), 'uniqExactArgMax': ('uniqExact', 'ArgMax'), 'quantileTiming': ('quantileTiming', ''), 'anyHeavy': ('anyHeavy', ''), 'uniq': ('uniq', ''), 'groupBitmapAnd': ('groupBitmapAnd', ''), 'argMin': ('argMin', ''), 'rankCorr': ('rankCorr', ''), 'kolmogorovSmirnovTest': ('kolmogorovSmirnovTest', ''), 'covarPop': ('covarPop', ''), 'quantilesTiming': ('quantilesTiming', ''), 'quantileExact': ('quantileExact', ''), 'median': ('median', ''), 'quantileBFloat16': ('quantileBFloat16', ''), 'avgWeighted': ('avgWeighted', ''), 'topKWeighted': ('topKWeighted', ''), 'largestTriangleThreeBuckets': ('largestTriangleThreeBuckets', ''), 'sumKahan': ('sumKahan', ''), 'stochasticLinearRegression': ('stochasticLinearRegression', ''), 'groupBitOr': ('groupBitOr', ''), 'varPop': ('varPop', ''), 'quantilesExactWeighted': ('quantilesExactWeighted', ''), 'quantilesTDigest': ('quantilesTDigest', ''), 'boundingRatio': ('boundingRatio', ''), 'groupArrayInsertAt': ('groupArrayInsertAt', ''), 'quantilesBFloat16': ('quantilesBFloat16', ''), 'exponentialMovingAverage': ('exponentialMovingAverage', ''), 'quantilesExact': ('quantilesExact', ''), 'groupBitmap': ('groupBitmap', ''), 'covarSamp': ('covarSamp', ''), 'kurtSamp': ('kurtSamp', ''), 'quantilesTimingWeighted': ('quantilesTimingWeighted', ''), 'avg': ('avg', ''), 'quantilesBFloat16Weighted': ('quantilesBFloat16Weighted', ''), 'groupArrayMovingAvg': ('groupArrayMovingAvg', ''), 'stddevPop': ('stddevPop', ''), 'maxIntersectionsPosition': ('maxIntersectionsPosition', ''), 'groupBitAnd': ('groupBitAnd', ''), 'theilsU': ('theilsU', ''), 'quantileDeterministic': ('quantileDeterministic', ''), 'corr': ('corr', ''), 'stddevSamp': ('stddevSamp', ''), 'uniqTheta': ('uniqTheta', ''), 'groupArraySample': ('groupArraySample', ''), 'quantile': ('quantile', ''), 'last_value': ('last_value', ''), 'quantilesDeterministic': ('quantilesDeterministic', ''), 'maxIntersections': ('maxIntersections', ''), 'sumCount': ('sumCount', ''), 'uniqHLL12': ('uniqHLL12', ''), 'sum': ('sum', ''), 'quantileBFloat16Weighted': ('quantileBFloat16Weighted', ''), 'groupArrayLast': ('groupArrayLast', ''), 'quantileTimingWeighted': ('quantileTimingWeighted', ''), 'sumWithOverflow': ('sumWithOverflow', ''), 'skewSamp': ('skewSamp', ''), 'entropy': ('entropy', ''), 'kurtPop': ('kurtPop', ''), 'sparkBar': ('sparkBar', ''), 'quantileExactWeighted': ('quantileExactWeighted', ''), 'quantileInterpolatedWeighted': ('quantileInterpolatedWeighted', ''), 'groupUniqArray': ('groupUniqArray', ''), 'first_value': ('first_value', ''), 'uniqCombined': ('uniqCombined', ''), 'groupBitmapXor': ('groupBitmapXor', ''), 'varSamp': ('varSamp', ''), 'argMax': ('argMax', ''), 'min': ('min', ''), 'quantilesGK': ('quantilesGK', ''), 'any': ('any', ''), 'groupBitXor': ('groupBitXor', ''), 'quantilesInterpolatedWeighted': ('quantilesInterpolatedWeighted', ''), 'intervalLengthSum': ('intervalLengthSum', ''), 'deltaSum': ('deltaSum', ''), 'quantileTDigest': ('quantileTDigest', ''), 'stochasticLogisticRegression': ('stochasticLogisticRegression', ''), 'anyLast': ('anyLast', ''), 'topK': ('topK', ''), 'quantilesExactHigh': ('quantilesExactHigh', ''), 'welchTTest': ('welchTTest', ''), 'quantiles': ('quantiles', ''), 'cramersVBiasCorrected': ('cramersVBiasCorrected', ''), 'quantilesExactLow': ('quantilesExactLow', ''), 'cramersV': ('cramersV', ''), 'quantileTDigestWeighted': ('quantileTDigestWeighted', ''), 'meanZTest': ('meanZTest', ''), 'uniqCombined64': ('uniqCombined64', ''), 'categoricalInformationValue': ('categoricalInformationValue', ''), 'groupBitmapOr': ('groupBitmapOr', ''), 'quantilesTDigestWeighted': ('quantilesTDigestWeighted', ''), 'quantileGK': ('quantileGK', ''), 'quantileExactHigh': ('quantileExactHigh', ''), 'count': ('count', ''), 'quantileExactLow': ('quantileExactLow', ''), 'simpleLinearRegression': ('simpleLinearRegression', ''), 'deltaSumTimestamp': ('deltaSumTimestamp', ''), 'skewPop': ('skewPop', ''), 'contingency': ('contingency', ''), 'max': ('max', ''), 'studentTTest': ('studentTTest', ''), 'mannWhitneyUTest': ('mannWhitneyUTest', ''), 'groupArrayMovingSum': ('groupArrayMovingSum', ''), 'groupArray': ('groupArray', ''), 'uniqExact': ('uniqExact', '')}
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.SEMI: 'SEMI'>, <TokenType.OUTER: 'OUTER'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.ANY: 'ANY'>, <TokenType.ANTI: 'ANTI'>, <TokenType.INNER: 'INNER'>, <TokenType.CROSS: 'CROSS'>, <TokenType.ASOF: 'ASOF'>}
TABLE_ALIAS_TOKENS =
{<TokenType.INT128: 'INT128'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.UUID: 'UUID'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.TRUE: 'TRUE'>, <TokenType.END: 'END'>, <TokenType.NAME: 'NAME'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UINT256: 'UINT256'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.JSON: 'JSON'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATE: 'DATE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.DESC: 'DESC'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.NESTED: 'NESTED'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.CHAR: 'CHAR'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.ALL: 'ALL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.SHOW: 'SHOW'>, <TokenType.DATE32: 'DATE32'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.VAR: 'VAR'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.USE: 'USE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ENUM: 'ENUM'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.TABLE: 'TABLE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.MERGE: 'MERGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.TIME: 'TIME'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.DIV: 'DIV'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT: 'INT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.SUPER: 'SUPER'>, <TokenType.BIT: 'BIT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.DELETE: 'DELETE'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.FILTER: 'FILTER'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT: 'UINT'>, <TokenType.IS: 'IS'>, <TokenType.MODEL: 'MODEL'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CACHE: 'CACHE'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IPV6: 'IPV6'>, <TokenType.INT256: 'INT256'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FALSE: 'FALSE'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.SOME: 'SOME'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.INET: 'INET'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.SET: 'SET'>, <TokenType.ASC: 'ASC'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.ROWS: 'ROWS'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.CASE: 'CASE'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.FIRST: 'FIRST'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.TEXT: 'TEXT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.NULL: 'NULL'>, <TokenType.JSONB: 'JSONB'>, <TokenType.MAP: 'MAP'>, <TokenType.ROW: 'ROW'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.XML: 'XML'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.TOP: 'TOP'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>}
ALIAS_TOKENS =
{<TokenType.INT128: 'INT128'>, <TokenType.TINYINT: 'TINYINT'>, <TokenType.KILL: 'KILL'>, <TokenType.DATETIME64: 'DATETIME64'>, <TokenType.TSRANGE: 'TSRANGE'>, <TokenType.AUTO_INCREMENT: 'AUTO_INCREMENT'>, <TokenType.INT4MULTIRANGE: 'INT4MULTIRANGE'>, <TokenType.APPLY: 'APPLY'>, <TokenType.UUID: 'UUID'>, <TokenType.IPPREFIX: 'IPPREFIX'>, <TokenType.TRUE: 'TRUE'>, <TokenType.END: 'END'>, <TokenType.NAME: 'NAME'>, <TokenType.VARCHAR: 'VARCHAR'>, <TokenType.PARTITION: 'PARTITION'>, <TokenType.INT8RANGE: 'INT8RANGE'>, <TokenType.DATEMULTIRANGE: 'DATEMULTIRANGE'>, <TokenType.UINT256: 'UINT256'>, <TokenType.SETTINGS: 'SETTINGS'>, <TokenType.DOUBLE: 'DOUBLE'>, <TokenType.IPV4: 'IPV4'>, <TokenType.DECIMAL: 'DECIMAL'>, <TokenType.TIMESTAMP_MS: 'TIMESTAMP_MS'>, <TokenType.NCHAR: 'NCHAR'>, <TokenType.PIVOT: 'PIVOT'>, <TokenType.VARBINARY: 'VARBINARY'>, <TokenType.JSON: 'JSON'>, <TokenType.OVERWRITE: 'OVERWRITE'>, <TokenType.OPERATOR: 'OPERATOR'>, <TokenType.DATE: 'DATE'>, <TokenType.ISNULL: 'ISNULL'>, <TokenType.FULL: 'FULL'>, <TokenType.TIMESTAMP_S: 'TIMESTAMP_S'>, <TokenType.CURRENT_DATETIME: 'CURRENT_DATETIME'>, <TokenType.CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'>, <TokenType.REPLACE: 'REPLACE'>, <TokenType.YEAR: 'YEAR'>, <TokenType.STRUCT: 'STRUCT'>, <TokenType.TIMESTAMPTZ: 'TIMESTAMPTZ'>, <TokenType.DESC: 'DESC'>, <TokenType.BIGDECIMAL: 'BIGDECIMAL'>, <TokenType.ENUM8: 'ENUM8'>, <TokenType.DEFAULT: 'DEFAULT'>, <TokenType.UNKNOWN: 'UNKNOWN'>, <TokenType.NESTED: 'NESTED'>, <TokenType.OVERLAPS: 'OVERLAPS'>, <TokenType.NVARCHAR: 'NVARCHAR'>, <TokenType.CHAR: 'CHAR'>, <TokenType.BIGINT: 'BIGINT'>, <TokenType.BIGSERIAL: 'BIGSERIAL'>, <TokenType.INT4RANGE: 'INT4RANGE'>, <TokenType.VOLATILE: 'VOLATILE'>, <TokenType.ALL: 'ALL'>, <TokenType.PERCENT: 'PERCENT'>, <TokenType.TRUNCATE: 'TRUNCATE'>, <TokenType.LOAD: 'LOAD'>, <TokenType.SHOW: 'SHOW'>, <TokenType.DATE32: 'DATE32'>, <TokenType.BEGIN: 'BEGIN'>, <TokenType.CURRENT_DATE: 'CURRENT_DATE'>, <TokenType.PRAGMA: 'PRAGMA'>, <TokenType.UNIQUEIDENTIFIER: 'UNIQUEIDENTIFIER'>, <TokenType.COMMENT: 'COMMENT'>, <TokenType.INTERVAL: 'INTERVAL'>, <TokenType.UPDATE: 'UPDATE'>, <TokenType.VAR: 'VAR'>, <TokenType.LONGBLOB: 'LONGBLOB'>, <TokenType.USERDEFINED: 'USERDEFINED'>, <TokenType.USE: 'USE'>, <TokenType.EXISTS: 'EXISTS'>, <TokenType.VIEW: 'VIEW'>, <TokenType.ENUM: 'ENUM'>, <TokenType.PSEUDO_TYPE: 'PSEUDO_TYPE'>, <TokenType.TINYTEXT: 'TINYTEXT'>, <TokenType.CURRENT_TIME: 'CURRENT_TIME'>, <TokenType.TABLE: 'TABLE'>, <TokenType.EXECUTE: 'EXECUTE'>, <TokenType.OFFSET: 'OFFSET'>, <TokenType.MERGE: 'MERGE'>, <TokenType.MONEY: 'MONEY'>, <TokenType.CURRENT_USER: 'CURRENT_USER'>, <TokenType.SEMI: 'SEMI'>, <TokenType.TIME: 'TIME'>, <TokenType.VARIANT: 'VARIANT'>, <TokenType.DIV: 'DIV'>, <TokenType.TIMETZ: 'TIMETZ'>, <TokenType.ANY: 'ANY'>, <TokenType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>, <TokenType.INT: 'INT'>, <TokenType.TEMPORARY: 'TEMPORARY'>, <TokenType.UINT128: 'UINT128'>, <TokenType.IPADDRESS: 'IPADDRESS'>, <TokenType.TINYBLOB: 'TINYBLOB'>, <TokenType.HLLSKETCH: 'HLLSKETCH'>, <TokenType.DATABASE: 'DATABASE'>, <TokenType.NUMMULTIRANGE: 'NUMMULTIRANGE'>, <TokenType.SCHEMA: 'SCHEMA'>, <TokenType.SUPER: 'SUPER'>, <TokenType.BIT: 'BIT'>, <TokenType.LONGTEXT: 'LONGTEXT'>, <TokenType.USMALLINT: 'USMALLINT'>, <TokenType.COLLATE: 'COLLATE'>, <TokenType.DICTIONARY: 'DICTIONARY'>, <TokenType.ANTI: 'ANTI'>, <TokenType.DELETE: 'DELETE'>, <TokenType.ESCAPE: 'ESCAPE'>, <TokenType.BPCHAR: 'BPCHAR'>, <TokenType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>, <TokenType.OBJECT: 'OBJECT'>, <TokenType.IMAGE: 'IMAGE'>, <TokenType.TIMESTAMP: 'TIMESTAMP'>, <TokenType.TSMULTIRANGE: 'TSMULTIRANGE'>, <TokenType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>, <TokenType.ASOF: 'ASOF'>, <TokenType.FILTER: 'FILTER'>, <TokenType.FLOAT: 'FLOAT'>, <TokenType.UINT: 'UINT'>, <TokenType.IS: 'IS'>, <TokenType.WINDOW: 'WINDOW'>, <TokenType.MODEL: 'MODEL'>, <TokenType.REFRESH: 'REFRESH'>, <TokenType.UBIGINT: 'UBIGINT'>, <TokenType.PROCEDURE: 'PROCEDURE'>, <TokenType.TIMESTAMP_NS: 'TIMESTAMP_NS'>, <TokenType.CACHE: 'CACHE'>, <TokenType.SMALLSERIAL: 'SMALLSERIAL'>, <TokenType.IPV6: 'IPV6'>, <TokenType.INT256: 'INT256'>, <TokenType.NUMRANGE: 'NUMRANGE'>, <TokenType.RECURSIVE: 'RECURSIVE'>, <TokenType.ENUM16: 'ENUM16'>, <TokenType.FALSE: 'FALSE'>, <TokenType.DESCRIBE: 'DESCRIBE'>, <TokenType.CONSTRAINT: 'CONSTRAINT'>, <TokenType.SOME: 'SOME'>, <TokenType.TSTZRANGE: 'TSTZRANGE'>, <TokenType.FUNCTION: 'FUNCTION'>, <TokenType.MEDIUMTEXT: 'MEDIUMTEXT'>, <TokenType.COLUMN: 'COLUMN'>, <TokenType.INET: 'INET'>, <TokenType.UTINYINT: 'UTINYINT'>, <TokenType.RIGHT: 'RIGHT'>, <TokenType.INDEX: 'INDEX'>, <TokenType.SET: 'SET'>, <TokenType.ASC: 'ASC'>, <TokenType.NULLABLE: 'NULLABLE'>, <TokenType.UDECIMAL: 'UDECIMAL'>, <TokenType.SMALLMONEY: 'SMALLMONEY'>, <TokenType.ROWS: 'ROWS'>, <TokenType.STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'>, <TokenType.UNIQUE: 'UNIQUE'>, <TokenType.FOREIGN_KEY: 'FOREIGN_KEY'>, <TokenType.BOOLEAN: 'BOOLEAN'>, <TokenType.COMMIT: 'COMMIT'>, <TokenType.REFERENCES: 'REFERENCES'>, <TokenType.ROWVERSION: 'ROWVERSION'>, <TokenType.CASE: 'CASE'>, <TokenType.FINAL: 'FINAL'>, <TokenType.ORDINALITY: 'ORDINALITY'>, <TokenType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>, <TokenType.NATURAL: 'NATURAL'>, <TokenType.FIRST: 'FIRST'>, <TokenType.HSTORE: 'HSTORE'>, <TokenType.OBJECT_IDENTIFIER: 'OBJECT_IDENTIFIER'>, <TokenType.MEDIUMBLOB: 'MEDIUMBLOB'>, <TokenType.COMMAND: 'COMMAND'>, <TokenType.TEXT: 'TEXT'>, <TokenType.NEXT: 'NEXT'>, <TokenType.INT8MULTIRANGE: 'INT8MULTIRANGE'>, <TokenType.GEOMETRY: 'GEOMETRY'>, <TokenType.RANGE: 'RANGE'>, <TokenType.ARRAY: 'ARRAY'>, <TokenType.KEEP: 'KEEP'>, <TokenType.SERIAL: 'SERIAL'>, <TokenType.LEFT: 'LEFT'>, <TokenType.NULL: 'NULL'>, <TokenType.JSONB: 'JSONB'>, <TokenType.MAP: 'MAP'>, <TokenType.ROW: 'ROW'>, <TokenType.UNPIVOT: 'UNPIVOT'>, <TokenType.GEOGRAPHY: 'GEOGRAPHY'>, <TokenType.FIXEDSTRING: 'FIXEDSTRING'>, <TokenType.XML: 'XML'>, <TokenType.BINARY: 'BINARY'>, <TokenType.DATERANGE: 'DATERANGE'>, <TokenType.MEDIUMINT: 'MEDIUMINT'>, <TokenType.SMALLINT: 'SMALLINT'>, <TokenType.UMEDIUMINT: 'UMEDIUMINT'>, <TokenType.DATETIME: 'DATETIME'>, <TokenType.SEQUENCE: 'SEQUENCE'>, <TokenType.TOP: 'TOP'>, <TokenType.LOWCARDINALITY: 'LOWCARDINALITY'>}
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>>}
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
- FUNC_TOKENS
- 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
- CONSTRAINT_PARSERS
- ALTER_PARSERS
- SCHEMA_UNNAMED_CONSTRAINTS
- 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
- USABLES
- CAST_ACTIONS
- INSERT_ALTERNATIVES
- CLONE_KEYWORDS
- HISTORICAL_DATA_KIND
- OPCLASS_FOLLOW_KEYWORDS
- OPTYPE_FOLLOW_TOKENS
- TABLE_INDEX_HINT_TOKENS
- 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
- 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
517 class Generator(generator.Generator): 518 QUERY_HINTS = False 519 STRUCT_DELIMITER = ("(", ")") 520 NVL2_SUPPORTED = False 521 TABLESAMPLE_REQUIRES_PARENS = False 522 TABLESAMPLE_SIZE_IS_ROWS = False 523 TABLESAMPLE_KEYWORDS = "SAMPLE" 524 LAST_DAY_SUPPORTS_DATE_PART = False 525 CAN_IMPLEMENT_ARRAY_ANY = True 526 SUPPORTS_TO_NUMBER = False 527 528 STRING_TYPE_MAPPING = { 529 exp.DataType.Type.CHAR: "String", 530 exp.DataType.Type.LONGBLOB: "String", 531 exp.DataType.Type.LONGTEXT: "String", 532 exp.DataType.Type.MEDIUMBLOB: "String", 533 exp.DataType.Type.MEDIUMTEXT: "String", 534 exp.DataType.Type.TINYBLOB: "String", 535 exp.DataType.Type.TINYTEXT: "String", 536 exp.DataType.Type.TEXT: "String", 537 exp.DataType.Type.VARBINARY: "String", 538 exp.DataType.Type.VARCHAR: "String", 539 } 540 541 SUPPORTED_JSON_PATH_PARTS = { 542 exp.JSONPathKey, 543 exp.JSONPathRoot, 544 exp.JSONPathSubscript, 545 } 546 547 TYPE_MAPPING = { 548 **generator.Generator.TYPE_MAPPING, 549 **STRING_TYPE_MAPPING, 550 exp.DataType.Type.ARRAY: "Array", 551 exp.DataType.Type.BIGINT: "Int64", 552 exp.DataType.Type.DATE32: "Date32", 553 exp.DataType.Type.DATETIME64: "DateTime64", 554 exp.DataType.Type.DOUBLE: "Float64", 555 exp.DataType.Type.ENUM: "Enum", 556 exp.DataType.Type.ENUM8: "Enum8", 557 exp.DataType.Type.ENUM16: "Enum16", 558 exp.DataType.Type.FIXEDSTRING: "FixedString", 559 exp.DataType.Type.FLOAT: "Float32", 560 exp.DataType.Type.INT: "Int32", 561 exp.DataType.Type.MEDIUMINT: "Int32", 562 exp.DataType.Type.INT128: "Int128", 563 exp.DataType.Type.INT256: "Int256", 564 exp.DataType.Type.LOWCARDINALITY: "LowCardinality", 565 exp.DataType.Type.MAP: "Map", 566 exp.DataType.Type.NESTED: "Nested", 567 exp.DataType.Type.NULLABLE: "Nullable", 568 exp.DataType.Type.SMALLINT: "Int16", 569 exp.DataType.Type.STRUCT: "Tuple", 570 exp.DataType.Type.TINYINT: "Int8", 571 exp.DataType.Type.UBIGINT: "UInt64", 572 exp.DataType.Type.UINT: "UInt32", 573 exp.DataType.Type.UINT128: "UInt128", 574 exp.DataType.Type.UINT256: "UInt256", 575 exp.DataType.Type.USMALLINT: "UInt16", 576 exp.DataType.Type.UTINYINT: "UInt8", 577 exp.DataType.Type.IPV4: "IPv4", 578 exp.DataType.Type.IPV6: "IPv6", 579 exp.DataType.Type.AGGREGATEFUNCTION: "AggregateFunction", 580 exp.DataType.Type.SIMPLEAGGREGATEFUNCTION: "SimpleAggregateFunction", 581 } 582 583 TRANSFORMS = { 584 **generator.Generator.TRANSFORMS, 585 exp.AnyValue: rename_func("any"), 586 exp.ApproxDistinct: rename_func("uniq"), 587 exp.ArrayFilter: lambda self, e: self.func("arrayFilter", e.expression, e.this), 588 exp.ArraySize: rename_func("LENGTH"), 589 exp.ArraySum: rename_func("arraySum"), 590 exp.ArgMax: arg_max_or_min_no_count("argMax"), 591 exp.ArgMin: arg_max_or_min_no_count("argMin"), 592 exp.Array: inline_array_sql, 593 exp.CastToStrType: rename_func("CAST"), 594 exp.CountIf: rename_func("countIf"), 595 exp.CurrentDate: lambda self, e: self.func("CURRENT_DATE"), 596 exp.DateAdd: date_delta_sql("DATE_ADD"), 597 exp.DateDiff: date_delta_sql("DATE_DIFF"), 598 exp.Explode: rename_func("arrayJoin"), 599 exp.Final: lambda self, e: f"{self.sql(e, 'this')} FINAL", 600 exp.IsNan: rename_func("isNaN"), 601 exp.JSONExtract: json_extract_segments("JSONExtractString", quoted_index=False), 602 exp.JSONExtractScalar: json_extract_segments("JSONExtractString", quoted_index=False), 603 exp.JSONPathKey: json_path_key_only_name, 604 exp.JSONPathRoot: lambda *_: "", 605 exp.Map: lambda self, e: _lower_func(var_map_sql(self, e)), 606 exp.Nullif: rename_func("nullIf"), 607 exp.PartitionedByProperty: lambda self, e: f"PARTITION BY {self.sql(e, 'this')}", 608 exp.Pivot: no_pivot_sql, 609 exp.Quantile: _quantile_sql, 610 exp.RegexpLike: lambda self, e: self.func("match", e.this, e.expression), 611 exp.Rand: rename_func("randCanonical"), 612 exp.Select: transforms.preprocess([transforms.eliminate_qualify]), 613 exp.StartsWith: rename_func("startsWith"), 614 exp.StrPosition: lambda self, e: self.func( 615 "position", e.this, e.args.get("substr"), e.args.get("position") 616 ), 617 exp.VarMap: lambda self, e: _lower_func(var_map_sql(self, e)), 618 exp.Xor: lambda self, e: self.func("xor", e.this, e.expression, *e.expressions), 619 } 620 621 PROPERTIES_LOCATION = { 622 **generator.Generator.PROPERTIES_LOCATION, 623 exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED, 624 exp.PartitionedByProperty: exp.Properties.Location.POST_SCHEMA, 625 exp.OnCluster: exp.Properties.Location.POST_NAME, 626 } 627 628 JOIN_HINTS = False 629 TABLE_HINTS = False 630 EXPLICIT_UNION = True 631 GROUPINGS_SEP = "" 632 633 # there's no list in docs, but it can be found in Clickhouse code 634 # see `ClickHouse/src/Parsers/ParserCreate*.cpp` 635 ON_CLUSTER_TARGETS = { 636 "DATABASE", 637 "TABLE", 638 "VIEW", 639 "DICTIONARY", 640 "INDEX", 641 "FUNCTION", 642 "NAMED COLLECTION", 643 } 644 645 def _jsonpathsubscript_sql(self, expression: exp.JSONPathSubscript) -> str: 646 this = self.json_path_part(expression.this) 647 return str(int(this) + 1) if is_int(this) else this 648 649 def likeproperty_sql(self, expression: exp.LikeProperty) -> str: 650 return f"AS {self.sql(expression, 'this')}" 651 652 def _any_to_has( 653 self, 654 expression: exp.EQ | exp.NEQ, 655 default: t.Callable[[t.Any], str], 656 prefix: str = "", 657 ) -> str: 658 if isinstance(expression.left, exp.Any): 659 arr = expression.left 660 this = expression.right 661 elif isinstance(expression.right, exp.Any): 662 arr = expression.right 663 this = expression.left 664 else: 665 return default(expression) 666 667 return prefix + self.func("has", arr.this.unnest(), this) 668 669 def eq_sql(self, expression: exp.EQ) -> str: 670 return self._any_to_has(expression, super().eq_sql) 671 672 def neq_sql(self, expression: exp.NEQ) -> str: 673 return self._any_to_has(expression, super().neq_sql, "NOT ") 674 675 def regexpilike_sql(self, expression: exp.RegexpILike) -> str: 676 # Manually add a flag to make the search case-insensitive 677 regex = self.func("CONCAT", "'(?i)'", expression.expression) 678 return self.func("match", expression.this, regex) 679 680 def datatype_sql(self, expression: exp.DataType) -> str: 681 # String is the standard ClickHouse type, every other variant is just an alias. 682 # Additionally, any supplied length parameter will be ignored. 683 # 684 # https://clickhouse.com/docs/en/sql-reference/data-types/string 685 if expression.this in self.STRING_TYPE_MAPPING: 686 return "String" 687 688 return super().datatype_sql(expression) 689 690 def cte_sql(self, expression: exp.CTE) -> str: 691 if expression.args.get("scalar"): 692 this = self.sql(expression, "this") 693 alias = self.sql(expression, "alias") 694 return f"{this} AS {alias}" 695 696 return super().cte_sql(expression) 697 698 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 699 return super().after_limit_modifiers(expression) + [ 700 ( 701 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 702 if expression.args.get("settings") 703 else "" 704 ), 705 ( 706 self.seg("FORMAT ") + self.sql(expression, "format") 707 if expression.args.get("format") 708 else "" 709 ), 710 ] 711 712 def parameterizedagg_sql(self, expression: exp.ParameterizedAgg) -> str: 713 params = self.expressions(expression, key="params", flat=True) 714 return self.func(expression.name, *expression.expressions) + f"({params})" 715 716 def anonymousaggfunc_sql(self, expression: exp.AnonymousAggFunc) -> str: 717 return self.func(expression.name, *expression.expressions) 718 719 def combinedaggfunc_sql(self, expression: exp.CombinedAggFunc) -> str: 720 return self.anonymousaggfunc_sql(expression) 721 722 def combinedparameterizedagg_sql(self, expression: exp.CombinedParameterizedAgg) -> str: 723 return self.parameterizedagg_sql(expression) 724 725 def placeholder_sql(self, expression: exp.Placeholder) -> str: 726 return f"{{{expression.name}: {self.sql(expression, 'kind')}}}" 727 728 def oncluster_sql(self, expression: exp.OnCluster) -> str: 729 return f"ON CLUSTER {self.sql(expression, 'this')}" 730 731 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 732 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 733 exp.Properties.Location.POST_NAME 734 ): 735 this_name = self.sql(expression.this, "this") 736 this_properties = " ".join( 737 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 738 ) 739 this_schema = self.schema_columns_sql(expression.this) 740 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 741 742 return super().createable_sql(expression, locations) 743 744 def prewhere_sql(self, expression: exp.PreWhere) -> str: 745 this = self.indent(self.sql(expression, "this")) 746 return f"{self.seg('PREWHERE')}{self.sep()}{this}"
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. Default: 2.
- indent: The indentation size in a formatted string. 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.JSONPathKey'>, <class 'sqlglot.expressions.JSONPathSubscript'>, <class 'sqlglot.expressions.JSONPathRoot'>}
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.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.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.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.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', 'NAMED COLLECTION', 'INDEX', 'VIEW', 'TABLE', 'DATABASE', 'FUNCTION'}
680 def datatype_sql(self, expression: exp.DataType) -> str: 681 # String is the standard ClickHouse type, every other variant is just an alias. 682 # Additionally, any supplied length parameter will be ignored. 683 # 684 # https://clickhouse.com/docs/en/sql-reference/data-types/string 685 if expression.this in self.STRING_TYPE_MAPPING: 686 return "String" 687 688 return super().datatype_sql(expression)
698 def after_limit_modifiers(self, expression: exp.Expression) -> t.List[str]: 699 return super().after_limit_modifiers(expression) + [ 700 ( 701 self.seg("SETTINGS ") + self.expressions(expression, key="settings", flat=True) 702 if expression.args.get("settings") 703 else "" 704 ), 705 ( 706 self.seg("FORMAT ") + self.sql(expression, "format") 707 if expression.args.get("format") 708 else "" 709 ), 710 ]
def
combinedparameterizedagg_sql(self, expression: sqlglot.expressions.CombinedParameterizedAgg) -> str:
731 def createable_sql(self, expression: exp.Create, locations: t.DefaultDict) -> str: 732 if expression.kind in self.ON_CLUSTER_TARGETS and locations.get( 733 exp.Properties.Location.POST_NAME 734 ): 735 this_name = self.sql(expression.this, "this") 736 this_properties = " ".join( 737 [self.sql(prop) for prop in locations[exp.Properties.Location.POST_NAME]] 738 ) 739 this_schema = self.schema_columns_sql(expression.this) 740 return f"{this_name}{self.sep()}{this_properties}{self.sep()}{this_schema}" 741 742 return super().createable_sql(expression, locations)
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
- indexcolumnconstraint_sql
- nvl2_sql
- comprehension_sql
- columnprefix_sql
- opclass_sql
- predict_sql
- forin_sql
- refresh_sql
- operator_sql
- toarray_sql
- tsordstotime_sql
- tsordstodate_sql
- unixdate_sql
- lastday_sql
- arrayany_sql
- generateseries_sql
- struct_sql
- partitionrange_sql
- truncatetable_sql
- convert_sql