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