Edit on GitHub

sqlglot.typing

View Source

  1from __future__ import annotations
  2
  3import typing as t
  4
  5from sqlglot import exp
  6from sqlglot.helper import subclasses
  7from builtins import type as Type
  8
  9if t.TYPE_CHECKING:
 10    from sqlglot.optimizer.annotate_types import TypeAnnotator
 11
 12ExprMetadataType = dict[Type[exp.Expr], dict[str, t.Any]]
 13
 14
 15def annotate_by_numeric_arg(self: TypeAnnotator, expression: exp.Expr) -> exp.Expr:
 16    """
 17    Annotates math functions (e.g. FLOOR) that preserve numeric and unknown types, and return INT
 18    otherwise.
 19
 20    Assumes `this` is set, which holds for valid ASTs because it's a required argument.
 21    """
 22    this: exp.Expr = expression.this
 23
 24    self._set_type(
 25        expression,
 26        this.type
 27        if this.is_type(exp.DType.UNKNOWN, *exp.DataType.NUMERIC_TYPES)
 28        else exp.DType.INT,
 29    )
 30    return expression
 31
 32
 33def annotate_int_as_double(self: TypeAnnotator, expression: exp.Expr) -> exp.Expr:
 34    """
 35    Annotates math functions (e.g. FLOOR) that return DOUBLE for integers and strings, and the input
 36    type otherwise.
 37
 38    Assumes `this` is set, which holds for valid ASTs because it's a required argument.
 39    """
 40    this: exp.Expr = expression.this
 41
 42    self._set_type(
 43        expression,
 44        exp.DType.DOUBLE
 45        if this.is_type(*exp.DataType.INTEGER_TYPES, *exp.DataType.TEXT_TYPES)
 46        else this.type,
 47    )
 48    return expression
 49
 50
 51TIMESTAMP_EXPRESSIONS = {
 52    exp.CurrentTimestamp,
 53    exp.StrToTime,
 54    exp.TimeStrToTime,
 55    exp.TimestampAdd,
 56    exp.TimestampSub,
 57    exp.UnixToTime,
 58}
 59
 60EXPRESSION_METADATA: ExprMetadataType = {
 61    **{
 62        expr_type: {"annotator": lambda self, e: self._annotate_binary(e)}
 63        for expr_type in subclasses(exp.__name__, exp.Binary)
 64    },
 65    **{
 66        expr_type: {"annotator": lambda self, e: self._annotate_unary(e)}
 67        for expr_type in subclasses(
 68            exp.__name__,
 69            (
 70                exp.Unary,
 71                exp.Alias,
 72                exp.IgnoreNulls,
 73                exp.RespectNulls,
 74                exp.FormatPhrase,
 75                exp.TeradataTitle,
 76            ),
 77        )
 78    },
 79    **{
 80        expr_type: {"returns": exp.DType.BIGINT}
 81        for expr_type in {
 82            exp.ApproxDistinct,
 83            exp.ArraySize,
 84            exp.CountIf,
 85            exp.DenseRank,
 86            exp.Int64,
 87            exp.Ntile,
 88            exp.Rank,
 89            exp.RowNumber,
 90            exp.UnixSeconds,
 91            exp.UnixMicros,
 92            exp.UnixMillis,
 93        }
 94    },
 95    **{
 96        expr_type: {"returns": exp.DType.BINARY}
 97        for expr_type in {
 98            exp.FromBase32,
 99            exp.FromBase64,
100        }
101    },
102    **{
103        expr_type: {"returns": exp.DType.BOOLEAN}
104        for expr_type in {
105            exp.All,
106            exp.Any,
107            exp.Between,
108            exp.Boolean,
109            exp.Contains,
110            exp.EndsWith,
111            exp.Exists,
112            exp.In,
113            exp.IsInf,
114            exp.IsNan,
115            exp.LogicalAnd,
116            exp.LogicalOr,
117            exp.StartsWith,
118        }
119    },
120    **{
121        expr_type: {"returns": exp.DType.DATE}
122        for expr_type in {
123            exp.CurrentDate,
124            exp.Date,
125            exp.DateFromParts,
126            exp.DateStrToDate,
127            exp.DiToDate,
128            exp.LastDay,
129            exp.StrToDate,
130            exp.TimeStrToDate,
131            exp.TsOrDsToDate,
132        }
133    },
134    **{
135        expr_type: {"returns": exp.DType.DATETIME}
136        for expr_type in {
137            exp.CurrentDatetime,
138            exp.Datetime,
139            exp.DatetimeAdd,
140            exp.DatetimeSub,
141        }
142    },
143    **{
144        expr_type: {"returns": exp.DType.DOUBLE}
145        for expr_type in {
146            exp.Asin,
147            exp.Asinh,
148            exp.Acos,
149            exp.CovarPop,
150            exp.CovarSamp,
151            exp.Acosh,
152            exp.ApproxQuantile,
153            exp.Atan,
154            exp.Atanh,
155            exp.Avg,
156            exp.Cbrt,
157            exp.Cos,
158            exp.Cosh,
159            exp.Cot,
160            exp.Degrees,
161            exp.Exp,
162            exp.Kurtosis,
163            exp.Ln,
164            exp.Log,
165            exp.Pi,
166            exp.Pow,
167            exp.PercentileCont,
168            exp.Quantile,
169            exp.Radians,
170            exp.Round,
171            exp.SafeDivide,
172            exp.Sin,
173            exp.Sinh,
174            exp.Sqrt,
175            exp.Stddev,
176            exp.StddevPop,
177            exp.StddevSamp,
178            exp.Rand,
179            exp.Tan,
180            exp.Tanh,
181            exp.ToDouble,
182            exp.CumeDist,
183            exp.PercentRank,
184            exp.Variance,
185            exp.VariancePop,
186            exp.Skewness,
187        }
188    },
189    **{
190        expr_type: {"returns": exp.DType.INT}
191        for expr_type in {
192            exp.Ascii,
193            exp.BitLength,
194            exp.DatetimeDiff,
195            exp.DayOfMonth,
196            exp.DayOfWeek,
197            exp.DayOfYear,
198            exp.Getbit,
199            exp.Hour,
200            exp.TimestampDiff,
201            exp.TimeDiff,
202            exp.Unicode,
203            exp.DateToDi,
204            exp.Levenshtein,
205            exp.Length,
206            exp.Sign,
207            exp.StrPosition,
208            exp.TsOrDiToDi,
209            exp.Quarter,
210            exp.UnixDate,
211        }
212    },
213    **{
214        expr_type: {"returns": exp.DType.INTERVAL}
215        for expr_type in {
216            exp.Interval,
217            exp.JustifyDays,
218            exp.JustifyHours,
219            exp.JustifyInterval,
220            exp.MakeInterval,
221        }
222    },
223    **{
224        expr_type: {"returns": exp.DType.JSON}
225        for expr_type in {
226            exp.ParseJSON,
227        }
228    },
229    **{
230        expr_type: {"returns": exp.DType.TIME}
231        for expr_type in {
232            exp.CurrentTime,
233            exp.Localtime,
234            exp.Time,
235            exp.TimeAdd,
236            exp.TimeSub,
237        }
238    },
239    **{
240        expr_type: {"returns": exp.DType.TIMESTAMPLTZ}
241        for expr_type in {
242            exp.TimestampLtzFromParts,
243        }
244    },
245    **{
246        expr_type: {"returns": exp.DType.TIMESTAMPTZ}
247        for expr_type in {
248            exp.CurrentTimestampLTZ,
249            exp.TimestampTzFromParts,
250        }
251    },
252    **{expr_type: {"returns": exp.DType.TIMESTAMP} for expr_type in TIMESTAMP_EXPRESSIONS},
253    **{
254        expr_type: {"returns": exp.DType.TINYINT}
255        for expr_type in {
256            exp.Day,
257            exp.DayOfWeekIso,
258            exp.Month,
259            exp.Week,
260            exp.WeekOfYear,
261            exp.Year,
262            exp.YearOfWeek,
263            exp.YearOfWeekIso,
264        }
265    },
266    **{
267        expr_type: {"returns": exp.DType.VARCHAR}
268        for expr_type in {
269            exp.ArrayToString,
270            exp.Concat,
271            exp.ConcatWs,
272            exp.Chr,
273            exp.CurrentCatalog,
274            exp.CurrentRole,
275            exp.CurrentSchema,
276            exp.CurrentVersion,
277            exp.CurrentUser,
278            exp.Dayname,
279            exp.DateToDateStr,
280            exp.DPipe,
281            exp.GroupConcat,
282            exp.Initcap,
283            exp.Lower,
284            exp.MD5,
285            exp.Monthname,
286            exp.RawString,
287            exp.Repeat,
288            exp.SHA,
289            exp.SHA2,
290            exp.SessionUser,
291            exp.Space,
292            exp.String,
293            exp.Substring,
294            exp.TimeToStr,
295            exp.TimeToTimeStr,
296            exp.Trim,
297            exp.ToBase32,
298            exp.ToBase64,
299            exp.ToChar,
300            exp.Translate,
301            exp.TsOrDsToDateStr,
302            exp.Typeof,
303            exp.UnixToStr,
304            exp.UnixToTimeStr,
305            exp.Upper,
306        }
307    },
308    **{
309        expr_type: {"annotator": annotate_by_numeric_arg}
310        for expr_type in {
311            exp.Ceil,
312            exp.Floor,
313        }
314    },
315    **{
316        expr_type: {"annotator": lambda self, e: self._annotate_by_args(e, "this")}
317        for expr_type in {
318            exp.Abs,
319            exp.AnyValue,
320            exp.ArrayConcatAgg,
321            exp.ArrayReverse,
322            exp.ArraySlice,
323            exp.Filter,
324            exp.FirstValue,
325            exp.HavingMax,
326            exp.LastValue,
327            exp.Limit,
328            exp.NthValue,
329            exp.Order,
330            exp.ArraySort,
331            exp.Window,
332        }
333    },
334    **{
335        expr_type: {"annotator": lambda self, e: self._annotate_by_args(e, "this", "expressions")}
336        for expr_type in {
337            exp.ArrayConcat,
338            exp.Coalesce,
339            exp.Greatest,
340            exp.Least,
341        }
342    },
343    **{
344        expr_type: {
345            "annotator": lambda self, e: self._annotate_by_args(
346                e, "this", "expressions", array=e.args.get("count") is not None
347            )
348        }
349        for expr_type in {exp.Max, exp.Min}
350    },
351    **{
352        expr_type: {"annotator": lambda self, e: self._annotate_by_array_element(e)}
353        for expr_type in {
354            exp.ArrayFirst,
355            exp.ArrayLast,
356        }
357    },
358    exp.Anonymous: {"annotator": lambda self, e: self._set_type(e, self.schema.get_udf_type(e))},
359    **{
360        expr_type: {"annotator": lambda self, e: self._annotate_timeunit(e)}
361        for expr_type in {
362            exp.DateAdd,
363            exp.DateSub,
364            exp.DateTrunc,
365        }
366    },
367    **{
368        expr_type: {"annotator": lambda self, e: self._set_type(e, e.args["to"])}
369        for expr_type in {
370            exp.Cast,
371            exp.TryCast,
372        }
373    },
374    **{
375        expr_type: {"annotator": lambda self, e: self._annotate_map(e)}
376        for expr_type in {
377            exp.Map,
378            exp.VarMap,
379        }
380    },
381    exp.Array: {"annotator": lambda self, e: self._annotate_by_args(e, "expressions", array=True)},
382    exp.ArrayAgg: {"annotator": lambda self, e: self._annotate_by_args(e, "this", array=True)},
383    exp.Bracket: {"annotator": lambda self, e: self._annotate_bracket(e)},
384    exp.Case: {
385        "annotator": lambda self, e: self._annotate_by_args(
386            e, *[if_expr.args["true"] for if_expr in e.args["ifs"]], "default"
387        )
388    },
389    exp.Count: {
390        "annotator": lambda self, e: self._set_type(
391            e, exp.DType.BIGINT if e.args.get("big_int") else exp.DType.INT
392        )
393    },
394    exp.DateDiff: {
395        "annotator": lambda self, e: self._set_type(
396            e, exp.DType.BIGINT if e.args.get("big_int") else exp.DType.INT
397        )
398    },
399    exp.DataType: {"annotator": lambda _, e: e},
400    exp.Div: {"annotator": lambda self, e: self._annotate_div(e)},
401    exp.Distinct: {"annotator": lambda self, e: self._annotate_by_args(e, "expressions")},
402    exp.Dot: {"annotator": lambda self, e: self._annotate_dot(e)},
403    exp.Explode: {"annotator": lambda self, e: self._annotate_explode(e)},
404    exp.Extract: {"annotator": lambda self, e: self._annotate_extract(e)},
405    exp.HexString: {
406        "annotator": lambda self, e: self._set_type(
407            e,
408            exp.DType.BIGINT if e.args.get("is_integer") else exp.DType.BINARY,
409        )
410    },
411    exp.GenerateSeries: {
412        "annotator": lambda self, e: self._annotate_by_args(e, "start", "end", "step", array=True)
413    },
414    exp.GenerateDateArray: {
415        "annotator": lambda self, e: self._set_type(e, exp.DataType.from_str("ARRAY<DATE>"))
416    },
417    exp.GenerateTimestampArray: {
418        "annotator": lambda self, e: self._set_type(e, exp.DataType.from_str("ARRAY<TIMESTAMP>"))
419    },
420    exp.If: {"annotator": lambda self, e: self._annotate_by_args(e, "true", "false")},
421    exp.Lag: {"annotator": lambda self, e: self._annotate_by_args(e, "this", "default")},
422    exp.Lead: {"annotator": lambda self, e: self._annotate_by_args(e, "this", "default")},
423    exp.Literal: {"annotator": lambda self, e: self._annotate_literal(e)},
424    exp.Null: {"returns": exp.DType.NULL},
425    exp.Nullif: {"annotator": lambda self, e: self._annotate_by_args(e, "this", "expression")},
426    exp.PropertyEQ: {"annotator": lambda self, e: self._annotate_by_args(e, "expression")},
427    exp.Struct: {"annotator": lambda self, e: self._annotate_struct(e)},
428    exp.Sum: {
429        "annotator": lambda self, e: self._annotate_by_args(e, "this", "expressions", promote=True)
430    },
431    exp.Timestamp: {
432        "annotator": lambda self, e: self._set_type(
433            e,
434            exp.DType.TIMESTAMPTZ if e.args.get("with_tz") else exp.DType.TIMESTAMP,
435        )
436    },
437    exp.ToMap: {"annotator": lambda self, e: self._annotate_to_map(e)},
438    exp.Unnest: {"annotator": lambda self, e: self._annotate_unnest(e)},
439    exp.WithinGroup: {"annotator": lambda self, e: self._annotate_within_group(e)},
440    exp.Subquery: {"annotator": lambda self, e: self._annotate_subquery(e)},
441}

ExprMetadataType = dict[type[sqlglot.expressions.core.Expr], dict[str, typing.Any]]

def annotate_by_numeric_arg( self: sqlglot.optimizer.annotate_types.TypeAnnotator, expression: sqlglot.expressions.core.Expr) -> sqlglot.expressions.core.Expr: View Source

16def annotate_by_numeric_arg(self: TypeAnnotator, expression: exp.Expr) -> exp.Expr:
17    """
18    Annotates math functions (e.g. FLOOR) that preserve numeric and unknown types, and return INT
19    otherwise.
20
21    Assumes `this` is set, which holds for valid ASTs because it's a required argument.
22    """
23    this: exp.Expr = expression.this
24
25    self._set_type(
26        expression,
27        this.type
28        if this.is_type(exp.DType.UNKNOWN, *exp.DataType.NUMERIC_TYPES)
29        else exp.DType.INT,
30    )
31    return expression

Annotates math functions (e.g. FLOOR) that preserve numeric and unknown types, and return INT otherwise.

Assumes this is set, which holds for valid ASTs because it's a required argument.

def annotate_int_as_double( self: sqlglot.optimizer.annotate_types.TypeAnnotator, expression: sqlglot.expressions.core.Expr) -> sqlglot.expressions.core.Expr: View Source

34def annotate_int_as_double(self: TypeAnnotator, expression: exp.Expr) -> exp.Expr:
35    """
36    Annotates math functions (e.g. FLOOR) that return DOUBLE for integers and strings, and the input
37    type otherwise.
38
39    Assumes `this` is set, which holds for valid ASTs because it's a required argument.
40    """
41    this: exp.Expr = expression.this
42
43    self._set_type(
44        expression,
45        exp.DType.DOUBLE
46        if this.is_type(*exp.DataType.INTEGER_TYPES, *exp.DataType.TEXT_TYPES)
47        else this.type,
48    )
49    return expression

Annotates math functions (e.g. FLOOR) that return DOUBLE for integers and strings, and the input type otherwise.

Assumes this is set, which holds for valid ASTs because it's a required argument.

TIMESTAMP_EXPRESSIONS = {<class 'sqlglot.expressions.temporal.CurrentTimestamp'>, <class 'sqlglot.expressions.temporal.TimestampAdd'>, <class 'sqlglot.expressions.temporal.TimeStrToTime'>, <class 'sqlglot.expressions.temporal.TimestampSub'>, <class 'sqlglot.expressions.temporal.StrToTime'>, <class 'sqlglot.expressions.temporal.UnixToTime'>}

EXPRESSION_METADATA: dict[type[sqlglot.expressions.core.Expr], dict[str, typing.Any]] = {<class 'sqlglot.expressions.core.Add'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Adjacent'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.And'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContainedBy'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayContainsAll'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayOverlaps'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayPosition'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Binary'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseAnd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseLeftShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseOr'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseRightShift'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseXor'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Collate'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Connector'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Corr'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.DPipe'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.core.Distance'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.DistanceNd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Div'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Dot'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.EQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Escape'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ExtendsLeft'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ExtendsRight'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.GT'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.GTE'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Glob'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.ILike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.IntDiv'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Is'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONArrayContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContains'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsAllTopKeys'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsAnyTopKeys'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBContainsTopKey'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBDeleteAtPath'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBExtract'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBExtractScalar'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONBPathExists'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONExtract'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.json.JSONExtractScalar'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Kwarg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.LT'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.LTE'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Like'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Match'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Mod'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Mul'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NestedJSONSelect'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NullSafeEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.NullSafeNEQ'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Operator'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Or'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Overlaps'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Pow'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.core.PropertyEQ'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.string.RegexpFullMatch'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.string.RegexpILike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.RegexpLike'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.SimilarTo'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Sub'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Xor'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Alias'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.BitwiseNot'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.FormatPhrase'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.IgnoreNulls'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Neg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Not'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Paren'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.PivotAlias'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.RespectNulls'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.TeradataTitle'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Unary'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.UnixSeconds'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.RowNumber'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.core.ApproxDistinct'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.UnixMillis'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.temporal.UnixMicros'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.DenseRank'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.Ntile'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.Rank'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.array.ArraySize'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.functions.Int64'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.aggregate.CountIf'>: {'returns': <DType.BIGINT: 'BIGINT'>}, <class 'sqlglot.expressions.string.FromBase32'>: {'returns': <DType.BINARY: 'BINARY'>}, <class 'sqlglot.expressions.string.FromBase64'>: {'returns': <DType.BINARY: 'BINARY'>}, <class 'sqlglot.expressions.aggregate.LogicalAnd'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Boolean'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.functions.Exists'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsNan'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.In'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.EndsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.StartsWith'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.math.IsInf'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Between'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.string.Contains'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.Any'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.core.All'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.aggregate.LogicalOr'>: {'returns': <DType.BOOLEAN: 'BOOLEAN'>}, <class 'sqlglot.expressions.temporal.LastDay'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DateStrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DateFromParts'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.Date'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.CurrentDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.TimeStrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.DiToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.StrToDate'>: {'returns': <DType.DATE: 'DATE'>}, <class 'sqlglot.expressions.temporal.CurrentDatetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.Datetime'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeSub'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.temporal.DatetimeAdd'>: {'returns': <DType.DATETIME: 'DATETIME'>}, <class 'sqlglot.expressions.math.Sqrt'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Round'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Asin'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Atan'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Pi'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.ApproxQuantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Stddev'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentRank'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Ln'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Variance'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.PercentileCont'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Kurtosis'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.functions.Rand'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Degrees'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CumeDist'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.SafeDivide'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Acos'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cot'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Tanh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cos'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Sinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Atanh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Avg'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Asinh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Acosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.string.ToDouble'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Exp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.StddevPop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Quantile'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Log'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cbrt'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.VariancePop'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.Skewness'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Radians'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.aggregate.CovarSamp'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Cosh'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.math.Tan'>: {'returns': <DType.DOUBLE: 'DOUBLE'>}, <class 'sqlglot.expressions.temporal.TimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfMonth'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Levenshtein'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DatetimeDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Quarter'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.BitLength'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.StrPosition'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.UnixDate'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Unicode'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.Hour'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TimestampDiff'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.TsOrDiToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfYear'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Sign'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Ascii'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DayOfWeek'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.string.Length'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.DateToDi'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.math.Getbit'>: {'returns': <DType.INT: 'INT'>}, <class 'sqlglot.expressions.temporal.JustifyInterval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.JustifyHours'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.JustifyDays'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.datatypes.Interval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.temporal.MakeInterval'>: {'returns': <DType.INTERVAL: 'INTERVAL'>}, <class 'sqlglot.expressions.json.ParseJSON'>: {'returns': <DType.JSON: 'JSON'>}, <class 'sqlglot.expressions.temporal.TimeSub'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Time'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.Localtime'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.CurrentTime'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimeAdd'>: {'returns': <DType.TIME: 'TIME'>}, <class 'sqlglot.expressions.temporal.TimestampLtzFromParts'>: {'returns': <DType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>}, <class 'sqlglot.expressions.temporal.TimestampTzFromParts'>: {'returns': <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>}, <class 'sqlglot.expressions.temporal.CurrentTimestampLTZ'>: {'returns': <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>}, <class 'sqlglot.expressions.temporal.CurrentTimestamp'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampAdd'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimeStrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.TimestampSub'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.StrToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.UnixToTime'>: {'returns': <DType.TIMESTAMP: 'TIMESTAMP'>}, <class 'sqlglot.expressions.temporal.DayOfWeekIso'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Month'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.YearOfWeekIso'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.YearOfWeek'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Day'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Year'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.WeekOfYear'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.temporal.Week'>: {'returns': <DType.TINYINT: 'TINYINT'>}, <class 'sqlglot.expressions.functions.CurrentVersion'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Translate'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.UnixToTimeStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ConcatWs'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Substring'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToChar'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.UnixToStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Chr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.String'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentSchema'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA2'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToBase64'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Initcap'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentRole'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.aggregate.GroupConcat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.SHA'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.MD5'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.query.RawString'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.DateToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TsOrDsToDateStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.TimeToTimeStr'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Lower'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Repeat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Concat'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.Monthname'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.ToBase32'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.CurrentCatalog'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Upper'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.array.ArrayToString'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Trim'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.core.Typeof'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.functions.SessionUser'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.string.Space'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.temporal.Dayname'>: {'returns': <DType.VARCHAR: 'VARCHAR'>}, <class 'sqlglot.expressions.math.Ceil'>: {'annotator': <function annotate_by_numeric_arg>}, <class 'sqlglot.expressions.math.Floor'>: {'annotator': <function annotate_by_numeric_arg>}, <class 'sqlglot.expressions.core.HavingMax'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Window'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.math.Abs'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArraySort'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.FirstValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.LastValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArraySlice'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.NthValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayReverse'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Filter'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Limit'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.ArrayConcatAgg'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.query.Order'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.AnyValue'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Greatest'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Least'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Coalesce'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayConcat'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Max'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.aggregate.Min'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayFirst'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.ArrayLast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.core.Anonymous'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.DateTrunc'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.DateSub'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.temporal.DateAdd'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.Cast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.functions.TryCast'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.Map'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.VarMap'>: {'annotator': <function <dictcomp>.<lambda>>}, <class 'sqlglot.expressions.array.Array'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.ArrayAgg'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Bracket'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.functions.Case'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Count'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.DateDiff'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.datatypes.DataType'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Distinct'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Explode'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.Extract'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.query.HexString'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.GenerateSeries'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.GenerateDateArray'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.GenerateTimestampArray'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.functions.If'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Lag'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Lead'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Literal'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.Null'>: {'returns': <DType.NULL: 'NULL'>}, <class 'sqlglot.expressions.functions.Nullif'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Struct'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.aggregate.Sum'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.temporal.Timestamp'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.ToMap'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.array.Unnest'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.core.WithinGroup'>: {'annotator': <function <lambda>>}, <class 'sqlglot.expressions.query.Subquery'>: {'annotator': <function <lambda>>}}