Skip to content

Instantly share code, notes, and snippets.

@0xffhh

0xffhh/Kusto Language Bridge

Created September 29, 2020 12:15
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save 0xffhh/2c0987e5c92133ea70f8371d52891553 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save 0xffhh/2c0987e5c92133ea70f8371d52891553 to your computer and use it in GitHub Desktop.
Download ZIP
The kusto language definition file as used by defender atp
Raw
Kusto Language Bridge
This file has been truncated, but you can view the full file.
//Source: https://securitycenter.windows.com/assets/monaco/vs/language/kusto/Kusto.Language.Bridge.min.js
Bridge.assembly("Kusto.Language.Bridge", function() {
"use strict";
Bridge.define("Kusto.Language.Aggregates", {
statics: {
fields: {
Sum: null,
SumIf: null,
Cnt: null,
Count: null,
CountIf: null,
DCount: null,
DCountIf: null,
TDigest: null,
TDigestMerge: null,
MergeTDigests: null,
Hll: null,
HllMerge: null,
Min: null,
MinIf: null,
Max: null,
MaxIf: null,
Avg: null,
AvgIf: null,
MakeList_Depricated: null,
MakeList: null,
MakeListIf: null,
MakeListWithNulls: null,
MakeSet_Depricated: null,
MakeSet: null,
MakeSetIf: null,
Passthrough: null,
MakeDictionary: null,
MakeBag: null,
MakeBagIf: null,
BuildSchema: null,
BinaryAllOr: null,
BinaryAllAnd: null,
BinaryAllXor: null,
PercentileReturn: null,
PercentileArrayReturn: null,
Percentile: null,
Percentiles: null,
PercentilesArray: null,
PercentileW: null,
PercentilesW: null,
PercentilesWArray: null,
Stdev: null,
StdevIf: null,
Stdevp: null,
Variance: null,
VarianceIf: null,
Variancep: null,
Any: null,
AnyIf: null,
ArgMin: null,
ArgMax: null,
ArgMin_Depricated: null,
ArgMax_Depricated: null
},
props: {
All: null
},
ctors: {
init: function() {
this.Sum = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("sum", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("sum");
this.SumIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("sumif", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("sumif");
this.Cnt = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cnt", Kusto.Language.Symbols.ScalarTypes.Long).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("cnt").Hide();
this.Count = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("count", Kusto.Language.Symbols.ScalarTypes.Long).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("count");
this.CountIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("countif", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("countif");
this.DCount = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dcount", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("accuracy", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("dcount");
this.DCountIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dcountif", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("accuracy", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("dcountif");
this.TDigest = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("weight", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("tdigest");
this.TDigestMerge = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tdigest_merge", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("tdigest_merge");
this.MergeTDigests = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("merge_tdigests", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("merge_tdigests");
this.Hll = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hll", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.NotRealOrBool), new Kusto.Language.Symbols.Parameter.ctor("accuracy", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("hll");
this.HllMerge = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hll_merge", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("hll", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("hll_merge");
this.Min = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("min", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.String)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("min");
this.MinIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("minif", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("minif");
this.Max = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("max", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.String)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("max");
this.MaxIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("maxif", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("maxif");
this.Avg = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("avg", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Integer)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Real)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Decimal, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Decimal)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.DateTime)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("avg");
this.AvgIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("avgif", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Decimal, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Decimal), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("avgif");
this.MakeList_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("makelist", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("list").Hide();
this.MakeList = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_list", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("list");
this.MakeListIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_list_if", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("list");
this.MakeListWithNulls = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_list_with_nulls", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("list");
this.MakeSet_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("makeset", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("set").Hide();
this.MakeSet = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_set", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("set");
this.MakeSetIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_set_if", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("set");
this.Passthrough = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("passthrough", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).Hide();
this.MakeDictionary = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_dictionary", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("dictionary").Hide();
this.MakeBag = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_bag", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("bag");
this.MakeBagIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_bag_if", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("maxSize", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("bag");
this.BuildSchema = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("buildschema", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("schema");
this.BinaryAllOr = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("binary_all_or", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.BinaryAllAnd = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("binary_all_and", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.BinaryAllXor = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("binary_all_xor", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).Hide();
this.PercentileReturn = function(table, args, signature) {
var cols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
return Kusto.Language.Aggregates.AddPercentileColumns(cols, signature, "expr", "percentile", args), new Kusto.Language.Symbols.TupleSymbol.$ctor1(cols)
};
this.PercentileArrayReturn = function(table, args, signature) {
var cols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor),
valueArg = Kusto.Language.FunctionHelpers.GetArgument(args, signature, "expr"),
valueArgName = Kusto.Language.FunctionHelpers.GetExpressionResultName(valueArg);
return cols.add(new Kusto.Language.Symbols.ColumnSymbol("percentiles_" + (valueArgName || ""), Kusto.Language.Symbols.ScalarTypes.Dynamic)), new Kusto.Language.Symbols.TupleSymbol.$ctor1(cols)
};
this.Percentile = new Kusto.Language.Symbols.FunctionSymbol.ctor("percentile", Kusto.Language.Aggregates.PercentileReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number)]);
this.Percentiles = new Kusto.Language.Symbols.FunctionSymbol.ctor("percentiles", Kusto.Language.Aggregates.PercentileReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]);
this.PercentilesArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("percentiles_array", [new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Aggregates.PercentileArrayReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Aggregates.PercentileArrayReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("percentiles", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.PercentileW = new Kusto.Language.Symbols.FunctionSymbol.ctor("percentilew", Kusto.Language.Aggregates.PercentileReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("weight", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number)]);
this.PercentilesW = new Kusto.Language.Symbols.FunctionSymbol.ctor("percentilesw", Kusto.Language.Aggregates.PercentileReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("weight", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]);
this.PercentilesWArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("percentilesw_array", [new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Aggregates.PercentileArrayReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("weight", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("percentile", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Aggregates.PercentileArrayReturn, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("weight", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.$ctor2("percentiles", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Stdev = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("stdev", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("stdev");
this.StdevIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("stdevif", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("stdevif");
this.Stdevp = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("stdevp", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("stdevp");
this.Variance = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("variance", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("variance");
this.VarianceIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("varianceif", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("varianceif");
this.Variancep = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("variancep", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("variancep");
this.Any = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("any", [new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetAnyResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetAnyResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]);
this.AnyIf = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("anyif", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("expr", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("anyif");
this.ArgMin = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("arg_min", [new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("minimized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("minimized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]);
this.ArgMax = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("arg_max", [new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("maximized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("maximized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]);
this.ArgMin_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("argmin", [new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxDepResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("minimized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxDepResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("minimized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]).WithResultNamePrefix("min").Hide();
this.ArgMax_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("argmax", [new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxDepResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("maximized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor2(Kusto.Language.Aggregates.GetArgMinMaxDepResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("maximized", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("returned", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]).WithResultNamePrefix("max").Hide();
this.All = System.Array.init([Kusto.Language.Aggregates.Sum, Kusto.Language.Aggregates.SumIf, Kusto.Language.Aggregates.Cnt, Kusto.Language.Aggregates.Count, Kusto.Language.Aggregates.CountIf, Kusto.Language.Aggregates.DCount, Kusto.Language.Aggregates.DCountIf, Kusto.Language.Aggregates.TDigest, Kusto.Language.Aggregates.TDigestMerge, Kusto.Language.Aggregates.MergeTDigests, Kusto.Language.Aggregates.Hll, Kusto.Language.Aggregates.HllMerge, Kusto.Language.Aggregates.Min, Kusto.Language.Aggregates.MinIf, Kusto.Language.Aggregates.Max, Kusto.Language.Aggregates.MaxIf, Kusto.Language.Aggregates.Avg, Kusto.Language.Aggregates.AvgIf, Kusto.Language.Aggregates.MakeList_Depricated, Kusto.Language.Aggregates.MakeList, Kusto.Language.Aggregates.MakeListIf, Kusto.Language.Aggregates.MakeListWithNulls, Kusto.Language.Aggregates.MakeSet_Depricated, Kusto.Language.Aggregates.MakeSet, Kusto.Language.Aggregates.MakeSetIf, Kusto.Language.Aggregates.MakeDictionary, Kusto.Language.Aggregates.MakeBag, Kusto.Language.Aggregates.MakeBagIf, Kusto.Language.Aggregates.BuildSchema, Kusto.Language.Aggregates.Passthrough, Kusto.Language.Aggregates.Percentile, Kusto.Language.Aggregates.Percentiles, Kusto.Language.Aggregates.PercentilesArray, Kusto.Language.Aggregates.PercentileW, Kusto.Language.Aggregates.PercentilesW, Kusto.Language.Aggregates.PercentilesWArray, Kusto.Language.Aggregates.Stdev, Kusto.Language.Aggregates.StdevIf, Kusto.Language.Aggregates.Stdevp, Kusto.Language.Aggregates.Variance, Kusto.Language.Aggregates.VarianceIf, Kusto.Language.Aggregates.Variancep, Kusto.Language.Aggregates.Any, Kusto.Language.Aggregates.AnyIf, Kusto.Language.Aggregates.ArgMin, Kusto.Language.Aggregates.ArgMax, Kusto.Language.Aggregates.ArgMin_Depricated, Kusto.Language.Aggregates.ArgMax_Depricated, Kusto.Language.Aggregates.BinaryAllOr, Kusto.Language.Aggregates.BinaryAllAnd, Kusto.Language.Aggregates.BinaryAllXor], Kusto.Language.Symbols.FunctionSymbol)
}
},
methods: {
AddPercentileColumns: function(columns, signature, valueParameterName, percentileParameterName, args) {
var valueArg = Kusto.Language.FunctionHelpers.GetArgument(args, signature, valueParameterName),
valueArgName = Kusto.Language.FunctionHelpers.GetExpressionResultName(valueArg),
percentileParameter = signature.GetParameter(percentileParameterName),
argumentParameters = signature.GetArgumentParameters(args),
start = {},
length = {},
resultType, p;
for (Kusto.Language.FunctionHelpers.GetArgumentRange(argumentParameters, percentileParameter, start, length), resultType = valueArg.ResultType, Bridge.referenceEquals(resultType, Kusto.Language.Symbols.ScalarTypes.Int) ? resultType = Kusto.Language.Symbols.ScalarTypes.Long : Bridge.referenceEquals(resultType, Kusto.Language.Symbols.ScalarTypes.Decimal) && (resultType = Kusto.Language.Symbols.ScalarTypes.Real), p = start.v; p < (start.v + length.v | 0); p = p + 1 | 0) {
var percentileArg = System.Array.getItem(args, p, Kusto.Language.Syntax.Expression),
percentileFragment = Kusto.Language.FunctionHelpers.MakeValidNameFragment(Kusto.Language.FunctionHelpers.GetLiteralValue(percentileArg)),
name = (percentileParameterName || "") + "_" + (valueArgName || "") + "_" + (percentileFragment || "");
columns.add(new Kusto.Language.Symbols.ColumnSymbol(name, resultType))
}
},
GetAnyResult: function(table, args) {
for (var arg, c, c1, col, $t, columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor), doNotRepeat = new(System.Collections.Generic.HashSet$1(Kusto.Language.Symbols.ColumnSymbol).$ctor1)(Kusto.Language.FunctionHelpers.GetSummarizeByColumns(args)), i = 0; i < System.Array.getCount(args, Kusto.Language.Syntax.Expression); i = i + 1 | 0)
if (arg = System.Array.getItem(args, i, Kusto.Language.Syntax.Expression), Bridge.is(arg, Kusto.Language.Syntax.StarExpression)) {
$t = Bridge.getEnumerator(table.Columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext()) c = $t.Current, doNotRepeat.contains(c) || columns.add(c.WithName("any_" + (c.Name || "")))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} else(c1 = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null ? columns.add(c1.WithName("any_" + (c1.Name || ""))) : (col = new Kusto.Language.Symbols.ColumnSymbol(Kusto.Language.Binding.Binder.GetExpressionResultName(arg, "column"), arg.ResultType), columns.add(col));
return new Kusto.Language.Symbols.TupleSymbol.$ctor1(columns)
},
GetArgMinMaxResult: function(table, args) {
for (var arg, c, c1, col, $t, columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor), doNotRepeat = new(System.Collections.Generic.HashSet$1(Kusto.Language.Symbols.ColumnSymbol).$ctor1)(Kusto.Language.FunctionHelpers.GetSummarizeByColumns(args)), i = 0; i < System.Array.getCount(args, Kusto.Language.Syntax.Expression); i = i + 1 | 0)
if (arg = System.Array.getItem(args, i, Kusto.Language.Syntax.Expression), Bridge.is(arg, Kusto.Language.Syntax.StarExpression)) {
$t = Bridge.getEnumerator(table.Columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext()) c = $t.Current, doNotRepeat.contains(c) || columns.add(c)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} else(c1 = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null ? (doNotRepeat.add(c1), columns.add(new Kusto.Language.Symbols.ColumnSymbol(c1.Name, c1.Type))) : (col = new Kusto.Language.Symbols.ColumnSymbol(Kusto.Language.Binding.Binder.GetExpressionResultName(arg, "column"), arg.ResultType), columns.add(col));
return new Kusto.Language.Symbols.TupleSymbol.$ctor1(columns)
},
GetArgMinMaxDepResult: function(table, args) {
var $t, columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor),
doNotRepeat, i, arg, c, c1, col;
if (System.Array.getCount(args, Kusto.Language.Syntax.Expression) > 0) {
var primaryArg = System.Array.getItem(args, 0, Kusto.Language.Syntax.Expression),
primaryColName = Kusto.Language.Binding.Binder.GetExpressionResultName(primaryArg, "column"),
primaryCol = new Kusto.Language.Symbols.ColumnSymbol(primaryColName, primaryArg.ResultType);
for (columns.add(primaryCol), doNotRepeat = new(System.Collections.Generic.HashSet$1(Kusto.Language.Symbols.ColumnSymbol).$ctor1)(Kusto.Language.FunctionHelpers.GetSummarizeByColumns(args)), i = 1; i < System.Array.getCount(args, Kusto.Language.Syntax.Expression); i = i + 1 | 0)
if (arg = System.Array.getItem(args, i, Kusto.Language.Syntax.Expression), Bridge.is(arg, Kusto.Language.Syntax.StarExpression)) {
$t = Bridge.getEnumerator(table.Columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext()) c = $t.Current, Bridge.referenceEquals(c, primaryArg.ReferencedSymbol) || doNotRepeat.contains(c) || columns.add(c.WithName((primaryColName || "") + "_" + (c.Name || "")))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} else(c1 = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null ? columns.add(c1.WithName((primaryColName || "") + "_" + (c1.Name || ""))) : (col = new Kusto.Language.Symbols.ColumnSymbol((primaryColName || "") + "_" + (Kusto.Language.Binding.Binder.GetExpressionResultName(arg, "column") || ""), arg.ResultType), columns.add(col))
}
return new Kusto.Language.Symbols.TupleSymbol.$ctor1(columns)
}
}
}
});
Bridge.define("Kusto.Language.AriaBridgeCommands", {
statics: {
props: {
All: null
},
ctors: {
init: function() {
this.All = System.Array.init([Kusto.Language.EngineCommands.ShowVersion], Kusto.Language.Symbols.CommandSymbol)
}
}
}
});
Bridge.define("Kusto.Language.Binding.Binder", {
statics: {
fields: {
s_symbolListPool: null,
s_diagnosticListPool: null,
s_columnListPool: null,
s_tableListPool: null,
s_functionListPool: null,
s_signatureListPool: null,
s_patternListPool: null,
s_expressionListPool: null,
s_typeListPool: null,
s_stringSetPool: null,
s_uniqueNameTablePool: null,
s_projectionBuilderPool: null,
s_parameterListPool: null,
LiteralBoolInfo: null,
LiteralIntInfo: null,
LiteralLongInfo: null,
LiteralRealInfo: null,
LiteralDecimalInfo: null,
LiteralStringInfo: null,
LiteralDateTimeInfo: null,
LiteralTimeSpanInfo: null,
LiteralGuidInfo: null,
LiteralDynamicInfo: null,
UnknownInfo: null,
ErrorInfo: null,
VoidInfo: null
},
ctors: {
init: function() {
this.s_symbolListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.Symbol)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Symbol).ctor)
}, function(list) {
list.clear()
});
this.s_diagnosticListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Diagnostic)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Diagnostic).ctor)
}, function(list) {
list.clear()
});
this.s_columnListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor)
}, function(list) {
list.clear()
});
this.s_tableListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.TableSymbol)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.TableSymbol).ctor)
}, function(list) {
list.clear()
});
this.s_functionListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.FunctionSymbol)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.FunctionSymbol).ctor)
}, function(list) {
list.clear()
});
this.s_signatureListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.Signature)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Signature).ctor)
}, function(list) {
list.clear()
});
this.s_patternListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.PatternSignature)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.PatternSignature).ctor)
}, function(list) {
list.clear()
});
this.s_expressionListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Syntax.Expression)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Syntax.Expression).ctor)
}, function(list) {
list.clear()
});
this.s_typeListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.TypeSymbol)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.TypeSymbol).ctor)
}, function(list) {
list.clear()
});
this.s_stringSetPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.HashSet$1(System.String)))(function() {
return new(System.Collections.Generic.HashSet$1(System.String).ctor)
}, function(s) {
s.clear()
});
this.s_uniqueNameTablePool = new(Kusto.Language.Utils.ObjectPool$1(Kusto.Language.Utils.UniqueNameTable))(function() {
return new Kusto.Language.Utils.UniqueNameTable
}, function(t) {
t.Clear()
});
this.s_projectionBuilderPool = new(Kusto.Language.Utils.ObjectPool$1(Kusto.Language.Binding.ProjectionBuilder))(function() {
return new Kusto.Language.Binding.ProjectionBuilder
}, function(b) {
b.Clear()
});
this.s_parameterListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.Parameter)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Parameter).ctor)
}, function(list) {
list.clear()
});
this.LiteralBoolInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Bool, void 0, !0, void 0);
this.LiteralIntInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Int, void 0, !0, void 0);
this.LiteralLongInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Long, void 0, !0, void 0);
this.LiteralRealInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Real, void 0, !0, void 0);
this.LiteralDecimalInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Decimal, void 0, !0, void 0);
this.LiteralStringInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.String, void 0, !0, void 0);
this.LiteralDateTimeInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.DateTime, void 0, !0, void 0);
this.LiteralTimeSpanInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.TimeSpan, void 0, !0, void 0);
this.LiteralGuidInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Guid, void 0, !0, void 0);
this.LiteralDynamicInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Dynamic, void 0, !0, void 0);
this.UnknownInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ScalarTypes.Unknown, void 0, !0, void 0);
this.ErrorInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ErrorSymbol.Instance);
this.VoidInfo = new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.VoidSymbol.Instance)
}
},
methods: {
Bind: function(root, globals, localBindingCache, semanticInfoSetter, cancellationToken) {
var bindingCache, binder, treeBinder;
localBindingCache === void 0 && (localBindingCache = null);
semanticInfoSetter === void 0 && (semanticInfoSetter = null);
cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken);
bindingCache = globals.Cache.GetOrCreate(Kusto.Language.Binding.GlobalBindingCache);
bindingCache;
binder = new Kusto.Language.Binding.Binder(globals, globals.Cluster, globals.Database, null, Kusto.Language.Binding.Binder.GetDefaultOuterScope(globals), bindingCache, localBindingCache, semanticInfoSetter, cancellationToken);
treeBinder = new Kusto.Language.Binding.Binder.TreeBinder(binder);
root.Accept$1(treeBinder)
},
GetDefaultOuterScope: function(globals) {
var outerScope = null;
return System.Array.getCount(globals.Parameters, Kusto.Language.Symbols.ParameterSymbol) > 0 && (outerScope = new Kusto.Language.Binding.LocalScope.ctor, outerScope.AddSymbols(globals.Parameters)), outerScope
},
DefaultSetSemanticInfo: function(node, info) {
if (info != null) {
var data = node.GetExtendedData(!0);
data.SemanticInfo = info
}
},
BindExpansion: function(expansionRoot, outer, currentCluster, currentDatabase, currentFunction, outerScope, locals) {
var binder = new Kusto.Language.Binding.Binder(outer._globals, currentCluster || outer._currentCluster, currentDatabase || outer._currentDatabase, currentFunction, outerScope, outer._globalBindingCache, outer._localBindingCache, outer._semanticInfoSetter, outer._cancellationToken),
treeBinder;
locals != null && binder.SetLocals(locals);
treeBinder = new Kusto.Language.Binding.Binder.TreeBinder(binder);
expansionRoot.Accept$1(treeBinder)
},
GetComputedReturnType: function(signature, globals, argumentTypes) {
var binder;
argumentTypes === void 0 && (argumentTypes = null);
var currentDatabase = globals.GetDatabase(Bridge.cast(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol)),
currentCluster = globals.GetCluster(currentDatabase),
bindingCache = globals.Cache.GetOrCreate(Kusto.Language.Binding.GlobalBindingCache);
return bindingCache, binder = new Kusto.Language.Binding.Binder(globals, currentCluster, currentDatabase, Bridge.as(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol), Kusto.Language.Binding.Binder.GetDefaultOuterScope(globals), bindingCache, null, null, Bridge.getDefaultValue(Kusto.Language.Utils.CancellationToken)), binder.GetComputedSignatureResult(signature, null, argumentTypes).Type
},
GetSymbolsInScope: function(root, position, globals, match, include, list, cancellationToken) {
var bindingCache = globals.Cache.GetOrCreate(Kusto.Language.Binding.GlobalBindingCache),
binder, startNode;
bindingCache;
binder = new Kusto.Language.Binding.Binder(globals, globals.Cluster, globals.Database, null, Kusto.Language.Binding.Binder.GetDefaultOuterScope(globals), bindingCache, null, null, cancellationToken);
startNode = Kusto.Language.Binding.Binder.GetStartNode(root, position);
binder.SetContext(startNode, position);
binder.GetSymbolsInContext(startNode, match, include, list)
},
GetRowScope: function(root, position, globals, cancellationToken) {
var bindingCache, binder, startNode;
return cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), bindingCache = globals.Cache.GetOrCreate(Kusto.Language.Binding.GlobalBindingCache), bindingCache, binder = new Kusto.Language.Binding.Binder(globals, globals.Cluster, globals.Database, null, Kusto.Language.Binding.Binder.GetDefaultOuterScope(globals), bindingCache, null, null, cancellationToken), startNode = Kusto.Language.Binding.Binder.GetStartNode(root, position), binder.SetContext(startNode, position), binder._rowScope
},
GetStartNode: function(root, position) {
var token = root.GetTokenAt(position),
prev;
return token != null && position <= token.TextStart ? (prev = token.GetPreviousToken(), prev != null && prev.Depth >= token.Depth) ? prev.Parent : token.Parent : null
},
IsFunctionCallName: function(name) {
var fn;
return (fn = Bridge.as(name.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && Bridge.referenceEquals(fn.Name, name)
},
IsInvocableFunctionName: function(location) {
return location.GetFirstAncestor(Kusto.Language.Syntax.CustomCommand) == null || location.GetFirstAncestor(Kusto.Language.Syntax.FunctionBody) != null
},
IsPossibleInvocableFunctionWithoutArgumentList: function(location) {
return !Kusto.Language.Binding.Binder.IsFunctionCallName(location) && Kusto.Language.Binding.Binder.IsInvocableFunctionName(location)
},
IsEvaluateFunctionName: function(name) {
var fn;
return (fn = Bridge.as(name.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && Bridge.is(fn.Parent, Kusto.Language.Syntax.EvaluateOperator)
},
IsInCommand: function(location) {
var command = location.GetFirstAncestor(Kusto.Language.Syntax.Command),
functionBody = location.GetFirstAncestor(Kusto.Language.Syntax.FunctionBody);
return command != null && functionBody == null
},
RemoveFunctionsThatCannotBeInvokedWithZeroArgs: function(list) {
for (var fn, i = list.Count - 1 | 0; i >= 0; i = i - 1 | 0)(fn = Bridge.as(list.getItem(i), Kusto.Language.Symbols.FunctionSymbol)) != null && fn.MinArgumentCount > 0 && list.removeAt(i)
},
GetWildcardSymbols: function(pattern, symbols, matchingSymbols) {
var $t, symbol;
$t = Bridge.getEnumerator(symbols, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) symbol = $t.Current, Kusto.Language.KustoFacts.Matches(pattern, symbol.Name) && matchingSymbols.add(symbol)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
IsInTabularContext: function(element) {
var fc, pe, hint;
for ((fc = Bridge.as(element.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && Bridge.referenceEquals(fc.Name, element) && (element = element.Parent); Bridge.is(element.Parent, Kusto.Language.Syntax.ParenthesizedExpression) || Bridge.is(element.Parent, Kusto.Language.Syntax.SyntaxList) || Bridge.is(element.Parent, Kusto.Language.Syntax.SeparatedElement);) element = element.Parent;
return element.Parent != null && ((pe = Bridge.as(element.Parent, Kusto.Language.Syntax.PipeExpression)) != null && Bridge.referenceEquals(pe.Expression, element) || (hint = element.Parent.GetCompletionHint(element.IndexInParent), hint === Kusto.Language.Editor.CompletionHint.Table || hint === Kusto.Language.Editor.CompletionHint.Tabular)) ? !0 : !1
},
IsFuzzyUnionOperand: function(element) {
var fc, context, pe, uo, np, b;
for ((fc = Bridge.as(element.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && Bridge.referenceEquals(fc.Name, element) && (element = element.Parent); Bridge.is(element.Parent, Kusto.Language.Syntax.ParenthesizedExpression) || Bridge.is(element.Parent, Kusto.Language.Syntax.SyntaxList) || Bridge.is(element.Parent, Kusto.Language.Syntax.SeparatedElement);) element = element.Parent;
return (context = element.Parent, context != null && ((pe = Bridge.as(context, Kusto.Language.Syntax.PipeExpression)) != null && Bridge.referenceEquals(pe.Expression, element) && (context = pe.Operator), (uo = Bridge.as(context, Kusto.Language.Syntax.UnionOperator)) != null)) ? (np = Kusto.Language.Syntax.SyntaxListExtensions.GetByName$1(uo.Parameters, Kusto.Language.KustoFacts.UnionIsFuzzyProperty), np != null && (b = Bridge.as(np.Expression.ConstantValue, System.Boolean)) != null && b) : !1
},
GetOperatorKind: function(kind) {
switch (kind) {
case Kusto.Language.Syntax.SyntaxKind.AddExpression:
return Kusto.Language.Symbols.OperatorKind.Add;
case Kusto.Language.Syntax.SyntaxKind.SubtractExpression:
return Kusto.Language.Symbols.OperatorKind.Subtract;
case Kusto.Language.Syntax.SyntaxKind.MultiplyExpression:
return Kusto.Language.Symbols.OperatorKind.Multiply;
case Kusto.Language.Syntax.SyntaxKind.DivideExpression:
return Kusto.Language.Symbols.OperatorKind.Divide;
case Kusto.Language.Syntax.SyntaxKind.ModuloExpression:
return Kusto.Language.Symbols.OperatorKind.Modulo;
case Kusto.Language.Syntax.SyntaxKind.UnaryMinusExpression:
return Kusto.Language.Symbols.OperatorKind.UnaryMinus;
case Kusto.Language.Syntax.SyntaxKind.UnaryPlusExpression:
return Kusto.Language.Symbols.OperatorKind.UnaryPlus;
case Kusto.Language.Syntax.SyntaxKind.EqualExpression:
return Kusto.Language.Symbols.OperatorKind.Equal;
case Kusto.Language.Syntax.SyntaxKind.NotEqualExpression:
return Kusto.Language.Symbols.OperatorKind.NotEqual;
case Kusto.Language.Syntax.SyntaxKind.LessThanExpression:
return Kusto.Language.Symbols.OperatorKind.LessThan;
case Kusto.Language.Syntax.SyntaxKind.LessThanOrEqualExpression:
return Kusto.Language.Symbols.OperatorKind.LessThanOrEqual;
case Kusto.Language.Syntax.SyntaxKind.GreaterThanExpression:
return Kusto.Language.Symbols.OperatorKind.GreaterThan;
case Kusto.Language.Syntax.SyntaxKind.GreaterThanOrEqualExpression:
return Kusto.Language.Symbols.OperatorKind.GreaterThanOrEqual;
case Kusto.Language.Syntax.SyntaxKind.EqualTildeExpression:
return Kusto.Language.Symbols.OperatorKind.EqualTilde;
case Kusto.Language.Syntax.SyntaxKind.BangTildeExpression:
return Kusto.Language.Symbols.OperatorKind.BangTilde;
case Kusto.Language.Syntax.SyntaxKind.HasExpression:
return Kusto.Language.Symbols.OperatorKind.Has;
case Kusto.Language.Syntax.SyntaxKind.HasCsExpression:
return Kusto.Language.Symbols.OperatorKind.HasCs;
case Kusto.Language.Syntax.SyntaxKind.NotHasExpression:
return Kusto.Language.Symbols.OperatorKind.NotHas;
case Kusto.Language.Syntax.SyntaxKind.NotHasCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotHasCs;
case Kusto.Language.Syntax.SyntaxKind.HasPrefixExpression:
return Kusto.Language.Symbols.OperatorKind.HasPrefix;
case Kusto.Language.Syntax.SyntaxKind.HasPrefixCsExpression:
return Kusto.Language.Symbols.OperatorKind.HasPrefixCs;
case Kusto.Language.Syntax.SyntaxKind.NotHasPrefixExpression:
return Kusto.Language.Symbols.OperatorKind.NotHasPrefix;
case Kusto.Language.Syntax.SyntaxKind.NotHasPrefixCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotHasPrefixCs;
case Kusto.Language.Syntax.SyntaxKind.HasSuffixExpression:
return Kusto.Language.Symbols.OperatorKind.HasSuffix;
case Kusto.Language.Syntax.SyntaxKind.HasSuffixCsExpression:
return Kusto.Language.Symbols.OperatorKind.HasSuffixCs;
case Kusto.Language.Syntax.SyntaxKind.NotHasSuffixExpression:
return Kusto.Language.Symbols.OperatorKind.NotHasSuffix;
case Kusto.Language.Syntax.SyntaxKind.NotHasSuffixCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotHasSuffixCs;
case Kusto.Language.Syntax.SyntaxKind.LikeExpression:
return Kusto.Language.Symbols.OperatorKind.Like;
case Kusto.Language.Syntax.SyntaxKind.LikeCsExpression:
return Kusto.Language.Symbols.OperatorKind.LikeCs;
case Kusto.Language.Syntax.SyntaxKind.NotLikeExpression:
return Kusto.Language.Symbols.OperatorKind.NotLike;
case Kusto.Language.Syntax.SyntaxKind.NotLikeCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotLikeCs;
case Kusto.Language.Syntax.SyntaxKind.ContainsExpression:
return Kusto.Language.Symbols.OperatorKind.Contains;
case Kusto.Language.Syntax.SyntaxKind.ContainsCsExpression:
return Kusto.Language.Symbols.OperatorKind.ContainsCs;
case Kusto.Language.Syntax.SyntaxKind.NotContainsExpression:
return Kusto.Language.Symbols.OperatorKind.NotContains;
case Kusto.Language.Syntax.SyntaxKind.NotContainsCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotContainsCs;
case Kusto.Language.Syntax.SyntaxKind.StartsWithExpression:
return Kusto.Language.Symbols.OperatorKind.StartsWith;
case Kusto.Language.Syntax.SyntaxKind.StartsWithCsExpression:
return Kusto.Language.Symbols.OperatorKind.StartsWithCs;
case Kusto.Language.Syntax.SyntaxKind.NotStartsWithExpression:
return Kusto.Language.Symbols.OperatorKind.NotStartsWith;
case Kusto.Language.Syntax.SyntaxKind.NotStartsWithCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotStartsWithCs;
case Kusto.Language.Syntax.SyntaxKind.EndsWithExpression:
return Kusto.Language.Symbols.OperatorKind.EndsWith;
case Kusto.Language.Syntax.SyntaxKind.EndsWithCsExpression:
return Kusto.Language.Symbols.OperatorKind.EndsWithCs;
case Kusto.Language.Syntax.SyntaxKind.NotEndsWithExpression:
return Kusto.Language.Symbols.OperatorKind.NotEndsWith;
case Kusto.Language.Syntax.SyntaxKind.NotEndsWithCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotEndsWith;
case Kusto.Language.Syntax.SyntaxKind.MatchesRegexExpression:
return Kusto.Language.Symbols.OperatorKind.MatchRegex;
case Kusto.Language.Syntax.SyntaxKind.InExpression:
return Kusto.Language.Symbols.OperatorKind.In;
case Kusto.Language.Syntax.SyntaxKind.InCsExpression:
return Kusto.Language.Symbols.OperatorKind.InCs;
case Kusto.Language.Syntax.SyntaxKind.NotInExpression:
return Kusto.Language.Symbols.OperatorKind.NotIn;
case Kusto.Language.Syntax.SyntaxKind.NotInCsExpression:
return Kusto.Language.Symbols.OperatorKind.NotInCs;
case Kusto.Language.Syntax.SyntaxKind.BetweenExpression:
return Kusto.Language.Symbols.OperatorKind.Between;
case Kusto.Language.Syntax.SyntaxKind.NotBetweenExpression:
return Kusto.Language.Symbols.OperatorKind.NotBetween;
case Kusto.Language.Syntax.SyntaxKind.AndExpression:
return Kusto.Language.Symbols.OperatorKind.And;
case Kusto.Language.Syntax.SyntaxKind.OrExpression:
return Kusto.Language.Symbols.OperatorKind.Or;
case Kusto.Language.Syntax.SyntaxKind.SearchExpression:
return Kusto.Language.Symbols.OperatorKind.Search;
case Kusto.Language.Syntax.SyntaxKind.HasAnyExpression:
return Kusto.Language.Symbols.OperatorKind.HasAny;
default:
return Kusto.Language.Symbols.OperatorKind.None
}
},
TryGetLiteralStringValue: function(expression, value) {
var objValue = {};
return Kusto.Language.Binding.Binder.TryGetLiteralValue(expression, objValue) ? (value.v = Bridge.as(objValue.v, System.String), value.v != null) : (value.v = null, !1)
},
TryGetLiteralValue: function(expression, value) {
var sn, nr, vs;
return (sn = Bridge.as(expression, Kusto.Language.Syntax.SimpleNamedExpression)) != null && (expression = sn.Expression), expression.IsLiteral ? (value.v = expression.LiteralValue, value.v != null) : (nr = Bridge.as(expression, Kusto.Language.Syntax.NameReference)) != null && (vs = Bridge.as(nr.ReferencedSymbol, Kusto.Language.Symbols.VariableSymbol)) != null && vs.IsConstant ? (value.v = vs.ConstantValue, !0) : (value.v = null, !1)
},
IsPromotable: function(type1, type2) {
var type1Scalar, type2Scalar;
return (type1Scalar = Bridge.as(type1, Kusto.Language.Symbols.ScalarSymbol)) != null && (type2Scalar = Bridge.as(type2, Kusto.Language.Symbols.ScalarSymbol)) != null && type2Scalar.IsWiderThan(type1Scalar)
},
Promote: function(symbol) {
return Bridge.referenceEquals(symbol, Kusto.Language.Symbols.ScalarTypes.Int) ? Kusto.Language.Symbols.ScalarTypes.Long : Bridge.referenceEquals(symbol, Kusto.Language.Symbols.ScalarTypes.Decimal) ? Kusto.Language.Symbols.ScalarTypes.Real : symbol
},
GetWidestArgumentType: function(signature, argumentTypes) {
for (var argType, s, widestType = null, i = 0; i < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol); i = i + 1 | 0) argType = System.Array.getItem(argumentTypes, i, Kusto.Language.Symbols.TypeSymbol), (s = Bridge.as(argType, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsNumeric && !Bridge.referenceEquals(s, widestType) && (widestType == null || s.IsWiderThan(widestType)) && (widestType = s);
return widestType
},
GetCommonArgumentType: function(argumentParameters, argumentTypes) {
for (var parameter, argType, commonType = null, hadUnknown = !1, i = 0; i < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol); i = i + 1 | 0) parameter = System.Array.getItem(argumentParameters, i, Kusto.Language.Symbols.Parameter), parameter != null && (argType = System.Array.getItem(argumentTypes, i, Kusto.Language.Symbols.TypeSymbol), (parameter.TypeKind === Kusto.Language.Symbols.ParameterTypeKind.CommonScalar && argType.IsScalar || parameter.TypeKind === Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic && argType.IsScalar || parameter.TypeKind === Kusto.Language.Symbols.ParameterTypeKind.CommonNumber && Kusto.Language.Binding.Binder.IsNumber(argType) || parameter.TypeKind === Kusto.Language.Symbols.ParameterTypeKind.CommonSummable && Kusto.Language.Binding.Binder.IsSummable(argType)) && (commonType == null ? Bridge.referenceEquals(argType, Kusto.Language.Symbols.ScalarTypes.Unknown) ? hadUnknown = !0 : commonType = argType : Kusto.Language.Binding.Binder.IsPromotable(commonType, argType) ? commonType = argType : Bridge.referenceEquals(commonType, Kusto.Language.Symbols.ScalarTypes.Dynamic) && (commonType = argType)));
return commonType == null && hadUnknown ? Kusto.Language.Symbols.ScalarTypes.Unknown : commonType
},
GetCommonScalarType: function(types) {
var commonType, hadUnknown, i, type;
for (types === void 0 && (types = []), commonType = null, hadUnknown = !1, i = 0; i < types.length; i = i + 1 | 0) type = types[System.Array.index(i, types)], type.IsScalar && (commonType == null ? Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Unknown) ? hadUnknown = !0 : commonType = type : Kusto.Language.Binding.Binder.IsPromotable(commonType, type) ? commonType = type : Kusto.Language.Binding.Binder.SymbolsAssignable(commonType, Kusto.Language.Symbols.ScalarTypes.Dynamic) && (commonType = type));
return commonType == null && hadUnknown ? Kusto.Language.Symbols.ScalarTypes.Unknown : commonType
},
IsInvokeOperatorFunctionCall: function(functionCall) {
var p;
return Bridge.is(functionCall.Parent, Kusto.Language.Syntax.InvokeOperator) || (p = Bridge.as(functionCall.Parent, Kusto.Language.Syntax.PathExpression)) != null && Bridge.referenceEquals(p.Selector, functionCall) && Bridge.is(p.Parent, Kusto.Language.Syntax.InvokeOperator)
},
GetRepresentativeType: function(parameter) {
switch (parameter.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
return System.Array.getItem(parameter.DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol);
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
case Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable:
return Kusto.Language.Symbols.TableSymbol.Empty;
default:
return Kusto.Language.Symbols.ScalarTypes.Dynamic
}
},
UnifyColumnsWithSameNameAndType: function(columns) {
var $t, uniqueNames = Kusto.Language.Binding.Binder.s_uniqueNameTablePool.AllocateFromPool(),
newColumns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
map, i, col, sameNamedColumns, colType, name;
try {
for (map = Kusto.Language.Binding.Binder.BuildColumnNameMap(columns), i = 0; i < columns.Count; i = i + 1 | 0)
if (col = columns.getItem(i), sameNamedColumns = {}, map.tryGetValue(col.Name, sameNamedColumns)) {
if (sameNamedColumns.v.Count === 1) newColumns.add(Kusto.Language.Binding.Binder.GetUniqueColumn(col, uniqueNames));
else if (sameNamedColumns.v.Count > 1) {
$t = Bridge.getEnumerator(sameNamedColumns.v);
try {
while ($t.moveNext()) colType = $t.Current, name = uniqueNames.GetOrAddName((col.Name || "") + "_" + (colType.Name || "")), newColumns.add(new Kusto.Language.Symbols.ColumnSymbol(name, colType))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
}
map.remove(col.Name)
} columns.clear();
columns.AddRange(newColumns)
} finally {
Kusto.Language.Binding.Binder.s_uniqueNameTablePool.ReturnToPool(uniqueNames);
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(newColumns)
}
},
UnifyColumnsWithSameName: function(columns) {
var newColumns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
map, i, col, sameNamedColumns, types, commonType;
try {
for (map = Kusto.Language.Binding.Binder.BuildColumnNameMap(columns), i = 0; i < columns.Count; i = i + 1 | 0) col = columns.getItem(i), sameNamedColumns = {}, map.tryGetValue(col.Name, sameNamedColumns) && (sameNamedColumns.v.Count === 1 ? newColumns.add(col) : sameNamedColumns.v.Count > 1 && (types = sameNamedColumns.v.ToArray(), commonType = Kusto.Language.Binding.Binder.GetCommonScalarType(types), commonType == null && (commonType = Kusto.Language.Symbols.ScalarTypes.Dynamic), Bridge.referenceEquals(col.Type, commonType) ? newColumns.add(col) : newColumns.add(new Kusto.Language.Symbols.ColumnSymbol(col.Name, commonType))), map.remove(col.Name));
columns.clear();
columns.AddRange(newColumns)
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(newColumns)
}
},
MakeColumnNamesUnique: function(columns) {
var names = Kusto.Language.Binding.Binder.s_uniqueNameTablePool.AllocateFromPool(),
newColumns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
i, col;
try {
for (i = 0; i < columns.Count; i = i + 1 | 0) col = columns.getItem(i), newColumns.add(Kusto.Language.Binding.Binder.GetUniqueColumn(col, names));
columns.clear();
columns.AddRange(newColumns)
} finally {
Kusto.Language.Binding.Binder.s_uniqueNameTablePool.ReturnToPool(names);
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(newColumns)
}
},
BuildColumnNameMap: function(columns) {
for (var col, sameNameColumns, map = new(System.Collections.Generic.Dictionary$2(System.String, System.Collections.Generic.List$1(Kusto.Language.Symbols.TypeSymbol))), i = 0; i < columns.Count; i = i + 1 | 0) col = columns.getItem(i), sameNameColumns = {}, map.tryGetValue(col.Name, sameNameColumns) || (sameNameColumns.v = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.TypeSymbol).ctor), map.add(col.Name, sameNameColumns.v)), sameNameColumns.v.contains(col.Type) || sameNameColumns.v.add(col.Type);
return map
},
GetCommonColumns$2: function(columnsA, columnsB, result) {
var $t, columns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
c;
try {
Kusto.Language.Binding.Binder.GetCommonColumns$1(columnsA, columnsB, columns);
$t = Bridge.getEnumerator(columns);
try {
while ($t.moveNext()) c = $t.Current, result.add(c)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(columns)
}
},
GetCommonColumns$1: function(columnsA, columnsB, result) {
var $t, $t1, names = Kusto.Language.Binding.Binder.s_stringSetPool.AllocateFromPool(),
c, c1;
try {
$t = Bridge.getEnumerator(columnsB, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext()) c = $t.Current, names.add(c.Name)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
$t1 = Bridge.getEnumerator(columnsA, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t1.moveNext()) c1 = $t1.Current, names.contains(c1.Name) && result.add(c1)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Binding.Binder.s_stringSetPool.ReturnToPool(names)
}
},
GetCommonColumns: function(tables, common) {
var columnsA, columnsC, i;
if (common.clear(), System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol) === 1) common.AddRange(System.Array.getItem(tables, 0, Kusto.Language.Symbols.TableSymbol).Columns);
else if (System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol) === 2) Kusto.Language.Binding.Binder.GetCommonColumns$1(System.Array.getItem(tables, 0, Kusto.Language.Symbols.TableSymbol).Columns, System.Array.getItem(tables, 1, Kusto.Language.Symbols.TableSymbol).Columns, common);
else if (System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol) > 2) {
columnsA = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool();
columnsC = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool();
try {
for (Kusto.Language.Binding.Binder.GetCommonColumns$1(System.Array.getItem(tables, 0, Kusto.Language.Symbols.TableSymbol).Columns, System.Array.getItem(tables, 1, Kusto.Language.Symbols.TableSymbol).Columns, columnsA), i = 2; i < System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol); i = i + 1 | 0) Kusto.Language.Binding.Binder.GetCommonColumns$1(columnsA, System.Array.getItem(tables, i, Kusto.Language.Symbols.TableSymbol).Columns, columnsC), i < (System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol) - 1 | 0) && (columnsA.clear(), columnsA.AddRange(columnsC), columnsC.clear());
common.AddRange(columnsC)
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(columnsA);
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(columnsC)
}
}
},
GetUniqueColumn: function(column, uniqueNames) {
var uniqueName = uniqueNames.GetOrAddName(column.Name);
return Bridge.referenceEquals(uniqueName, column.Name) ? column : new Kusto.Language.Symbols.ColumnSymbol(uniqueName, column.Type)
},
CreateColumnsFromSchema$1: function(schema, columns, declaredNames, diagnostics) {
for (var expr, nat, s, i = 0, n = schema.Columns.Count; i < n; i = i + 1 | 0) {
expr = schema.Columns.getItem$1(i).Element$1;
do {
if (Bridge.is(expr, Kusto.Language.Syntax.NameAndTypeDeclaration)) {
nat = Bridge.cast(expr, Kusto.Language.Syntax.NameAndTypeDeclaration);
Kusto.Language.Binding.Binder.CreateColumnsFromSchema(nat, columns, declaredNames, diagnostics);
break
}
if (Bridge.is(expr, Kusto.Language.Syntax.StarExpression)) {
s = Bridge.cast(expr, Kusto.Language.Syntax.StarExpression);
break
}
} while (0)
}
},
CreateColumnsFromSchema: function(declaration, columns, declaredNames, diagnostics) {
var $t, name = declaration.Name.SimpleName,
p, type;
do {
if ($t = declaration.Type, Bridge.is($t, Kusto.Language.Syntax.PrimitiveTypeExpression)) {
p = Bridge.cast($t, Kusto.Language.Syntax.PrimitiveTypeExpression);
type = Kusto.Language.Binding.Binder.GetType(p);
Kusto.Language.Binding.Binder.DeclareColumnName(declaredNames, name, diagnostics, declaration.Name) && columns.add(new Kusto.Language.Symbols.ColumnSymbol(name, type));
break
}
if (Bridge.is($t, Kusto.Language.Syntax.SchemaTypeExpression)) {
var s = Bridge.cast($t, Kusto.Language.Syntax.SchemaTypeExpression),
subSchemaColumns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
subSchemaNames = Kusto.Language.Binding.Binder.s_stringSetPool.AllocateFromPool();
try {
Kusto.Language.Binding.Binder.CreateColumnsFromSchema$1(s, subSchemaColumns, subSchemaNames, diagnostics);
Kusto.Language.Binding.Binder.DeclareColumnName(declaredNames, name, diagnostics, declaration.Name) && columns.add(new Kusto.Language.Symbols.ColumnSymbol(name, new Kusto.Language.Symbols.TableSymbol.$ctor2(subSchemaColumns)))
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(subSchemaColumns);
Kusto.Language.Binding.Binder.s_stringSetPool.ReturnToPool(subSchemaNames)
}
break
}
diagnostics.add(Kusto.Language.DiagnosticFacts.GetInvalidColumnDeclaration().WithLocation(declaration));
break
} while (0)
},
DeclareColumnName: function(declaredNames, newName, diagnostics, location) {
return declaredNames.contains(newName) ? (diagnostics.add(Kusto.Language.DiagnosticFacts.GetDuplicateColumnDeclaration(newName).WithLocation(location)), !1) : (declaredNames.add(newName), !0)
},
GetFunctionResultName: function(fc, defaultName, row) {
var $t, name, name1, name2, _discard1;
defaultName === void 0 && (defaultName = "");
row === void 0 && (row = null);
var fs = Bridge.as(fc.ReferencedSymbol, Kusto.Language.Symbols.FunctionSymbol),
kind = ($t = fs != null ? fs.ResultNameKind : null, $t != null ? $t : Kusto.Language.Symbols.ResultNameKind.None),
prefix = fs != null ? fs.ResultNamePrefix : null;
return kind === Kusto.Language.Symbols.ResultNameKind.NameAndFirstArgument ? (prefix = fs.Name, kind = Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument) : kind === Kusto.Language.Symbols.ResultNameKind.NameAndOnlyArgument && (prefix = fs.Name, kind = Kusto.Language.Symbols.ResultNameKind.PrefixAndOnlyArgument), kind === Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument ? fc.ArgumentList.Expressions.Count > 0 ? (name = Kusto.Language.Binding.Binder.GetExpressionResultName(fc.ArgumentList.Expressions.getItem$1(0).Element$1, defaultName), prefix != null ? (prefix || "") + "_" + (name || "") : name) : prefix != null ? (prefix || "") + "_" : null : kind === Kusto.Language.Symbols.ResultNameKind.PrefixAndOnlyArgument && fc.ArgumentList.Expressions.Count === 1 ? (name1 = Kusto.Language.Binding.Binder.GetExpressionResultName(fc.ArgumentList.Expressions.getItem$1(0).Element$1, defaultName), prefix != null ? (prefix || "") + "_" + (name1 || "") : name1) : kind === Kusto.Language.Symbols.ResultNameKind.FirstArgumentValueIfColumn && fc.ArgumentList.Expressions.Count > 0 && (name2 = Bridge.as(fc.ArgumentList.Expressions.getItem$1(0).Element$1.ConstantValue, System.String)) != null ? (_discard1 = {}, row != null && row.TryGetColumn(name2, _discard1) ? name2 : defaultName) : kind === Kusto.Language.Symbols.ResultNameKind.FirstArgument ? fc.ArgumentList.Expressions.Count > 0 ? Kusto.Language.Binding.Binder.GetExpressionResultName(fc.ArgumentList.Expressions.getItem$1(0).Element$1, defaultName) : null : kind === Kusto.Language.Symbols.ResultNameKind.PrefixOnly && prefix != null ? prefix : kind === Kusto.Language.Symbols.ResultNameKind.OnlyArgument && fc.ArgumentList.Expressions.Count === 1 ? Kusto.Language.Binding.Binder.GetExpressionResultName(fc.ArgumentList.Expressions.getItem$1(0).Element$1, defaultName) : defaultName
},
GetExpressionResultName: function(expr, defaultName, row) {
var n, be, p, left, right, e, left1, right1, o, s, f;
defaultName === void 0 && (defaultName = "");
row === void 0 && (row = null);
do return Bridge.is(expr, Kusto.Language.Syntax.NameReference) ? (n = Bridge.cast(expr, Kusto.Language.Syntax.NameReference), n.SimpleName) : Bridge.is(expr, Kusto.Language.Syntax.BrackettedExpression) && (be = Bridge.cast(expr, Kusto.Language.Syntax.BrackettedExpression), be.Expression.Kind === Kusto.Language.Syntax.SyntaxKind.StringLiteralExpression || be.Expression.Kind === Kusto.Language.Syntax.SyntaxKind.CompoundStringLiteralExpression) ? Bridge.cast(be.Expression.LiteralValue, System.String) : Bridge.is(expr, Kusto.Language.Syntax.PathExpression) ? (p = Bridge.cast(expr, Kusto.Language.Syntax.PathExpression), Bridge.referenceEquals(p.Expression.ResultType, Kusto.Language.Symbols.ScalarTypes.Dynamic) || Bridge.referenceEquals(p.Expression.ResultType, Kusto.Language.Symbols.ScalarTypes.Unknown) ? (left = Kusto.Language.Binding.Binder.GetExpressionResultName(p.Expression, null), right = Kusto.Language.Binding.Binder.GetExpressionResultName(p.Selector, null), System.String.format("{0}_{1}", left, right)) : Kusto.Language.Binding.Binder.GetExpressionResultName(p.Selector, defaultName)) : Bridge.is(expr, Kusto.Language.Syntax.ElementExpression) ? (e = Bridge.cast(expr, Kusto.Language.Syntax.ElementExpression), Bridge.referenceEquals(e.Expression.ResultType, Kusto.Language.Symbols.ScalarTypes.Dynamic) || Bridge.referenceEquals(e.Expression.ResultType, Kusto.Language.Symbols.ScalarTypes.Unknown) ? (left1 = Kusto.Language.Binding.Binder.GetExpressionResultName(e.Expression, null), right1 = Kusto.Language.Binding.Binder.GetExpressionResultName(e.Selector, null), System.String.format("{0}_{1}", left1, right1)) : Kusto.Language.Binding.Binder.GetExpressionResultName(e.Selector, defaultName)) : Bridge.is(expr, Kusto.Language.Syntax.OrderedExpression) ? (o = Bridge.cast(expr, Kusto.Language.Syntax.OrderedExpression), Kusto.Language.Binding.Binder.GetExpressionResultName(o.Expression, defaultName)) : Bridge.is(expr, Kusto.Language.Syntax.SimpleNamedExpression) ? (s = Bridge.cast(expr, Kusto.Language.Syntax.SimpleNamedExpression), s.Name.SimpleName) : Bridge.is(expr, Kusto.Language.Syntax.FunctionCallExpression) ? (f = Bridge.cast(expr, Kusto.Language.Syntax.FunctionCallExpression), Kusto.Language.Binding.Binder.GetFunctionResultName(f, defaultName, row)) : defaultName; while (0)
},
GetNameDeclarationName: function(expr) {
var nd, nr, le, cs;
do {
if (Bridge.is(expr, Kusto.Language.Syntax.NameDeclaration)) return nd = Bridge.cast(expr, Kusto.Language.Syntax.NameDeclaration), nd.Name.SimpleName;
if (Bridge.is(expr, Kusto.Language.Syntax.NameReference)) return nr = Bridge.cast(expr, Kusto.Language.Syntax.NameReference), nr.Name.SimpleName;
if (Bridge.is(expr, Kusto.Language.Syntax.LiteralExpression)) {
if (le = Bridge.cast(expr, Kusto.Language.Syntax.LiteralExpression), le.Kind === Kusto.Language.Syntax.SyntaxKind.StringLiteralExpression) return Bridge.cast(le.LiteralValue, System.String);
break
}
if (Bridge.is(expr, Kusto.Language.Syntax.CompoundStringLiteralExpression)) return cs = Bridge.cast(expr, Kusto.Language.Syntax.CompoundStringLiteralExpression), Bridge.cast(cs.LiteralValue, System.String)
} while (0);
return null
},
GetDeclaredType: function(typeExpression, diagnostics, binder) {
var p, s, columns, i, n, expr;
diagnostics === void 0 && (diagnostics = null);
binder === void 0 && (binder = null);
do {
if (Bridge.is(typeExpression, Kusto.Language.Syntax.PrimitiveTypeExpression)) return p = Bridge.cast(typeExpression, Kusto.Language.Syntax.PrimitiveTypeExpression), Kusto.Language.Binding.Binder.GetType(p, diagnostics);
if (Bridge.is(typeExpression, Kusto.Language.Syntax.SchemaTypeExpression)) {
if (s = Bridge.cast(typeExpression, Kusto.Language.Syntax.SchemaTypeExpression), s.Columns.Count === 1 && Bridge.is(s.Columns.getItem$1(0).Element$1, Kusto.Language.Syntax.StarExpression)) return Kusto.Language.Symbols.TableSymbol.Empty;
columns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool();
try {
for (i = 0, n = s.Columns.Count; i < n; i = i + 1 | 0)
if (expr = s.Columns.getItem$1(i).Element$1, !expr.IsMissing)
do {
if (Bridge.is(expr, Kusto.Language.Syntax.NameAndTypeDeclaration)) {
var nat = Bridge.cast(expr, Kusto.Language.Syntax.NameAndTypeDeclaration),
declaredType = Kusto.Language.Binding.Binder.GetDeclaredType(nat.Type, diagnostics, binder),
newColumn = new Kusto.Language.Symbols.ColumnSymbol(nat.Name.SimpleName, declaredType);
columns.add(newColumn);
binder != null && binder.SetSemanticInfo(nat.Name, Kusto.Language.Binding.Binder.GetSemanticInfo(newColumn));
break
}
diagnostics != null && diagnostics.add(Kusto.Language.DiagnosticFacts.GetInvalidColumnDeclaration().WithLocation(expr));
break
} while (0);
return new Kusto.Language.Symbols.TableSymbol.$ctor2(columns)
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(columns)
}
}
return diagnostics != null && diagnostics.add(Kusto.Language.DiagnosticFacts.GetInvalidTypeExpression().WithLocation(typeExpression)), Kusto.Language.Symbols.ErrorSymbol.Instance
} while (0)
},
GetType: function(primitiveType, diagnostics) {
diagnostics === void 0 && (diagnostics = null);
var typeName = primitiveType.Type.Text,
type = Kusto.Language.Symbols.ScalarTypes.GetSymbol(typeName);
return type != null ? type : (diagnostics != null && diagnostics.add(Kusto.Language.DiagnosticFacts.GetInvalidTypeName(typeName).WithLocation(primitiveType.Type)), Kusto.Language.Symbols.ErrorSymbol.Instance)
},
IsInteger: function(type) {
var s;
return (s = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsInteger
},
IsRealOrDecimal: function(type) {
return Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Real, type) || Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Decimal, type)
},
IsStringOrDynamic: function(type) {
return Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.String, type) || Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Dynamic, type)
},
IsNumber: function(type) {
var s;
return (s = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsNumeric
},
IsIntegerOrDynamic: function(type) {
return Kusto.Language.Binding.Binder.IsInteger(type) || Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Dynamic, type)
},
IsSummable: function(type) {
var s;
return (s = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsSummable
},
IsTabular: function(type) {
return type != null && type.IsTabular
},
IsDatabase: function(symbol) {
return Bridge.is(symbol, Kusto.Language.Symbols.DatabaseSymbol)
},
IsCluster: function(symbol) {
return Bridge.is(symbol, Kusto.Language.Symbols.ClusterSymbol)
},
GetSemanticInfo: function(referencedSymbol, diagnostics) {
return diagnostics === void 0 && (diagnostics = []), Kusto.Language.Binding.Binder.CreateSemanticInfo(referencedSymbol, Bridge.cast(diagnostics, System.Collections.Generic.IEnumerable$1(Kusto.Language.Diagnostic)))
},
CreateSemanticInfo: function(referencedSymbol, diagnostics) {
diagnostics === void 0 && (diagnostics = null);
switch (referencedSymbol.Kind) {
case Kusto.Language.Symbols.SymbolKind.Operator:
case Kusto.Language.Symbols.SymbolKind.Column:
case Kusto.Language.Symbols.SymbolKind.Table:
case Kusto.Language.Symbols.SymbolKind.Database:
case Kusto.Language.Symbols.SymbolKind.Cluster:
case Kusto.Language.Symbols.SymbolKind.Parameter:
case Kusto.Language.Symbols.SymbolKind.Function:
case Kusto.Language.Symbols.SymbolKind.Pattern:
case Kusto.Language.Symbols.SymbolKind.Group:
case Kusto.Language.Symbols.SymbolKind.MaterializedView:
return new Kusto.Language.Syntax.SemanticInfo.$ctor1(referencedSymbol, Kusto.Language.Binding.Binder.GetResultType(referencedSymbol), diagnostics);
case Kusto.Language.Symbols.SymbolKind.Variable:
var v = Bridge.cast(referencedSymbol, Kusto.Language.Symbols.VariableSymbol);
return new Kusto.Language.Syntax.SemanticInfo.$ctor1(referencedSymbol, Kusto.Language.Binding.Binder.GetResultType(referencedSymbol), diagnostics, v.IsConstant, void 0);
case Kusto.Language.Symbols.SymbolKind.Scalar:
case Kusto.Language.Symbols.SymbolKind.Tuple:
return new Kusto.Language.Syntax.SemanticInfo.$ctor3(Bridge.cast(referencedSymbol, Kusto.Language.Symbols.TypeSymbol), diagnostics);
default:
return new Kusto.Language.Syntax.SemanticInfo.$ctor1(null, Kusto.Language.Symbols.ErrorSymbol.Instance, diagnostics)
}
},
GetResultType: function(symbol) {
return Kusto.Language.Symbols.Symbol.GetExpressionResultType(symbol)
},
SymbolsAssignable$1: function(targetTypes, sourceType, conversion) {
conversion === void 0 && (conversion = 0);
for (var i = 0; i < System.Array.getCount(targetTypes, Kusto.Language.Symbols.TypeSymbol); i = i + 1 | 0)
if (Kusto.Language.Binding.Binder.SymbolsAssignable(System.Array.getItem(targetTypes, i, Kusto.Language.Symbols.TypeSymbol), sourceType, conversion)) return !0;
return !1
},
SymbolsAssignable: function(targetType, sourceType, conversion) {
if (conversion === void 0 && (conversion = 0), Bridge.referenceEquals(targetType, sourceType)) return !0;
if (targetType == null || sourceType == null) return !1;
if (Bridge.referenceEquals(sourceType, Kusto.Language.Symbols.ScalarTypes.Unknown) && targetType.IsScalar || Bridge.referenceEquals(targetType, Kusto.Language.Symbols.ScalarTypes.Unknown) && sourceType.IsScalar) return !0;
if (targetType.Kind !== sourceType.Kind) return !1;
switch (targetType.Kind) {
case Kusto.Language.Symbols.SymbolKind.Column:
var tarCol = Bridge.cast(targetType, Kusto.Language.Symbols.ColumnSymbol),
srcCol = Bridge.cast(sourceType, Kusto.Language.Symbols.ColumnSymbol);
return Bridge.referenceEquals(tarCol.Name, srcCol.Name) && Kusto.Language.Binding.Binder.SymbolsAssignable(tarCol.Type, srcCol.Type, conversion);
case Kusto.Language.Symbols.SymbolKind.Tuple:
case Kusto.Language.Symbols.SymbolKind.Group:
return Kusto.Language.Binding.Binder.MembersEqual(targetType, sourceType);
case Kusto.Language.Symbols.SymbolKind.Table:
return Kusto.Language.Binding.Binder.TablesAssignable(Bridge.cast(targetType, Kusto.Language.Symbols.TableSymbol), Bridge.cast(sourceType, Kusto.Language.Symbols.TableSymbol));
case Kusto.Language.Symbols.SymbolKind.Scalar:
switch (conversion) {
case Kusto.Language.Binding.Conversion.Promotable:
return Kusto.Language.Binding.Binder.IsPromotable(Bridge.cast(sourceType, Kusto.Language.Symbols.TypeSymbol), Bridge.cast(targetType, Kusto.Language.Symbols.TypeSymbol));
case Kusto.Language.Binding.Conversion.Compatible:
return Kusto.Language.Binding.Binder.IsPromotable(Bridge.cast(sourceType, Kusto.Language.Symbols.TypeSymbol), Bridge.cast(targetType, Kusto.Language.Symbols.TypeSymbol)) || Kusto.Language.Binding.Binder.IsPromotable(Bridge.cast(targetType, Kusto.Language.Symbols.TypeSymbol), Bridge.cast(sourceType, Kusto.Language.Symbols.TypeSymbol));
case Kusto.Language.Binding.Conversion.Any:
return !0;
default:
return !1
}
}
return !1
},
MembersEqual: function(target, source) {
if (System.Array.getCount(target.Members, Kusto.Language.Symbols.Symbol) !== System.Array.getCount(source.Members, Kusto.Language.Symbols.Symbol)) return !1;
for (var i = 0, n = System.Array.getCount(target.Members, Kusto.Language.Symbols.Symbol); i < n; i = i + 1 | 0)
if (!Kusto.Language.Binding.Binder.SymbolsAssignable(System.Array.getItem(target.Members, i, Kusto.Language.Symbols.Symbol), System.Array.getItem(source.Members, i, Kusto.Language.Symbols.Symbol))) return !1;
return !0
},
TablesAssignable: function(target, source) {
var $t, tarCol, valueColumn;
$t = Bridge.getEnumerator(target.Columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext())
if (tarCol = $t.Current, valueColumn = {}, !source.TryGetColumn(tarCol.Name, valueColumn) || !Kusto.Language.Binding.Binder.SymbolsAssignable(tarCol.Type, valueColumn.v.Type)) return !1
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !0
},
GetQueryParameterInfo: function(name, parameters) {
for (var i = 0, n = System.Array.getCount(parameters, Kusto.Language.Binding.Binder.QueryParameterInfo); i < n; i = i + 1 | 0)
if (System.Linq.Enumerable.from(System.Array.getItem(parameters, i, Kusto.Language.Binding.Binder.QueryParameterInfo).Names).contains(name)) return System.Array.getItem(parameters, i, Kusto.Language.Binding.Binder.QueryParameterInfo);
return null
},
Contains: function(values, value, caseSensitive) {
var stringValue = Bridge.as(value, System.String),
i, n, v, i1, n1;
if (stringValue != null) {
for (i = 0, n = System.Array.getCount(values, System.Object); i < n; i = i + 1 | 0)
if (v = Bridge.as(System.Array.getItem(values, i, System.Object), System.String), System.String.compare(stringValue, v, !caseSensitive) === 0) return !0
} else
for (i1 = 0, n1 = System.Array.getCount(values, System.Object); i1 < n1; i1 = i1 + 1 | 0)
if (Bridge.referenceEquals(System.Array.getItem(values, i1, System.Object), value)) return !0;
return !1
},
ArgumentsHaveErrorsOrUnknown: function(argumentTypes) {
for (var type, i = 0; i < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol); i = i + 1 | 0)
if (type = System.Array.getItem(argumentTypes, i, Kusto.Language.Symbols.TypeSymbol), type.IsError || Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Unknown)) return !0;
return !1
},
IsNamedArgument: function(argument) {
return Bridge.is(argument, Kusto.Language.Syntax.NamedExpression)
},
GetNamedArgumentNameNode: function(argument) {
var sn, cn;
do return Bridge.is(argument, Kusto.Language.Syntax.SimpleNamedExpression) ? (sn = Bridge.cast(argument, Kusto.Language.Syntax.SimpleNamedExpression), sn.Name) : Bridge.is(argument, Kusto.Language.Syntax.CompoundNamedExpression) ? (cn = Bridge.cast(argument, Kusto.Language.Syntax.CompoundNamedExpression), cn.Names) : null; while (0)
},
CheckArgumentCount: function(expressions, expectedCount, diagnostics) {
return expressions.Count === expectedCount ? !0 : (diagnostics.add(Kusto.Language.DiagnosticFacts.GetArgumentCountExpected(expectedCount).WithLocation(expressions)), !1)
}
}
},
fields: {
_globals: null,
_currentCluster: null,
_currentDatabase: null,
_currentFunction: null,
_localScope: null,
_rowScope: null,
_rightRowScope: null,
_pathScope: null,
_implicitArgumentType: null,
_scopeKind: 0,
_aliasedDatabases: null,
_globalBindingCache: null,
_localBindingCache: null,
_semanticInfoSetter: null,
_cancellationToken: null,
_openClusters: null,
_openDatabases: null,
_openTables: null,
openColumns: null,
tupleMap: null
},
props: {
RowScopeOrEmpty: {
get: function() {
return this._rowScope || Kusto.Language.Symbols.TableSymbol.Empty
}
},
RightRowScopeOrEmpty: {
get: function() {
return this._rightRowScope || Kusto.Language.Symbols.TableSymbol.Empty
}
}
},
ctors: {
init: function() {
this._cancellationToken = new Kusto.Language.Utils.CancellationToken;
this._aliasedDatabases = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.DatabaseSymbol))
},
ctor: function(globals, currentCluster, currentDatabase, currentFunction, outerScope, globalBindingCache, localBindingCache, semanticInfoSetter, cancellationToken) {
this.$initialize();
this._globals = globals;
this._currentCluster = currentCluster || globals.Cluster;
this._currentDatabase = currentDatabase || globals.Database;
this._currentFunction = currentFunction;
this._globalBindingCache = globalBindingCache || new Kusto.Language.Binding.GlobalBindingCache;
this._localBindingCache = localBindingCache || new Kusto.Language.Binding.LocalBindingCache;
this._localScope = new Kusto.Language.Binding.LocalScope.ctor(outerScope);
this._semanticInfoSetter = semanticInfoSetter || Kusto.Language.Binding.Binder.DefaultSetSemanticInfo;
this._cancellationToken = cancellationToken
}
},
methods: {
SetLocals: function(locals) {
var $t, local;
$t = Bridge.getEnumerator(locals, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) local = $t.Current, this._localScope.AddSymbol(local)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
SetContext: function(contextNode, position) {
if (position === void 0 && (position = -1), contextNode != null) {
var builder = new Kusto.Language.Binding.Binder.ContextBuilder(this, position >= 0 ? position : contextNode.TextStart);
contextNode.Accept$1(builder)
}
},
GetArgumentScope: function(fc, outerScope) {
var fs;
return (fs = Bridge.as(this.GetReferencedSymbol(fc.Name), Kusto.Language.Symbols.FunctionSymbol)) != null && this._globals.IsAggregateFunction(fs) ? Kusto.Language.Binding.Binder.ScopeKind.Normal : outerScope === Kusto.Language.Binding.Binder.ScopeKind.Aggregate ? Kusto.Language.Binding.Binder.ScopeKind.Aggregate : Kusto.Language.Binding.Binder.ScopeKind.Normal
},
GetSemanticInfo: function(node) {
return node != null ? node.GetSemanticInfo() : null
},
SetSemanticInfo: function(node, info) {
node != null && (Bridge.staticEquals(this._semanticInfoSetter, null) ? null : this._semanticInfoSetter(node, info))
},
GetResultTypeOrError: function(expression) {
var $t;
return (($t = this.GetSemanticInfo(expression)) != null ? $t.ResultType : null) || Kusto.Language.Symbols.ErrorSymbol.Instance
},
GetResultType: function(expression) {
var $t;
return ($t = this.GetSemanticInfo(expression)) != null ? $t.ResultType : null
},
GetReferencedSymbol: function(expression) {
var $t;
return ($t = this.GetSemanticInfo(expression)) != null ? $t.ReferencedSymbol : null
},
GetIsConstant: function(expression) {
var $t, $t1;
return $t = ($t1 = this.GetSemanticInfo(expression)) != null ? $t1.IsConstant : null, $t != null ? $t : !1
},
GetCluster: function(name) {
var cluster = this._globals.GetCluster$1(name);
return cluster || this.GetOpenCluster(name)
},
GetOpenCluster: function(name) {
this._openClusters == null && (this._openClusters = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.ClusterSymbol)));
var cluster = {};
return this._openClusters.tryGetValue(name, cluster) || (cluster.v = new Kusto.Language.Symbols.ClusterSymbol.$ctor1(name, null, !0), this._openClusters.add(name, cluster.v)), cluster.v
},
GetDatabase: function(name, cluster) {
var db, list;
if (cluster === void 0 && (cluster = null), cluster = cluster || this._currentCluster, Bridge.referenceEquals(cluster, this._currentCluster) && System.String.compare(this._currentDatabase.Name, name, !0) === 0) return this._currentDatabase;
if (db = {}, this._aliasedDatabases.tryGetValue(name, db)) return db.v;
list = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool();
try {
return cluster.GetMembers$1(name, Kusto.Language.Symbols.SymbolMatch.Database, list, !0), list.Count >= 1 ? Bridge.cast(list.getItem(0), Kusto.Language.Symbols.DatabaseSymbol) : cluster.IsOpen ? this.GetOpenDatabase(name, cluster) : null
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(list)
}
},
GetDatabase$1: function(name) {
var cluster = Bridge.as(this._pathScope, Kusto.Language.Symbols.ClusterSymbol) || this._currentCluster;
return this.GetDatabase(name, cluster) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)
},
GetOpenDatabase: function(name, cluster) {
var map, database;
return cluster = cluster || this._currentCluster, this._openDatabases == null && (this._openDatabases = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.ClusterSymbol, System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.DatabaseSymbol)))), map = {}, this._openDatabases.tryGetValue(cluster, map) || (map.v = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.DatabaseSymbol)), this._openDatabases.add(cluster, map.v)), database = {}, map.v.tryGetValue(name, database) || (database.v = new Kusto.Language.Symbols.DatabaseSymbol.$ctor1(name, null, !0), map.v.add(name, database.v)), database.v
},
GetTable: function(name, database) {
database === void 0 && (database = null);
database = database || this._currentDatabase;
var list = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool();
try {
return database.GetMembers$1(name, Kusto.Language.Symbols.SymbolMatch.Table, list), list.Count >= 1 ? Bridge.cast(list.getItem(0), Kusto.Language.Symbols.TableSymbol) : database.IsOpen ? this.GetOpenTable(name, database) : null
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(list)
}
},
GetOpenTable: function(name, database) {
var map, table;
return this._openTables == null && (this._openTables = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.DatabaseSymbol, System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.TableSymbol)))), map = {}, this._openTables.tryGetValue(database, map) || (map.v = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.TableSymbol)), this._openTables.add(database, map.v)), table = {}, map.v.tryGetValue(name, table) || (table.v = new Kusto.Language.Symbols.TableSymbol.$ctor3(name).WithIsOpen(!0), map.v.add(name, table.v)), table.v
},
GetOpenColumn: function(name, table) {
var columnMap, column;
return this.openColumns == null && (this.openColumns = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.TableSymbol, System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.ColumnSymbol)))), columnMap = {}, this.openColumns.tryGetValue(table, columnMap) || (columnMap.v = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.ColumnSymbol)), this.openColumns.add(table, columnMap.v)), column = {}, columnMap.v.tryGetValue(name, column) || (column.v = new Kusto.Language.Symbols.ColumnSymbol(name, Kusto.Language.Symbols.ScalarTypes.Unknown), columnMap.v.add(name, column.v)), column.v
},
GetDeclaredAndInferredColumns$1: function(table, columns) {
columns.AddRange(table.Columns);
var columnMap = {};
table.IsOpen && this.openColumns != null && this.openColumns.tryGetValue(table, columnMap) && columns.AddRange(columnMap.v.getValues())
},
GetDeclaredAndInferredColumns: function(table) {
if (table.IsOpen && this.openColumns != null && this.openColumns.containsKey(table)) {
var list = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
return this.GetDeclaredAndInferredColumns$1(table, list), list
}
return table.Columns
},
TryGetDeclaredOrInferredColumn: function(table, name, column) {
var c;
return (c = Bridge.as(table.GetFirstMember(name, Kusto.Language.Symbols.SymbolMatch.Column), Kusto.Language.Symbols.ColumnSymbol)) != null ? (column.v = c, !0) : table.IsOpen ? (column.v = this.GetOpenColumn(name, table), !0) : (column.v = null, !1)
},
GetTuple: function(table) {
this.tupleMap == null && (this.tupleMap = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.TableSymbol, Kusto.Language.Symbols.TupleSymbol)));
var tuple = {};
return this.tupleMap.tryGetValue(table, tuple) || (tuple.v = new Kusto.Language.Symbols.TupleSymbol.$ctor1(table.Columns, table), this.tupleMap.add(table, tuple.v)), tuple.v
},
CanCache: function(tables) {
return Bridge.referenceEquals(tables, this._currentDatabase.Tables) || System.Linq.Enumerable.from(tables).all(Bridge.fn.bind(this, function(t) {
return this._globals.IsDatabaseTable(t)
}))
},
GetTableOfColumnsUnifiedByName: function(tables) {
var $t, unifiedColumnsTable = {},
cache, columns, table;
if (!this._globalBindingCache.UnifiedNameColumnsMap.tryGetValue(tables, unifiedColumnsTable)) {
cache = this.CanCache(tables);
tables = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.TableSymbol, tables);
columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
$t = Bridge.getEnumerator(tables, Kusto.Language.Symbols.TableSymbol);
try {
while ($t.moveNext()) table = $t.Current, columns.AddRange(table.Columns)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Binding.Binder.UnifyColumnsWithSameName(columns);
unifiedColumnsTable.v = new Kusto.Language.Symbols.TableSymbol.$ctor2(columns).WithIsOpen(System.Linq.Enumerable.from(tables).any(function(t) {
return t.IsOpen
}));
cache && this._globalBindingCache.UnifiedNameColumnsMap.set(tables, unifiedColumnsTable.v)
}
return unifiedColumnsTable.v
},
GetTableOfColumnsUnifiedByNameAndType: function(tables) {
var $t, unifiedColumnsTable = {},
cache, columns, table;
if (!this._globalBindingCache.UnifiedNameAndTypeColumnsMap.tryGetValue(tables, unifiedColumnsTable)) {
cache = this.CanCache(tables);
tables = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.TableSymbol, tables);
columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
$t = Bridge.getEnumerator(tables, Kusto.Language.Symbols.TableSymbol);
try {
while ($t.moveNext()) table = $t.Current, columns.AddRange(table.Columns)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Binding.Binder.UnifyColumnsWithSameNameAndType(columns);
unifiedColumnsTable.v = new Kusto.Language.Symbols.TableSymbol.$ctor2(columns).WithIsOpen(System.Linq.Enumerable.from(tables).any(function(t) {
return t.IsOpen
}));
cache && this._globalBindingCache.UnifiedNameAndTypeColumnsMap.set(tables, unifiedColumnsTable.v)
}
return unifiedColumnsTable.v
},
GetTableOfCommonColumns: function(tables) {
var commonColumnsTable = {},
cache, columns;
return this._globalBindingCache.CommonColumnsMap.tryGetValue(tables, commonColumnsTable) || (cache = this.CanCache(tables), tables = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.TableSymbol, tables), columns = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor), Kusto.Language.Binding.Binder.GetCommonColumns(tables, columns), commonColumnsTable.v = new Kusto.Language.Symbols.TableSymbol.$ctor2(columns), System.Array.getCount(tables, Kusto.Language.Symbols.TableSymbol) > 0 && System.Linq.Enumerable.from(tables).all(function(t) {
return t.IsOpen
}) && (commonColumnsTable.v = commonColumnsTable.v.WithIsOpen(!0)), cache && this._globalBindingCache.CommonColumnsMap.set(tables, commonColumnsTable.v)), commonColumnsTable.v
},
GetSymbolsInContext: function(contextNode, match, include, list) {
var memberMatch, table, tuple, dbMatch;
if (this._pathScope != null) memberMatch = match & 11, Bridge.is(this._pathScope, Kusto.Language.Symbols.TableSymbol) && !Kusto.Language.Binding.Binder.IsInCommand(contextNode) && (memberMatch &= -2), (memberMatch & Kusto.Language.Symbols.SymbolMatch.Column) != 0 ? (table = Bridge.as(this._pathScope, Kusto.Language.Symbols.TableSymbol)) != null && table.IsOpen ? list.AddRange(this.GetDeclaredAndInferredColumns(table)) : (tuple = Bridge.as(this._pathScope, Kusto.Language.Symbols.TupleSymbol)) != null && tuple.RelatedTable != null && tuple.RelatedTable.IsOpen ? list.AddRange(this.GetDeclaredAndInferredColumns(tuple.RelatedTable)) : this._pathScope.GetMembers(memberMatch, list) : memberMatch !== 0 && this._pathScope.GetMembers(memberMatch, list), (match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && this.GetSpecialFunctions(null, list);
else switch (this._scopeKind) {
case Kusto.Language.Binding.Binder.ScopeKind.Normal:
this._rowScope != null && (match & Kusto.Language.Symbols.SymbolMatch.Column) != 0 && (this._rightRowScope != null ? (list.add(new Kusto.Language.Symbols.VariableSymbol("$left", this.GetTuple(this._rowScope))), list.add(new Kusto.Language.Symbols.VariableSymbol("$right", this.GetTuple(this._rightRowScope))), Kusto.Language.Binding.Binder.GetCommonColumns$2(this.GetDeclaredAndInferredColumns(this._rowScope), this.GetDeclaredAndInferredColumns(this._rightRowScope), list)) : this._rowScope.GetMembers(match, list));
this._localScope.GetSymbols(match, list);
(match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && (include & Kusto.Language.IncludeFunctionKind.BuiltInFunctions) != 0 && this.GetFunctionsInScope$1(match, null, Kusto.Language.IncludeFunctionKind.BuiltInFunctions, list);
this._currentDatabase != null && (dbMatch = match, (include & Kusto.Language.IncludeFunctionKind.DatabaseFunctions) == 0 && (dbMatch &= -9), this._currentDatabase.GetMembers(dbMatch, list));
(match & Kusto.Language.Symbols.SymbolMatch.Database) != 0 && this._currentCluster.GetMembers(match, list);
(match & Kusto.Language.Symbols.SymbolMatch.Cluster) != 0 && list.AddRange(this._globals.Clusters);
break;
case Kusto.Language.Binding.Binder.ScopeKind.Aggregate:
(match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && this.GetFunctionsInScope$1(match, null, include, list);
break;
case Kusto.Language.Binding.Binder.ScopeKind.PlugIn:
(match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && this.GetFunctionsInScope$1(match, null, include, list)
}
},
GetSpecialFunctions: function(name, functions) {
if (this._pathScope != null) switch (this._pathScope.Kind) {
case Kusto.Language.Symbols.SymbolKind.Cluster:
(name == null || Bridge.referenceEquals(Kusto.Language.Functions.Database.Name, name)) && functions.add(Kusto.Language.Functions.Database);
break;
case Kusto.Language.Symbols.SymbolKind.Database:
(name == null || Bridge.referenceEquals(Kusto.Language.Functions.Database.Name, name)) && (functions.add(Kusto.Language.Functions.Table), functions.add(Kusto.Language.Functions.ExternalTable), functions.add(Kusto.Language.Functions.MaterializedView))
}
},
GetFunctionsInScope$1: function(match, name, include, functions) {
var $t, allFunctions = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool(),
fn;
try {
this.GetFunctionsInScope(this._scopeKind, name, include, allFunctions);
$t = Bridge.getEnumerator(allFunctions);
try {
while ($t.moveNext()) fn = $t.Current, Kusto.Language.Symbols.SymbolMatchExtensions.Matches(fn, match) && functions.add(fn)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(allFunctions)
}
},
GetFunctionsInScope: function(kind, name, include, functions) {
var fn, fn1, fn2;
if (this._pathScope != null) this.GetSpecialFunctions(name, functions);
else switch (kind) {
case Kusto.Language.Binding.Binder.ScopeKind.Aggregate:
name == null ? (functions.AddRange(this._globals.Aggregates), this.GetFunctionsInScope(Kusto.Language.Binding.Binder.ScopeKind.Normal, name, include, functions)) : (fn = this._globals.GetAggregate(name), fn != null ? functions.add(fn) : this.GetFunctionsInScope(Kusto.Language.Binding.Binder.ScopeKind.Normal, name, include, functions));
break;
case Kusto.Language.Binding.Binder.ScopeKind.PlugIn:
name == null ? functions.AddRange(this._globals.PlugIns) : (fn1 = this._globals.GetPlugIn(name), fn1 != null && functions.add(fn1));
break;
default:
(include & Kusto.Language.IncludeFunctionKind.BuiltInFunctions) != 0 && (name == null ? functions.AddRange(this._globals.Functions) : functions.Count === 0 && (fn2 = this._globals.GetFunction(name), fn2 != null && functions.add(fn2)));
(name == null || functions.Count === 0) && (include & Kusto.Language.IncludeFunctionKind.LocalFunctions) != 0 && this.GetLocalFunctionsInScope(name, functions);
(name == null || functions.Count === 0) && (include & Kusto.Language.IncludeFunctionKind.DatabaseFunctions) != 0 && this._currentDatabase != null && this._currentDatabase.GetMembers$1(name, Kusto.Language.Symbols.SymbolMatch.Function, functions)
}
},
GetLocalFunctionsInScope: function(name, functions) {
var $t, locals = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool(),
local, resultType, fn, ps;
try {
this._localScope.GetSymbols$1(name, Kusto.Language.Symbols.SymbolMatch.Local, locals);
$t = Bridge.getEnumerator(locals);
try {
while ($t.moveNext()) local = $t.Current, resultType = Kusto.Language.Binding.Binder.GetResultType(local), (fn = Bridge.as(resultType, Kusto.Language.Symbols.FunctionSymbol)) != null ? functions.add(fn) : (ps = Bridge.as(resultType, Kusto.Language.Symbols.PatternSymbol)) != null && functions.add(ps)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(locals)
}
},
IsInsideFunctionDeclaration: function(location) {
return location.GetFirstAncestor(Kusto.Language.Syntax.CustomCommand) != null || this._currentFunction != null
},
BindName: function(name, match, location) {
var tuple, tuple1, list, allowZeroArgumentInvocation, ds, cs, col, tuple2, ds1, table, item, resultType, fn, sig, sigResult, returnType;
if (Bridge.referenceEquals(name, "")) return Kusto.Language.Binding.Binder.ErrorInfo;
if (this._pathScope != null) {
if (Bridge.referenceEquals(this._pathScope, Kusto.Language.Symbols.ScalarTypes.Dynamic)) return Kusto.Language.Binding.Binder.LiteralDynamicInfo;
if (Bridge.referenceEquals(this._pathScope, Kusto.Language.Symbols.ScalarTypes.Unknown)) return Kusto.Language.Binding.Binder.UnknownInfo;
if (Bridge.referenceEquals(this._pathScope, Kusto.Language.Symbols.ErrorSymbol.Instance)) return Kusto.Language.Binding.Binder.ErrorInfo
} else {
if (Bridge.referenceEquals(name, "$left") && this._rowScope != null && this._rightRowScope != null) return tuple = this.GetTuple(this._rowScope), new Kusto.Language.Syntax.SemanticInfo.$ctor1(tuple, tuple);
if (Bridge.referenceEquals(name, "$right") && this._rightRowScope != null) return tuple1 = this.GetTuple(this._rightRowScope), new Kusto.Language.Syntax.SemanticInfo.$ctor1(tuple1, tuple1)
}
list = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool();
try {
if (allowZeroArgumentInvocation = !1, Kusto.Language.Binding.Binder.IsFunctionCallName(location))(ds = Bridge.as(this._pathScope, Kusto.Language.Symbols.DatabaseSymbol)) != null ? Bridge.referenceEquals(name, Kusto.Language.Functions.Table.Name) ? list.add(Kusto.Language.Functions.Table) : Bridge.referenceEquals(name, Kusto.Language.Functions.ExternalTable.Name) ? list.add(Kusto.Language.Functions.ExternalTable) : Bridge.referenceEquals(name, Kusto.Language.Functions.MaterializedView.Name) ? list.add(Kusto.Language.Functions.MaterializedView) : this._pathScope.GetMembers$1(name, Kusto.Language.Symbols.SymbolMatch.Function, list) : (cs = Bridge.as(this._pathScope, Kusto.Language.Symbols.ClusterSymbol)) != null && Bridge.referenceEquals(name, Kusto.Language.Functions.Database.Name) ? list.add(Kusto.Language.Functions.Database) : this.GetFunctionsInScope(this._scopeKind, name, Kusto.Language.IncludeFunctionKind.All, list);
else {
if (this.IsInsideFunctionDeclaration(location) && this._currentDatabase.GetAnyTable(name) != null && (match &= -9), this._pathScope != null)
if (col = {}, (tuple2 = Bridge.as(this._pathScope, Kusto.Language.Symbols.TupleSymbol)) != null && tuple2.RelatedTable != null && tuple2.RelatedTable.IsOpen && this.TryGetDeclaredOrInferredColumn(tuple2.RelatedTable, name, col)) list.add(col.v);
else if ((ds1 = Bridge.as(this._pathScope, Kusto.Language.Symbols.DatabaseSymbol)) != null) {
if (this._pathScope.GetMembers$1(name, match & Kusto.Language.Symbols.SymbolMatch.Function, list), Kusto.Language.Binding.Binder.RemoveFunctionsThatCannotBeInvokedWithZeroArgs(list), allowZeroArgumentInvocation = list.Count > 0, list.Count === 0 && this._pathScope.GetMembers$1(name, match & -9, list), list.Count === 0 && ds1.IsOpen) return table = this.GetOpenTable(name, ds1), new Kusto.Language.Syntax.SemanticInfo.$ctor1(table, table)
} else(!Bridge.is(this._pathScope, Kusto.Language.Symbols.TableSymbol) || Kusto.Language.Binding.Binder.IsInCommand(location)) && this._pathScope.GetMembers$1(name, match, list);
list.Count === 0 && this._rowScope != null && this._rowScope.GetMembers$1(name, match, list);
list.Count === 0 && this._rightRowScope != null && this._rightRowScope.GetMembers$1(name, match, list);
list.Count === 0 && (this._localScope.GetSymbols$1(name, match, list), allowZeroArgumentInvocation = list.Count > 0);
list.Count === 0 && Kusto.Language.Binding.Binder.IsPossibleInvocableFunctionWithoutArgumentList(location) && (match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && (this.GetFunctionsInScope(this._scopeKind, name, Kusto.Language.IncludeFunctionKind.DatabaseFunctions, list), Kusto.Language.Binding.Binder.RemoveFunctionsThatCannotBeInvokedWithZeroArgs(list), allowZeroArgumentInvocation = list.Count > 0);
list.Count === 0 && this._currentDatabase != null && this._currentDatabase.GetMembers$1(name, match, list);
list.Count === 0 && this._currentCluster != null && (match & Kusto.Language.Symbols.SymbolMatch.Database) != 0 && this._currentCluster.GetMembers$1(name, match, list);
list.Count === 0 && (match & Kusto.Language.Symbols.SymbolMatch.Function) != 0 && this.GetFunctionsInScope(this._scopeKind, name, Kusto.Language.IncludeFunctionKind.BuiltInFunctions, list);
list.Count === 0 && this._rowScope != null && this._rowScope.IsOpen && (match & Kusto.Language.Symbols.SymbolMatch.Column) != 0 && list.add(this.GetOpenColumn(name, this._rowScope))
}
return list.Count === 1 ? (item = list.getItem(0), resultType = Kusto.Language.Binding.Binder.GetResultType(item), (fn = Bridge.as(resultType, Kusto.Language.Symbols.FunctionSymbol)) != null && Kusto.Language.Binding.Binder.IsPossibleInvocableFunctionWithoutArgumentList(location) ? (sig = System.Linq.Enumerable.from(fn.Signatures).firstOrDefault(function(s) {
return s.MinArgumentCount === 0
}, null), sig != null && allowZeroArgumentInvocation ? (sigResult = this.GetSignatureResult(sig, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Syntax.Expression).Instance, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.TypeSymbol).Instance), new Kusto.Language.Syntax.SemanticInfo.$ctor1(item, sigResult.Type, void 0, !1, sigResult.Expander)) : (returnType = this.GetCommonReturnType(fn.Signatures, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Syntax.Expression).Instance, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.TypeSymbol).Instance), new Kusto.Language.Syntax.SemanticInfo.ctor(item, returnType, Kusto.Language.DiagnosticFacts.GetFunctionRequiresArgumentList(name).WithLocation(location)))) : Kusto.Language.Binding.Binder.CreateSemanticInfo(item)) : list.Count === 0 ? Kusto.Language.Binding.Binder.IsFunctionCallName(location) ? this._globals.GetAggregate(name) != null && this._scopeKind !== Kusto.Language.Binding.Binder.ScopeKind.Aggregate ? new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetAggregateNotAllowedInThisContext(name).WithLocation(location)) : this._globals.GetPlugIn(name) != null && this._scopeKind !== Kusto.Language.Binding.Binder.ScopeKind.PlugIn ? new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetPluginNotAllowedInThisContext(name).WithLocation(location)) : Kusto.Language.Binding.Binder.IsEvaluateFunctionName(location) ? Kusto.Language.PlugIns.GetPlugIn(name) != null ? new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetPlugInFunctionIsNotEnabled(name).WithLocation(location)) : new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetPlugInFunctionNotDefined(name).WithLocation(location)) : Kusto.Language.Binding.Binder.IsFuzzyUnionOperand(location) ? null : new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetFunctionNotDefined(name).WithLocation(location)) : Kusto.Language.Binding.Binder.IsInTabularContext(location) ? Kusto.Language.Binding.Binder.IsFuzzyUnionOperand(location) ? new Kusto.Language.Syntax.SemanticInfo.$ctor2((new Kusto.Language.Symbols.TableSymbol.ctor).WithIsOpen(!0), Kusto.Language.DiagnosticFacts.GetFuzzyUnionOperandNotDefined(name).WithLocation(location)) : new Kusto.Language.Syntax.SemanticInfo.$ctor2((new Kusto.Language.Symbols.TableSymbol.ctor).WithIsOpen(!0), Kusto.Language.DiagnosticFacts.GetNameDoesNotReferToAnyKnownTable(name).WithLocation(location)) : new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetNameDoesNotReferToAnyKnownItem(name).WithLocation(location)) : new Kusto.Language.Syntax.SemanticInfo.ctor(new Kusto.Language.Symbols.GroupSymbol.$ctor1(System.Linq.Enumerable.from(list).toList(Bridge.global.Kusto.Language.Symbols.Symbol)), Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetNameRefersToMoreThanOneItem(name).WithLocation(location))
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(list)
}
},
GetBinaryOperatorInfo$1: function(kind, left, right, location) {
return this.GetBinaryOperatorInfo(kind, left, this.GetResultTypeOrError(left), right, this.GetResultTypeOrError(right), location)
},
GetBinaryOperatorInfo: function(kind, left, leftType, right, rightType, location) {
var $arguments = Kusto.Language.Binding.Binder.s_expressionListPool.AllocateFromPool(),
argumentTypes = Kusto.Language.Binding.Binder.s_typeListPool.AllocateFromPool();
try {
return $arguments.add(left), $arguments.add(right), argumentTypes.add(leftType), argumentTypes.add(rightType), this.GetOperatorInfo$1(kind, $arguments, argumentTypes, location)
} finally {
Kusto.Language.Binding.Binder.s_expressionListPool.ReturnToPool($arguments);
Kusto.Language.Binding.Binder.s_typeListPool.ReturnToPool(argumentTypes)
}
},
GetUnaryOperatorInfo: function(kind, operand, location) {
var $arguments = Kusto.Language.Binding.Binder.s_expressionListPool.AllocateFromPool();
try {
return $arguments.add(operand), this.GetOperatorInfo(kind, $arguments, location)
} finally {
Kusto.Language.Binding.Binder.s_expressionListPool.ReturnToPool($arguments)
}
},
GetOperatorInfo: function(kind, $arguments, location) {
var argumentTypes = Kusto.Language.Binding.Binder.s_typeListPool.AllocateFromPool(),
i;
try {
for (i = 0; i < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression); i = i + 1 | 0) argumentTypes.add(this.GetResultTypeOrError(System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression)));
return this.GetOperatorInfo$1(kind, $arguments, argumentTypes, location)
} finally {
Kusto.Language.Binding.Binder.s_typeListPool.ReturnToPool(argumentTypes)
}
},
GetOperatorInfo$1: function(kind, $arguments, argumentTypes, location) {
var matchingSignatures = Kusto.Language.Binding.Binder.s_signatureListPool.AllocateFromPool(),
diagnostics = Kusto.Language.Binding.Binder.s_diagnosticListPool.AllocateFromPool(),
op, sigResult, returnType;
try {
return op = this._globals.GetOperator(kind), this.GetBestMatchingSignatures(op.Signatures, $arguments, argumentTypes, matchingSignatures), matchingSignatures.Count === 1 ? (this.CheckSignature(matchingSignatures.getItem(0), $arguments, argumentTypes, location, diagnostics), sigResult = this.GetSignatureResult(matchingSignatures.getItem(0), $arguments, argumentTypes), new Kusto.Language.Syntax.SemanticInfo.$ctor1(matchingSignatures.getItem(0).Symbol, sigResult.Type, diagnostics, this.AllAreConstant($arguments), void 0)) : (Kusto.Language.Binding.Binder.ArgumentsHaveErrorsOrUnknown(argumentTypes) || diagnostics.add(Kusto.Language.DiagnosticFacts.GetOperatorNotDefined$1(location.ToString(Kusto.Language.Syntax.IncludeTrivia.Interior), argumentTypes).WithLocation(location)), returnType = this.GetCommonReturnType(matchingSignatures, $arguments, argumentTypes), new Kusto.Language.Syntax.SemanticInfo.$ctor1(matchingSignatures.getItem(0).Symbol, returnType, diagnostics))
} finally {
Kusto.Language.Binding.Binder.s_signatureListPool.ReturnToPool(matchingSignatures);
Kusto.Language.Binding.Binder.s_diagnosticListPool.ReturnToPool(diagnostics)
}
},
AllAreConstant: function(expressions) {
for (var i = 0; i < System.Array.getCount(expressions, Kusto.Language.Syntax.Expression); i = i + 1 | 0)
if (!this.GetIsConstant(System.Array.getItem(expressions, i, Kusto.Language.Syntax.Expression))) return !1;
return !0
},
GetArgumentsAndTypes: function(functionCall, $arguments, argumentTypes) {
for (var arg, expressions = functionCall.ArgumentList.Expressions, i = 0, n = expressions.Count; i < n; i = i + 1 | 0) arg = expressions.getItem$1(i).Element$1, $arguments.add(arg), argumentTypes.add(this.GetResultTypeOrError(arg));
Kusto.Language.Binding.Binder.IsInvokeOperatorFunctionCall(functionCall) && ($arguments.insert(0, functionCall.Name), argumentTypes.insert(0, this._implicitArgumentType))
},
GetSignatureResult: function(signature, $arguments, argumentTypes) {
if ($arguments == null) throw new System.ArgumentNullException.$ctor1("arguments");
if (argumentTypes == null) throw new System.ArgumentNullException.$ctor1("argumentTypes");
var argumentParameters = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool();
try {
return signature.GetArgumentParameters$1($arguments, argumentParameters), this.GetSignatureResult$1(signature, $arguments, argumentTypes, argumentParameters)
} finally {
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters)
}
},
GetSignatureResult$1: function(signature, $arguments, argumentTypes, argumentParameters) {
var iArg, clusterName, databaseName, tableName, externalTableName, materializedViewName;
if ($arguments == null) throw new System.ArgumentNullException.$ctor1("arguments");
if (argumentTypes == null) throw new System.ArgumentNullException.$ctor1("argumentTypes");
if (argumentParameters == null) throw new System.ArgumentNullException.$ctor1("argumentParameters");
switch (signature.ReturnKind) {
case Kusto.Language.Symbols.ReturnTypeKind.Declared:
return Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(signature.DeclaredReturnType);
case Kusto.Language.Symbols.ReturnTypeKind.Computed:
return this.GetComputedSignatureResult(signature, $arguments, argumentTypes);
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, iArg, Kusto.Language.Symbols.TypeSymbol) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Parameter1:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 1, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, iArg, Kusto.Language.Symbols.TypeSymbol) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Parameter2:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 2, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, iArg, Kusto.Language.Symbols.TypeSymbol) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.ParameterN:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) - 1 | 0, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, iArg, Kusto.Language.Symbols.TypeSymbol) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.ParameterNLiteral:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) - 1 | 0, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) ? this.GetTypeOfType(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression)) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Promoted:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(iArg >= 0 && iArg < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? Kusto.Language.Binding.Binder.Promote(System.Array.getItem(argumentTypes, iArg, Kusto.Language.Symbols.TypeSymbol)) : Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Common:
return Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes) || Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Widest:
return Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(Kusto.Language.Binding.Binder.GetWidestArgumentType(signature, argumentTypes) || Kusto.Language.Symbols.ErrorSymbol.Instance);
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Cluster:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), clusterName = {}, iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) && Kusto.Language.Binding.Binder.TryGetLiteralStringValue(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression), clusterName) ? Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(this.GetCluster(clusterName.v)) : Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(new Kusto.Language.Symbols.ClusterSymbol.$ctor1("", null, !0));
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Database:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), databaseName = {}, iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) && Kusto.Language.Binding.Binder.TryGetLiteralStringValue(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression), databaseName) ? Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(this.GetDatabase$1(databaseName.v)) : Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(new Kusto.Language.Symbols.DatabaseSymbol.$ctor1("", null, !0));
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Table:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), tableName = {}, iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) && Kusto.Language.Binding.Binder.TryGetLiteralStringValue(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression), tableName) ? Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(this.GetTableFunctionResult(tableName.v)) : Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(Kusto.Language.Symbols.TableSymbol.Empty.WithIsOpen(!0));
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0ExternalTable:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), externalTableName = {}, iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) && Kusto.Language.Binding.Binder.TryGetLiteralStringValue(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression), externalTableName) ? Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(this.GetExternalTableFunctionResult(externalTableName.v)) : Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(Kusto.Language.Symbols.TableSymbol.Empty.WithIsOpen(!0));
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0MaterializedView:
return iArg = Kusto.Language.Utils.ListExtensions.IndexOf(Bridge.global.Kusto.Language.Symbols.Parameter, argumentParameters, System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter)), materializedViewName = {}, iArg >= 0 && iArg < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) && Kusto.Language.Binding.Binder.TryGetLiteralStringValue(System.Array.getItem($arguments, iArg, Kusto.Language.Syntax.Expression), materializedViewName) ? Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(this.GetMaterializedViewFunctionResult(materializedViewName.v)) : Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(Kusto.Language.Symbols.TableSymbol.Empty.WithIsOpen(!0));
case Kusto.Language.Symbols.ReturnTypeKind.Custom:
return Kusto.Language.Binding.Binder.SignatureResult.op_Implicit(signature.CustomReturnType(this._rowScope || Kusto.Language.Symbols.TableSymbol.Empty, $arguments, signature) || Kusto.Language.Symbols.ErrorSymbol.Instance);
default:
throw new System.NotImplementedException.ctor;
}
},
GetComputedSignatureResult: function(signature, $arguments, argumentTypes) {
var $t, outerScope, expansion, returnType;
return $arguments === void 0 && ($arguments = null), argumentTypes === void 0 && (argumentTypes = null), outerScope = this._localScope.Copy(), System.Nullable.eq(signature.FunctionBodyFacts, Kusto.Language.Symbols.FunctionBodyFacts.None) ? new Kusto.Language.Binding.Binder.SignatureResult.$ctor1(signature.NonVariableComputedReturnType, this.GetDeferredCallSiteExpansion(signature, $arguments, argumentTypes, outerScope)) : (expansion = this.GetCallSiteExpansion(signature, $arguments, argumentTypes, outerScope), returnType = (expansion != null && ($t = expansion.Expression) != null ? $t.ResultType : null) || Kusto.Language.Symbols.ErrorSymbol.Instance, new Kusto.Language.Binding.Binder.SignatureResult.$ctor1(returnType, function() {
return expansion
}))
},
GetDeferredCallSiteExpansion: function(signature, $arguments, argumentTypes, outerScope) {
$arguments === void 0 && ($arguments = null);
argumentTypes === void 0 && (argumentTypes = null);
outerScope === void 0 && (outerScope = null);
var expansion = null,
args = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Syntax.Expression, $arguments),
types = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.TypeSymbol, argumentTypes);
return Bridge.fn.bind(this, function() {
return expansion == null && (this._globalBindingCache, expansion = this.GetCallSiteExpansion(signature, args, types, outerScope)), expansion
})
},
GetTableFunctionResult: function(name) {
var pathDb = Bridge.as(this._pathScope, Kusto.Language.Symbols.DatabaseSymbol),
match, symbols, result;
if (pathDb == null) {
match = 18;
symbols = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool();
try {
return this._localScope.GetSymbols$1(name, match, symbols), symbols.Count > 0 ? (result = Kusto.Language.Binding.Binder.GetResultType(symbols.getItem(0)), Bridge.as(result, Kusto.Language.Symbols.TableSymbol) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)) : this.GetTable(name, this._currentDatabase) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(symbols)
}
} else return this.GetTable(name, pathDb || this._currentDatabase) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)
},
GetExternalTableFunctionResult: function(name) {
var db = Bridge.as(this._pathScope, Kusto.Language.Symbols.DatabaseSymbol) || this._currentDatabase;
return db.GetExternalTable(name) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)
},
GetMaterializedViewFunctionResult: function(name) {
var db = Bridge.as(this._pathScope, Kusto.Language.Symbols.DatabaseSymbol) || this._currentDatabase;
return db.GetMaterializedView(name) || Bridge.cast(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.Symbols.TypeSymbol)
},
GetCommonReturnType: function(signatures, $arguments, argumentTypes) {
var firstType, i, type;
if (System.Array.getCount(signatures, Kusto.Language.Symbols.Signature) === 0) return Kusto.Language.Symbols.ErrorSymbol.Instance;
if (System.Array.getCount(signatures, Kusto.Language.Symbols.Signature) === 1) return this.GetSignatureResult(System.Array.getItem(signatures, 0, Kusto.Language.Symbols.Signature), $arguments, argumentTypes).Type;
for (firstType = this.GetSignatureResult(System.Array.getItem(signatures, 0, Kusto.Language.Symbols.Signature), $arguments, argumentTypes).Type, i = 1; i < System.Array.getCount(signatures, Kusto.Language.Symbols.Signature); i = i + 1 | 0)
if (type = this.GetSignatureResult(System.Array.getItem(signatures, i, Kusto.Language.Symbols.Signature), $arguments, argumentTypes).Type, !Kusto.Language.Binding.Binder.SymbolsAssignable(firstType, type)) return Kusto.Language.Binding.Binder.ArgumentsHaveErrorsOrUnknown(argumentTypes) ? Kusto.Language.Symbols.ScalarTypes.Unknown : Kusto.Language.Symbols.ErrorSymbol.Instance;
return firstType
},
GetBestMatchingSignatures: function(signatures, $arguments, argumentTypes, result) {
var $t, $t1, $t2, argCount = System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol),
closestCount, maxCount, s, s1, mostMatchingParameterCount, s2, count, i, f, best, i1, i2;
if (System.Array.getCount(signatures, Kusto.Language.Symbols.Signature) !== 0) {
if (System.Array.getCount(signatures, Kusto.Language.Symbols.Signature) === 1) {
result.add(System.Array.getItem(signatures, 0, Kusto.Language.Symbols.Signature));
return
}
if (System.Array.getCount(signatures, Kusto.Language.Symbols.Signature) > 1) {
closestCount = 0;
maxCount = 0;
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext()) s = $t.Current, argCount >= s.MinArgumentCount && argCount <= s.MaxArgumentCount ? result.add(s) : argCount < s.MinArgumentCount && closestCount > s.MinArgumentCount && (closestCount = s.MinArgumentCount), s.MaxArgumentCount > maxCount && (maxCount = s.MaxArgumentCount)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
if (result.Count === 0) {
closestCount === 0 && (closestCount = maxCount);
$t1 = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.Signature);
try {
while ($t1.moveNext()) s1 = $t1.Current, closestCount >= s1.MinArgumentCount && closestCount <= s1.MaxArgumentCount && result.add(s1)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
}
if (result.Count > 1) {
mostMatchingParameterCount = 0;
$t2 = Bridge.getEnumerator(result);
try {
while ($t2.moveNext()) s2 = $t2.Current, count = this.GetParameterMatchCount(s2, $arguments, argumentTypes), count > mostMatchingParameterCount && (mostMatchingParameterCount = count)
} finally {
Bridge.is($t2, System.IDisposable) && $t2.System$IDisposable$Dispose()
}
for (i = result.Count - 1 | 0; i >= 0; i = i - 1 | 0) f = result.getItem(i), this.GetParameterMatchCount(f, $arguments, argumentTypes) !== mostMatchingParameterCount && result.removeAt(i);
if (result.Count > 1) {
for (best = result.getItem(0), i1 = 1; i1 < result.Count; i1 = i1 + 1 | 0) this.IsBetterSignatureMatch(result.getItem(i1), best, $arguments, argumentTypes) && (best = result.getItem(i1));
for (i2 = 0; i2 < result.Count; i2 = i2 + 1 | 0)
if (!Bridge.referenceEquals(result.getItem(i2), best) && !this.IsBetterSignatureMatch(best, result.getItem(i2), $arguments, argumentTypes)) return;
result.clear();
result.add(best)
}
}
}
},
IsBetterSignatureMatch: function(signature1, signature2, $arguments, argumentTypes) {
var argCount = System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol),
matchCount1 = this.GetParameterMatchCount(signature1, $arguments, argumentTypes),
matchCount2 = this.GetParameterMatchCount(signature2, $arguments, argumentTypes),
better, i;
if (matchCount1 === argCount && matchCount2 < argCount) return !0;
for (better = null, i = 0; i < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol); i = i + 1 | 0)
if (this.IsBetterParameterMatch(signature1, signature2, $arguments, argumentTypes, i)) {
if (Bridge.referenceEquals(better, signature2)) break;
better = signature1
} else if (this.IsBetterParameterMatch(signature2, signature1, $arguments, argumentTypes, i)) {
if (Bridge.referenceEquals(better, signature1)) {
better = null;
break
}
better = signature2
}
return Bridge.referenceEquals(better, signature1) ? !0 : matchCount1 > matchCount2
},
IsBetterParameterMatch: function(signature1, signature2, $arguments, argumentTypes, argumentIndex) {
var argumentParameters1 = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool(),
argumentParameters2 = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool(),
matches1, matches2;
try {
return signature1.GetArgumentParameters$1($arguments, argumentParameters1), signature2.GetArgumentParameters$1($arguments, argumentParameters2), matches1 = this.GetParameterMatchKind(signature1, argumentParameters1, $arguments, argumentTypes, argumentParameters1.getItem(argumentIndex), System.Array.getItem($arguments, argumentIndex, Kusto.Language.Syntax.Expression), System.Array.getItem(argumentTypes, argumentIndex, Kusto.Language.Symbols.TypeSymbol)), matches2 = this.GetParameterMatchKind(signature2, argumentParameters2, $arguments, argumentTypes, argumentParameters2.getItem(argumentIndex), System.Array.getItem($arguments, argumentIndex, Kusto.Language.Syntax.Expression), System.Array.getItem(argumentTypes, argumentIndex, Kusto.Language.Symbols.TypeSymbol)), matches1 > matches2
} finally {
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters2);
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters1)
}
},
GetParameterMatchCount: function(signature, $arguments, argumentTypes) {
var argCount = System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol),
matches = 0,
argumentParameters = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool(),
i;
try {
for (signature.GetArgumentParameters$1($arguments, argumentParameters), i = 0; i < argCount; i = i + 1 | 0) this.GetParameterMatchKind(signature, argumentParameters, $arguments, argumentTypes, argumentParameters.getItem(i), System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression), System.Array.getItem(argumentTypes, i, Kusto.Language.Symbols.TypeSymbol)) !== Kusto.Language.Binding.Binder.MatchKind.None && (matches = matches + 1 | 0)
} finally {
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters)
}
return matches
},
GetParameterMatchKind: function(signature, argumentParameters, $arguments, argumentTypes, parameter, argument, argumentType) {
var lit, value, commonType;
if (parameter == null) return Kusto.Language.Binding.Binder.MatchKind.None;
if (Bridge.referenceEquals(argumentType, Kusto.Language.Symbols.ScalarTypes.Unknown)) return Kusto.Language.Binding.Binder.MatchKind.Unknown;
if (parameter.DefaultValueIndicator != null && Bridge.referenceEquals(argumentType, Kusto.Language.Symbols.ScalarTypes.String) && (lit = Bridge.as(argument, Kusto.Language.Syntax.LiteralExpression)) != null && (value = Bridge.as(lit.LiteralValue, System.String)) != null && Bridge.referenceEquals(value, parameter.DefaultValueIndicator)) return Kusto.Language.Binding.Binder.MatchKind.Exact;
if (Bridge.is(argument, Kusto.Language.Syntax.StarExpression)) return parameter.ArgumentKind === Kusto.Language.Symbols.ArgumentKind.Star ? Kusto.Language.Binding.Binder.MatchKind.Exact : Kusto.Language.Binding.Binder.MatchKind.None;
if (parameter.ArgumentKind === Kusto.Language.Symbols.ArgumentKind.Star) return Kusto.Language.Binding.Binder.MatchKind.None;
switch (parameter.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
if (Kusto.Language.Binding.Binder.SymbolsAssignable$1(parameter.DeclaredTypes, argumentType, Kusto.Language.Binding.Conversion.None)) return System.Array.getCount(parameter.DeclaredTypes, Kusto.Language.Symbols.TypeSymbol) === 1 ? Kusto.Language.Binding.Binder.MatchKind.Exact : Kusto.Language.Binding.Binder.MatchKind.OneOfTwo;
if (Kusto.Language.Binding.Binder.SymbolsAssignable$1(parameter.DeclaredTypes, argumentType, Kusto.Language.Binding.Conversion.Promotable)) return Kusto.Language.Binding.Binder.MatchKind.Promoted;
if (this.AllowLooseParameterMatching(signature) && Kusto.Language.Binding.Binder.SymbolsAssignable$1(parameter.DeclaredTypes, argumentType, Kusto.Language.Binding.Conversion.Compatible)) return Kusto.Language.Binding.Binder.MatchKind.Compatible;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Scalar:
if (argumentType.IsScalar) return Kusto.Language.Binding.Binder.MatchKind.Scalar;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Integer:
if (Kusto.Language.Binding.Binder.IsInteger(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.OneOfTwo;
break;
case Kusto.Language.Symbols.ParameterTypeKind.RealOrDecimal:
if (Kusto.Language.Binding.Binder.IsRealOrDecimal(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.OneOfTwo;
break;
case Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic:
if (Kusto.Language.Binding.Binder.IsStringOrDynamic(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.OneOfTwo;
break;
case Kusto.Language.Symbols.ParameterTypeKind.IntegerOrDynamic:
if (Kusto.Language.Binding.Binder.IsIntegerOrDynamic(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.OneOfTwo;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Number:
if (Kusto.Language.Binding.Binder.IsNumber(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.Number;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Summable:
if (Kusto.Language.Binding.Binder.IsSummable(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.Summable;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
case Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable:
if (Kusto.Language.Binding.Binder.IsTabular(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.Tabular;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Database:
if (Kusto.Language.Binding.Binder.IsDatabase(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.Database;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Cluster:
if (Kusto.Language.Binding.Binder.IsCluster(argumentType)) return Kusto.Language.Binding.Binder.MatchKind.Cluster;
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotBool:
if (!Kusto.Language.Binding.Binder.SymbolsAssignable(argumentType, Kusto.Language.Symbols.ScalarTypes.Bool)) return Kusto.Language.Binding.Binder.MatchKind.NotType;
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotRealOrBool:
if (!Kusto.Language.Binding.Binder.SymbolsAssignable(argumentType, Kusto.Language.Symbols.ScalarTypes.Real) && !Kusto.Language.Binding.Binder.SymbolsAssignable(argumentType, Kusto.Language.Symbols.ScalarTypes.Bool)) return Kusto.Language.Binding.Binder.MatchKind.NotType;
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotDynamic:
if (!Kusto.Language.Binding.Binder.SymbolsAssignable(argumentType, Kusto.Language.Symbols.ScalarTypes.Dynamic)) return Kusto.Language.Binding.Binder.MatchKind.NotType;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Parameter0:
return this.GetParameterMatchKind(signature, argumentParameters, $arguments, argumentTypes, System.Array.getItem(argumentParameters, 0, Kusto.Language.Symbols.Parameter), argument, argumentType);
case Kusto.Language.Symbols.ParameterTypeKind.Parameter1:
return this.GetParameterMatchKind(signature, argumentParameters, $arguments, argumentTypes, System.Array.getItem(argumentParameters, 1, Kusto.Language.Symbols.Parameter), argument, argumentType);
case Kusto.Language.Symbols.ParameterTypeKind.Parameter2:
return this.GetParameterMatchKind(signature, argumentParameters, $arguments, argumentTypes, System.Array.getItem(argumentParameters, 2, Kusto.Language.Symbols.Parameter), argument, argumentType);
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalar:
case Kusto.Language.Symbols.ParameterTypeKind.CommonNumber:
case Kusto.Language.Symbols.ParameterTypeKind.CommonSummable:
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic:
if (commonType = Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes), commonType != null) {
if (Kusto.Language.Binding.Binder.SymbolsAssignable(commonType, argumentType, Kusto.Language.Binding.Conversion.None)) return Kusto.Language.Binding.Binder.MatchKind.Exact;
if (Kusto.Language.Binding.Binder.SymbolsAssignable(commonType, argumentType, Kusto.Language.Binding.Conversion.Promotable)) return Kusto.Language.Binding.Binder.MatchKind.Promoted;
if (this.AllowLooseParameterMatching(signature) && Kusto.Language.Binding.Binder.SymbolsAssignable(commonType, argumentType, Kusto.Language.Binding.Conversion.Compatible)) return Kusto.Language.Binding.Binder.MatchKind.Compatible;
if (parameter.TypeKind === Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic && Kusto.Language.Binding.Binder.SymbolsAssignable(argumentType, Kusto.Language.Symbols.ScalarTypes.Dynamic)) return Kusto.Language.Binding.Binder.MatchKind.Exact
}
}
return Kusto.Language.Binding.Binder.MatchKind.None
},
BindFunctionCallOrPattern: function(functionCall) {
var symbol = this.GetResultTypeOrError(functionCall.Name),
fn, ps;
return (fn = Bridge.as(symbol, Kusto.Language.Symbols.FunctionSymbol)) != null ? this.BindFunctionCall(functionCall, fn) : (ps = Bridge.as(symbol, Kusto.Language.Symbols.PatternSymbol)) != null ? this.BindPattern(functionCall, ps) : symbol.IsError ? Kusto.Language.Binding.Binder.IsFuzzyUnionOperand(functionCall) ? new Kusto.Language.Syntax.SemanticInfo.$ctor2((new Kusto.Language.Symbols.TableSymbol.ctor).WithIsOpen(!0), Kusto.Language.DiagnosticFacts.GetFuzzyUnionOperandNotDefined(functionCall.Name.SimpleName).WithLocation(functionCall)) : null : Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol) && Kusto.Language.Binding.Binder.IsInTabularContext(functionCall) && Kusto.Language.Binding.Binder.IsFuzzyUnionOperand(functionCall) ? functionCall.Name.GetSemanticInfo() : new Kusto.Language.Syntax.SemanticInfo.$ctor2(Kusto.Language.Symbols.ErrorSymbol.Instance, Kusto.Language.DiagnosticFacts.GetNameIsNotAFunction(functionCall.Name.SimpleName).WithLocation(functionCall.Name))
},
BindFunctionCall: function(functionCall, fn) {
var diagnostics = Kusto.Language.Binding.Binder.s_diagnosticListPool.AllocateFromPool(),
$arguments = Kusto.Language.Binding.Binder.s_expressionListPool.AllocateFromPool(),
argumentTypes = Kusto.Language.Binding.Binder.s_typeListPool.AllocateFromPool(),
matchingSignatures = Kusto.Language.Binding.Binder.s_signatureListPool.AllocateFromPool(),
sigResult, types, returnType;
try {
return this.GetArgumentsAndTypes(functionCall, $arguments, argumentTypes), this.GetBestMatchingSignatures(fn.Signatures, $arguments, argumentTypes, matchingSignatures), matchingSignatures.Count === 1 ? (this.CheckSignature(matchingSignatures.getItem(0), $arguments, argumentTypes, functionCall.Name, diagnostics), sigResult = this.GetSignatureResult(matchingSignatures.getItem(0), $arguments, argumentTypes), new Kusto.Language.Syntax.SemanticInfo.$ctor1(fn, sigResult.Type, diagnostics, fn.IsConstantFoldable && this.AllAreConstant($arguments), sigResult.Expander)) : ($arguments.Count === 0 && fn.MinArgumentCount > 0 ? diagnostics.add(Kusto.Language.DiagnosticFacts.GetFunctionExpectsArgumentCountRange(fn.Name, fn.MinArgumentCount, fn.MaxArgumentCount).WithLocation(functionCall.Name)) : Kusto.Language.Binding.Binder.ArgumentsHaveErrorsOrUnknown(argumentTypes) || (types = System.Linq.Enumerable.from($arguments).select(Bridge.fn.bind(this, function(e) {
return this.GetResultTypeOrError(e)
})).toList(Kusto.Language.Symbols.TypeSymbol), diagnostics.add(Kusto.Language.DiagnosticFacts.GetFunctionNotDefinedWithMatchingParameters(functionCall.Name.SimpleName, types).WithLocation(functionCall.Name))), returnType = this.GetCommonReturnType(matchingSignatures, $arguments, argumentTypes), new Kusto.Language.Syntax.SemanticInfo.$ctor1(fn, returnType, diagnostics, fn.IsConstantFoldable && this.AllAreConstant($arguments), void 0))
} finally {
Kusto.Language.Binding.Binder.s_diagnosticListPool.ReturnToPool(diagnostics);
Kusto.Language.Binding.Binder.s_expressionListPool.ReturnToPool($arguments);
Kusto.Language.Binding.Binder.s_typeListPool.ReturnToPool(argumentTypes);
Kusto.Language.Binding.Binder.s_signatureListPool.ReturnToPool(matchingSignatures)
}
},
BindPattern: function(functionCall, pattern) {
var diagnostics = Kusto.Language.Binding.Binder.s_diagnosticListPool.AllocateFromPool(),
matchingPatterns = Kusto.Language.Binding.Binder.s_patternListPool.AllocateFromPool(),
$arguments = Kusto.Language.Binding.Binder.s_expressionListPool.AllocateFromPool(),
i, n, argument, type, result;
try {
for (System.Array.getCount(pattern.Parameters, Kusto.Language.Symbols.Parameter) !== functionCall.ArgumentList.Expressions.Count && diagnostics.add(Kusto.Language.DiagnosticFacts.GetArgumentCountExpected(System.Array.getCount(pattern.Parameters, Kusto.Language.Symbols.Parameter))), i = 0, n = System.Array.getCount(pattern.Parameters, Kusto.Language.Symbols.Parameter); i < n; i = i + 1 | 0) argument = functionCall.ArgumentList.Expressions.getItem$1(i).Element$1, $arguments.add(argument), type = System.Array.getItem(System.Array.getItem(pattern.Parameters, i, Kusto.Language.Symbols.Parameter).DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol), this.CheckIsExactType(argument, type, diagnostics) && this.CheckIsLiteral(argument, diagnostics);
return diagnostics.Count > 0 ? new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ErrorSymbol.Instance, diagnostics) : (this.GetMatchingPatterns(pattern.Signatures, $arguments, matchingPatterns), matchingPatterns.Count === 0) ? (diagnostics.add(Kusto.Language.DiagnosticFacts.GetNoPatternMatchesArguments().WithLocation(functionCall.Name)), new Kusto.Language.Syntax.SemanticInfo.$ctor3(Kusto.Language.Symbols.ErrorSymbol.Instance, diagnostics)) : (result = this.GetReturnType$1(matchingPatterns), new Kusto.Language.Syntax.SemanticInfo.$ctor1(pattern, result, diagnostics))
} finally {
Kusto.Language.Binding.Binder.s_diagnosticListPool.ReturnToPool(diagnostics);
Kusto.Language.Binding.Binder.s_patternListPool.ReturnToPool(matchingPatterns);
Kusto.Language.Binding.Binder.s_expressionListPool.ReturnToPool($arguments)
}
},
GetMatchingPatterns: function(signatures, $arguments, matchingSignatures) {
var $t, sig;
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.PatternSignature);
try {
while ($t.moveNext()) sig = $t.Current, this.PatternMatches(sig, $arguments) && matchingSignatures.add(sig)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
PatternMatches: function(signature, $arguments) {
var $t, $t1, i, matchValue, argValue;
if (System.Array.getCount(signature.ArgumentValues, System.String) !== System.Array.getCount($arguments, Kusto.Language.Syntax.Expression)) return !1;
for (i = 0; i < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression); i = i + 1 | 0)
if (matchValue = System.Array.getItem(signature.ArgumentValues, i, System.String), argValue = ($t = ($t1 = System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression).LiteralValue) != null ? Bridge.toString($t1) : null, $t != null ? $t : ""), !Bridge.referenceEquals(matchValue, argValue)) return !1;
return !0
},
GetReturnType$1: function(signatures) {
var $t, paths = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool(),
signature, type;
try {
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.PatternSignature);
try {
while ($t.moveNext()) {
if (signature = $t.Current, type = this.GetReturnType(signature), signature.PathValue == null) return type;
paths.add(new Kusto.Language.Symbols.VariableSymbol(Bridge.toString(signature.PathValue), type))
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return new Kusto.Language.Symbols.DatabaseSymbol.$ctor1("", paths)
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(paths)
}
},
GetReturnType: function(signature) {
if (signature.Declaration != null) {
var expr = signature.Declaration.Body.Expression;
return expr != null ? this.GetResultTypeOrError(expr) : Kusto.Language.Symbols.VoidSymbol.Instance
}
return Kusto.Language.Symbols.ErrorSymbol.Instance
},
GetCallSiteExpansion: function(signature, $arguments, argumentTypes, outerScope) {
var AddExpansionToCache, TryGetExpansionFromCache, callSiteInfo, expansion, functionBodyGrammar, body;
if (($arguments === void 0 && ($arguments = null), argumentTypes === void 0 && (argumentTypes = null), outerScope === void 0 && (outerScope = null), AddExpansionToCache = null, TryGetExpansionFromCache = null, signature.ReturnKind !== Kusto.Language.Symbols.ReturnTypeKind.Computed) || this._localBindingCache.SignaturesComputingExpansion.contains(signature)) return null;
this._localBindingCache.SignaturesComputingExpansion.add(signature);
TryGetExpansionFromCache = Bridge.fn.bind(this, function(callsite, expansion) {
return this._localBindingCache.CallSiteToExpansionMap.tryGetValue(callsite, expansion) || this._globalBindingCache.CallSiteToExpansionMap.tryGetValue(callsite, expansion)
});
AddExpansionToCache = Bridge.fn.bind(this, function(callsite, expansion) {
if (!System.Nullable.neq(System.Nullable.band(callsite.Signature.FunctionBodyFacts, Kusto.Language.Symbols.FunctionBodyFacts.Table), 0)) {
var shouldCacheGlobally = this.IsDatabaseFunction(Bridge.as(callsite.Signature.Symbol, Kusto.Language.Symbols.FunctionSymbol)) && System.Nullable.neq(callsite.Signature.FunctionBodyFacts, Kusto.Language.Symbols.FunctionBodyFacts.None);
shouldCacheGlobally ? this._globalBindingCache.CallSiteToExpansionMap.add(callsite, expansion) : this._localBindingCache.CallSiteToExpansionMap.add(callsite, expansion)
}
});
try {
if (callSiteInfo = this.GetCallSiteInfo(signature, $arguments, argumentTypes), expansion = {}, !TryGetExpansionFromCache(callSiteInfo, expansion)) {
try {
if (functionBodyGrammar = Kusto.Language.Parsing.QueryGrammar.From(this._globals).FunctionBody, body = this.GetFunctionBody(signature), expansion.v = Kusto.Language.Parsing.SyntaxParsers.ParseFirst(Bridge.global.Kusto.Language.Syntax.FunctionBody, functionBodyGrammar, body, !1), expansion.v != null) {
var $function = Bridge.as(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol),
isDatabaseFunction = this.IsDatabaseFunction($function),
currentDatabase = isDatabaseFunction ? this._globals.GetDatabase($function) : null,
currentCluster = isDatabaseFunction ? this._globals.GetCluster(currentDatabase) : null;
Kusto.Language.Binding.Binder.BindExpansion(expansion.v, this, currentCluster, currentDatabase, Bridge.as(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol), outerScope, callSiteInfo.Locals);
this.SetSignatureBindingInfo(signature, expansion.v)
}
} catch ($e1) {
$e1 = System.Exception.create($e1)
}
AddExpansionToCache(callSiteInfo, expansion.v)
}
return expansion.v
} finally {
this._localBindingCache.SignaturesComputingExpansion.remove(signature)
}
},
IsDatabaseFunction: function($function) {
return System.Array.getCount($function.Signatures, Kusto.Language.Symbols.Signature) === 1 && System.Array.getItem($function.Signatures, 0, Kusto.Language.Symbols.Signature).Declaration == null && System.Array.getItem($function.Signatures, 0, Kusto.Language.Symbols.Signature).Body != null && this._globals.IsDatabaseFunction($function)
},
SetSignatureBindingInfo: function(signature, body) {
var $t, returnType;
signature.FunctionBodyFacts == null && (signature.FunctionBodyFacts = this.ComputeFunctionBodyFacts(signature, body));
signature.HasVariableReturnType || (returnType = (($t = body.Expression) != null ? $t.ResultType : null) || Kusto.Language.Symbols.ErrorSymbol.Instance, signature.NonVariableComputedReturnType = returnType)
},
GetCallSiteInfo: function(signature, $arguments, argumentTypes) {
var locals = this.GetArgumentsAsLocals(signature, $arguments, argumentTypes);
return new Kusto.Language.Binding.CallSiteInfo(signature, locals)
},
GetArgumentsAsLocals: function(signature, $arguments, argumentTypes) {
var $t, locals = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.VariableSymbol).ctor),
argumentParameters = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool(),
p, argIndex;
try {
$arguments != null ? signature.GetArgumentParameters$1($arguments, argumentParameters) : argumentTypes != null && signature.GetArgumentParameters$2(System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol), argumentParameters);
$t = Bridge.getEnumerator(signature.Parameters, Kusto.Language.Symbols.Parameter);
try {
while ($t.moveNext())
if (p = $t.Current, argIndex = argumentParameters != null ? argumentParameters.indexOf(p) : -1, argIndex >= 0 && !!($arguments != null & argIndex < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression))) {
var arg = System.Array.getItem($arguments, argIndex, Kusto.Language.Syntax.Expression),
argType = argumentTypes != null && argIndex < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, argIndex, Kusto.Language.Symbols.TypeSymbol) : arg.ResultType,
literalValue = {},
isLiteral = Kusto.Language.Binding.Binder.TryGetLiteralValue(arg, literalValue);
locals.add(new Kusto.Language.Symbols.VariableSymbol(p.Name, argType, isLiteral, literalValue.v))
} else {
var type = argIndex >= 0 && argumentTypes != null && argIndex < System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) ? System.Array.getItem(argumentTypes, argIndex, Kusto.Language.Symbols.TypeSymbol) : Kusto.Language.Binding.Binder.GetRepresentativeType(p),
isConstant = p.IsOptional && p.DefaultValue != null,
constantValue = {
v: null
};
isConstant && Kusto.Language.Binding.Binder.TryGetLiteralValue(p.DefaultValue, constantValue);
locals.add(new Kusto.Language.Symbols.VariableSymbol(p.Name, type, isConstant, constantValue.v))
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.VariableSymbol, locals)
} finally {
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters)
}
},
GetFunctionBody: function(signature) {
var body = signature.Body.trim();
return System.String.startsWith(body, "{") || (body = "{" + (body || "")), System.String.endsWith(body, "}") || (body = (body || "") + "\n}"), body
},
ComputeFunctionBodyFacts: function(signature, body) {
var $t, $t1, $t2, result = Kusto.Language.Symbols.FunctionBodyFacts.None,
isTabular = Bridge.is(($t = body.Expression) != null ? $t.ResultType : null, Kusto.Language.Symbols.TableSymbol),
fc, p, isLiteral, fce, facts;
$t1 = Bridge.getEnumerator(body.GetDescendants(Kusto.Language.Syntax.FunctionCallExpression, function(_fc) {
return Bridge.referenceEquals(_fc.ReferencedSymbol, Kusto.Language.Functions.Table) || Bridge.referenceEquals(_fc.ReferencedSymbol, Kusto.Language.Functions.ExternalTable) || Bridge.referenceEquals(_fc.ReferencedSymbol, Kusto.Language.Functions.MaterializedView) || Bridge.referenceEquals(_fc.ReferencedSymbol, Kusto.Language.Functions.Database) || Bridge.referenceEquals(_fc.ReferencedSymbol, Kusto.Language.Functions.Cluster)
}), Kusto.Language.Syntax.FunctionCallExpression);
try {
while ($t1.moveNext()) fc = $t1.Current, Bridge.referenceEquals(fc.ReferencedSymbol, Kusto.Language.Functions.Table) ? result |= (p = Bridge.as(fc.Parent, Kusto.Language.Syntax.PathExpression)) != null && Bridge.referenceEquals(p.Selector, fc) ? Kusto.Language.Symbols.FunctionBodyFacts.QualifiedTable : Kusto.Language.Symbols.FunctionBodyFacts.Table : Bridge.referenceEquals(fc.ReferencedSymbol, Kusto.Language.Functions.ExternalTable) ? result |= Kusto.Language.Symbols.FunctionBodyFacts.ExternalTable : Bridge.referenceEquals(fc.ReferencedSymbol, Kusto.Language.Functions.MaterializedView) ? result |= Kusto.Language.Symbols.FunctionBodyFacts.MaterializedView : Bridge.referenceEquals(fc.ReferencedSymbol, Kusto.Language.Functions.Database) ? result |= Kusto.Language.Symbols.FunctionBodyFacts.Database : Bridge.referenceEquals(fc.ReferencedSymbol, Kusto.Language.Functions.Cluster) && (result |= Kusto.Language.Symbols.FunctionBodyFacts.Cluster), isLiteral = fc.ArgumentList.Expressions.Count > 0 && fc.ArgumentList.Expressions.getItem$1(0).Element$1.IsLiteral, !isLiteral && isTabular && (result |= Kusto.Language.Symbols.FunctionBodyFacts.VariableReturn)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
isTabular && System.Linq.Enumerable.from(signature.Parameters).any(function(p1) {
return p1.IsTabular
}) && (result |= Kusto.Language.Symbols.FunctionBodyFacts.VariableReturn);
$t2 = Bridge.getEnumerator(body.GetDescendants(Kusto.Language.Syntax.Expression, function(fc1) {
return Bridge.is(fc1.ReferencedSymbol, Kusto.Language.Symbols.FunctionSymbol)
}), Kusto.Language.Syntax.Expression);
try {
while ($t2.moveNext()) fce = $t2.Current, facts = this.GetFunctionBodyFacts(fce), result |= facts
} finally {
Bridge.is($t2, System.IDisposable) && $t2.System$IDisposable$Dispose()
}
return result
},
GetFunctionBodyFacts: function(expr) {
var $t, fs, signature, functionCall, $arguments, argumentTypes;
if ((fs = Bridge.as(expr.ReferencedSymbol, Kusto.Language.Symbols.FunctionSymbol)) != null) {
if (signature = System.Array.getItem(fs.Signatures, 0, Kusto.Language.Symbols.Signature), signature.FunctionBodyFacts == null)
if (signature.ReturnKind === Kusto.Language.Symbols.ReturnTypeKind.Computed)
if ((functionCall = Bridge.as(expr, Kusto.Language.Syntax.FunctionCallExpression)) != null) {
$arguments = Kusto.Language.Binding.Binder.s_expressionListPool.AllocateFromPool();
argumentTypes = Kusto.Language.Binding.Binder.s_typeListPool.AllocateFromPool();
try {
this.GetArgumentsAndTypes(functionCall, $arguments, argumentTypes);
this.GetComputedSignatureResult(signature, $arguments, argumentTypes)
} finally {
Kusto.Language.Binding.Binder.s_expressionListPool.ReturnToPool($arguments);
Kusto.Language.Binding.Binder.s_typeListPool.ReturnToPool(argumentTypes)
}
} else this.GetComputedSignatureResult(signature, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Syntax.Expression).Instance, Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.TypeSymbol).Instance);
else signature.FunctionBodyFacts = Kusto.Language.Symbols.FunctionBodyFacts.None;
return $t = signature.FunctionBodyFacts, $t != null ? $t : Kusto.Language.Symbols.FunctionBodyFacts.None
}
return Kusto.Language.Symbols.FunctionBodyFacts.None
},
AddLetDeclarationToScope: function(scope, statement, diagnostics) {
diagnostics === void 0 && (diagnostics = null);
scope.AddSymbol(this.GetReferencedSymbol(statement.Name))
},
AddDeclarationsToLocalScope: function(declarations) {
for (var d, i = 0, n = declarations.Count; i < n; i = i + 1 | 0) d = declarations.getItem$1(i).Element$1, this.AddDeclarationToLocalScope(d.NameAndType.Name)
},
AddDeclarationsToLocalScope$1: function(declarations) {
for (var d, i = 0, n = declarations.Count; i < n; i = i + 1 | 0) d = declarations.getItem$1(i).Element$1, this.AddDeclarationToLocalScope(d.Name)
},
AddDeclarationToLocalScope: function(node) {
var s;
(s = node.ReferencedSymbol) != null && this._localScope.AddSymbol(s)
},
BindParameterDeclarations: function(parameters) {
for (var p, i = 0; i < parameters.Count; i = i + 1 | 0) p = parameters.getItem$1(i).Element$1, this.BindParameterDeclaration(p)
},
BindParameterDeclarations$1: function(parameters) {
for (var p, i = 0; i < parameters.Count; i = i + 1 | 0) p = parameters.getItem$1(i).Element$1, this.BindParameterDeclaration$1(p)
},
BindParameterDeclaration: function(node) {
this.BindParameterDeclaration$1(node.NameAndType)
},
BindParameterDeclaration$1: function(node) {
var name = node.Name.SimpleName,
type = this.GetTypeFromTypeExpression(node.Type),
symbol;
System.String.isNullOrEmpty(name) || (symbol = new Kusto.Language.Symbols.ParameterSymbol(name, type), this.SetSemanticInfo(node.Name, new Kusto.Language.Syntax.SemanticInfo.$ctor1(symbol, type)))
},
BindColumnDeclarations: function(parameters) {
for (var p, i = 0; i < parameters.Count; i = i + 1 | 0) p = parameters.getItem$1(i).Element$1, this.BindColumnDeclaration(p)
},
BindColumnDeclaration: function(node) {
var name = node.NameAndType.Name.SimpleName,
type = this.GetTypeFromTypeExpression(node.NameAndType.Type),
symbol;
System.String.isNullOrEmpty(name) || (symbol = new Kusto.Language.Symbols.ColumnSymbol(name, type), this.SetSemanticInfo(node.NameAndType.Name, new Kusto.Language.Syntax.SemanticInfo.$ctor1(symbol, type)))
},
GetScanStepTuple: function(node) {
var $t, columns = Kusto.Language.Binding.Binder.s_columnListPool.AllocateFromPool(),
elem, c;
try {
if (this.GetDeclaredAndInferredColumns$1(this._rowScope, columns), node.DeclareClause != null) {
$t = Bridge.getEnumerator(node.DeclareClause.Declarations, "GetEnumerator$1");
try {
while ($t.moveNext()) elem = $t.Current, (c = Bridge.as(elem.Element$1.NameAndType.Name.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null && columns.add(c)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
}
return new Kusto.Language.Symbols.TupleSymbol.$ctor1(columns, this._rowScope)
} finally {
Kusto.Language.Binding.Binder.s_columnListPool.ReturnToPool(columns)
}
},
BindStepDeclarations: function(node) {
var $t, stepTuple = this.GetScanStepTuple(node);
$t = Bridge.getEnumerator(node.Steps, "GetEnumerator$1");
try {
while ($t.moveNext()) {
var step = $t.Current,
name = step.Name.SimpleName,
local = new Kusto.Language.Symbols.VariableSymbol(name, stepTuple);
this.SetSemanticInfo(step.Name, new Kusto.Language.Syntax.SemanticInfo.$ctor1(local, stepTuple))
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
AddStepDeclarationsToLocalScope: function(node) {
var $t, stepTuple = this.GetScanStepTuple(node),
step;
$t = Bridge.getEnumerator(node.Steps, "GetEnumerator$1");
try {
while ($t.moveNext()) step = $t.Current, this.AddDeclarationToLocalScope(step.Name)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
AddTableColumns: function(symbol, columns) {
var $t, t, g, s;
do {
if (Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol)) {
t = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol);
this.GetDeclaredAndInferredColumns$1(t, columns);
break
}
if (Bridge.is(symbol, Kusto.Language.Symbols.GroupSymbol)) {
g = Bridge.cast(symbol, Kusto.Language.Symbols.GroupSymbol);
$t = Bridge.getEnumerator(g.Members, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) s = $t.Current, this.AddTableColumns(s, columns)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
break
}
} while (0)
},
AddTables: function(symbol, tables) {
var $t, t, g, m;
do {
if (Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol)) {
t = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol);
tables.add(t);
break
}
if (Bridge.is(symbol, Kusto.Language.Symbols.GroupSymbol)) {
g = Bridge.cast(symbol, Kusto.Language.Symbols.GroupSymbol);
$t = Bridge.getEnumerator(g.Members, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) m = $t.Current, this.AddTables(m, tables)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
break
}
} while (0)
},
GetFindColumnsTable: function(node) {
var tables = this.GetFindTables(node);
return this.GetTableOfColumnsUnifiedByName(tables)
},
GetFindTables: function(node) {
return node.InClause != null ? this.GetReferencedTables(node.InClause.Expressions) : this._currentDatabase.Tables
},
GetSearchColumnsTable: function(node) {
if (this._rowScope != null && node.InClause == null) return this._rowScope;
var tables = this.GetSearchTables(node);
return this.GetTableOfColumnsUnifiedByNameAndType(tables)
},
GetSearchTables: function(node) {
return node.InClause != null ? this.GetReferencedTables(node.InClause.Expressions) : this._rowScope != null ? System.Array.init([this._rowScope], Kusto.Language.Symbols.TableSymbol) : this._currentDatabase.Tables
},
GetReferencedTables: function(list) {
var $t, tables = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.TableSymbol).ctor),
x, ts, gs;
$t = Bridge.getEnumerator(list, "GetEnumerator$1");
try {
while ($t.moveNext()) x = $t.Current, (ts = Bridge.as(x.Element$1.ResultType, Kusto.Language.Symbols.TableSymbol)) != null ? tables.add(ts) : (gs = Bridge.as(x.Element$1.ResultType, Kusto.Language.Symbols.GroupSymbol)) != null && tables.AddRange(System.Linq.Enumerable.from(gs.Members).ofType(Kusto.Language.Symbols.TableSymbol))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return tables
},
GetColumnsInColumnList: function(expressions, columns, diagnostics) {
var $t, elem;
$t = Bridge.getEnumerator(expressions, "GetEnumerator$1");
try {
while ($t.moveNext()) elem = $t.Current, this.GetReferencedColumn(elem.Element$1, columns, diagnostics)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
GetReferencedColumn: function(expression, columns, diagnostics) {
var c;
(c = Bridge.as(this.GetReferencedSymbol(expression), Kusto.Language.Symbols.ColumnSymbol)) != null ? columns.add(c) : diagnostics.add(Kusto.Language.DiagnosticFacts.GetColumnExpected().WithLocation(expression))
},
GetReferencedColumnsInTree: function(node, columns) {
var nr, c, i, child, sn;
for ((nr = Bridge.as(node, Kusto.Language.Syntax.NameReference)) != null && (c = Bridge.as(this.GetReferencedSymbol(nr), Kusto.Language.Symbols.ColumnSymbol)) != null && (columns.contains(c) || columns.add(c)), i = 0; i < node.ChildCount; i = i + 1 | 0) child = node.GetChild(i), (sn = Bridge.as(child, Kusto.Language.Syntax.SyntaxNode)) != null && this.GetReferencedColumnsInTree(sn, columns)
},
CreateProjectionColumns$1: function(expressions, builder, diagnostics, isRename, isReplace, isReorder, isExtend, aggregates, doNotRepeat) {
var $t, elem;
isRename === void 0 && (isRename = !1);
isReplace === void 0 && (isReplace = !1);
isReorder === void 0 && (isReorder = !1);
isExtend === void 0 && (isExtend = !1);
aggregates === void 0 && (aggregates = !1);
doNotRepeat === void 0 && (doNotRepeat = !1);
$t = Bridge.getEnumerator(expressions, "GetEnumerator$1");
try {
while ($t.moveNext()) elem = $t.Current, this.CreateProjectionColumns(elem.Element$1, builder, diagnostics, isRename, isReplace, isReorder, isExtend, aggregates, doNotRepeat, void 0)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
CreateProjectionColumns: function(expression, builder, diagnostics, isRename, isReplace, isReorder, isExtend, aggregates, doNotRepeat, columnType) {
var $t, $t1, $t2, $t3, $t4, $t5, $t6, col, type, oe, n, cs, n1, tu, i, fs1, c, c1, tupleType, i1, nameDecl, name, fs11, i2, nameDecl1, f, ts, fs, c2, name1, s, c3, rs, column, group, members, m, c4, g, name2;
if (isRename === void 0 && (isRename = !1), isReplace === void 0 && (isReplace = !1), isReorder === void 0 && (isReorder = !1), isExtend === void 0 && (isExtend = !1), aggregates === void 0 && (aggregates = !1), doNotRepeat === void 0 && (doNotRepeat = !1), columnType === void 0 && (columnType = null), oe = Bridge.as(expression, Kusto.Language.Syntax.OrderedExpression), oe != null && (expression = oe.Expression), isRename) {
do {
if (Bridge.is(expression, Kusto.Language.Syntax.SimpleNamedExpression)) {
n = Bridge.cast(expression, Kusto.Language.Syntax.SimpleNamedExpression);
(cs = Bridge.as(this.GetReferencedSymbol(n.Expression), Kusto.Language.Symbols.ColumnSymbol)) != null ? (col = builder.Rename(cs.Name, n.Name.SimpleName, diagnostics, n.Name), col != null && this.SetSemanticInfo(n.Name, Kusto.Language.Binding.Binder.CreateSemanticInfo(col))) : diagnostics.add(Kusto.Language.DiagnosticFacts.GetColumnExpected().WithLocation(n.Expression));
break
}
diagnostics.add(Kusto.Language.DiagnosticFacts.GetRenameAssignmentExpected().WithLocation(expression));
break
} while (0)
} else
do {
if (Bridge.is(expression, Kusto.Language.Syntax.SimpleNamedExpression)) {
if (n1 = Bridge.cast(expression, Kusto.Language.Syntax.SimpleNamedExpression), (tu = Bridge.as(this.GetResultType(n1.Expression), Kusto.Language.Symbols.TupleSymbol)) != null)
for (col = new Kusto.Language.Symbols.ColumnSymbol(n1.Name.SimpleName, columnType || System.Array.getItem(tu.Columns, 0, Kusto.Language.Symbols.ColumnSymbol).Type), builder.Declare(col, diagnostics, n1.Name, !0), this.SetSemanticInfo(n1.Name, Kusto.Language.Binding.Binder.CreateSemanticInfo(col)), doNotRepeat && builder.DoNotAdd(System.Array.getItem(tu.Columns, 0, Kusto.Language.Symbols.ColumnSymbol)), i = 1; i < System.Array.getCount(tu.Members, Kusto.Language.Symbols.Symbol); i = i + 1 | 0)(fs1 = Bridge.as(this.GetReferencedSymbol(n1.Expression), Kusto.Language.Symbols.FunctionSymbol)) != null ? this.AddFunctionTupleResultColumn(fs1, System.Array.getItem(tu.Columns, i, Kusto.Language.Symbols.ColumnSymbol), builder, doNotRepeat, aggregates) : builder.Add(System.Array.getItem(tu.Columns, i, Kusto.Language.Symbols.ColumnSymbol), void 0, !1, doNotRepeat);
else(c = Bridge.as(n1.Expression.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null ? (col = new Kusto.Language.Symbols.ColumnSymbol(n1.Name.SimpleName, columnType || c.Type), builder.Declare(col, diagnostics, n1.Name, !0), this.SetSemanticInfo(n1.Name, Kusto.Language.Binding.Binder.CreateSemanticInfo(col)), doNotRepeat && builder.DoNotAdd(c)) : (col = new Kusto.Language.Symbols.ColumnSymbol(n1.Name.SimpleName, columnType || this.GetResultTypeOrError(n1.Expression)), builder.Declare(col, diagnostics, n1.Name, isExtend), this.SetSemanticInfo(n1.Name, Kusto.Language.Binding.Binder.CreateSemanticInfo(col)));
break
}
if (Bridge.is(expression, Kusto.Language.Syntax.CompoundNamedExpression)) {
if (c1 = Bridge.cast(expression, Kusto.Language.Syntax.CompoundNamedExpression), (tupleType = Bridge.as(this.GetResultTypeOrError(c1.Expression), Kusto.Language.Symbols.TupleSymbol)) != null) {
for (i1 = 0; i1 < System.Array.getCount(tupleType.Columns, Kusto.Language.Symbols.ColumnSymbol); i1 = i1 + 1 | 0) col = System.Array.getItem(tupleType.Columns, i1, Kusto.Language.Symbols.ColumnSymbol), type = columnType || col.Type, i1 < c1.Names.Names.Count ? (nameDecl = c1.Names.Names.getItem$1(i1).Element$1, name = nameDecl.SimpleName, col = new Kusto.Language.Symbols.ColumnSymbol(name, type), builder.Declare(col, diagnostics, nameDecl, isExtend), this.SetSemanticInfo(nameDecl, Kusto.Language.Binding.Binder.CreateSemanticInfo(col)), doNotRepeat && builder.DoNotAdd(System.Array.getItem(tupleType.Columns, i1, Kusto.Language.Symbols.ColumnSymbol))) : (fs11 = Bridge.as(this.GetReferencedSymbol(c1.Expression), Kusto.Language.Symbols.FunctionSymbol)) != null ? this.AddFunctionTupleResultColumn(fs11, col, builder, doNotRepeat, aggregates) : builder.Add(col, void 0, isExtend, doNotRepeat);
for (i2 = System.Array.getCount(tupleType.Members, Kusto.Language.Symbols.Symbol); i2 < c1.Names.Names.Count; i2 = i2 + 1 | 0) nameDecl1 = c1.Names.Names.getItem$1(i2), diagnostics.add(Kusto.Language.DiagnosticFacts.GetTheNameDoesNotHaveCorrespondingExpression().WithLocation(nameDecl1))
} else diagnostics.add(Kusto.Language.DiagnosticFacts.GetTheExpressionDoesNotHaveMultipleValues().WithLocation(c1.Names));
break
}
if (Bridge.is(expression, Kusto.Language.Syntax.FunctionCallExpression)) {
if (f = Bridge.cast(expression, Kusto.Language.Syntax.FunctionCallExpression), (ts = Bridge.as(this.GetResultType(f), Kusto.Language.Symbols.TupleSymbol)) != null && (fs = Bridge.as(this.GetReferencedSymbol(f), Kusto.Language.Symbols.FunctionSymbol)) != null) {
$t = Bridge.getEnumerator(ts.Members, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) c2 = Bridge.cast($t.Current, Kusto.Language.Symbols.ColumnSymbol), this.AddFunctionTupleResultColumn(fs, c2, builder, doNotRepeat, aggregates)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} else name1 = Kusto.Language.Binding.Binder.GetFunctionResultName(f, null, this._rowScope), col = new Kusto.Language.Symbols.ColumnSymbol(($t1 = name1, $t1 != null ? $t1 : "Column1"), columnType || this.GetResultTypeOrError(f)), builder.Add(col, ($t2 = name1, $t2 != null ? $t2 : "Column"), isExtend, !1);
break
}
if (Bridge.is(expression, Kusto.Language.Syntax.StarExpression)) {
s = Bridge.cast(expression, Kusto.Language.Syntax.StarExpression);
$t3 = Bridge.getEnumerator(this.GetDeclaredAndInferredColumns(this._rowScope), Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t3.moveNext()) c3 = $t3.Current, builder.Add(c3, void 0, !0, doNotRepeat)
} finally {
Bridge.is($t3, System.IDisposable) && $t3.System$IDisposable$Dispose()
}
break
}
if (rs = this.GetReferencedSymbol(expression), (column = Bridge.as(rs, Kusto.Language.Symbols.ColumnSymbol)) != null) builder.Declare(column.WithType(columnType || column.Type), diagnostics, expression, isReplace), doNotRepeat && builder.DoNotAdd(column);
else if ((group = Bridge.as(rs, Kusto.Language.Symbols.GroupSymbol)) != null && isReorder) {
members = Kusto.Language.Binding.Binder.s_symbolListPool.AllocateFromPool();
try {
oe != null && oe.Ordering != null ? oe.Ordering.AscOrDescKeyword.Kind === Kusto.Language.Syntax.SyntaxKind.DescKeyword ? members.AddRange(System.Linq.Enumerable.from(group.Members).orderByDescending(function(m) {
return m.Name
})) : members.AddRange(System.Linq.Enumerable.from(group.Members).orderBy(function(m) {
return m.Name
})) : members.AddRange(group.Members);
$t4 = Bridge.getEnumerator(members);
try {
while ($t4.moveNext()) m = $t4.Current, (c4 = Bridge.as(m, Kusto.Language.Symbols.ColumnSymbol)) != null && builder.Add(c4, void 0, !1, !0)
} finally {
Bridge.is($t4, System.IDisposable) && $t4.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Binding.Binder.s_symbolListPool.ReturnToPool(members)
}
} else(g = Bridge.as(this.GetResultType(expression), Kusto.Language.Symbols.GroupSymbol)) != null ? diagnostics.add(Kusto.Language.DiagnosticFacts.GetTheExpressionRefersToMoreThanOneColumn().WithLocation(expression)) : (type = this.GetResultTypeOrError(expression), type.IsError || type.IsScalar ? (name2 = Kusto.Language.Binding.Binder.GetExpressionResultName(expression, null), col = new Kusto.Language.Symbols.ColumnSymbol(($t5 = name2, $t5 != null ? $t5 : "Column1"), columnType || this.GetResultTypeOrError(expression)), builder.Add(col, ($t6 = name2, $t6 != null ? $t6 : "Column"), isExtend, !1)) : diagnostics.add(Kusto.Language.DiagnosticFacts.GetScalarTypeExpected().WithLocation(expression)));
break
} while (0)
},
AddFunctionTupleResultColumn: function($function, column, builder, doNotRepeat) {
if (builder.CanAdd(column)) {
var prefix = $function.ResultNamePrefix;
prefix != null ? builder.Add(column.WithName(($function.ResultNamePrefix || "") + "_" + (column.Name || "")), void 0, !1, doNotRepeat) : builder.Add(column, void 0, !1, doNotRepeat)
}
},
GetTypeFromTypeExpression: function(typeExpression, diagnostics) {
return diagnostics === void 0 && (diagnostics = null), Kusto.Language.Binding.Binder.GetDeclaredType(typeExpression, diagnostics, this)
},
GetTypeOfType: function(typeofLiteral) {
return Bridge.as(this.GetReferencedSymbol(typeofLiteral), Kusto.Language.Symbols.TypeSymbol) || Kusto.Language.Symbols.ErrorSymbol.Instance
},
IsTabular: function(expr) {
return Kusto.Language.Binding.Binder.IsTabular(this.GetResultTypeOrError(expr))
},
IsColumn: function(expr) {
return Bridge.is(this.GetReferencedSymbol(expr), Kusto.Language.Symbols.ColumnSymbol)
},
CheckQueryParameters: function(parameters, queryParameters, diagnostics) {
var names = Kusto.Language.Binding.Binder.s_stringSetPool.AllocateFromPool(),
i, n;
try {
for (i = 0, n = parameters.Count; i < n; i = i + 1 | 0) this.CheckQueryParameter$1(parameters.getItem$1(i), queryParameters, names, diagnostics)
} finally {
Kusto.Language.Binding.Binder.s_stringSetPool.ReturnToPool(names)
}
},
CheckQueryParameters$1: function(parameters, queryParameters, diagnostics) {
var names = Kusto.Language.Binding.Binder.s_stringSetPool.AllocateFromPool(),
i, n;
try {
for (i = 0, n = parameters.Count; i < n; i = i + 1 | 0) this.CheckQueryParameter$1(parameters.getItem$1(i).Element$1, queryParameters, names, diagnostics)
} finally {
Kusto.Language.Binding.Binder.s_stringSetPool.ReturnToPool(names)
}
},
CheckQueryParameter$1: function(parameter, queryParameters, namesAlreadySpecified, diagnostics) {
var $t, name = parameter.Name.SimpleName,
info, n;
if (!System.String.isNullOrEmpty(name))
if (info = Kusto.Language.Binding.Binder.GetQueryParameterInfo(name, queryParameters), info != null) {
$t = Bridge.getEnumerator(info.Names, System.String);
try {
while ($t.moveNext())
if (n = $t.Current, !info.IsRepeatable)
if (namesAlreadySpecified.contains(n)) {
diagnostics.add(Kusto.Language.DiagnosticFacts.GetParameterAlreadySpecified(name).WithLocation(parameter.Name));
break
} else namesAlreadySpecified.add(n)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
this.CheckQueryParameter(parameter, info, diagnostics)
} else diagnostics.add(Kusto.Language.DiagnosticFacts.GetUnknownParameterName(name).WithLocation(parameter.Name))
},
CheckQueryParameter: function(parameter, info, diagnostics) {
if (!this.IsAnyQueryParameterKind(parameter, info)) {
var valueInfo = System.Array.getItem(info.ValueInfos, 0, Kusto.Language.Binding.Binder.QueryParameterValueInfo);
switch (valueInfo.Kind) {
case Kusto.Language.Binding.Binder.QueryParameterKind.Fixed:
this.CheckIsType(parameter.Expression, valueInfo.FixedType, Kusto.Language.Binding.Conversion.Compatible, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Integer:
this.CheckIsInteger(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Number:
this.CheckIsNumber(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.RealOrDecimal:
this.CheckIsRealOrDecimal(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Scalar:
this.CheckIsScalar(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.StringOrDynamic:
this.CheckIsStringOrDynamic(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Summable:
this.CheckIsSummable(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.StringLiteral:
this.CheckIsLiteral(parameter.Expression, diagnostics);
this.CheckIsExactType(parameter.Expression, Kusto.Language.Symbols.ScalarTypes.String, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.BoolLiteral:
this.CheckIsLiteral(parameter.Expression, diagnostics);
this.CheckIsExactType(parameter.Expression, Kusto.Language.Symbols.ScalarTypes.Bool, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Column:
this.CheckIsColumn(parameter.Expression, diagnostics);
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Identifier:
this.CheckIsTokenLiteral(parameter.Expression, valueInfo.Values, valueInfo.CaseSensitive, diagnostics)
}
valueInfo.Kind !== Kusto.Language.Binding.Binder.QueryParameterKind.Identifier && valueInfo.Values != null && System.Array.getCount(valueInfo.Values, System.Object) > 0 && (this.CheckIsLiteral(parameter.Expression, diagnostics), this.CheckLiteralValue(parameter.Expression, valueInfo.Values, valueInfo.CaseSensitive, diagnostics))
}
},
IsAnyQueryParameterKind: function(parameter, info) {
var $t, type = this.GetResultTypeOrError(parameter.Expression),
valueInfo;
$t = Bridge.getEnumerator(info.ValueInfos, Kusto.Language.Binding.Binder.QueryParameterValueInfo);
try {
while ($t.moveNext())
if (valueInfo = $t.Current, this.IsQueryParameterKind(parameter, valueInfo)) return !0
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !1
},
IsQueryParameterKind: function(parameter, valueInfo) {
var type = this.GetResultTypeOrError(parameter.Expression);
switch (valueInfo.Kind) {
case Kusto.Language.Binding.Binder.QueryParameterKind.Fixed:
if (!this.IsType(parameter.Expression, valueInfo.FixedType, Kusto.Language.Binding.Conversion.Compatible)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Integer:
if (!Kusto.Language.Binding.Binder.IsInteger(type)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Number:
if (!Kusto.Language.Binding.Binder.IsNumber(type)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.RealOrDecimal:
if (!Kusto.Language.Binding.Binder.IsRealOrDecimal(type)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Scalar:
if (!type.IsScalar) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.StringOrDynamic:
if (!Kusto.Language.Binding.Binder.IsStringOrDynamic(type)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Summable:
if (!Kusto.Language.Binding.Binder.IsSummable(type)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.StringLiteral:
if (!(parameter.Expression.IsLiteral && this.IsType(parameter.Expression, Kusto.Language.Symbols.ScalarTypes.String))) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.BoolLiteral:
if (!(parameter.Expression.IsLiteral && this.IsType(parameter.Expression, Kusto.Language.Symbols.ScalarTypes.Bool))) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Column:
if (!Bridge.is(this.GetReferencedSymbol(parameter.Expression), Kusto.Language.Symbols.ColumnSymbol)) return !1;
break;
case Kusto.Language.Binding.Binder.QueryParameterKind.Identifier:
if (!this.IsTokenLiteral(parameter.Expression, valueInfo.Values, valueInfo.CaseSensitive)) return !1
}
return valueInfo.Kind !== Kusto.Language.Binding.Binder.QueryParameterKind.Identifier && valueInfo.Values != null && System.Array.getCount(valueInfo.Values, System.Object) > 0 && (!parameter.Expression.IsLiteral || !this.IsLiteralValue(parameter.Expression, valueInfo.Values, valueInfo.CaseSensitive)) ? !1 : !0
},
CheckDataValueTypes: function(expressions, columns, diagnostics) {
var i, n, expr;
for (columns.Count > 0 && expressions.Count % columns.Count != 0 && diagnostics.add(Kusto.Language.DiagnosticFacts.GetIncorrectNumberOfDataValues(columns.Count).WithLocation(expressions)), i = 0, n = expressions.Count; i < n; i = i + 1 | 0) expr = expressions.getItem$1(i).Element$1, this.CheckIsScalar(expr, diagnostics)
},
CheckIsScalar: function(expression, diagnostics, resultType) {
if (resultType === void 0 && (resultType = null), resultType == null && (resultType = this.GetResultType(expression)), resultType != null) {
if (resultType.IsScalar) return !0;
resultType.IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetScalarTypeExpected().WithLocation(expression))
}
return !1
},
CheckIsInteger: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsInteger(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeInteger().WithLocation(expression)), !1)
},
CheckIsRealOrDecimal: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsRealOrDecimal(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeRealOrDecimal().WithLocation(expression)), !1)
},
CheckIsIntegerOrDynamic: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsIntegerOrDynamic(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeIntegerOrDynamic().WithLocation(expression)), !1)
},
CheckIsStringOrDynamic: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsStringOrDynamic(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustHaveType([Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ScalarTypes.Dynamic]).WithLocation(expression)), !1)
},
CheckIsNumber: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsNumber(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeNumeric().WithLocation(expression)), !1)
},
CheckIsSummable: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsSummable(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeSummable().WithLocation(expression)), !1)
},
CheckIsExactType: function(expression, type, diagnostics) {
return this.CheckIsType(expression, type, Kusto.Language.Binding.Conversion.None, diagnostics)
},
CheckIsTypeOrDynamic: function(expression, type, canPromote, diagnostics) {
var exprType = this.GetResultTypeOrError(expression);
return Kusto.Language.Binding.Binder.SymbolsAssignable(type, exprType, canPromote ? Kusto.Language.Binding.Conversion.Promotable : Kusto.Language.Binding.Conversion.None) || Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Dynamic, exprType) ? !0 : (exprType.IsError || (Kusto.Language.Binding.Binder.SymbolsAssignable(Kusto.Language.Symbols.ScalarTypes.Dynamic, type) ? diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustHaveType([type]).WithLocation(expression)) : diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustHaveType([type, Kusto.Language.Symbols.ScalarTypes.Dynamic]).WithLocation(expression))), !1)
},
IsType: function(expression, type, conversionKind) {
conversionKind === void 0 && (conversionKind = 0);
var exprType = this.GetResultTypeOrError(expression);
return Kusto.Language.Binding.Binder.SymbolsAssignable(type, exprType, conversionKind)
},
CheckIsType: function(expression, type, conversionKind, diagnostics) {
return this.IsType(expression, type, conversionKind) ? !0 : (this.GetResultTypeOrError(expression).IsError || type.IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustHaveType([type]).WithLocation(expression)), !1)
},
CheckIsNotType: function(expression, type, diagnostics) {
var exprType = this.GetResultTypeOrError(expression);
return Bridge.referenceEquals(exprType, Kusto.Language.Symbols.ScalarTypes.Unknown) ? !0 : Kusto.Language.Binding.Binder.SymbolsAssignable(type, exprType) ? (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetTypeNotAllowed(type).WithLocation(expression)), !1) : !0
},
CheckIsIntervalType: function(expression, rangeType, diagnostics) {
var info = this.GetBinaryOperatorInfo(Kusto.Language.Symbols.OperatorKind.Add, expression, rangeType, expression, this.GetResultTypeOrError(expression), expression);
return info.ReferencedSymbol != null && Kusto.Language.Binding.Binder.SymbolsAssignable(rangeType, info.ResultType) ? !0 : (rangeType.IsError || this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetTypeIsNotIntervalType(this.GetResultTypeOrError(expression), rangeType).WithLocation(expression)), !1)
},
IsLiteralOrName: function(expression) {
return Bridge.is(expression, Kusto.Language.Syntax.LiteralExpression) || Bridge.is(expression, Kusto.Language.Syntax.CompoundStringLiteralExpression) || expression.Kind === Kusto.Language.Syntax.SyntaxKind.DynamicExpression || expression.Kind === Kusto.Language.Syntax.SyntaxKind.NameReference
},
CheckIsIdentifierNameDeclaration: function(name, diagnostics) {
return Bridge.is(name.Name, Kusto.Language.Syntax.TokenName) ? !0 : (diagnostics.add(Kusto.Language.DiagnosticFacts.GetIdentifierNameOnly().WithLocation(name)), !1)
},
CheckIsLiteralOrName: function(expression, diagnostics) {
return this.IsLiteralOrName(expression) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeConstantOrIdentifier().WithLocation(expression)), !1)
},
CheckIsTabular: function(expression, diagnostics, resultType) {
if (resultType === void 0 && (resultType = null), resultType = resultType || this.GetResultType(expression), resultType != null) {
if (resultType.IsTabular) return !0;
resultType.IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetTableExpected().WithLocation(expression))
}
return !1
},
CheckIsSingleColumnTable: function(expression, diagnostics, resultType) {
if (resultType === void 0 && (resultType = null), resultType = resultType || this.GetResultType(expression), resultType != null) {
var table = Bridge.as(resultType, Kusto.Language.Symbols.TableSymbol);
if (table != null && System.Array.getCount(table.Columns, Kusto.Language.Symbols.ColumnSymbol) === 1) return !0;
resultType.IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetSingleColumnTableExpected().WithLocation(expression))
}
return !1
},
CheckIsDatabase: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsDatabase(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetDatabaseExpected().WithLocation(expression)), !1)
},
CheckIsCluster: function(expression, diagnostics) {
return Kusto.Language.Binding.Binder.IsCluster(this.GetResultTypeOrError(expression)) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetClusterExpected().WithLocation(expression)), !1)
},
CheckIsColumn: function(expression, diagnostics) {
return Bridge.is(this.GetReferencedSymbol(expression), Kusto.Language.Symbols.ColumnSymbol) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetColumnExpected().WithLocation(expression)), !1)
},
CheckIsLiteral: function(expression, diagnostics) {
return expression.IsLiteral ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeLiteral().WithLocation(expression)), !1)
},
CheckIsLiteralValue: function(expression, diagnostics) {
return expression.IsLiteral && expression.Kind !== Kusto.Language.Syntax.SyntaxKind.TokenLiteralExpression ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeLiteralScalarValue().WithLocation(expression)), !1)
},
CheckLiteralStringNotEmpty: function(expression, diagnostics) {
var $t, result = this.GetResultTypeOrError(expression),
value;
if (!result.IsError && expression.IsLiteral) {
if (value = ($t = expression.LiteralValue) != null ? Bridge.toString($t) : null, !System.String.isNullOrEmpty(value)) return !0;
diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustNotBeEmpty().WithLocation(expression))
}
return !1
},
IsTokenLiteral: function(expression, values, caseSensitive) {
if (expression.Kind === Kusto.Language.Syntax.SyntaxKind.TokenLiteralExpression) {
if (values != null && System.Array.getCount(values, System.Object) > 0) {
var value = Kusto.Language.Utils.ConvertHelper.ChangeType(expression.LiteralValue, System.Array.getItem(values, 0, System.Object));
return Kusto.Language.Binding.Binder.Contains(values, value, caseSensitive)
}
return !0
}
return !1
},
CheckIsTokenLiteral: function(expression, values, caseSensitive, diagnostics) {
var result = this.GetResultTypeOrError(expression);
if (!result.IsError) {
if (this.IsTokenLiteral(expression, values, caseSensitive)) return !0;
diagnostics.add(Kusto.Language.DiagnosticFacts.GetTokenExpected$1(System.Linq.Enumerable.from(values).select(function(v) {
return Bridge.toString(v)
}).toList(System.String)).WithLocation(expression))
}
return !1
},
CheckIsToken: function(token, values, caseSensitive, diagnostics) {
var value = Kusto.Language.Utils.ConvertHelper.ChangeType(token.Text, System.Array.getItem(values, 0, System.Object));
return Kusto.Language.Binding.Binder.Contains(values, value, caseSensitive) ? !0 : (token.HasSyntaxDiagnostics || diagnostics.add(Kusto.Language.DiagnosticFacts.GetTokenExpected$1(System.Linq.Enumerable.from(values).select(function(v) {
return Bridge.toString(v)
}).toList(System.String)).WithLocation(token)), !1)
},
IsLiteralValue: function(expression, values, caseSensitive) {
if (!expression.IsLiteral) return !1;
var value = Kusto.Language.Utils.ConvertHelper.ChangeType(expression.LiteralValue, System.Array.getItem(values, 0, System.Object));
return Kusto.Language.Binding.Binder.Contains(values, value, caseSensitive)
},
CheckLiteralValue: function(expression, values, caseSensitive, diagnostics) {
var result = this.GetResultTypeOrError(expression);
if (!result.IsError) {
if (this.IsLiteralValue(expression, values, caseSensitive)) return !0;
diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustHaveValue$1(System.Object, values).WithLocation(expression))
}
return !1
},
CheckIsConstant: function(expression, diagnostics) {
return this.GetIsConstant(expression) || Bridge.is(expression.ReferencedSymbol, Kusto.Language.Symbols.ParameterSymbol) ? !0 : (this.GetResultTypeOrError(expression).IsError || diagnostics.add(Kusto.Language.DiagnosticFacts.GetExpressionMustBeConstant().WithLocation(expression)), !1)
},
CheckSignature: function(signature, $arguments, argumentTypes, location, dx) {
var $t, argCount = System.Array.getCount($arguments, Kusto.Language.Syntax.Expression),
initialDxCount = dx.Count,
namedArgumentsAllowed, hadOutOfOrderNamedArgument, reportedUnnamedArgument, i, orderedParameter, argumentParameters, i1, parameter, iArg;
if (signature.IsValidArgumentCount(argCount) || (signature.HasRepeatableParameters ? argCount < signature.MinArgumentCount || argCount > signature.MaxArgumentCount ? dx.add(Kusto.Language.DiagnosticFacts.GetFunctionExpectsArgumentCountRange(signature.Symbol.Name, signature.MinArgumentCount, signature.MaxArgumentCount).WithLocation(location)) : dx.add(Kusto.Language.DiagnosticFacts.GetFunctionHasIncorrectNumberOfArguments().WithLocation(location)) : argCount !== System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) && dx.add(Kusto.Language.DiagnosticFacts.GetFunctionExpectsArgumentCountExact(signature.Symbol.Name, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter)).WithLocation(location))), namedArgumentsAllowed = this.NamedArgumentsAllowed(signature), namedArgumentsAllowed && dx.Count === initialDxCount)
for (hadOutOfOrderNamedArgument = !1, reportedUnnamedArgument = !1, i = 0; i < argCount; i = i + 1 | 0) {
var argument = System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression),
simpleNamed = Bridge.as(argument, Kusto.Language.Syntax.SimpleNamedExpression),
isNamed = simpleNamed != null,
namedParameter = isNamed ? signature.GetParameter(simpleNamed.Name.SimpleName) : null;
isNamed && namedParameter == null && dx.add(Kusto.Language.DiagnosticFacts.GetUnknownArgumentName().WithLocation(simpleNamed.Name));
isNamed && !hadOutOfOrderNamedArgument ? (orderedParameter = i < System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) ? System.Array.getItem(signature.Parameters, i, Kusto.Language.Symbols.Parameter) : null, hadOutOfOrderNamedArgument = !Bridge.referenceEquals(orderedParameter, namedParameter)) : isNamed || !hadOutOfOrderNamedArgument || reportedUnnamedArgument || (dx.add(Kusto.Language.DiagnosticFacts.GetUnnamedArgumentAfterOutofOrderNamedArgument().WithLocation(argument)), reportedUnnamedArgument = !0)
}
argumentParameters = Kusto.Language.Binding.Binder.s_parameterListPool.AllocateFromPool();
try {
if (signature.GetArgumentParameters$1($arguments, argumentParameters), dx.Count === initialDxCount)
for (i1 = 0; i1 < argCount; i1 = i1 + 1 | 0) this.CheckArgument(signature, argumentParameters, $arguments, argumentTypes, i1, dx);
if (namedArgumentsAllowed && dx.Count === initialDxCount) {
$t = Bridge.getEnumerator(signature.Parameters, Kusto.Language.Symbols.Parameter);
try {
while ($t.moveNext()) parameter = $t.Current, parameter.IsOptional || (iArg = argumentParameters.indexOf(parameter), iArg < 0 && dx.add(Kusto.Language.DiagnosticFacts.GetMissingArgumentForParameter(parameter.Name).WithLocation(location)))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
}
} finally {
Kusto.Language.Binding.Binder.s_parameterListPool.ReturnToPool(argumentParameters)
}
},
NamedArgumentsAllowed: function(signature) {
var fn = Bridge.as(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol);
return fn != null && !this._globals.IsBuiltInFunction(fn)
},
AllowLooseParameterMatching: function(signature) {
var fs;
return (fs = Bridge.as(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol)) != null && (this._globals.IsDatabaseFunction(fs) || System.Array.getItem(fs.Signatures, 0, Kusto.Language.Symbols.Signature).Declaration != null)
},
CheckArgument: function(signature, argumentParameters, $arguments, argumentTypes, argumentIndex, diagnostics) {
var argument = System.Array.getItem($arguments, argumentIndex, Kusto.Language.Syntax.Expression),
argumentType = System.Array.getItem(argumentTypes, argumentIndex, Kusto.Language.Symbols.TypeSymbol),
parameter = System.Array.getItem(argumentParameters, argumentIndex, Kusto.Language.Symbols.Parameter),
cn, sn, commonType, commonType1, commonType2, commonType3;
if (parameter != null)
if (Bridge.is(argument, Kusto.Language.Syntax.StarExpression) && signature.Symbol.Kind !== Kusto.Language.Symbols.SymbolKind.Operator) parameter.ArgumentKind !== Kusto.Language.Symbols.ArgumentKind.Star ? diagnostics.add(Kusto.Language.DiagnosticFacts.GetStarExpressionNotAllowed().WithLocation(argument)) : argumentIndex < (System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) - 1 | 0) && diagnostics.add(Kusto.Language.DiagnosticFacts.GetStarExpressionMustBeLastArgument().WithLocation(argument));
else {
(cn = Bridge.as(argument, Kusto.Language.Syntax.CompoundNamedExpression)) != null && diagnostics.add(Kusto.Language.DiagnosticFacts.GetCompoundNamedArgumentsNotSupported().WithLocation(cn.Names));
(sn = Bridge.as(argument, Kusto.Language.Syntax.SimpleNamedExpression)) != null && (argument = sn.Expression);
switch (parameter.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
switch (this.GetParameterMatchKind(signature, argumentParameters, $arguments, argumentTypes, parameter, argument, argumentType)) {
case Kusto.Language.Binding.Binder.MatchKind.Compatible:
case Kusto.Language.Binding.Binder.MatchKind.None:
this.AllowLooseParameterMatching(signature) || diagnostics.add(Kusto.Language.DiagnosticFacts.GetTypeExpected$1(parameter.DeclaredTypes).WithLocation(argument))
}
break;
case Kusto.Language.Symbols.ParameterTypeKind.Scalar:
this.CheckIsScalar(argument, diagnostics, argumentType);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Integer:
this.CheckIsInteger(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.RealOrDecimal:
this.CheckIsRealOrDecimal(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.IntegerOrDynamic:
this.CheckIsIntegerOrDynamic(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic:
this.CheckIsStringOrDynamic(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Number:
this.CheckIsNumber(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Summable:
this.CheckIsSummable(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotBool:
this.CheckIsScalar(argument, diagnostics) && this.CheckIsNotType(argument, Kusto.Language.Symbols.ScalarTypes.Bool, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotRealOrBool:
this.CheckIsScalar(argument, diagnostics) && (this.CheckIsNotType(argument, Kusto.Language.Symbols.ScalarTypes.Real, diagnostics), this.CheckIsNotType(argument, Kusto.Language.Symbols.ScalarTypes.Bool, diagnostics));
break;
case Kusto.Language.Symbols.ParameterTypeKind.NotDynamic:
this.CheckIsScalar(argument, diagnostics) && this.CheckIsNotType(argument, Kusto.Language.Symbols.ScalarTypes.Dynamic, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
this.CheckIsTabular(argument, diagnostics, argumentType);
break;
case Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable:
this.CheckIsSingleColumnTable(argument, diagnostics, argumentType);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Database:
this.CheckIsDatabase(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Cluster:
this.CheckIsCluster(argument, diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Parameter0:
this.CheckIsExactType(argument, System.Array.getItem(argumentTypes, 0, Kusto.Language.Symbols.TypeSymbol), diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Parameter1:
this.CheckIsExactType(argument, System.Array.getItem(argumentTypes, 1, Kusto.Language.Symbols.TypeSymbol), diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.Parameter2:
this.CheckIsExactType(argument, System.Array.getItem(argumentTypes, 2, Kusto.Language.Symbols.TypeSymbol), diagnostics);
break;
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalar:
this.CheckIsScalar(argument, diagnostics) && (commonType = Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes), commonType != null && this.CheckIsType(argument, commonType, Kusto.Language.Binding.Conversion.Promotable, diagnostics));
break;
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic:
this.CheckIsScalar(argument, diagnostics) && (commonType1 = Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes), commonType1 != null && this.CheckIsTypeOrDynamic(argument, commonType1, !0, diagnostics));
break;
case Kusto.Language.Symbols.ParameterTypeKind.CommonNumber:
this.CheckIsNumber(argument, diagnostics) && (commonType2 = Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes), commonType2 != null && this.CheckIsType(argument, commonType2, Kusto.Language.Binding.Conversion.Promotable, diagnostics));
break;
case Kusto.Language.Symbols.ParameterTypeKind.CommonSummable:
this.CheckIsSummable(argument, diagnostics) && (commonType3 = Kusto.Language.Binding.Binder.GetCommonArgumentType(argumentParameters, argumentTypes), commonType3 != null && this.CheckIsType(argument, commonType3, Kusto.Language.Binding.Conversion.Promotable, diagnostics))
}
switch (parameter.ArgumentKind) {
case Kusto.Language.Symbols.ArgumentKind.Column:
this.CheckIsColumn(argument, diagnostics);
break;
case Kusto.Language.Symbols.ArgumentKind.Constant:
this.CheckIsConstant(argument, diagnostics);
break;
case Kusto.Language.Symbols.ArgumentKind.Literal:
this.CheckIsLiteral(argument, diagnostics) && System.Array.getCount(parameter.Values, System.Object) > 0 && this.CheckLiteralValue(argument, parameter.Values, parameter.IsCaseSensitive, diagnostics);
break;
case Kusto.Language.Symbols.ArgumentKind.LiteralNotEmpty:
this.CheckIsLiteral(argument, diagnostics) && this.CheckLiteralStringNotEmpty(argument, diagnostics)
}
}
}
}
});
Bridge.define("Kusto.Language.Syntax.SyntaxVisitor");
Bridge.define("Kusto.Language.Binding.Binder.MatchKind", {
$kind: "nested enum",
statics: {
fields: {
None: 0,
Unknown: 1,
NotType: 2,
Scalar: 3,
Summable: 4,
Number: 5,
Compatible: 6,
Promoted: 7,
Tabular: 8,
Table: 9,
Database: 10,
Cluster: 11,
OneOfTwo: 12,
Exact: 13
}
}
});
Bridge.define("Kusto.Language.Syntax.SyntaxVisitor$1", function() {
return {}
});
Bridge.define("Kusto.Language.Binding.Binder.QueryParameterInfo", {
$kind: "nested class",
props: {
Names: null,
ValueInfos: null,
IsRepeatable: !1
},
ctors: {
$ctor2: function(names, valueInfos, isRepeatable) {
isRepeatable === void 0 && (isRepeatable = !1);
this.$initialize();
this.Names = names;
this.ValueInfos = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Binding.Binder.QueryParameterValueInfo, valueInfos);
this.IsRepeatable = isRepeatable
},
$ctor5: function(name, valueInfos, isRepeatable) {
isRepeatable === void 0 && (isRepeatable = !1);
Kusto.Language.Binding.Binder.QueryParameterInfo.$ctor2.call(this, System.Array.init([name], System.String), valueInfos, isRepeatable)
},
ctor: function(names, kind, caseSensitive, values, isRepeatable) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
isRepeatable === void 0 && (isRepeatable = !1);
Kusto.Language.Binding.Binder.QueryParameterInfo.$ctor2.call(this, names, System.Array.init([new Kusto.Language.Binding.Binder.QueryParameterValueInfo.$ctor1(kind, caseSensitive, values)], Kusto.Language.Binding.Binder.QueryParameterValueInfo), isRepeatable)
},
$ctor1: function(names, fixedType, caseSensitive, values, isRepeatable) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
isRepeatable === void 0 && (isRepeatable = !1);
Kusto.Language.Binding.Binder.QueryParameterInfo.$ctor2.call(this, names, System.Array.init([new Kusto.Language.Binding.Binder.QueryParameterValueInfo.$ctor2(fixedType, caseSensitive, values)], Kusto.Language.Binding.Binder.QueryParameterValueInfo), isRepeatable)
},
$ctor3: function(name, kind, caseSensitive, values, isRepeatable) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
isRepeatable === void 0 && (isRepeatable = !1);
Kusto.Language.Binding.Binder.QueryParameterInfo.$ctor2.call(this, System.Array.init([name], System.String), System.Array.init([new Kusto.Language.Binding.Binder.QueryParameterValueInfo.ctor(kind, null, caseSensitive, values)], Kusto.Language.Binding.Binder.QueryParameterValueInfo), isRepeatable)
},
$ctor4: function(name, fixedType, caseSensitive, values, isRepeatable) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
isRepeatable === void 0 && (isRepeatable = !1);
Kusto.Language.Binding.Binder.QueryParameterInfo.$ctor2.call(this, System.Array.init([name], System.String), System.Array.init([new Kusto.Language.Binding.Binder.QueryParameterValueInfo.$ctor2(fixedType, caseSensitive, values)], Kusto.Language.Binding.Binder.QueryParameterValueInfo), isRepeatable)
}
}
});
Bridge.define("Kusto.Language.Binding.Binder.QueryParameterKind", {
$kind: "nested enum",
statics: {
fields: {
Fixed: 0,
Scalar: 1,
Integer: 2,
RealOrDecimal: 3,
StringOrDynamic: 4,
Number: 5,
StringLiteral: 6,
BoolLiteral: 7,
Summable: 8,
Identifier: 9,
NameDeclaration: 10,
NameDeclarationList: 11,
Column: 12
}
}
});
Bridge.define("Kusto.Language.Binding.Binder.QueryParameterValueInfo", {
$kind: "nested class",
props: {
Kind: 0,
FixedType: null,
CaseSensitive: !1,
Values: null
},
ctors: {
ctor: function(kind, fixedType, caseSensitive, values) {
this.$initialize();
this.Kind = kind;
this.FixedType = fixedType;
this.CaseSensitive = caseSensitive;
this.Values = Kusto.Language.Utils.ListExtensions.ToReadOnly(System.Object, values)
},
$ctor1: function(kind, caseSensitive, values) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
Kusto.Language.Binding.Binder.QueryParameterValueInfo.ctor.call(this, kind, null, caseSensitive, values)
},
$ctor2: function(fixedType, caseSensitive, values) {
caseSensitive === void 0 && (caseSensitive = !0);
values === void 0 && (values = null);
Kusto.Language.Binding.Binder.QueryParameterValueInfo.ctor.call(this, Kusto.Language.Binding.Binder.QueryParameterKind.Fixed, fixedType, caseSensitive, values)
}
}
});
Bridge.define("Kusto.Language.Binding.Binder.ScopeKind", {
$kind: "nested enum",
statics: {
fields: {
Normal: 0,
Aggregate: 1,
PlugIn: 2
}
}
});
Bridge.define("Kusto.Language.Binding.Binder.SignatureResult", {
$kind: "nested struct",
statics: {
methods: {
op_Implicit: function(type) {
return new Kusto.Language.Binding.Binder.SignatureResult.$ctor1(type, null)
},
getDefaultValue: function() {
return new Kusto.Language.Binding.Binder.SignatureResult
}
}
},
props: {
Type: null,
Expander: null
},
ctors: {
$ctor1: function(type, expander) {
this.$initialize();
this.Type = type;
this.Expander = expander
},
ctor: function() {
this.$initialize()
}
},
methods: {
getHashCode: function() {
return Bridge.addHash([5716221070, this.Type, this.Expander])
},
equals: function(o) {
return Bridge.is(o, Kusto.Language.Binding.Binder.SignatureResult) ? Bridge.equals(this.Type, o.Type) && Bridge.equals(this.Expander, o.Expander) : !1
},
$clone: function() {
return this
}
}
});
Bridge.define("Kusto.Language.Binding.CallSiteInfo", {
props: {
Signature: null,
Locals: null
},
ctors: {
ctor: function(signature, locals) {
this.$initialize();
this.Signature = signature;
this.Locals = locals
}
},
methods: {
toString: function() {
return (this.Signature.Symbol.Name || "") + "(" + (Bridge.toArray(System.Linq.Enumerable.from(this.Locals).select(function(v) {
return v.IsConstant && v.ConstantValue != null ? System.String.format("{0}={1}", v.Name, v.ConstantValue) : v.Name
})).join(",") || "") + ")"
}
}
});
Bridge.define("Kusto.Language.Binding.Conversion", {
$kind: "enum",
statics: {
fields: {
None: 0,
Promotable: 1,
Compatible: 2,
Any: 3
}
}
});
Bridge.define("Kusto.Language.Binding.GlobalBindingCache", {
fields: {
UnifiedNameColumnsMap: null,
UnifiedNameAndTypeColumnsMap: null,
CommonColumnsMap: null,
CallSiteToExpansionMap: null
},
ctors: {
init: function() {
this.UnifiedNameColumnsMap = new(System.Collections.Generic.Dictionary$2(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.TableSymbol), Kusto.Language.Symbols.TableSymbol))(null, Kusto.Language.Utils.ReadOnlyListComparer$1(Kusto.Language.Symbols.TableSymbol).Default);
this.UnifiedNameAndTypeColumnsMap = new(System.Collections.Generic.Dictionary$2(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.TableSymbol), Kusto.Language.Symbols.TableSymbol))(null, Kusto.Language.Utils.ReadOnlyListComparer$1(Kusto.Language.Symbols.TableSymbol).Default);
this.CommonColumnsMap = new(System.Collections.Generic.Dictionary$2(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.TableSymbol), Kusto.Language.Symbols.TableSymbol))(null, Kusto.Language.Utils.ReadOnlyListComparer$1(Kusto.Language.Symbols.TableSymbol).Default);
this.CallSiteToExpansionMap = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Binding.CallSiteInfo, Kusto.Language.Syntax.FunctionBody))(null, Kusto.Language.Binding.CallSiteInfo.Comparer.Instance)
}
}
});
Bridge.define("Kusto.Language.Binding.LocalBindingCache", {
fields: {
SignaturesComputingExpansion: null,
CallSiteToExpansionMap: null
},
ctors: {
init: function() {
this.SignaturesComputingExpansion = new(System.Collections.Generic.HashSet$1(Kusto.Language.Symbols.Signature).ctor);
this.CallSiteToExpansionMap = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Binding.CallSiteInfo, Kusto.Language.Syntax.FunctionBody))(null, Kusto.Language.Binding.CallSiteInfo.Comparer.Instance)
}
}
});
Bridge.define("Kusto.Language.Binding.LocalScope", {
statics: {
methods: {
GetMinimalOuterScope: function(outerScope) {
while (outerScope != null && outerScope._symbols == null && outerScope._sharedScope == null) outerScope = outerScope._outerScope;
return outerScope
}
}
},
fields: {
_outerScope: null,
_symbols: null,
_sharedScope: null
},
ctors: {
$ctor1: function(symbols, outerScope, sharedScope) {
this.$initialize();
this._symbols = symbols;
this._outerScope = Kusto.Language.Binding.LocalScope.GetMinimalOuterScope(outerScope);
this._sharedScope = sharedScope
},
ctor: function(outerScope) {
outerScope === void 0 && (outerScope = null);
Kusto.Language.Binding.LocalScope.$ctor1.call(this, null, outerScope, null)
}
},
methods: {
ContainsSymbol: function(name) {
return this._symbols != null && this._symbols.containsKey(name) || this._sharedScope != null && this._sharedScope.ContainsSymbol(name)
},
Copy: function() {
return this._symbols != null && this._symbols.count > 0 && (this._sharedScope = new Kusto.Language.Binding.LocalScope.$ctor1(this._symbols, null, this._sharedScope), this._symbols = null), new Kusto.Language.Binding.LocalScope.$ctor1(null, this._outerScope, this._sharedScope)
},
AddSymbol: function(symbol) {
return symbol != null ? (this._symbols == null && (this._symbols = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.Symbol))), this._symbols.set(symbol.Name, symbol), !0) : !1
},
AddSymbols: function(symbols) {
var $t, symbol;
$t = Bridge.getEnumerator(symbols, Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) symbol = $t.Current, this.AddSymbol(symbol)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
GetSymbols$1: function(name, match, symbols) {
var $t, decl, symbol;
if (this._symbols != null)
if (name != null) {
if (decl = {}, this._symbols.tryGetValue(name, decl) && Kusto.Language.Symbols.SymbolMatchExtensions.Matches$1(decl.v, name, match)) {
symbols.add(decl.v);
return
}
} else {
$t = Bridge.getEnumerator(this._symbols.getValues(), Kusto.Language.Symbols.Symbol);
try {
while ($t.moveNext()) symbol = $t.Current, Kusto.Language.Symbols.SymbolMatchExtensions.Matches$1(symbol, name, match) && symbols.add(symbol)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
} this._sharedScope != null && this._sharedScope.GetSymbols$1(name, match, symbols);
this._outerScope != null && this._outerScope.GetSymbols$1(name, match, symbols)
},
GetSymbols: function(match, symbols) {
this.GetSymbols$1(null, match, symbols)
}
}
});
Bridge.define("Kusto.Language.Binding.ProjectionBuilder", {
fields: {
_projection: null,
_doNotAdd: null,
_columnIndexMap: null,
_declaredNames: null,
_uniqueNames: null
},
ctors: {
init: function() {
this._projection = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
this._doNotAdd = new(System.Collections.Generic.HashSet$1(Kusto.Language.Symbols.ColumnSymbol).ctor);
this._columnIndexMap = new(System.Collections.Generic.Dictionary$2(System.String, System.Int32));
this._declaredNames = new(System.Collections.Generic.HashSet$1(System.String).ctor);
this._uniqueNames = new Kusto.Language.Utils.UniqueNameTable
},
ctor: function() {
this.$initialize()
}
},
methods: {
Clear: function() {
this._projection.clear();
this._doNotAdd.clear();
this._columnIndexMap.clear();
this._uniqueNames.Clear();
this._declaredNames.clear()
},
GetProjection: function() {
return this._projection
},
AddRange: function(columns, declare, doNotRepeat) {
var $t, column, c;
declare === void 0 && (declare = !1);
doNotRepeat === void 0 && (doNotRepeat = !1);
$t = Bridge.getEnumerator(columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t.moveNext()) column = $t.Current, c = this.Add(column, void 0, !1, doNotRepeat), declare && c != null && this._declaredNames.add(c.Name)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
DoNotAdd: function(column) {
this._doNotAdd.add(column)
},
CanAdd: function(column) {
return !this._doNotAdd.contains(column)
},
Add: function(column, baseName, replace, doNotRepeat) {
var index, uniqueName;
return (baseName === void 0 && (baseName = null), replace === void 0 && (replace = !1), doNotRepeat === void 0 && (doNotRepeat = !1), this._doNotAdd.contains(column)) ? column : (index = {}, replace && this._columnIndexMap.tryGetValue(column.Name, index) ? this._projection.setItem(index.v, column) : (uniqueName = this._uniqueNames.GetOrAddName(column.Name, baseName), Bridge.referenceEquals(uniqueName, column.Name) || (column = column.WithName(uniqueName)), this._projection.add(column), this._columnIndexMap.add(column.Name, this._projection.Count - 1 | 0)), doNotRepeat && this._doNotAdd.add(column), column)
},
Declare: function(column, diagnostics, location, replace) {
var index, added;
if (replace === void 0 && (replace = !1), this._declaredNames.contains(column.Name)) {
diagnostics.add(Kusto.Language.DiagnosticFacts.GetDuplicateColumnDeclaration(column.Name).WithLocation(location));
return
}
index = {};
replace && this._columnIndexMap.tryGetValue(column.Name, index) ? (this._projection.setItem(index.v, column), this._declaredNames.add(column.Name)) : (added = this.Add(column), added != null && this._declaredNames.add(added.Name))
},
Rename: function(oldName, newName, diagnostics, location) {
var index = {},
oldColumn, newColumn;
return this._columnIndexMap.tryGetValue(oldName, index) ? this._declaredNames.contains(newName) ? (diagnostics.add(Kusto.Language.DiagnosticFacts.GetDuplicateColumnDeclaration(newName).WithLocation(location)), null) : (oldColumn = this._projection.getItem(index.v), newColumn = oldColumn.WithName(newName), this._projection.setItem(index.v, newColumn), this._columnIndexMap.remove(oldName), this._columnIndexMap.add(newName, index.v), this._declaredNames.add(newName), this._uniqueNames.AddName(newName), newColumn) : null
}
}
});
Bridge.define("Kusto.Language.ClusterManagerCommands", {
statics: {
props: {
All: null
},
ctors: {
init: function() {
this.All = System.Array.init([Kusto.Language.EngineCommands.ShowVersion], Kusto.Language.Symbols.CommandSymbol)
}
}
}
});
Bridge.define("Kusto.Language.DataManagerCommands", {
statics: {
props: {
All: null
},
ctors: {
init: function() {
this.All = System.Array.init([Kusto.Language.EngineCommands.ShowVersion], Kusto.Language.Symbols.CommandSymbol)
}
}
}
});
Bridge.define("Kusto.Language.Diagnostic", {
statics: {
fields: {
NoDiagnostics: null
},
ctors: {
init: function() {
this.NoDiagnostics = System.Array.init(0, null, Kusto.Language.Diagnostic)
}
}
},
fields: {
start: 0,
length: 0
},
props: {
Code: null,
Category: null,
Severity: null,
Message: null,
HasLocation: {
get: function() {
return this.length > 0
}
},
Start: {
get: function() {
return this.start
}
},
Length: {
get: function() {
return this.length
}
},
End: {
get: function() {
return this.Start + this.Length | 0
}
}
},
ctors: {
ctor: function(code, message) {
Kusto.Language.Diagnostic.$ctor2.call(this, code, null, null, message, 0, 0)
},
$ctor1: function(code, category, severity, message) {
Kusto.Language.Diagnostic.$ctor2.call(this, code, category, severity, message, 0, 0)
},
$ctor2: function(code, category, severity, message, start, length) {
var $t, $t1, $t2, $t3;
this.$initialize();
this.Code = ($t = code, $t != null ? $t : "");
this.Category = ($t1 = category, $t1 != null ? $t1 : Kusto.Language.DiagnosticCategory.General);
this.Severity = ($t2 = severity, $t2 != null ? $t2 : Kusto.Language.DiagnosticSeverity.Error);
this.Message = ($t3 = message, $t3 != null ? $t3 : "");
this.start = start >= 0 ? start : 0;
this.length = length >= 0 ? length : 0
}
},
methods: {
With: function(code, category, severity, message, start, length) {
var $t, $t1, $t2, $t3;
return code === void 0 && (code = null), category === void 0 && (category = null), severity === void 0 && (severity = null), message === void 0 && (message = null), start === void 0 && (start = -1), length === void 0 && (length = -1), code = ($t = code, $t != null ? $t : this.Code), category = ($t1 = category, $t1 != null ? $t1 : this.Category), severity = ($t2 = severity, $t2 != null ? $t2 : this.Severity), message = ($t3 = message, $t3 != null ? $t3 : this.Message), start = start >= 0 ? start : this.start, length = length >= 0 ? length : this.length, Bridge.referenceEquals(code, this.Code) && Bridge.referenceEquals(category, this.Code) && Bridge.referenceEquals(severity, this.Severity) && Bridge.referenceEquals(message, this.Message) && start === this.start && length === this.length ? this : new Kusto.Language.Diagnostic.$ctor2(code, category, severity, message, start, length)
},
WithCode: function(code) {
return this.With(code, void 0, void 0, void 0, -1, -1)
},
WithCategory: function(category) {
return this.With(void 0, category, void 0, void 0, -1, -1)
},
WithSeverity: function(severity) {
return this.With(void 0, void 0, severity, void 0, -1, -1)
},
WithMessage: function(message) {
return this.With(void 0, void 0, void 0, message, -1, -1)
},
WithLocation: function(location) {
return this.With(void 0, void 0, void 0, void 0, location.TextStart, location.Width)
},
WithLocation$1: function(start, length) {
return this.With(void 0, void 0, void 0, void 0, start, length)
}
}
});
Bridge.define("Kusto.Language.DiagnosticCategory", {
statics: {
fields: {
General: null,
Correctness: null,
Performance: null
},
ctors: {
init: function() {
this.General = "General";
this.Correctness = "Correctness";
this.Performance = "Performance"
}
}
}
});
Bridge.define("Kusto.Language.DiagnosticFacts", {
statics: {
methods: {
GetMissingCharacter: function(ch) {
return new Kusto.Language.Diagnostic.ctor("KUS001", System.String.format("Missing '{0}'", [Bridge.box(ch, System.Char, String.fromCharCode, System.Char.getHashCode)]))
},
GetUnexpectedCharacter: function(text) {
return new Kusto.Language.Diagnostic.ctor("KUS002", System.String.format("Unexpected: '{0}'", [text]))
},
GetMalformedToken: function(term) {
return new Kusto.Language.Diagnostic.ctor("KUS003", System.String.format("Malformed {0}", [term]))
},
GetMalformedLiteral: function() {
return new Kusto.Language.Diagnostic.ctor("KUS004", "Malformed literal")
},
GetTokenExpected: function(kinds) {
return kinds === void 0 && (kinds = []), Kusto.Language.DiagnosticFacts.GetTokenExpected$2(Bridge.cast(kinds, System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Syntax.SyntaxKind)))
},
GetTokenExpected$2: function(kinds) {
return Kusto.Language.DiagnosticFacts.GetTokenExpected$1(System.Linq.Enumerable.from(kinds).select(function(k) {
return Kusto.Language.Syntax.SyntaxFacts.GetText(k)
}))
},
GetTokenExpected$1: function(texts) {
var list = Kusto.Language.Utils.ListExtensions.Join(System.Linq.Enumerable.from(texts).select(function(t) {
return System.String.format("'{0}'", [t])
}).ToArray(System.String), ", ", " or ");
return new Kusto.Language.Diagnostic.ctor("KUS005", System.String.format("Expected: {0}", [list]))
},
GetTokenExpected$3: function(tokens) {
return tokens === void 0 && (tokens = []), Kusto.Language.DiagnosticFacts.GetTokenExpected$1(Bridge.cast(tokens, System.Collections.Generic.IReadOnlyList$1(System.String)))
},
GetMissingElement: function(term) {
return new Kusto.Language.Diagnostic.ctor("KUS006", System.String.format("Missing {0}", [term]))
},
GetMissingName: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("name")
},
GetMissingValue: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("value")
},
GetMissingExpression: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("expression")
},
GetMissingNumber: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("number")
},
GetMissingString: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("string")
},
GetMissingBoolean: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("boolean")
},
GetMissingTypeOfLiteral: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("typeof")
},
GetMissingFunctionCall: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("function call")
},
GetMissingFunctionDeclaration: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("function declaration")
},
GetMissingTypeName: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("type name")
},
GetMissingParameter: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("parameter")
},
GetMissingFirstOrLast: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("first or last")
},
GetMissingJsonValue: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("json value")
},
GetMissingJoinOnClause: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("join on condition clause")
},
GetMissingJsonPair: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("json key:value pair")
},
GetMissingStatement: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("statement")
},
GetMissingPatternMatch: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("pattern match clause")
},
GetMissingClause: function() {
return Kusto.Language.DiagnosticFacts.GetMissingElement("clause")
},
GetMissingClause$1: function(clauseName) {
return Kusto.Language.DiagnosticFacts.GetMissingElement(System.String.format("{0} clause", [clauseName]))
},
GetParsePatternMustStartWithColumnNameOrStar: function() {
return new Kusto.Language.Diagnostic.ctor("KUS100", "The pattern must start with a column name or *")
},
GetParsePatternNameDoesNotFollowStringLiteral: function() {
return new Kusto.Language.Diagnostic.ctor("KUS101", "The column name must follow a string literal")
},
GetParsePatternStringLiteralMustFollowStar: function() {
return new Kusto.Language.Diagnostic.ctor("KUS102", "A string literal must follow a *")
},
GetParsePatternUsingStarAfterStringColumnIsAmbiguous: function() {
return new Kusto.Language.Diagnostic.ctor("KUS103", "Using * after parsing a string column is abmiguous.")
},
GetInvalidPatternPart: function() {
return new Kusto.Language.Diagnostic.ctor("KUS104", "Invalid pattern part.")
},
GetIdentifierNameOnly: function() {
return new Kusto.Language.Diagnostic.ctor("KUS105", "The name must be a single identifier only.")
},
GetOperatorNotDefined: function(name, argumentTypes) {
return argumentTypes === void 0 && (argumentTypes = []), Kusto.Language.DiagnosticFacts.GetOperatorNotDefined$1(name, Bridge.cast(argumentTypes, System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.TypeSymbol)))
},
GetOperatorNotDefined$1: function(name, argumentTypes) {
if (System.Array.getCount(argumentTypes, Kusto.Language.Symbols.TypeSymbol) === 1) return new Kusto.Language.Diagnostic.ctor("KUS106", System.String.format("The operator '{0}' is not defined for the operand type {1}.", name, System.Array.getItem(argumentTypes, 0, Kusto.Language.Symbols.TypeSymbol).Name));
var list = Kusto.Language.Utils.ListExtensions.Join(System.Linq.Enumerable.from(argumentTypes).select(function(t) {
return t.Name
}).toList(System.String), ", ", " and ");
return new Kusto.Language.Diagnostic.ctor("KUS106", System.String.format("The operator '{0}' is not defined for the operand types {1}.", name, list))
},
GetTypeExpected: function(type) {
return new Kusto.Language.Diagnostic.ctor("KUS107", System.String.format("A value of type '{0}' expected.", [type.Name]))
},
GetTypeExpected$1: function(types) {
if (System.Array.getCount(types, Kusto.Language.Symbols.TypeSymbol) === 0) return Kusto.Language.DiagnosticFacts.GetTypeExpected(System.Array.getItem(types, 0, Kusto.Language.Symbols.TypeSymbol));
var list = Kusto.Language.Utils.ListExtensions.Join(System.Linq.Enumerable.from(types).select(function(t) {
return "'" + (t.Name || "") + "'"
}).toList(System.String), ", ", " or ");
return new Kusto.Language.Diagnostic.ctor("KUS107", System.String.format("A value of type {0} expected.", [list]))
},
GetScalarTypeExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS108", System.String.format("Scalar value expected.", null))
},
GetColumnExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS109", "Column name expected.")
},
GetRenameAssignmentExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS110", "Column rename assignment expected.")
},
GetTableExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS111", "Table expected.")
},
GetTableOrScalarExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS112", "A table or scalar value expected.")
},
GetSingleColumnTableExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS113", "A table with only one column expected.")
},
GetDatabaseExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS114", "Database expected.")
},
GetClusterExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS115", "Cluster expected.")
},
GetTypeNotAllowed: function(type) {
return new Kusto.Language.Diagnostic.ctor("KUS116", System.String.format("The value of type '{0}' is not allowed in this context.", [type.Name]))
},
GetFunctionRequiresArgumentList: function(functionName) {
return new Kusto.Language.Diagnostic.ctor("KUS117", System.String.format("The function '{0}' requires an argument list.", [functionName]))
},
GetArgumentCountExpected: function(count) {
return count === 0 ? new Kusto.Language.Diagnostic.ctor("KUS118", System.String.format("No arguments expected.", null)) : count === 1 ? new Kusto.Language.Diagnostic.ctor("KUS118", System.String.format("1 argument expected.", null)) : new Kusto.Language.Diagnostic.ctor("KUS118", System.String.format("{0} arguments expected.", [Bridge.box(count, System.Int32)]))
},
GetFunctionExpectsArgumentCountExact: function(functionName, count) {
return count === 0 ? new Kusto.Language.Diagnostic.ctor("KUS119", System.String.format("The function '{0}' expects no arguments.", [functionName])) : count === 1 ? new Kusto.Language.Diagnostic.ctor("KUS119", System.String.format("The function '{0}' expects 1 argument.", [functionName])) : new Kusto.Language.Diagnostic.ctor("KUS119", System.String.format("The function '{0}' expects {1} arguments.", functionName, Bridge.box(count, System.Int32)))
},
GetFunctionExpectsArgumentCountRange: function(functionName, min, max) {
return min === max ? Kusto.Language.DiagnosticFacts.GetFunctionExpectsArgumentCountExact(functionName, min) : new Kusto.Language.Diagnostic.ctor("KUS120", System.String.format("The function '{0}' expects between {1} and {2} arguments.", functionName, Bridge.box(min, System.Int32), Bridge.box(max, System.Int32)))
},
GetFunctionHasIncorrectNumberOfArguments: function() {
return new Kusto.Language.Diagnostic.ctor("KUS121", System.String.format("The function call has an incorrect number of arguments.", null))
},
GetScalarFunctionNotDefined: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS122", System.String.format("The scalar function '{0}' is not defined.", [name]))
},
GetAggregateFunctionNotDefined: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS123", System.String.format("The aggregate function '{0}' is not defined.", [name]))
},
GetPlugInFunctionNotDefined: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS124", System.String.format("The plug-in function '{0}' is not defined.", [name]))
},
GetPlugInFunctionIsNotEnabled: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS125", System.String.format("The plug-in function '{0}' is not enabled.", [name]))
},
GetPluginNotAllowedInThisContext: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS126", System.String.format("The plug-in function '{0}' is not allowed in this context.", [name]))
},
GetFunctionNotDefinedWithMatchingParameters: function(name, argumentTypes) {
var types = Bridge.toArray(System.Linq.Enumerable.from(argumentTypes).select(function(p) {
return p.Name
})).join(", ");
return new Kusto.Language.Diagnostic.ctor("KUS127", System.String.format("The function '{0}' is not compatible with arguments ({1})", name, types))
},
GetNameIsNotAFunction: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS128", System.String.format("The name '{0}' does not refer to a function.", [name]))
},
GetExpressionMustBeConstant: function() {
return new Kusto.Language.Diagnostic.ctor("KUS129", "The expression must be a constant.")
},
GetExpressionMustBeConstantOrIdentifier: function() {
return new Kusto.Language.Diagnostic.ctor("KUS130", "The expression must be a constant or identifier.")
},
GetExpressionMustBeLiteral: function() {
return new Kusto.Language.Diagnostic.ctor("KUS131", System.String.format("The expression must be a literal.", null))
},
GetExpressionMustBeLiteralScalarValue: function() {
return new Kusto.Language.Diagnostic.ctor("KUS132", System.String.format("The expression must be a literal scalar value.", null))
},
GetExpressionMustNotBeEmpty: function() {
return new Kusto.Language.Diagnostic.ctor("KUS133", System.String.format("The expression value must not be empty.", null))
},
GetExpressionMustBeInteger: function() {
return new Kusto.Language.Diagnostic.ctor("KUS134", "The expression value must be an integer.")
},
GetExpressionMustBeRealOrDecimal: function() {
return new Kusto.Language.Diagnostic.ctor("KUS135", "The expression value must be an real or decimal number.")
},
GetExpressionMustBeIntegerOrDynamic: function() {
return new Kusto.Language.Diagnostic.ctor("KUS136", "The expression value must be an integer or dynamic.")
},
GetExpressionMustBeNumeric: function() {
return new Kusto.Language.Diagnostic.ctor("KUS137", "The expression value must be a number.")
},
GetExpressionMustBeSummable: function() {
return new Kusto.Language.Diagnostic.ctor("KUS138", "The argument value must be a number, timespan or datetime.")
},
GetMultiValuedExpressionCannotBeAssignedToVariable: function() {
return new Kusto.Language.Diagnostic.ctor("KUS139", "The multi-valued expression cannot be assigned to a variable.")
},
GetExpressionMustHaveValue$1: function(T, values) {
if (System.Array.getCount(values, T) === 1) return new Kusto.Language.Diagnostic.ctor("KUS140", System.String.format("The expression must be the value: {0}", [System.Array.getItem(values, 0, T)]));
var list = Kusto.Language.Utils.ListExtensions.Join(System.Linq.Enumerable.from(values).select(function(v) {
return Bridge.toString(v)
}).toList(System.String), ", ", " or ");
return new Kusto.Language.Diagnostic.ctor("KUS140", System.String.format("The expression must be one of the values: {0}", [list]))
},
GetExpressionMustHaveValue: function(T, values) {
return values === void 0 && (values = []), Kusto.Language.DiagnosticFacts.GetExpressionMustHaveValue$1(T, Bridge.cast(values, System.Collections.Generic.IReadOnlyList$1(T)))
},
GetExpressionMustHaveType$1: function(types) {
if (System.Array.getCount(types, Kusto.Language.Symbols.Symbol) === 1) return new Kusto.Language.Diagnostic.ctor("KUS141", System.String.format("The expression must have the type {0}.", [System.Array.getItem(types, 0, Kusto.Language.Symbols.Symbol).Name]));
var list = Kusto.Language.Utils.ListExtensions.Join(System.Linq.Enumerable.from(types).select(function(s) {
return s.Name
}).toList(System.String), ", ", " or ");
return new Kusto.Language.Diagnostic.ctor("KUS141", System.String.format("The expression must have one of the types: {0}.", [list]))
},
GetExpressionMustHaveType: function(types) {
return types === void 0 && (types = []), Kusto.Language.DiagnosticFacts.GetExpressionMustHaveType$1(Bridge.cast(types, System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.Symbol)))
},
GetNameDoesNotReferToAnyKnownItem: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS142", System.String.format("The name '{0}' does not refer to any known column, table, variable or function.", [name]))
},
GetFunctionNotDefined: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS143", System.String.format("The function '{0}' is not defined.", [name]))
},
GetAggregateNotAllowedInThisContext: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS144", System.String.format("The aggregate function '{0}' is not allowed in this context.", [name]))
},
GetColumnMustExistOnBothSidesOfJoin: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS145", System.String.format("The column '{0}' must exist on both sides of the join.", [name]))
},
GetNameRefersToMoreThanOneItem: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS146", System.String.format("The name '{0}' refers to more than one column or variable", [name]))
},
GetTheElementAccessOperatorIsNotAllowedInThisContext: function() {
return new Kusto.Language.Diagnostic.ctor("KUS147", "The element access operator [] is not allowed in this context.")
},
GetTheExpressionHasNoName: function() {
return new Kusto.Language.Diagnostic.ctor("KUS148", "A column name cannot be inferred for this expression.")
},
GetTheExpressionDoesNotHaveMultipleValues: function() {
return new Kusto.Language.Diagnostic.ctor("KUS149", "The expression does not have multiple named values.")
},
GetTheNameDoesNotHaveCorrespondingExpression: function() {
return new Kusto.Language.Diagnostic.ctor("KUS150", "The name does not have a corresponding expression.")
},
GetInvalidTypeName: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS160", System.String.format("The name '{0}' is not a valid type name.", [name]))
},
GetInvalidColumnDeclaration: function() {
return new Kusto.Language.Diagnostic.ctor("KUS170", "The syntax is not a valid column declaration.")
},
GetDuplicateColumnDeclaration: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS171", System.String.format("A column with the name '{0}' is already declared.", [name]))
},
GetInvalidTypeExpression: function() {
return new Kusto.Language.Diagnostic.ctor("KUS172", "The syntax is not a valid type expression.")
},
GetIncorrectNumberOfDataValues: function(multiple) {
return new Kusto.Language.Diagnostic.ctor("KUS173", System.String.format("Incorrect number of data values. The values should appear in multiples of {0}.", [Bridge.box(multiple, System.Int32)]))
},
GetQueryOperatorCannotBeFirst: function() {
return new Kusto.Language.Diagnostic.ctor("KUS174", System.String.format("The operator cannot be the first operator in a query.", null))
},
GetQueryOperatorMustBeFirst: function() {
return new Kusto.Language.Diagnostic.ctor("KUS175", "The operator must be the first operator in the query.")
},
GetQueryOperatorExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS176", "Query operator expected.")
},
GetQueryOperatorNotAllowedInContext: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS177", System.String.format("The query operator '{0}' is not allowed in the current context.", [name]))
},
GetTypeIsNotIntervalType: function(intervalType, rangeType) {
return new Kusto.Language.Diagnostic.ctor("KUS178", System.String.format("The type '{0}' is not an appropriate interval type for '{1}'", intervalType.Name, rangeType.Name))
},
GetUnknownParameterName: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS179", System.String.format("The '{0}' is not a recognized parameter.", [name]))
},
GetParameterAlreadySpecified: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS180", System.String.format("The parameter '{0}' is already specified.", [name]))
},
GetNameDoesNotReferToTable: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS181", System.String.format("The name '{0}' does not refer to a table.", [name]))
},
GetInvalidJoinCondition: function() {
return new Kusto.Language.Diagnostic.ctor("KUS182", "The join condition must be either the name of a column common to both tables or in the form $left.<column> == $right.<column>.")
},
GetInvalidJoinConditionOperand: function(prefix) {
return new Kusto.Language.Diagnostic.ctor("KUS183", System.String.format("The join condition operand must be: {0}.<column>", [prefix]))
},
GetTheExpressionRefersToMoreThanOneColumn: function() {
return new Kusto.Language.Diagnostic.ctor("KUS184", "The expression refers to more than one column.")
},
GetPackMustBeLastItemInList: function() {
return new Kusto.Language.Diagnostic.ctor("KUS185", "The pack(*) expression must be the last item in the list.")
},
GetValueCountMustEqualParameterCount: function() {
return new Kusto.Language.Diagnostic.ctor("KUS185", "The number of values must equal the number of parameters.")
},
GetPathValueWithNoPathParameter: function() {
return new Kusto.Language.Diagnostic.ctor("KUS186", "A path value can only be specified when a path name is part of the declaration.")
},
GetPathValueExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS187", "A path value is expected.")
},
GetNoPatternMatchesArguments: function() {
return new Kusto.Language.Diagnostic.ctor("KUS188", "No pattern matches the specified arguments.")
},
GetDefaultValueExpected: function() {
return new Kusto.Language.Diagnostic.ctor("KUS189", "Default value expected.")
},
GetTableHasNoColumns: function() {
return new Kusto.Language.Diagnostic.ctor("KUS190", "The table has no columns")
},
GetStarExpressionNotAllowed: function() {
return new Kusto.Language.Diagnostic.ctor("KUS191", "The * syntax is not allowed here.")
},
GetStarExpressionMustBeLastArgument: function() {
return new Kusto.Language.Diagnostic.ctor("KUS192", "The * syntax must be the last argument.")
},
GetNamedArgumentsNotSupported: function() {
return new Kusto.Language.Diagnostic.ctor("KUS193", "Named arguments are not supported for this function.")
},
GetCompoundNamedArgumentsNotSupported: function() {
return new Kusto.Language.Diagnostic.ctor("KUS194", "Compound named arguments are not supported.")
},
GetUnnamedArgumentAfterOutofOrderNamedArgument: function() {
return new Kusto.Language.Diagnostic.ctor("KUS195", "All arguments after an unordered named argument must be named.")
},
GetUnknownArgumentName: function() {
return new Kusto.Language.Diagnostic.ctor("KUS196", System.String.format("The argument name does not refer to a declared parameter.", null))
},
GetMissingArgumentForParameter: function(parameterName) {
return new Kusto.Language.Diagnostic.ctor("KUS197", System.String.format("The argument for parameter '{0}' is missing.", [parameterName]))
},
GetIncompleteFragment: function() {
return new Kusto.Language.Diagnostic.ctor("KUS198", "The incomplete fragment is unexpected.")
},
GetNoColumnsInScope: function() {
return new Kusto.Language.Diagnostic.ctor("KUS199", "No columns are currently in scope.")
},
GetErrorInExpansion: function(name, errors) {
return new Kusto.Language.Diagnostic.ctor("KUS200", System.String.format("Failure in expansion of '{0}': {1}", name, errors))
},
GetVariableAlreadyDeclared: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS201", System.String.format("A variable with the name '{0}' has already been declared.", [name]))
},
GetMaterializedViewNameMustBeStringLiteral: function() {
return new Kusto.Language.Diagnostic.ctor("KUS202", System.String.format("Materialized view name must be a string literal", null))
},
AnalysisFailure: function(analyzerName, message) {
return new Kusto.Language.Diagnostic.ctor("KUS203", System.String.format("Failure in analysis '{0}': {1}", analyzerName, message))
},
GetNameDoesNotReferToAnyKnownTable: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS204", System.String.format("The name '{0}' does not refer to any known table, tabular variable or function.", [name]))
},
GetFuzzyUnionOperandNotDefined: function(name) {
return new Kusto.Language.Diagnostic.ctor("KUS205", System.String.format("The fuzzy union operand '{0}' does not refer to any known table, tabular variable or function.", [name])).WithSeverity(Kusto.Language.DiagnosticSeverity.Warning)
},
GetMissingCommand: function() {
return new Kusto.Language.Diagnostic.ctor("KUS300", "Missing command.")
}
}
}
});
Bridge.define("Kusto.Language.DiagnosticSeverity", {
statics: {
fields: {
Error: null,
Warning: null,
Suggestion: null,
Information: null,
Hidden: null
},
ctors: {
init: function() {
this.Error = "Error";
this.Warning = "Warning";
this.Suggestion = "Suggestion";
this.Information = "Information";
this.Hidden = "Hidden"
}
}
}
});
Bridge.define("Kusto.Language.Editor.KustoAnalyzer", {
props: {
Name: {
get: function() {
return Bridge.Reflection.getTypeName(Bridge.getType(this))
}
}
}
});
Bridge.define("Kusto.Language.Editor.BrackettingStyle", {
$kind: "enum",
statics: {
fields: {
None: 0,
Vertical: 1,
Diagonal: 2
}
}
});
Bridge.define("Kusto.Language.Editor.ClassificationInfo", {
statics: {
fields: {
Empty: null
},
ctors: {
init: function() {
this.Empty = new Kusto.Language.Editor.ClassificationInfo(null)
}
}
},
props: {
Classifications: null
},
ctors: {
ctor: function(classifications) {
this.$initialize();
this.Classifications = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Editor.ClassifiedRange, classifications)
}
}
});
Bridge.define("Kusto.Language.Editor.ClassificationKind", {
$kind: "enum",
statics: {
fields: {
PlainText: 0,
Comment: 1,
Punctuation: 2,
Directive: 3,
Literal: 4,
StringLiteral: 5,
Type: 6,
Column: 7,
Table: 8,
Database: 9,
Function: 10,
Parameter: 11,
Variable: 12,
Identifier: 13,
ClientParameter: 14,
QueryParameter: 15,
ScalarOperator: 16,
MathOperator: 17,
QueryOperator: 18,
Command: 19,
Keyword: 20,
MaterializedView: 21,
SchemaMember: 22,
SignatureParameter: 23
}
}
});
Bridge.define("Kusto.Language.Editor.ClassifiedRange", {
props: {
Kind: 0,
Start: 0,
Length: 0,
End: {
get: function() {
return this.Start + this.Length | 0
}
}
},
ctors: {
ctor: function(kind, start, length) {
this.$initialize();
this.Kind = kind;
this.Start = start;
this.Length = length
}
}
});
Bridge.define("Kusto.Language.Editor.ClassifiedText", {
props: {
Kind: 0,
Text: null
},
ctors: {
$ctor1: function(text) {
Kusto.Language.Editor.ClassifiedText.ctor.call(this, Kusto.Language.Editor.ClassificationKind.PlainText, text)
},
ctor: function(kind, text) {
this.$initialize();
this.Kind = kind;
this.Text = text
}
}
});
Bridge.define("Kusto.Language.Editor.TextRange", {
props: {
Start: 0,
Length: 0,
End: {
get: function() {
return this.Start + this.Length | 0
}
}
},
ctors: {
ctor: function(start, length) {
this.$initialize();
this.Start = start;
this.Length = length
}
}
});
Bridge.define("Kusto.Language.Editor.CodeBlock", {
fields: {
_codeService: null
},
props: {
Text: {
get: function() {
return this._codeService.Text
}
},
Start: 0,
Length: {
get: function() {
return this.Text.length
}
},
End: {
get: function() {
return this.Start + this.Length | 0
}
},
Kind: {
get: function() {
return this._codeService.Kind
}
},
Service: {
get: function() {
return this._codeService
}
}
},
ctors: {
ctor: function(start, codeService) {
this.$initialize();
this.Start = start;
var ols;
this._codeService = (ols = Bridge.as(codeService, Kusto.Language.Editor.OffsetCodeService)) != null ? ols.WithOffset(start) : new Kusto.Language.Editor.OffsetCodeService(codeService, start)
}
},
methods: {
WithStart: function(start) {
return new Kusto.Language.Editor.CodeBlock(start, this.Service)
}
}
});
Bridge.define("Kusto.Language.Editor.CodeKinds", {
statics: {
fields: {
Query: null,
Command: null,
Directive: null,
Unknown: null
},
ctors: {
init: function() {
this.Query = "Query";
this.Command = "Command";
this.Directive = "Directive";
this.Unknown = "Unknown"
}
}
}
});
Bridge.define("Kusto.Language.Editor.CodeScript", {
statics: {
methods: {
From: function(text, factory) {
var $t;
return Kusto.Language.Editor.CodeScript.CreateScript(($t = text, $t != null ? $t : ""), factory)
},
From$1: function(text, globals) {
return Kusto.Language.Editor.CodeScript.From(text, new Kusto.Language.Editor.KustoCodeServiceFactory(globals))
},
CreateScript: function(text, factory, existingBlocks) {
var lineStarts, blockStarts, existingBlockMap, blocks, i, blockText, service;
for (existingBlocks === void 0 && (existingBlocks = null), lineStarts = new(System.Collections.Generic.List$1(System.Int32).ctor), blockStarts = new(System.Collections.Generic.List$1(System.Int32).ctor), Kusto.Language.Editor.CodeScript.GetStarts(text, lineStarts, blockStarts), existingBlockMap = existingBlocks != null ? Kusto.Language.Utils.TextKeyedDictionaryExtensions.ToTextKeyedDictionary(Bridge.global.Kusto.Language.Editor.CodeBlock, Bridge.global.Kusto.Language.Editor.CodeBlock, existingBlocks, function(b) {
return b.Text
}, function(b) {
return b
}) : null, blocks = new(System.Collections.Generic.List$1(Kusto.Language.Editor.CodeBlock).ctor), i = 0; i < blockStarts.Count; i = i + 1 | 0) {
var start = blockStarts.getItem(i),
length = (i + 1 | 0) < blockStarts.Count ? blockStarts.getItem(i + 1 | 0) - start | 0 : text.length - start | 0,
block = {};
existingBlockMap != null && existingBlockMap.TryGetValue(text, start, length, block) ? block.v = block.v.WithStart(start) : (blockText = text.substr(start, length), service = {}, factory.TryGetCodeService(blockText, service) || (service.v = new Kusto.Language.Editor.UnknownCodeService(blockText)), block.v = new Kusto.Language.Editor.CodeBlock(start, service.v));
blocks.add(block.v)
}
return new Kusto.Language.Editor.CodeScript(text, lineStarts, blocks, factory)
},
GetStarts: function(text, lineStarts, blockStarts) {
var i, n, lb;
lineStarts.add(0);
blockStarts.add(0);
var allWhitespace = !0,
newBlockNextWhitespaceLine = !1,
newBlockNextNonWhitespaceLine = !1,
lineStart = 0;
for (i = 0, n = text.length; i < n;) lb = Kusto.Language.Parsing.TextFacts.GetLineBreakLength(text, i), lb > 0 ? (i = i + lb | 0, allWhitespace ? (newBlockNextWhitespaceLine && blockStarts.add(lineStart), newBlockNextWhitespaceLine = !0, newBlockNextNonWhitespaceLine = !0) : newBlockNextNonWhitespaceLine ? (blockStarts.add(lineStart), newBlockNextWhitespaceLine = !1, newBlockNextNonWhitespaceLine = !1) : newBlockNextWhitespaceLine = !1, lineStart = i, lineStarts.add(lineStart), allWhitespace = !0) : (System.Char.isWhiteSpace(String.fromCharCode(text.charCodeAt(i))) || (allWhitespace = !1), i = i + 1 | 0);
(allWhitespace && newBlockNextWhitespaceLine || !allWhitespace && newBlockNextNonWhitespaceLine) && blockStarts.add(lineStart)
}
}
},
fields: {
lineStarts: null,
blocks: null
},
props: {
Text: null,
Factory: null,
Blocks: {
get: function() {
return this.blocks
}
},
Globals: {
get: function() {
var $t;
return ($t = this.Factory.GetFactory(Kusto.Language.Editor.KustoCodeServiceFactory)) != null ? $t.Globals : null
}
}
},
ctors: {
ctor: function(text, lineStarts, blocks, factory) {
this.$initialize();
this.Text = text;
this.lineStarts = lineStarts;
this.blocks = blocks;
this.Factory = factory
}
},
methods: {
WithText: function(newText) {
var $t;
return Kusto.Language.Editor.CodeScript.CreateScript(($t = newText, $t != null ? $t : ""), this.Factory, this.Blocks)
},
WithFactory: function(factory) {
return Bridge.referenceEquals(factory, this.Factory) ? this : Kusto.Language.Editor.CodeScript.CreateScript(this.Text, factory, null)
},
WithTextAndFactory: function(newText, factory) {
return this.WithText(newText).WithFactory(factory)
},
WithGlobals: function(newGlobals) {
var kustoFactory = this.Factory.GetFactory(Kusto.Language.Editor.KustoCodeServiceFactory);
return kustoFactory != null ? this.WithFactory(this.Factory.WithFactory(kustoFactory.WithGlobals(newGlobals))) : this
},
GetBlockAtPosition: function(position) {
if (position === 0) return System.Array.getItem(this.Blocks, 0, Kusto.Language.Editor.CodeBlock);
if (position === this.Text.length) return System.Array.getItem(this.Blocks, System.Array.getCount(this.Blocks, Kusto.Language.Editor.CodeBlock) - 1 | 0, Kusto.Language.Editor.CodeBlock);
if (position >= 0 && position < this.Text.length) {
var index = Kusto.Language.Utils.ListExtensions.BinarySearch(Bridge.global.Kusto.Language.Editor.CodeBlock, this.blocks, function(b) {
return position < b.Start ? 1 : position >= b.End ? -1 : 0
});
return System.Array.getItem(this.Blocks, index, Kusto.Language.Editor.CodeBlock)
}
return null
},
TryGetTextPosition: function(line, lineOffset, position) {
var lineStart, lineEnd, lineLength;
if (line = line - 1 | 0, lineOffset = lineOffset - 1 | 0, position.v = 0, line < 0 || line >= this.lineStarts.Count) return !1;
for (lineStart = this.lineStarts.getItem(line), lineEnd = line < (this.lineStarts.Count - 1 | 0) ? this.lineStarts.getItem(line + 1 | 0) : this.Text.length; lineEnd > lineStart && Kusto.Language.Parsing.TextFacts.GetLineBreakLength(this.Text, lineEnd - 1 | 0) > 0;) lineEnd = lineEnd - 1 | 0;
return (lineLength = lineEnd - lineStart | 0, lineOffset < (lineLength + 1 | 0)) ? (position.v = lineStart + lineOffset | 0, !0) : !1
},
TryGetLineAndOffset: function(position, line, lineOffset) {
return Kusto.Language.Parsing.TextFacts.TryGetLineAndOffset(this.Text, position, this.lineStarts, line, lineOffset)
}
}
});
Bridge.define("Kusto.Language.Editor.CodeService");
Bridge.define("Kusto.Language.Editor.CodeServiceFactory", {
methods: {
GetFactory: function(TFactory) {
return Bridge.is(this, TFactory) ? Bridge.cast(this, TFactory) : null
},
WithFactory: function(factory) {
var af;
return (af = Bridge.as(factory, Kusto.Language.Editor.CodeServiceFactory.AggregateCodeServiceFactory)) != null ? af.WithFactory(this) : Bridge.referenceEquals(Bridge.getType(factory), Bridge.getType(this)) ? factory : new Kusto.Language.Editor.CodeServiceFactory.AggregateCodeServiceFactory(System.Array.init([this], Kusto.Language.Editor.CodeServiceFactory)).WithFactory(factory)
}
}
});
Bridge.define("Kusto.Language.Editor.CodeServiceFeatures", {
statics: {
fields: {
Diagnostics: null,
Classification: null,
Completion: null,
Outlining: null,
QuickInfo: null,
ClusterReferences: null,
DatabaseReferences: null,
MinimalText: null,
Formatting: null,
ClientParameters: null
},
ctors: {
init: function() {
this.Diagnostics = "Diagnostics";
this.Classification = "Classification";
this.Completion = "Completion";
this.Outlining = "Outlining";
this.QuickInfo = "QuickInfo";
this.ClusterReferences = "ClusterReferences";
this.DatabaseReferences = "DatabaseReferences";
this.MinimalText = "MinimalText";
this.Formatting = "Formatting";
this.ClientParameters = "ClientParameters"
}
}
}
});
Bridge.define("Kusto.Language.Editor.CompletionHint", {
$kind: "enum",
statics: {
fields: {
None: 0,
Inherit: 1,
Expression: 2,
Scalar: 4,
Tabular: 8,
Boolean: 16,
Number: 32,
Literal: 64,
Aggregate: 128,
TabularFunction: 256,
ScalarFunction: 512,
DatabaseFunction: 1024,
Function: 2048,
Declaration: 4096,
Column: 8192,
Table: 16384,
Database: 32768,
Cluster: 65536,
Syntax: 131072,
Query: 262144,
Command: 524288,
Keyword: 1048576,
Clause: 2097152
}
},
$flags: !0
});
Bridge.define("Kusto.Language.Editor.CompletionInfo", {
statics: {
fields: {
Empty: null
},
ctors: {
init: function() {
this.Empty = new Kusto.Language.Editor.CompletionInfo(null, 0, 0)
}
}
},
props: {
Items: null,
EditStart: 0,
EditLength: 0
},
ctors: {
ctor: function(items, editStart, editLength) {
this.$initialize();
this.Items = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Editor.CompletionItem, items);
this.EditStart = editStart;
this.EditLength = editLength
}
}
});
Bridge.define("Kusto.Language.Editor.CompletionItem", {
props: {
Kind: 0,
DisplayText: null,
MatchText: null,
EditText: null,
AfterText: null,
Priority: 0
},
ctors: {
ctor: function(kind, displayText, editText, afterText, matchText, priority) {
editText === void 0 && (editText = null);
afterText === void 0 && (afterText = null);
matchText === void 0 && (matchText = null);
priority === void 0 && (priority = 2);
var $t, $t1, $t2;
this.$initialize();
this.DisplayText = ($t = displayText, $t != null ? $t : "");
this.Kind = kind;
this.EditText = ($t1 = editText, $t1 != null ? $t1 : this.DisplayText);
this.AfterText = afterText;
this.MatchText = ($t2 = matchText, $t2 != null ? $t2 : displayText);
this.Priority = priority
}
},
methods: {
WithKind: function(kind) {
return new Kusto.Language.Editor.CompletionItem(kind, this.DisplayText, this.EditText, this.AfterText, this.MatchText, this.Priority)
},
WithDisplayText: function(displayText) {
return new Kusto.Language.Editor.CompletionItem(this.Kind, displayText, this.EditText, this.AfterText, this.MatchText, this.Priority)
},
WithEditText: function(editText) {
return new Kusto.Language.Editor.CompletionItem(this.Kind, this.DisplayText, editText, this.AfterText, this.MatchText, this.Priority)
},
WithAfterText: function(afterText) {
return new Kusto.Language.Editor.CompletionItem(this.Kind, this.DisplayText, this.EditText, afterText, this.MatchText, this.Priority)
},
WithMatchText: function(matchText) {
return new Kusto.Language.Editor.CompletionItem(this.Kind, this.DisplayText, this.EditText, this.AfterText, matchText, this.Priority)
},
WithPriority: function(priority) {
return new Kusto.Language.Editor.CompletionItem(this.Kind, this.DisplayText, this.EditText, this.AfterText, this.MatchText, priority)
}
}
});
Bridge.define("Kusto.Language.Editor.CompletionKind", {
$kind: "enum",
statics: {
fields: {
Unknown: 0,
Keyword: 1,
Punctuation: 2,
Syntax: 3,
Identifier: 4,
Example: 5,
ScalarPrefix: 6,
TabularPrefix: 7,
TabularSuffix: 8,
QueryPrefix: 9,
CommandPrefix: 10,
ScalarInfix: 11,
RenderChart: 12,
Column: 13,
Table: 14,
BuiltInFunction: 15,
LocalFunction: 16,
DatabaseFunction: 17,
AggregateFunction: 18,
Parameter: 19,
Variable: 20,
Database: 21,
Cluster: 22,
MaterialiedView: 23,
ScalarType: 24
}
}
});
Bridge.define("Kusto.Language.Editor.CompletionOptions", {
statics: {
fields: {
Default: null
},
ctors: {
init: function() {
this.Default = new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.OptionFlags.Default, Kusto.Language.IncludeFunctionKind.All)
}
},
methods: {
SetOption: function(flags, option, value) {
return value ? flags | option : flags & ~option
}
}
},
fields: {
flags: 0
},
props: {
IncludeSymbols: {
get: function() {
return (this.flags & Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludeSymbols) != 0
}
},
IncludeSyntax: {
get: function() {
return (this.flags & Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludeSyntax) != 0
}
},
IncludePunctuationOnlySyntax: {
get: function() {
return (this.flags & Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludePunctuation) != 0
}
},
EnableParameterInjection: {
get: function() {
return (this.flags & Kusto.Language.Editor.CompletionOptions.OptionFlags.EnableParameterInjection) != 0
}
},
AutoAppendWhitespace: {
get: function() {
return (this.flags & Kusto.Language.Editor.CompletionOptions.OptionFlags.AutoAppendWhitespace) != 0
}
},
IncludeFunctions: 0
},
ctors: {
ctor: function(flags, includeFunctionKind) {
this.$initialize();
this.flags = flags;
this.IncludeFunctions = includeFunctionKind
}
},
methods: {
WithIncludeSymbols: function(include) {
return new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.SetOption(this.flags, Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludeSymbols, include), this.IncludeFunctions)
},
WithIncludeFunctions: function(kind) {
return new Kusto.Language.Editor.CompletionOptions(this.flags, kind)
},
WithIncludeFunctions$1: function(include) {
return new Kusto.Language.Editor.CompletionOptions(this.flags, include ? Kusto.Language.IncludeFunctionKind.All : Kusto.Language.IncludeFunctionKind.None)
},
WithIncludeSyntax: function(include) {
return new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.SetOption(this.flags, Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludeSyntax, include), this.IncludeFunctions)
},
WithIncludePunctuationOnlySyntax: function(include) {
return new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.SetOption(this.flags, Kusto.Language.Editor.CompletionOptions.OptionFlags.IncludePunctuation, include), this.IncludeFunctions)
},
WithEnableParameterInjection: function(enable) {
return new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.SetOption(this.flags, Kusto.Language.Editor.CompletionOptions.OptionFlags.EnableParameterInjection, enable), this.IncludeFunctions)
},
WithAutoAppendWhitespace: function(enable) {
return new Kusto.Language.Editor.CompletionOptions(Kusto.Language.Editor.CompletionOptions.SetOption(this.flags, Kusto.Language.Editor.CompletionOptions.OptionFlags.AutoAppendWhitespace, enable), this.IncludeFunctions)
}
}
});
Bridge.define("Kusto.Language.Editor.CompletionOptions.OptionFlags", {
$kind: "nested enum",
statics: {
fields: {
IncludeSymbols: 1,
IncludeSyntax: 2,
IncludePunctuation: 4,
EnableParameterInjection: 16,
AutoAppendWhitespace: 32,
Default: 39
}
},
$flags: !0
});
Bridge.define("Kusto.Language.Editor.CompletionPriority", {
$kind: "enum",
statics: {
fields: {
Top: 0,
High: 1,
Normal: 2,
Low: 3
}
}
});
Bridge.define("Kusto.Language.Editor.FindRelatedOptions", {
$kind: "enum",
statics: {
fields: {
None: 0,
SeeThroughVariables: 1
}
},
$flags: !0
});
Bridge.define("Kusto.Language.Editor.FormattedText", {
props: {
Text: null,
Position: 0
},
ctors: {
ctor: function(newText, newPosition) {
this.$initialize();
this.Text = newText;
this.Position = newPosition
}
}
});
Bridge.define("Kusto.Language.Editor.FormattingOptions", {
statics: {
fields: {
Default: null
},
ctors: {
init: function() {
this.Default = new Kusto.Language.Editor.FormattingOptions(4, !0, Kusto.Language.Editor.BrackettingStyle.Vertical, Kusto.Language.Editor.PlacementStyle.Smart, Kusto.Language.Editor.PlacementStyle.None)
}
}
},
props: {
IndentationSize: 0,
InsertMissingTokens: !1,
BrackettingStyle: 0,
PipeOperatorStyle: 0,
SemicolonStyle: 0
},
ctors: {
ctor: function(indentationSize, insertMissingTokens, brackettingStyle, pipeOperatorStyle, semicolonStyle) {
this.$initialize();
this.IndentationSize = indentationSize;
this.InsertMissingTokens = insertMissingTokens;
this.BrackettingStyle = brackettingStyle;
this.PipeOperatorStyle = pipeOperatorStyle;
this.SemicolonStyle = semicolonStyle
}
},
methods: {
With: function(indentationSize, insertMissingTokens, brackettingStyle, pipeOperatorStyle, semicolonStyle) {
indentationSize === void 0 && (indentationSize = null);
insertMissingTokens === void 0 && (insertMissingTokens = null);
brackettingStyle === void 0 && (brackettingStyle = null);
pipeOperatorStyle === void 0 && (pipeOperatorStyle = null);
semicolonStyle === void 0 && (semicolonStyle = null);
var newIndentationSize = System.Nullable.hasValue(indentationSize) ? System.Nullable.getValue(indentationSize) : this.IndentationSize,
newInsertMissingTokens = System.Nullable.hasValue(insertMissingTokens) ? System.Nullable.getValue(insertMissingTokens) : this.InsertMissingTokens,
newBrackettingStyle = System.Nullable.hasValue(brackettingStyle) ? System.Nullable.getValue(brackettingStyle) : this.BrackettingStyle,
newPipeOperatorStyle = System.Nullable.hasValue(pipeOperatorStyle) ? System.Nullable.getValue(pipeOperatorStyle) : this.PipeOperatorStyle,
newSemicolonStyle = System.Nullable.hasValue(semicolonStyle) ? System.Nullable.getValue(semicolonStyle) : this.SemicolonStyle;
return newIndentationSize !== this.IndentationSize || newInsertMissingTokens !== this.InsertMissingTokens || newBrackettingStyle !== this.BrackettingStyle || newPipeOperatorStyle !== this.PipeOperatorStyle || newSemicolonStyle !== this.SemicolonStyle ? new Kusto.Language.Editor.FormattingOptions(newIndentationSize, newInsertMissingTokens, newBrackettingStyle, newPipeOperatorStyle, newSemicolonStyle) : this
},
WithIndentationSize: function(size) {
return this.With(size, void 0, void 0, void 0, void 0)
},
WithInsertMissingTokens: function(enable) {
return this.With(void 0, enable, void 0, void 0, void 0)
},
WithBrackettingStyle: function(style) {
return this.With(void 0, void 0, style, void 0, void 0)
},
WithPipeOperatorStyle: function(style) {
return this.With(void 0, void 0, void 0, style, void 0)
},
WithSemicolonStyle: function(style) {
return this.With(void 0, void 0, void 0, void 0, style)
}
}
});
Bridge.define("Kusto.Language.Editor.KustoAnalyzers", {
statics: {
fields: {
AvoidUsingContains: null,
AvoidUsingShortStringComparision: null,
NullAggregation: null,
All: null
},
ctors: {
init: function() {
this.AvoidUsingContains = new Kusto.Language.Editor.AvoidUsingContainsAnalyzer;
this.AvoidUsingShortStringComparision = new Kusto.Language.Editor.AvoidUsingShortStringComparisonRule;
this.NullAggregation = new Kusto.Language.Editor.NullAggregationDetector;
this.All = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Editor.KustoAnalyzer, System.Array.init([Kusto.Language.Editor.KustoAnalyzers.AvoidUsingContains, Kusto.Language.Editor.KustoAnalyzers.AvoidUsingShortStringComparision, Kusto.Language.Editor.KustoAnalyzers.NullAggregation], Kusto.Language.Editor.KustoAnalyzer))
}
}
}
});
Bridge.define("Kusto.Language.Editor.KustoClassifier", {
statics: {
methods: {
GetClassifications: function(root, start, length, clipToRange, list, cancellationToken) {
var end = start + length | 0,
limiter = function(range) {
var clipStart, clipEnd, last;
if (range.End > start && range.Start < end) {
if (clipToRange && (range.Start < start || range.End > end) && (clipStart = Math.max(range.Start, start), clipEnd = Math.min(range.End, end), range = new Kusto.Language.Editor.ClassifiedRange(range.Kind, clipStart, clipEnd - clipStart | 0)), list.Count > 0 && (last = list.getItem(list.Count - 1 | 0), last.Kind === range.Kind && last.End === range.Start)) {
list.setItem(list.Count - 1 | 0, new Kusto.Language.Editor.ClassifiedRange(last.Kind, last.Start, last.Length + range.Length | 0));
return
}
list.add(range)
}
};
root.WalkTokens$1(start, end, function(token) {
if (cancellationToken.ThrowIfCancellationRequested(), Kusto.Language.Editor.KustoClassifier.GetTriviaClassifications(token, limiter), token.IsLiteral && token.Prefix.length > 0) limiter(new Kusto.Language.Editor.ClassifiedRange(Kusto.Language.Editor.ClassificationKind.Keyword, token.TextStart, token.Prefix.length)), limiter(new Kusto.Language.Editor.ClassifiedRange(Kusto.Language.Editor.ClassificationKind.Literal, token.TextStart + token.Prefix.length | 0, token.Text.length - token.Prefix.length | 0));
else {
var kind = Kusto.Language.Editor.KustoClassifier.GetKind(token);
limiter(new Kusto.Language.Editor.ClassifiedRange(kind, token.TextStart, token.Width))
}
})
},
GetKind: function(token) {
var $step = 0,
$t, $asyncBody = Bridge.fn.bind(this, function() {
for (;;) {
$step = System.Array.min([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], $step);
switch ($step) {
case 0:
if (Kusto.Language.Editor.KustoClassifier.IsSkipped(token)) return Kusto.Language.Editor.ClassificationKind.PlainText;
if (Kusto.Language.Editor.KustoClassifier.IsCommandVerbToken(token)) return Kusto.Language.Editor.ClassificationKind.Command;
if (Bridge.is(token.Parent, Kusto.Language.Syntax.BracedName)) return Kusto.Language.Editor.ClassificationKind.ClientParameter;
if ($t = Kusto.Language.Syntax.SyntaxFacts.GetCategory(token.Kind), $t === Kusto.Language.Syntax.SyntaxCategory.Identifier) {
$step = 1;
continue
} else if ($t === Kusto.Language.Syntax.SyntaxCategory.Literal) {
$step = 2;
continue
} else if ($t === Kusto.Language.Syntax.SyntaxCategory.Keyword) {
$step = 3;
continue
} else if ($t === Kusto.Language.Syntax.SyntaxCategory.Punctuation) {
$step = 7;
continue
} else if ($t === Kusto.Language.Syntax.SyntaxCategory.Operator) {
$step = 8;
continue
} else {
$step = 9;
continue
}
$step = 10;
continue;
case 1:
return Kusto.Language.Editor.KustoClassifier.IsQueryParameter(token) ? Kusto.Language.Editor.ClassificationKind.QueryParameter : Kusto.Language.Editor.KustoClassifier.GetIdentifierKind(token);
case 2:
return token.Kind === Kusto.Language.Syntax.SyntaxKind.StringLiteralToken ? Kusto.Language.Editor.ClassificationKind.StringLiteral : Kusto.Language.Editor.ClassificationKind.Literal;
case 3:
if (Kusto.Language.Editor.KustoClassifier.IsIdentifierKeyword(token)) {
$step = 4;
continue
} else {
$step = 5;
continue
}
case 4:
$step = 1;
continue;
case 5:
return Kusto.Language.Editor.KustoClassifier.IsTypeToken(token) ? Kusto.Language.Editor.ClassificationKind.Type : Kusto.Language.Editor.KustoClassifier.IsScalarOperatorToken(token) ? Kusto.Language.Editor.ClassificationKind.ScalarOperator : Kusto.Language.Editor.KustoClassifier.IsQueryOperatorToken(token) ? Kusto.Language.Editor.ClassificationKind.QueryOperator : Kusto.Language.Editor.KustoClassifier.IsQueryParameter(token) ? Kusto.Language.Editor.ClassificationKind.QueryParameter : Kusto.Language.Editor.KustoClassifier.IsCommandVerbToken(token) ? Kusto.Language.Editor.ClassificationKind.Command : Kusto.Language.Editor.ClassificationKind.Keyword;
case 6:
case 7:
return Kusto.Language.Editor.ClassificationKind.Punctuation;
case 8:
return Kusto.Language.Editor.ClassificationKind.MathOperator;
case 9:
return token.Kind === Kusto.Language.Syntax.SyntaxKind.DirectiveToken ? Kusto.Language.Editor.ClassificationKind.Directive : Kusto.Language.Editor.ClassificationKind.PlainText;
case 10:
return;
default:
return
}
}
}, arguments);
return $asyncBody()
},
GetIdentifierKind: function(token) {
var $t, $t1, symbolKind = ($t = ($t1 = token.Parent.GetFirstAncestorOrSelf(Kusto.Language.Syntax.SyntaxNode, function(n) {
return n.ReferencedSymbol != null
})) != null ? $t1.ReferencedSymbol.Kind : null, $t != null ? $t : Kusto.Language.Symbols.SymbolKind.None);
switch (symbolKind) {
case Kusto.Language.Symbols.SymbolKind.Column:
return Kusto.Language.Editor.ClassificationKind.Column;
case Kusto.Language.Symbols.SymbolKind.Table:
return Kusto.Language.Editor.ClassificationKind.Table;
case Kusto.Language.Symbols.SymbolKind.Database:
return Kusto.Language.Editor.ClassificationKind.Database;
case Kusto.Language.Symbols.SymbolKind.Function:
case Kusto.Language.Symbols.SymbolKind.Pattern:
return Kusto.Language.Editor.ClassificationKind.Function;
case Kusto.Language.Symbols.SymbolKind.Variable:
return Kusto.Language.Editor.ClassificationKind.Variable;
case Kusto.Language.Symbols.SymbolKind.Parameter:
return Kusto.Language.Editor.ClassificationKind.Parameter;
case Kusto.Language.Symbols.SymbolKind.MaterializedView:
return Kusto.Language.Editor.ClassificationKind.MaterializedView;
default:
return Kusto.Language.Editor.KustoClassifier.IsName(token) ? Kusto.Language.Editor.ClassificationKind.Identifier : Kusto.Language.Editor.ClassificationKind.Keyword
}
},
IsSkipped: function(token) {
var ls;
return (ls = Bridge.as(token.Parent, Kusto.Language.Syntax.SyntaxList)) != null && Bridge.is(ls.Parent, Kusto.Language.Syntax.SkippedTokens)
},
IsName: function(token) {
return Bridge.is(token.Parent, Kusto.Language.Syntax.Name)
},
IsIdentifierKeyword: function(token) {
return Bridge.is(token.Parent, Kusto.Language.Syntax.TokenName)
},
IsTypeToken: function(token) {
var pt, type;
return (pt = Bridge.as(token.Parent, Kusto.Language.Syntax.PrimitiveTypeExpression)) != null ? (type = Kusto.Language.Binding.Binder.GetType(pt), type != null && !type.IsError) : !1
},
IsScalarOperatorToken: function(token) {
var b, u;
return (b = Bridge.as(token.Parent, Kusto.Language.Syntax.BinaryExpression)) != null && Bridge.referenceEquals(b.Operator, token) || (u = Bridge.as(token.Parent, Kusto.Language.Syntax.PrefixUnaryExpression)) != null && Bridge.referenceEquals(u.Operator, token)
},
IsQueryOperatorToken: function(token) {
var q, tc;
return (q = Bridge.as(token.Parent, Kusto.Language.Syntax.QueryOperator)) != null && Bridge.referenceEquals(q.GetChild(0), token) || (tc = Bridge.as(token.Parent, Kusto.Language.Syntax.TopNestedClause)) != null && Bridge.referenceEquals(tc.GetChild(0), token)
},
IsQueryParameter: function(token) {
var n, d, np;
return (n = Bridge.as(token.Parent, Kusto.Language.Syntax.Name)) != null && (d = Bridge.as(n.Parent, Kusto.Language.Syntax.NameDeclaration)) != null && (np = Bridge.as(d.Parent, Kusto.Language.Syntax.NamedParameter)) != null && Bridge.referenceEquals(np.GetChild(0), d)
},
IsCommandVerbToken: function(token) {
var c, cn, list, uc;
return (c = Bridge.as(token.Parent, Kusto.Language.Syntax.Command)) != null && c.GetChildIndex(token) < 2 || (cn = Bridge.as(token.Parent, Kusto.Language.Syntax.CustomNode)) != null && Bridge.is(cn.Parent, Kusto.Language.Syntax.CustomCommand) && cn.GetChildIndex(token) === 0 || (list = Bridge.as(token.Parent, Kusto.Language.Syntax.SyntaxList)) != null && (uc = Bridge.as(list.Parent, Kusto.Language.Syntax.UnknownCommand)) != null && Bridge.referenceEquals(uc.Parts.getItem$1(0), token)
},
GetTriviaClassifications: function(token, action) {
var trivia, i, start;
if (token.TriviaWidth > 0)
for (trivia = token.Trivia, i = 0; i < trivia.length; i = i + 1 | 0)
if (!Kusto.Language.Parsing.TextFacts.IsWhitespace(trivia.charCodeAt(i))) {
for (start = i; i < trivia.length; i = i + 1 | 0)
if (Kusto.Language.Parsing.TextFacts.IsLineBreakStart(trivia.charCodeAt(i))) break;
action(new Kusto.Language.Editor.ClassifiedRange(Kusto.Language.Editor.ClassificationKind.Comment, token.TriviaStart + start | 0, i - start | 0))
}
}
}
}
});
Bridge.define("Kusto.Language.Editor.KustoCompleter", {
statics: {
fields: {
AfterQueryStart: null,
s_parameterListPool: null,
punctuationWithoutSpace: null
},
ctors: {
init: function() {
this.AfterQueryStart = "\n| ";
this.s_parameterListPool = new(Kusto.Language.Utils.ObjectPool$1(System.Collections.Generic.List$1(Kusto.Language.Symbols.Parameter)))(function() {
return new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Parameter).ctor)
}, function(list) {
list.clear()
});
this.punctuationWithoutSpace = System.Array.init(["(", "[", "{", "*", "@", "$"], System.String)
}
},
methods: {
IsInsideComment: function(trivia, position) {
for (var ch, lbLen, p = 0; p < trivia.length; p = p + 1 | 0) {
if (position === p) break;
if (ch = trivia.charCodeAt(p), !Kusto.Language.Parsing.TextFacts.IsWhitespace(ch)) {
for (var start = p, end = p, hasLineBreak = !1; end < trivia.length; end = end + 1 | 0)
if (lbLen = Kusto.Language.Parsing.TextFacts.GetLineBreakLength(trivia, end), lbLen > 0) {
end = end + lbLen | 0;
hasLineBreak = !0;
break
} if (p = end - 1 | 0, hasLineBreak && position >= start && position < end || !hasLineBreak && position >= start) return !0
}
}
return !1
},
IsInsideLiteral: function(token, position) {
return Kusto.Language.Syntax.SyntaxFacts.GetCategory(token.Kind) === Kusto.Language.Syntax.SyntaxCategory.Literal && position >= token.TextStart && position <= token.End
},
IsStartOfQuery: function(context) {
while (Bridge.is(context, Kusto.Language.Syntax.Name) || Bridge.is(context, Kusto.Language.Syntax.NameReference) || Bridge.is(context, Kusto.Language.Syntax.ExpressionStatement)) context = context.Parent;
return Bridge.is(context, Kusto.Language.Syntax.QueryBlock) || Bridge.is(context, Kusto.Language.Syntax.SyntaxList$1(Kusto.Language.Syntax.SeparatedElement$1(Kusto.Language.Syntax.Statement))) || Bridge.is(context, Kusto.Language.Syntax.SeparatedElement$1(Kusto.Language.Syntax.Statement))
},
IsInvokeFunctionContext: function(node) {
var op = node != null ? node.GetFirstAncestorOrSelf(Kusto.Language.Syntax.QueryOperator) : null,
fc = node != null ? node.GetFirstAncestorOrSelf(Kusto.Language.Syntax.FunctionCallExpression) : null;
return Bridge.is(op, Kusto.Language.Syntax.InvokeOperator) && (fc == null || fc.TextStart < op.TextStart)
},
IsNameToken: function(kind) {
switch (Kusto.Language.Syntax.SyntaxFacts.GetCategory(kind)) {
case Kusto.Language.Syntax.SyntaxCategory.Identifier:
case Kusto.Language.Syntax.SyntaxCategory.Keyword:
return !0;
default:
return !1
}
},
HasAffinity$1: function(token, position) {
return position > token.TextStart && position < token.End || position === token.TextStart && Kusto.Language.Editor.KustoCompleter.IsNameToken(token.Kind) || position === token.End && Kusto.Language.Editor.KustoCompleter.IsNameToken(token.Kind)
},
HasAffinity: function(token, position) {
return position > token.TextStart && position < token.End || position === token.TextStart && Kusto.Language.Editor.KustoCompleter.IsNameToken(token.Kind) || position === token.End && Kusto.Language.Editor.KustoCompleter.IsNameToken(token.Kind)
},
ContainsOnlyOneToken: function(node) {
while (node != null && node.ChildCount === 1) {
var child = node.GetChild(0);
if (Bridge.is(child, Kusto.Language.Syntax.SyntaxToken)) return !0;
node = Bridge.as(child, Kusto.Language.Syntax.SyntaxNode)
}
return !1
},
GetLeftOfFunctionCall: function(expression) {
var parent = expression.Parent,
el, fc, pe;
return ((el = Bridge.as(parent, Kusto.Language.Syntax.ExpressionList)) != null && (parent = el.Parent), (fc = Bridge.as(parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && (parent = fc.Parent), (pe = Bridge.as(parent, Kusto.Language.Syntax.PathExpression)) != null) ? pe.Expression : null
},
GetSymbolMatch: function(hint) {
var match = Kusto.Language.Symbols.SymbolMatch.None;
return (hint & Kusto.Language.Editor.CompletionHint.Column) != 0 && (match |= Kusto.Language.Symbols.SymbolMatch.Column), (hint & Kusto.Language.Editor.CompletionHint.TabularFunction) != 0 && (match |= 280), (hint & 640) != 0 && (match |= 152), (hint & 3072) != 0 && (match |= Kusto.Language.Symbols.SymbolMatch.Function), (hint & 52) != 0 && (match |= 153), (hint & Kusto.Language.Editor.CompletionHint.Tabular) != 0 && (match |= 794), (hint & Kusto.Language.Editor.CompletionHint.Expression) != 0 && (match |= 411), (hint & Kusto.Language.Editor.CompletionHint.Table) != 0 && (match |= Kusto.Language.Symbols.SymbolMatch.Table), (hint & Kusto.Language.Editor.CompletionHint.Database) != 0 && (match |= Kusto.Language.Symbols.SymbolMatch.Database), (hint & Kusto.Language.Editor.CompletionHint.Cluster) != 0 && (match |= Kusto.Language.Symbols.SymbolMatch.Cluster), match
},
IsChildMissingOrEmpty: function(contextNode, childIndex) {
return Kusto.Language.Editor.KustoCompleter.IsChildMissing(contextNode, childIndex) || Kusto.Language.Editor.KustoCompleter.IsChildEmpty(contextNode, childIndex)
},
IsChildMissing: function(node, index) {
var child = node.GetChild(index);
return child != null && child.IsMissing
},
IsChildEmpty: function(node, index) {
var child = node.GetChild(index);
return (child == null || child.Width === 0) && !Kusto.Language.Editor.KustoCompleter.IsChildMissing(node, index)
},
GetChildIndex: function(node, position) {
for (var child, bestEmptyChild, i1, child1, firstChildBeyond = node.ChildCount, lastWasNullOrEmpty = !1, i = 0, n = node.ChildCount; i < n; i = i + 1 | 0)
if (child = node.GetChild(i), child != null) {
if (position > child.TextStart && position < child.End && child.Width > 0) return i;
if (position < child.TextStart) {
firstChildBeyond = i;
break
} else if (position === child.TextStart) {
if (child.Width === 0) {
firstChildBeyond = i + 1 | 0;
break
} else if (lastWasNullOrEmpty) {
firstChildBeyond = i;
break
}
} else lastWasNullOrEmpty = child.Width === 0
} else lastWasNullOrEmpty = !0;
for (bestEmptyChild = firstChildBeyond - 1 | 0, i1 = firstChildBeyond - 1 | 0; i1 >= 0; i1 = i1 - 1 | 0)
if (child1 = node.GetChild(i1), child1 != null && child1.Width > 0) break;
else bestEmptyChild = i1;
return bestEmptyChild
},
HasEmptyChild: function(element, position) {
var hasEmptyChild, i, n, child;
if (element == null) return !1;
if (position >= element.End && element.Kind === Kusto.Language.Syntax.SyntaxKind.List) return !0;
for (hasEmptyChild = !1, i = 0, n = element.ChildCount; i < n; i = i + 1 | 0) {
if (child = element.GetChild(i), child != null) {
if (position <= child.TextStart && hasEmptyChild) return !0;
if (position < child.End) return !1
}
hasEmptyChild = child == null || child.Width === 0
}
return hasEmptyChild
},
GetNearestAncestorWithEmptyChild: function(token, position) {
for (var node = token.Parent; node != null && !Kusto.Language.Editor.KustoCompleter.HasEmptyChild(node, position);) node = node.Parent;
return node
},
HasLetters: function(text) {
var $t, ch;
$t = Bridge.getEnumerator(text);
try {
while ($t.moveNext())
if (ch = $t.Current, System.Char.isLetter(ch)) return !0
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !1
},
ReturnTypeMatchesContext: function(signature, arg0Type, returnTypeHint) {
return (returnTypeHint & Kusto.Language.Editor.CompletionHint.Boolean) != 0 ? Kusto.Language.Editor.KustoCompleter.IsBooleanReturnType(signature, arg0Type) : (returnTypeHint & Kusto.Language.Editor.CompletionHint.Scalar) != 0 || (returnTypeHint & Kusto.Language.Editor.CompletionHint.Aggregate) != 0 ? Kusto.Language.Editor.KustoCompleter.IsNonBooleanScalarReturnType(signature, arg0Type) : (returnTypeHint & Kusto.Language.Editor.CompletionHint.Number) != 0 ? Kusto.Language.Editor.KustoCompleter.IsNumericReturnType(signature, arg0Type) : (returnTypeHint & Kusto.Language.Editor.CompletionHint.Column) != 0 ? !1 : !0
},
IsBooleanReturnType: function(signature, arg0Type) {
switch (signature.ReturnKind) {
case Kusto.Language.Symbols.ReturnTypeKind.Common:
case Kusto.Language.Symbols.ReturnTypeKind.Widest:
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0:
var s;
return (s = Bridge.as(arg0Type, Kusto.Language.Symbols.ScalarSymbol)) != null && Bridge.referenceEquals(s, Kusto.Language.Symbols.ScalarTypes.Bool);
case Kusto.Language.Symbols.ReturnTypeKind.Declared:
return Bridge.referenceEquals(signature.DeclaredReturnType, Kusto.Language.Symbols.ScalarTypes.Bool);
default:
return !1
}
},
IsNonBooleanScalarReturnType: function(signature, arg0Type) {
switch (signature.ReturnKind) {
case Kusto.Language.Symbols.ReturnTypeKind.Common:
case Kusto.Language.Symbols.ReturnTypeKind.Widest:
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0:
var s;
return (s = Bridge.as(arg0Type, Kusto.Language.Symbols.ScalarSymbol)) != null && !Bridge.referenceEquals(s, Kusto.Language.Symbols.ScalarTypes.Bool);
case Kusto.Language.Symbols.ReturnTypeKind.Declared:
return signature.DeclaredReturnType.IsScalar && !Bridge.referenceEquals(signature.DeclaredReturnType, Kusto.Language.Symbols.ScalarTypes.Bool);
default:
return !1
}
},
IsNumericReturnType: function(signature, arg0Type) {
var s, s2;
switch (signature.ReturnKind) {
case Kusto.Language.Symbols.ReturnTypeKind.Common:
case Kusto.Language.Symbols.ReturnTypeKind.Widest:
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0:
return (s = Bridge.as(arg0Type, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsNumeric;
case Kusto.Language.Symbols.ReturnTypeKind.Declared:
return (s2 = Bridge.as(signature.DeclaredReturnType, Kusto.Language.Symbols.ScalarSymbol)) != null && s2.IsNumeric;
default:
return !1
}
},
ParameterMatches: function(parameter, type) {
var s, s2, s3, tab, s4;
switch (parameter.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
if (Kusto.Language.Binding.Binder.SymbolsAssignable$1(parameter.DeclaredTypes, type) || Kusto.Language.Binding.Binder.IsPromotable(type, System.Array.getItem(parameter.DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol))) return !0;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Scalar:
return type.IsScalar;
case Kusto.Language.Symbols.ParameterTypeKind.Integer:
return (s = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsInteger;
case Kusto.Language.Symbols.ParameterTypeKind.RealOrDecimal:
return Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Real) || Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Decimal);
case Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic:
return Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.String) || Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Dynamic);
case Kusto.Language.Symbols.ParameterTypeKind.Number:
return (s2 = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s2.IsNumeric;
case Kusto.Language.Symbols.ParameterTypeKind.Summable:
return (s3 = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s3.IsSummable;
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
return type.IsTabular;
case Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable:
return (tab = Bridge.as(type, Kusto.Language.Symbols.TableSymbol)) != null && System.Array.getCount(tab.Columns, Kusto.Language.Symbols.ColumnSymbol) === 1;
case Kusto.Language.Symbols.ParameterTypeKind.Database:
return Bridge.is(type, Kusto.Language.Symbols.DatabaseSymbol);
case Kusto.Language.Symbols.ParameterTypeKind.Cluster:
return Bridge.is(type, Kusto.Language.Symbols.ClusterSymbol);
case Kusto.Language.Symbols.ParameterTypeKind.NotBool:
return Bridge.is(type, Kusto.Language.Symbols.ScalarSymbol) && !Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Bool);
case Kusto.Language.Symbols.ParameterTypeKind.NotRealOrBool:
return Bridge.is(type, Kusto.Language.Symbols.ScalarSymbol) && !Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Real) && !Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Bool);
case Kusto.Language.Symbols.ParameterTypeKind.NotDynamic:
return Bridge.is(type, Kusto.Language.Symbols.ScalarSymbol) && !Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Dynamic);
case Kusto.Language.Symbols.ParameterTypeKind.IntegerOrDynamic:
return (s4 = Bridge.as(type, Kusto.Language.Symbols.ScalarSymbol)) != null && s4.IsInteger || Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Dynamic);
case Kusto.Language.Symbols.ParameterTypeKind.Parameter0:
case Kusto.Language.Symbols.ParameterTypeKind.Parameter1:
case Kusto.Language.Symbols.ParameterTypeKind.Parameter2:
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalar:
case Kusto.Language.Symbols.ParameterTypeKind.CommonNumber:
case Kusto.Language.Symbols.ParameterTypeKind.CommonSummable:
case Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic:
return Bridge.is(type, Kusto.Language.Symbols.ScalarSymbol)
}
return !1
},
GetOperatorKind: function(opText) {
var kind = {
v: new Kusto.Language.Syntax.SyntaxKind
};
return Kusto.Language.Syntax.SyntaxFacts.TryGetKind(opText, kind) ? Kusto.Language.Syntax.SyntaxFacts.GetOperatorKind(kind.v) : Kusto.Language.Symbols.OperatorKind.None
}
}
},
fields: {
code: null,
options: null,
cancellationToken: null
},
ctors: {
init: function() {
this.cancellationToken = new Kusto.Language.Utils.CancellationToken
},
ctor: function(code, options, cancellationToken) {
this.$initialize();
this.code = code;
this.options = options;
this.cancellationToken = cancellationToken
}
},
methods: {
GetCompletionItems: function(position) {
var $t, $t1, completionToken = this.GetTokenWithAffinity(position),
editStart = ($t = completionToken != null ? completionToken.TextStart : null, $t != null ? $t : position),
editLength = ($t1 = completionToken != null ? completionToken.Width : null, $t1 != null ? $t1 : 0),
builder, mode, items, orderedItems;
return this.ShouldComplete(position) ? (builder = new Kusto.Language.Editor.KustoCompleter.CompletionBuilder, mode = Kusto.Language.Editor.KustoCompleter.CompletionMode.Combined, this.options.IncludeSymbols && (mode = this.GetSymbolCompletions(editStart, builder)), mode === Kusto.Language.Editor.KustoCompleter.CompletionMode.Combined && this.options.IncludeSyntax && this.GetSyntaxCompletions(editStart, builder), items = builder.ToList(), orderedItems = System.Linq.Enumerable.from(items).orderBy(Bridge.fn.bind(this, function(i) {
return this.GetOrderingRank(i)
})).thenBy(function(i) {
return i.Priority
}).thenBy(function(i) {
return i.DisplayText.toLowerCase()
}).ToArray(Kusto.Language.Editor.CompletionItem), new Kusto.Language.Editor.CompletionInfo(orderedItems, editStart, editLength)) : new Kusto.Language.Editor.CompletionInfo(Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Editor.CompletionItem).Instance, editStart, editLength)
},
ShouldAutoComplete: function(position, key) {
var token, expr;
if (key === 0 || !this.ShouldComplete(position) || System.Char.isControl(key) && key !== 8 || key === 13 || key === 10) return !1;
if (token = this.GetTokenLeftOfPosition(position), token != null)
if (System.Char.isWhiteSpace(String.fromCharCode(key)) && position === (token.End + 1 | 0)) {
switch (token.Kind) {
case Kusto.Language.Syntax.SyntaxKind.OpenParenToken:
case Kusto.Language.Syntax.SyntaxKind.OpenBracketToken:
case Kusto.Language.Syntax.SyntaxKind.OpenBraceToken:
case Kusto.Language.Syntax.SyntaxKind.CommaToken:
case Kusto.Language.Syntax.SyntaxKind.ColonToken:
case Kusto.Language.Syntax.SyntaxKind.BarToken:
case Kusto.Language.Syntax.SyntaxKind.EqualToken:
case Kusto.Language.Syntax.SyntaxKind.FatArrowToken:
case Kusto.Language.Syntax.SyntaxKind.CloseParenToken:
return !0
}
switch (Kusto.Language.Syntax.SyntaxFacts.GetCategory(token.Kind)) {
case Kusto.Language.Syntax.SyntaxCategory.Identifier:
case Kusto.Language.Syntax.SyntaxCategory.Operator:
case Kusto.Language.Syntax.SyntaxCategory.Keyword:
return !0
}
if (expr = this.GetCompleteExpressionLeftOfPosition(position), expr != null) return !0
} else if (token.End === position) {
if (key === 8) return Kusto.Language.Syntax.SyntaxFacts.GetCategory(token.Kind) === Kusto.Language.Syntax.SyntaxCategory.Identifier;
switch (token.Kind) {
case Kusto.Language.Syntax.SyntaxKind.OpenParenToken:
case Kusto.Language.Syntax.SyntaxKind.OpenBracketToken:
case Kusto.Language.Syntax.SyntaxKind.OpenBraceToken:
case Kusto.Language.Syntax.SyntaxKind.DotToken:
case Kusto.Language.Syntax.SyntaxKind.ColonToken:
case Kusto.Language.Syntax.SyntaxKind.EqualToken:
return !0
}
switch (Kusto.Language.Syntax.SyntaxFacts.GetCategory(token.Kind)) {
case Kusto.Language.Syntax.SyntaxCategory.Identifier:
case Kusto.Language.Syntax.SyntaxCategory.Operator:
case Kusto.Language.Syntax.SyntaxCategory.Keyword:
return !0
}
}
return !1
},
ShouldComplete: function(position) {
var tokenOffset = this.GetTokenIndex(position),
token = System.Array.getItem(this.code.LexerTokens, tokenOffset, Kusto.Language.Parsing.LexicalToken),
previous = tokenOffset > 0 ? System.Array.getItem(this.code.LexerTokens, tokenOffset - 1 | 0, Kusto.Language.Parsing.LexicalToken) : null,
affinity = this.GetTokenWithAffinity(position) || token,
leftOrSurrounding = position === token.TriviaStart ? previous || token : token;
return Kusto.Language.Editor.KustoCompleter.IsInsideLiteral(leftOrSurrounding, position) ? !1 : position <= affinity.TextStart && affinity.Trivia.length > 0 ? !Kusto.Language.Editor.KustoCompleter.IsInsideComment(token.Trivia, position - token.TriviaStart | 0) : !0
},
GetOrderingRank: function(item) {
var $t;
this.cancellationToken.ThrowIfCancellationRequested();
switch (item.Kind) {
case Kusto.Language.Editor.CompletionKind.Example:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Literal;
case Kusto.Language.Editor.CompletionKind.Keyword:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Keyword;
case Kusto.Language.Editor.CompletionKind.AggregateFunction:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Aggregate;
case Kusto.Language.Editor.CompletionKind.Column:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Column;
case Kusto.Language.Editor.CompletionKind.Table:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Table;
case Kusto.Language.Editor.CompletionKind.MaterialiedView:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.MaterializedView;
case Kusto.Language.Editor.CompletionKind.Variable:
case Kusto.Language.Editor.CompletionKind.Parameter:
return Bridge.referenceEquals(item.DisplayText, "$left") || Bridge.referenceEquals(item.DisplayText, "$right") ? Kusto.Language.Editor.KustoCompleter.OrderingRank.Literal : Kusto.Language.Editor.KustoCompleter.OrderingRank.Variable;
case Kusto.Language.Editor.CompletionKind.BuiltInFunction:
case Kusto.Language.Editor.CompletionKind.LocalFunction:
case Kusto.Language.Editor.CompletionKind.DatabaseFunction:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Function;
case Kusto.Language.Editor.CompletionKind.ScalarInfix:
return ($t = item.DisplayText.charCodeAt(0), System.Char.isDigit($t) || System.Char.isLetter($t)) ? Kusto.Language.Editor.KustoCompleter.OrderingRank.StringOperator : Kusto.Language.Editor.KustoCompleter.OrderingRank.MathOperator;
case Kusto.Language.Editor.CompletionKind.ScalarPrefix:
case Kusto.Language.Editor.CompletionKind.TabularPrefix:
case Kusto.Language.Editor.CompletionKind.TabularSuffix:
case Kusto.Language.Editor.CompletionKind.QueryPrefix:
case Kusto.Language.Editor.CompletionKind.Identifier:
case Kusto.Language.Editor.CompletionKind.Cluster:
case Kusto.Language.Editor.CompletionKind.Database:
case Kusto.Language.Editor.CompletionKind.Punctuation:
case Kusto.Language.Editor.CompletionKind.Syntax:
case Kusto.Language.Editor.CompletionKind.Unknown:
case Kusto.Language.Editor.CompletionKind.RenderChart:
default:
return Kusto.Language.Editor.KustoCompleter.OrderingRank.Other
}
},
IsInCommand: function(element) {
var body, statementList, command;
return element == null ? !1 : (body = element.GetFirstAncestorOrSelf(Kusto.Language.Syntax.FunctionBody), body != null) ? !1 : (statementList = element.GetFirstAncestorOrSelf(Kusto.Language.Syntax.SyntaxList$1(Kusto.Language.Syntax.SeparatedElement$1(Kusto.Language.Syntax.Statement))), command = element.GetFirstAncestorOrSelf(Kusto.Language.Syntax.Command), command != null) ? statementList != null && command.IsAncestorOf(statementList) ? !1 : !0 : !1
},
GetSymbolCompletions: function(position, builder) {
var $t, hint = Kusto.Language.Editor.CompletionHint.None,
contextNode = {},
contextChildIndex = {},
mode, symbols, match, isCommand, include, isInvoke, rowScope, symbol, fs, vs, vfs, item;
if (this.TryGetCompletionContext(position, contextNode, contextChildIndex)) {
if (mode = this.GetFunctionArgumentCompletions(position, contextNode.v, contextChildIndex.v, builder), mode === Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated) return mode;
hint = this.GetCompletionHint(contextNode.v, contextChildIndex.v)
}
symbols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Symbol).ctor);
match = this.GetSymbolMatch(position);
this.options.IncludeFunctions === Kusto.Language.IncludeFunctionKind.None && (match &= -9);
isCommand = this.IsInCommand(contextNode.v);
include = this.options.IncludeFunctions;
isCommand && (include &= Kusto.Language.IncludeFunctionKind.DatabaseFunctions);
Kusto.Language.Binding.Binder.GetSymbolsInScope(this.code.Syntax, position, this.code.Globals, match, include, symbols, this.cancellationToken);
isInvoke = Kusto.Language.Editor.KustoCompleter.IsInvokeFunctionContext(contextNode.v);
rowScope = isInvoke ? Kusto.Language.Binding.Binder.GetRowScope(this.code.Syntax, position, this.code.Globals, this.cancellationToken) : null;
$t = Bridge.getEnumerator(symbols);
try {
while ($t.moveNext())
if (symbol = $t.Current, !symbol.IsHidden) {
if (isInvoke && rowScope != null && !rowScope.IsOpen) {
if ((fs = Bridge.as(symbol, Kusto.Language.Symbols.FunctionSymbol)) != null && !this.IsApplicable(fs, rowScope)) continue;
if ((vs = Bridge.as(symbol, Kusto.Language.Symbols.VariableSymbol)) != null && (vfs = Bridge.as(vs.Type, Kusto.Language.Symbols.FunctionSymbol)) != null && !this.IsApplicable(vfs, rowScope)) continue
}
item = this.GetSymbolCompletionItem(symbol, contextNode.v, isCommand);
this.ShouldAugmentSymbolCompletionItem(symbol, hint) && (item = this.GetAugmentedCompletionItem(item));
builder.Add(item)
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return Kusto.Language.Editor.KustoCompleter.CompletionMode.Combined
},
IsApplicable: function($function, implicitFirstArgumentType) {
var $t, $t1, sig, p, t, ts;
if (Bridge.referenceEquals($function, Kusto.Language.Functions.Cluster) || Bridge.referenceEquals($function, Kusto.Language.Functions.Database) || Bridge.referenceEquals($function, Kusto.Language.Functions.Table) || Bridge.referenceEquals($function, Kusto.Language.Functions.ExternalTable) || Bridge.referenceEquals($function, Kusto.Language.Functions.MaterializedView)) return !0;
$t = Bridge.getEnumerator($function.Signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext())
if (sig = $t.Current, System.Array.getCount(sig.Parameters, Kusto.Language.Symbols.Parameter) !== 0) {
p = System.Array.getItem(sig.Parameters, 0, Kusto.Language.Symbols.Parameter);
switch (p.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
$t1 = Bridge.getEnumerator(p.DeclaredTypes, Kusto.Language.Symbols.TypeSymbol);
try {
while ($t1.moveNext())
if (t = $t1.Current, (ts = Bridge.as(t, Kusto.Language.Symbols.TableSymbol)) != null && Kusto.Language.Binding.Binder.SymbolsAssignable(t, implicitFirstArgumentType)) return !0
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
break;
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
return Bridge.is(implicitFirstArgumentType, Kusto.Language.Symbols.TableSymbol)
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !1
},
ShouldAugmentSymbolCompletionItem: function(symbol, hint) {
return (hint & Kusto.Language.Editor.CompletionHint.Boolean) != 0 && !Bridge.referenceEquals(Kusto.Language.Symbols.Symbol.GetExpressionResultType(symbol), Kusto.Language.Symbols.ScalarTypes.Bool)
},
GetSymbolCompletionItem: function(symbol, contextNode, nameOnly) {
var kind = this.GetCompletionKind(symbol),
editName = Kusto.Language.KustoFacts.BracketNameIfNecessary(symbol.Name),
t, f, builtIn, fdisplay, isInvoke, p, v, p1, d, cl;
do return Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol) ? (t = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol), Kusto.Language.Editor.KustoCompleter.IsStartOfQuery(contextNode) ? new Kusto.Language.Editor.CompletionItem(kind, t.Name, (editName || "") + (Kusto.Language.Editor.KustoCompleter.AfterQueryStart || "")) : new Kusto.Language.Editor.CompletionItem(kind, t.Name, editName)) : Bridge.is(symbol, Kusto.Language.Symbols.FunctionSymbol) ? (f = Bridge.cast(symbol, Kusto.Language.Symbols.FunctionSymbol), nameOnly) ? new Kusto.Language.Editor.CompletionItem(kind, f.Name, editName) : (builtIn = this.code.Globals.IsBuiltInFunction(f), builtIn && (editName = f.Name), fdisplay = f.Display, System.Linq.Enumerable.from(f.Signatures).max(function(s) {
return System.Array.getCount(s.Parameters, Kusto.Language.Symbols.Parameter)
}) === 0 ? (builtIn && (editName = (editName || "") + "()"), Kusto.Language.Editor.KustoCompleter.IsStartOfQuery(contextNode) ? new Kusto.Language.Editor.CompletionItem(kind, fdisplay, (editName || "") + (Kusto.Language.Editor.KustoCompleter.AfterQueryStart || ""), void 0, f.Name, 2) : new Kusto.Language.Editor.CompletionItem(kind, fdisplay, editName, void 0, f.Name, 2)) : (isInvoke = Kusto.Language.Editor.KustoCompleter.IsInvokeFunctionContext(contextNode), !this.options.EnableParameterInjection || f.MaxArgumentCount !== 1 || builtIn || isInvoke ? new Kusto.Language.Editor.CompletionItem(kind, fdisplay, (editName || "") + "(", ")", f.Name, 2) : new Kusto.Language.Editor.CompletionItem(kind, fdisplay, (editName || "") + "({parameter})", void 0, f.Name, 2))) : Bridge.is(symbol, Kusto.Language.Symbols.PatternSymbol) ? (p = Bridge.cast(symbol, Kusto.Language.Symbols.PatternSymbol), new Kusto.Language.Editor.CompletionItem(kind, p.Display, (editName || "") + "(", ")", p.Name, 2)) : Bridge.is(symbol, Kusto.Language.Symbols.VariableSymbol) ? (v = Bridge.cast(symbol, Kusto.Language.Symbols.VariableSymbol), Bridge.is(v.Type, Kusto.Language.Symbols.FunctionSymbol) ? this.GetSymbolCompletionItem(v.Type, contextNode, nameOnly) : Bridge.is(v.Type, Kusto.Language.Symbols.TableSymbol) && Kusto.Language.Editor.KustoCompleter.IsStartOfQuery(contextNode) ? new Kusto.Language.Editor.CompletionItem(kind, v.Name, (editName || "") + (Kusto.Language.Editor.KustoCompleter.AfterQueryStart || "")) : new Kusto.Language.Editor.CompletionItem(kind, v.Name, editName)) : Bridge.is(symbol, Kusto.Language.Symbols.ParameterSymbol) ? (p1 = Bridge.cast(symbol, Kusto.Language.Symbols.ParameterSymbol), Bridge.is(p1.Type, Kusto.Language.Symbols.FunctionSymbol) ? this.GetSymbolCompletionItem(p1.Type, contextNode, nameOnly) : new Kusto.Language.Editor.CompletionItem(kind, symbol.Name, editName)) : Bridge.is(symbol, Kusto.Language.Symbols.DatabaseSymbol) ? (d = Bridge.cast(symbol, Kusto.Language.Symbols.DatabaseSymbol), new Kusto.Language.Editor.CompletionItem(Kusto.Language.Editor.CompletionKind.Database, d.Name, editName)) : Bridge.is(symbol, Kusto.Language.Symbols.ClusterSymbol) ? (cl = Bridge.cast(symbol, Kusto.Language.Symbols.ClusterSymbol), new Kusto.Language.Editor.CompletionItem(Kusto.Language.Editor.CompletionKind.Cluster, cl.Name, Kusto.Language.KustoFacts.GetBrackettedName(cl.Name))) : new Kusto.Language.Editor.CompletionItem(kind, symbol.Name, editName); while (0)
},
GetTokenWithAffinity: function(position) {
if (System.Array.getCount(this.code.LexerTokens, Kusto.Language.Parsing.LexicalToken) === 0) return null;
var tokenOffset = this.GetTokenIndex(position),
token = System.Array.getItem(this.code.LexerTokens, tokenOffset, Kusto.Language.Parsing.LexicalToken),
previous = tokenOffset > 0 ? System.Array.getItem(this.code.LexerTokens, tokenOffset - 1 | 0, Kusto.Language.Parsing.LexicalToken) : null;
return Kusto.Language.Editor.KustoCompleter.HasAffinity$1(token, position) ? token : previous != null && Kusto.Language.Editor.KustoCompleter.HasAffinity$1(previous, position) ? previous : null
},
GetSymbolMatch: function(position) {
var match = Kusto.Language.Symbols.SymbolMatch.None,
contextNode = {},
index = {},
hint, grammarMatch;
return this.TryGetCompletionContext(position, contextNode, index) && (hint = this.GetCompletionHint(contextNode.v, index.v), match |= Kusto.Language.Editor.KustoCompleter.GetSymbolMatch(hint)), grammarMatch = this.GetSymbolMatchFromGrammar(position), match | grammarMatch
},
GetSymbolMatchFromGrammar: function(position) {
var match = Kusto.Language.Symbols.SymbolMatch.None;
return this.ScanGrammarAtPosition(position, Bridge.fn.bind(this, function(g) {
var i, n, hint;
for (this.cancellationToken.ThrowIfCancellationRequested(), i = 0, n = System.Array.getCount(g.Annotations, System.Object); i < n; i = i + 1 | 0) hint = new Kusto.Language.Editor.CompletionHint, (hint = Bridge.as(System.Array.getItem(g.Annotations, i, System.Object), System.Int32)) != null && (match |= Kusto.Language.Editor.KustoCompleter.GetSymbolMatch(hint))
})), match
},
TryGetFunctionOrOperatorArgument: function(contextNode, childIndex, signatures, $arguments, argumentIndex, argumentCount, parameterName) {
var $t, $t1, $t2, $t3, $t4, $t5, n, sn, functionCall, el, fc1, fs, fc2, fs2, be, os;
for (parameterName.v = null, n = contextNode, Bridge.is(n, Kusto.Language.Syntax.NamedExpression) && ((sn = Bridge.as(n, Kusto.Language.Syntax.SimpleNamedExpression)) != null && (parameterName.v = sn.Name.SimpleName), childIndex = ($t = ($t1 = n.Parent) != null ? $t1.GetChildIndex(n) : null, $t != null ? $t : 0), n = n.Parent); Kusto.Language.Editor.KustoCompleter.ContainsOnlyOneToken(n) && !Bridge.is(n.Parent, Kusto.Language.Syntax.SyntaxList);) childIndex = ($t2 = ($t3 = n.Parent) != null ? $t3.GetChildIndex(n) : null, $t2 != null ? $t2 : 0), n = n.Parent;
if (Bridge.is(n, Kusto.Language.Syntax.SeparatedElement) && childIndex === 0 && (childIndex = ($t4 = ($t5 = n.Parent) != null ? $t5.GetChildIndex(n) : null, $t4 != null ? $t4 : 0), n = n.Parent), functionCall = null, Bridge.is(n, Kusto.Language.Syntax.SyntaxList) && (el = Bridge.as(n.Parent, Kusto.Language.Syntax.ExpressionList)) != null && (fc1 = Bridge.as(el.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && (fs = Bridge.as(fc1.ReferencedSymbol, Kusto.Language.Symbols.FunctionSymbol)) != null) signatures.v = fs.Signatures, functionCall = fc1, $arguments.v = System.Linq.Enumerable.from(fc1.ArgumentList.Expressions).select(function(e) {
return e.Element$1
}).toList(Kusto.Language.Syntax.Expression), argumentIndex.v = childIndex, argumentCount.v = n.ChildCount;
else if (Bridge.is(n, Kusto.Language.Syntax.ExpressionList) && (fc2 = Bridge.as(n.Parent, Kusto.Language.Syntax.FunctionCallExpression)) != null && (fs2 = Bridge.as(fc2.ReferencedSymbol, Kusto.Language.Symbols.FunctionSymbol)) != null) signatures.v = fs2.Signatures, functionCall = fc2, $arguments.v = System.Linq.Enumerable.from(fc2.ArgumentList.Expressions).select(function(e) {
return e.Element$1
}).toList(Kusto.Language.Syntax.Expression), argumentIndex.v = 0, argumentCount.v = 1;
else return (be = Bridge.as(n, Kusto.Language.Syntax.BinaryExpression)) != null && (os = Bridge.as(be.ReferencedSymbol, Kusto.Language.Symbols.OperatorSymbol)) != null ? (signatures.v = os.Signatures, $arguments.v = function(_o1) {
return _o1.add(be.Left), _o1.add(be.Right), _o1
}(new(System.Collections.Generic.List$1(Kusto.Language.Syntax.Expression).$ctor2)(2)), argumentIndex.v = childIndex === 0 ? 0 : 1, argumentCount.v = 2, !0) : (signatures.v = null, $arguments.v = null, argumentIndex.v = 0, argumentCount.v = 0, !1);
return functionCall != null && $arguments.v != null && Kusto.Language.Editor.KustoCompleter.IsInvokeFunctionContext(functionCall.Parent) && ($arguments.v.insert(0, null), argumentIndex.v = argumentIndex.v + 1 | 0, argumentCount.v = argumentCount.v + 1 | 0), !0
},
GetFunctionArgumentCompletions: function(position, contextNode, childIndex, builder) {
var $t, $t1, $t2, $t3, $t4, signatures = {},
$arguments = {},
argumentIndex = {},
name = {},
fs, suggestions, s, examples, possibleParameters, sig, cpl, cc, dpl, ds, edpl, ds1, mvdpl, ds2, argParams, p, ex, x;
if (this.TryGetFunctionOrOperatorArgument(contextNode, childIndex, signatures, $arguments, argumentIndex, {}, name)) {
if (!Bridge.is(contextNode, Kusto.Language.Syntax.NamedExpression) && (fs = Bridge.as(System.Array.getItem(signatures.v, 0, Kusto.Language.Symbols.Signature).Symbol, Kusto.Language.Symbols.FunctionSymbol)) != null && this.ShowParameterNames(fs)) {
suggestions = this.GetArgumentNameSuggestions(signatures.v, $arguments.v, argumentIndex.v);
$t = Bridge.getEnumerator(suggestions);
try {
while ($t.moveNext()) s = $t.Current, builder.Add(new Kusto.Language.Editor.CompletionItem(Kusto.Language.Editor.CompletionKind.Parameter, (s || "") + "=", (s || "") + "=", void 0, s, 2))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
if (suggestions.Count > 0 && this.IsArgumentNameRequired$1(signatures.v, $arguments.v, argumentIndex.v)) return Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated
}
examples = null;
possibleParameters = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Parameter).ctor);
$t1 = Bridge.getEnumerator(signatures.v, Kusto.Language.Symbols.Signature);
try {
while ($t1.moveNext()) {
if (sig = $t1.Current, argumentIndex.v === 0) switch (sig.ReturnKind) {
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Cluster:
return builder.AddRange(this.GetMemberNameExamples(this.code.Globals.Clusters)), this.GetStringValuesInScope(position, contextNode, builder), Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated;
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Database:
return (cpl = Bridge.as(Kusto.Language.Editor.KustoCompleter.GetLeftOfFunctionCall(contextNode), Kusto.Language.Syntax.Expression)) != null ? (cc = Bridge.as(cpl.ResultType, Kusto.Language.Symbols.ClusterSymbol)) != null && builder.AddRange(this.GetMemberNameExamples(cc.Databases)) : builder.AddRange(this.GetMemberNameExamples(this.code.Globals.Cluster.Databases)), this.GetStringValuesInScope(position, contextNode, builder), Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated;
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0Table:
return (dpl = Bridge.as(Kusto.Language.Editor.KustoCompleter.GetLeftOfFunctionCall(contextNode), Kusto.Language.Syntax.Expression)) != null ? (ds = Bridge.as(dpl.ResultType, Kusto.Language.Symbols.DatabaseSymbol)) != null && builder.AddRange(this.GetMemberNameExamples(ds.Tables)) : builder.AddRange(this.GetMemberNameExamples(this.code.Globals.Database.Tables)), this.GetStringValuesInScope(position, contextNode, builder), Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated;
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0ExternalTable:
return (edpl = Bridge.as(Kusto.Language.Editor.KustoCompleter.GetLeftOfFunctionCall(contextNode), Kusto.Language.Syntax.Expression)) != null ? (ds1 = Bridge.as(edpl.ResultType, Kusto.Language.Symbols.DatabaseSymbol)) != null && builder.AddRange(this.GetMemberNameExamples(ds1.ExternalTables)) : builder.AddRange(this.GetMemberNameExamples(this.code.Globals.Database.ExternalTables)), this.GetStringValuesInScope(position, contextNode, builder), Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated;
case Kusto.Language.Symbols.ReturnTypeKind.Parameter0MaterializedView:
return (mvdpl = Bridge.as(Kusto.Language.Editor.KustoCompleter.GetLeftOfFunctionCall(contextNode), Kusto.Language.Syntax.Expression)) != null ? (ds2 = Bridge.as(mvdpl.ResultType, Kusto.Language.Symbols.DatabaseSymbol)) != null && builder.AddRange(this.GetMemberNameExamples(ds2.MaterializedViews)) : builder.AddRange(this.GetMemberNameExamples(this.code.Globals.Database.MaterializedViews)), this.GetStringValuesInScope(position, contextNode, builder), Kusto.Language.Editor.KustoCompleter.CompletionMode.Isolated
}
possibleParameters.clear();
name.v != null ? possibleParameters.add(sig.GetParameter(name.v)) : argumentIndex.v < $arguments.v.Count ? (argParams = sig.GetArgumentParameters($arguments.v), possibleParameters.add(argParams.getItem(argumentIndex.v))) : sig.GetPossibleParameters(argumentIndex.v, $arguments.v.Count, possibleParameters);
$t2 = Bridge.getEnumerator(possibleParameters);
try {
while ($t2.moveNext())
if (p = $t2.Current, System.Array.getCount(p.Examples, System.String) > 0) {
examples == null && (examples = new(System.Collections.Generic.HashSet$1(System.String).ctor));
$t3 = Bridge.getEnumerator(p.Examples, System.String);
try {
while ($t3.moveNext()) ex = $t3.Current, examples.add(ex)
} finally {
Bridge.is($t3, System.IDisposable) && $t3.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t2, System.IDisposable) && $t2.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
if (examples != null) {
$t4 = Bridge.getEnumerator(examples);
try {
while ($t4.moveNext()) x = $t4.Current, builder.Add(new Kusto.Language.Editor.CompletionItem(Kusto.Language.Editor.CompletionKind.Example, x))
} finally {
Bridge.is($t4, System.IDisposable) && $t4.System$IDisposable$Dispose()
}
}
}
return Kusto.Language.Editor.KustoCompleter.CompletionMode.Combined
},
GetStringValuesInScope: function(position, contextNode, builder) {
var $t, symbols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Symbol).ctor),
i, type, symbol, item;
for (Kusto.Language.Binding.Binder.GetSymbolsInScope(this.code.Syntax, position, this.code.Globals, Kusto.Language.Symbols.SymbolMatch.Local, Kusto.Language.IncludeFunctionKind.All, symbols, this.cancellationToken), i = symbols.Count - 1 | 0; i >= 0; i = i - 1 | 0) type = {}, this.TryGetScalarType(symbols.getItem(i), type) && Bridge.referenceEquals(type.v, Kusto.Language.Symbols.ScalarTypes.String) || symbols.removeAt(i);
$t = Bridge.getEnumerator(symbols);
try {
while ($t.moveNext()) symbol = $t.Current, item = this.GetSymbolCompletionItem(symbol, contextNode, !1), builder.Add(item)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
},
TryGetScalarType: function(symbol, type) {
var ps, vs, cs;
do return Bridge.is(symbol, Kusto.Language.Symbols.ParameterSymbol) ? (ps = Bridge.cast(symbol, Kusto.Language.Symbols.ParameterSymbol), type.v = ps.Type, !0) : Bridge.is(symbol, Kusto.Language.Symbols.VariableSymbol) ? (vs = Bridge.cast(symbol, Kusto.Language.Symbols.VariableSymbol), type.v = vs.Type, !0) : Bridge.is(symbol, Kusto.Language.Symbols.ColumnSymbol) ? (cs = Bridge.cast(symbol, Kusto.Language.Symbols.ColumnSymbol), type.v = cs.Type, !0) : (type.v = null, !1); while (0)
},
GetMemberNameExamples: function(symbols) {
return System.Linq.Enumerable.from(symbols).select(function(s) {
return new Kusto.Language.Editor.CompletionItem(Kusto.Language.Editor.CompletionKind.Example, Kusto.Language.KustoFacts.GetStringLiteral(s.Name))
})
},
ShowParameterNames: function($function) {
return !this.code.Globals.IsBuiltInFunction($function) && $function.MaxArgumentCount >= 2
},
IsArgumentNameRequired$1: function(signatures, $arguments, argumentIndex) {
var $t, sig;
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext())
if (sig = $t.Current, argumentIndex < sig.MaxArgumentCount && this.IsArgumentNameRequired(sig, $arguments, argumentIndex)) return !0
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !1
},
IsArgumentNameRequired: function(signature, $arguments, argumentIndex) {
var argumentParameters, unnamedArgumentParameters, i;
if (argumentIndex > 0)
for (argumentParameters = signature.GetArgumentParameters($arguments), unnamedArgumentParameters = signature.GetArgumentParameters($arguments, !1), i = 0; i < argumentIndex; i = i + 1 | 0)
if (!Bridge.referenceEquals(argumentParameters.getItem(i), unnamedArgumentParameters.getItem(i))) return !0;
return !1
},
GetSpecifiedArgumentNames: function($arguments) {
for (var arg, sn, names = new(System.Collections.Generic.HashSet$1(System.String).ctor), i = 0; i < System.Array.getCount($arguments, Kusto.Language.Syntax.Expression); i = i + 1 | 0) arg = System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression), (sn = Bridge.as(arg, Kusto.Language.Syntax.SimpleNamedExpression)) != null && names.add(sn.Name.SimpleName);
return names
},
GetArgumentNameSuggestions: function(signatures, $arguments, argumentIndex) {
var $t, $t1, specifiedNames = this.GetSpecifiedArgumentNames($arguments),
unspecifiedNames = new(System.Collections.Generic.HashSet$1(System.String).ctor),
suggestedNames = new(System.Collections.Generic.HashSet$1(System.String).ctor),
sig, argumentParameters, i, n, arg, p, p1;
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext())
if (sig = {
v: $t.Current
}, System.Array.getCount($arguments, Kusto.Language.Syntax.Expression) <= sig.v.MaxArgumentCount && System.Linq.Enumerable.from(specifiedNames).all(function($me, sig) {
return function(n) {
return System.Linq.Enumerable.from(sig.v.Parameters).any(function(p) {
return Bridge.referenceEquals(p.Name, n)
})
}
}(this, sig))) {
for (unspecifiedNames.clear(), argumentParameters = sig.v.GetArgumentParameters($arguments), i = 0, n = System.Array.getCount($arguments, Kusto.Language.Syntax.Expression); i < n; i = i + 1 | 0) i !== argumentIndex && (arg = System.Array.getItem($arguments, i, Kusto.Language.Syntax.Expression), p = argumentParameters.getItem(i), unspecifiedNames.add(p.Name));
$t1 = Bridge.getEnumerator(sig.v.Parameters, Kusto.Language.Symbols.Parameter);
try {
while ($t1.moveNext()) p1 = $t1.Current, specifiedNames.contains(p1.Name) || unspecifiedNames.contains(p1.Name) || suggestedNames.add(p1.Name)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return suggestedNames
},
GetCompletionHint$1: function(position) {
var contextNode = {},
index = {};
return this.TryGetCompletionContext(position, contextNode, index) ? this.GetCompletionHint(contextNode.v, index.v, Kusto.Language.Editor.CompletionHint.Query) : Kusto.Language.Editor.CompletionHint.Query
},
GetCompletionHint: function(contextNode, childIndex, defaultHint) {
var hint, i, n, parent, indexInParent;
if ((defaultHint === void 0 && (defaultHint = 0), hint = this.GetChildHint(contextNode, childIndex, defaultHint), Bridge.is(contextNode, Kusto.Language.Syntax.SeparatedElement) && childIndex === 1) || Kusto.Language.Editor.KustoCompleter.IsChildMissing(contextNode, childIndex)) return hint;
if (Kusto.Language.Editor.KustoCompleter.IsChildEmpty(contextNode, childIndex) || Bridge.is(contextNode, Kusto.Language.Syntax.SyntaxList))
while (contextNode != null) {
for (i = childIndex + 1 | 0, n = contextNode.ChildCount; i < n; i = i + 1 | 0)
if (!Kusto.Language.Editor.KustoCompleter.IsChildMissingOrEmpty(contextNode, i) || (hint |= this.GetChildHint(contextNode, i, defaultHint), Kusto.Language.Editor.KustoCompleter.IsChildMissing(contextNode, i))) return hint;
parent = contextNode.Parent;
indexInParent = parent != null ? parent.GetChildIndex(contextNode) : 0;
contextNode = parent;
childIndex = indexInParent
}
return hint
},
GetChildHint: function(contextNode, childIndex, $default) {
var hint, parent;
$default === void 0 && ($default = 0);
var signatures = {},
argumentIndex = {},
argumentCount = {},
parameterName = {};
if (this.TryGetFunctionOrOperatorArgument(contextNode, childIndex, signatures, {}, argumentIndex, argumentCount, parameterName)) return this.GetParameterHint(signatures.v, parameterName.v, argumentIndex.v, argumentCount.v);
for (;;) {
if (hint = contextNode.GetCompletionHint(childIndex), hint !== Kusto.Language.Editor.CompletionHint.Inherit) return hint;
if ((parent = contextNode.Parent) != null) childIndex = parent.GetChildIndex(contextNode), contextNode = parent;
else return $default
}
},
GetParameterHint: function(signatures, parameterName, iArgument, nArguments) {
var $t, $t1, hint = Kusto.Language.Editor.CompletionHint.None,
signature, parameterList, p;
$t = Bridge.getEnumerator(signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext())
if (signature = $t.Current, !signature.IsHidden)
if (parameterName != null) hint |= this.GetParameterHint$1(signature, signature.GetParameter(parameterName));
else {
parameterList = Kusto.Language.Editor.KustoCompleter.s_parameterListPool.AllocateFromPool();
try {
signature.GetPossibleParameters(iArgument, nArguments, parameterList);
$t1 = Bridge.getEnumerator(parameterList);
try {
while ($t1.moveNext()) p = $t1.Current, hint |= this.GetParameterHint$1(signature, p)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
} finally {
Kusto.Language.Editor.KustoCompleter.s_parameterListPool.ReturnToPool(parameterList)
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return hint
},
GetParameterHint$1: function(signature, parameter) {
if (parameter != null) {
switch (parameter.ArgumentKind) {
case Kusto.Language.Symbols.ArgumentKind.Column:
return Kusto.Language.Editor.CompletionHint.Column;
case Kusto.Language.Symbols.ArgumentKind.Star:
return Kusto.Language.Editor.CompletionHint.None
}
switch (parameter.TypeKind) {
case Kusto.Language.Symbols.ParameterTypeKind.Declared:
if (System.Array.getItem(parameter.DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol).IsScalar) return System.Array.getCount(parameter.DeclaredTypes, Kusto.Language.Symbols.TypeSymbol) === 1 && Bridge.referenceEquals(System.Array.getItem(parameter.DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol), Kusto.Language.Symbols.ScalarTypes.Bool) ? Kusto.Language.Editor.CompletionHint.Boolean : System.Linq.Enumerable.from(parameter.DeclaredTypes).all(function(t) {
var s;
(s = Bridge.as(t, Kusto.Language.Symbols.ScalarSymbol)) != null && s.IsNumeric
}) ? Kusto.Language.Editor.CompletionHint.Number : Kusto.Language.Editor.CompletionHint.Scalar;
if (System.Array.getItem(parameter.DeclaredTypes, 0, Kusto.Language.Symbols.TypeSymbol).IsTabular) return Kusto.Language.Editor.CompletionHint.Tabular;
break;
case Kusto.Language.Symbols.ParameterTypeKind.Parameter0:
return this.GetParameterHint$1(signature, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) > 0 ? System.Array.getItem(signature.Parameters, 0, Kusto.Language.Symbols.Parameter) : null);
case Kusto.Language.Symbols.ParameterTypeKind.Parameter1:
return this.GetParameterHint$1(signature, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) > 1 ? System.Array.getItem(signature.Parameters, 1, Kusto.Language.Symbols.Parameter) : null);
case Kusto.Language.Symbols.ParameterTypeKind.Parameter2:
return this.GetParameterHint$1(signature, System.Array.getCount(signature.Parameters, Kusto.Language.Symbols.Parameter) > 2 ? System.Array.getItem(signature.Parameters, 2, Kusto.Language.Symbols.Parameter) : null);
case Kusto.Language.Symbols.ParameterTypeKind.Tabular:
case Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable:
return Kusto.Language.Editor.CompletionHint.Tabular;
case Kusto.Language.Symbols.ParameterTypeKind.Database:
return Kusto.Language.Editor.CompletionHint.Database;
case Kusto.Language.Symbols.ParameterTypeKind.Cluster:
return Kusto.Language.Editor.CompletionHint.Cluster;
case Kusto.Language.Symbols.ParameterTypeKind.Number:
return Kusto.Language.Editor.CompletionHint.Number;
default:
return Kusto.Language.Editor.CompletionHint.Scalar
}
}
return Kusto.Language.Editor.CompletionHint.None
},
TryGetCompletionContext: function(position, contextNode, contextChildIndex) {
var token, hasAffinity, prev, tokenNode, prevToken, prevNode, nextToken, nextNode;
if (contextNode.v = null, contextChildIndex.v = 0, token = this.code.Syntax.GetTokenAt(position), token == null) return !1;
if (hasAffinity = Kusto.Language.Editor.KustoCompleter.HasAffinity(token, position), hasAffinity) return (prev = token.GetPreviousToken(!0), prev != null && prev.IsMissing) ? !1 : (contextNode.v = token.Parent, contextChildIndex.v = Kusto.Language.Editor.KustoCompleter.GetChildIndex(contextNode.v, position), !0);
if (tokenNode = Kusto.Language.Editor.KustoCompleter.GetNearestAncestorWithEmptyChild(token, position), position <= token.TextStart && !hasAffinity || token.Kind === Kusto.Language.Syntax.SyntaxKind.EndOfTextToken) {
if (prevToken = token.GetPreviousToken(), prevToken != null && (prevNode = Kusto.Language.Editor.KustoCompleter.GetNearestAncestorWithEmptyChild(prevToken, position), prevNode != null && (tokenNode == null || prevNode.Depth >= tokenNode.Depth))) return contextNode.v = prevNode, contextChildIndex.v = Kusto.Language.Editor.KustoCompleter.GetChildIndex(contextNode.v, position), !0
} else if (position >= token.End && !hasAffinity && (nextToken = token.GetNextToken(), nextToken != null && (nextNode = Kusto.Language.Editor.KustoCompleter.GetNearestAncestorWithEmptyChild(nextToken, position), nextNode != null && (tokenNode == null || nextNode.Depth > tokenNode.Depth)))) return contextNode.v = nextNode, contextChildIndex.v = Kusto.Language.Editor.KustoCompleter.GetChildIndex(contextNode.v, position), !0;
return tokenNode != null ? (contextNode.v = tokenNode, contextChildIndex.v = Kusto.Language.Editor.KustoCompleter.GetChildIndex(contextNode.v, position), !0) : !1
},
GetSyntaxCompletions: function(position, builder) {
var hints = this.GetCompletionHint$1(position),
match = this.GetSymbolMatch(position),
expr = this.GetCompleteExpressionLeftOfPosition(position);
this.ScanGrammarAtPosition(position, Bridge.fn.bind(this, function(p) {
var $t, $t1, hint, item, augmentedItem;
if (this.cancellationToken.ThrowIfCancellationRequested(), System.Array.getCount(p.Annotations, System.Object) > 0) {
$t = Bridge.getEnumerator(System.Linq.Enumerable.from(p.Annotations).ofType(Kusto.Language.Editor.CompletionHint));
try {
while ($t.moveNext()) hint = $t.Current, hints |= hint
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
$t1 = Bridge.getEnumerator(System.Linq.Enumerable.from(p.Annotations).ofType(Kusto.Language.Editor.CompletionItem));
try {
while ($t1.moveNext()) item = $t1.Current, this.IncludeSyntax(item, position, hints, match, expr) && (this.ShouldAugmentSyntaxCompletionItem(item) ? (augmentedItem = this.GetAugmentedCompletionItem(item), builder.Add(augmentedItem)) : builder.Add(item))
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
}))
},
GetAugmentedCompletionItem: function(item) {
return item.WithEditText((item.EditText || "") + " ")
},
ShouldAugmentSyntaxCompletionItem: function(item) {
var $t, $t1;
if (!this.options.AutoAppendWhitespace || System.Nullable.gt(($t = item.AfterText) != null ? $t.length : null, 0) || System.String.endsWith(item.EditText, "=") && ($t1 = item.EditText.charCodeAt(0), System.Char.isDigit($t1) || System.Char.isLetter($t1)) && item.EditText.length > 1 && !System.Char.isWhiteSpace(String.fromCharCode(item.EditText.charCodeAt(item.EditText.length - 2 | 0)))) return !1;
switch (item.Kind) {
case Kusto.Language.Editor.CompletionKind.Column:
case Kusto.Language.Editor.CompletionKind.BuiltInFunction:
case Kusto.Language.Editor.CompletionKind.LocalFunction:
case Kusto.Language.Editor.CompletionKind.DatabaseFunction:
case Kusto.Language.Editor.CompletionKind.AggregateFunction:
case Kusto.Language.Editor.CompletionKind.Parameter:
case Kusto.Language.Editor.CompletionKind.Variable:
case Kusto.Language.Editor.CompletionKind.Table:
case Kusto.Language.Editor.CompletionKind.Database:
case Kusto.Language.Editor.CompletionKind.Cluster:
return !1;
case Kusto.Language.Editor.CompletionKind.Punctuation:
return System.Linq.Enumerable.from(Kusto.Language.Editor.KustoCompleter.punctuationWithoutSpace).any(function(p) {
return Bridge.referenceEquals(item.DisplayText, p)
});
default:
return !0
}
},
ScanGrammarAtPosition: function(position, action) {
var offset = this.GetTokenIndex(position),
source = new(Kusto.Language.Parsing.ArraySource$1(Kusto.Language.Parsing.LexicalToken))(this.code.LexerTokens);
this.code.Grammar.Search$1(source, 0, !1, function(_parser, _source, _start, _prevWasMissing) {
_start !== offset || _prevWasMissing || action(_parser)
})
},
GetTokenLeftOfPosition: function(position) {
var token = this.code.Syntax.GetTokenAt(position),
hasAffinity = token != null && Kusto.Language.Editor.KustoCompleter.HasAffinity(token, position);
return token != null && (position < token.TextStart || !hasAffinity || token.Kind === Kusto.Language.Syntax.SyntaxKind.EndOfTextToken) && (token = token.GetPreviousToken()), token
},
GetCompleteExpressionLeftOfPosition: function(position) {
var token = this.GetTokenLeftOfPosition(position),
expr = token != null ? token.GetFirstAncestorOrSelf(Kusto.Language.Syntax.Expression) : null;
return expr != null && expr.End === token.End && !expr.HasMissingChildren() ? expr : null
},
GetTokenIndex: function(position) {
if (System.Array.getCount(this.code.LexerTokens, Kusto.Language.Parsing.LexicalToken) === 0) return 0;
if (position >= System.Array.getItem(this.code.LexerTokens, System.Array.getCount(this.code.LexerTokens, Kusto.Language.Parsing.LexicalToken) - 1 | 0, Kusto.Language.Parsing.LexicalToken).End) return System.Array.getCount(this.code.LexerTokens, Kusto.Language.Parsing.LexicalToken) - 1 | 0;
var offset = Kusto.Language.Utils.ListExtensions.BinarySearch(Bridge.global.Kusto.Language.Parsing.LexicalToken, this.code.LexerTokens, function(t) {
return position < t.TriviaStart ? 1 : position >= t.End ? -1 : 0
});
return offset >= 0 ? offset : 0
},
IncludeSyntax: function(item, position, hints, match, left) {
if (!this.options.IncludePunctuationOnlySyntax && item.Kind === Kusto.Language.Editor.CompletionKind.Punctuation) return !1;
switch (item.Kind) {
case Kusto.Language.Editor.CompletionKind.QueryPrefix:
return (hints & Kusto.Language.Editor.CompletionHint.Query) != 0 || (hints & Kusto.Language.Editor.CompletionHint.Keyword) != 0 || (match & Kusto.Language.Symbols.SymbolMatch.Tabular) != 0;
case Kusto.Language.Editor.CompletionKind.TabularPrefix:
return (match & Kusto.Language.Symbols.SymbolMatch.Tabular) != 0;
case Kusto.Language.Editor.CompletionKind.TabularSuffix:
return left != null && left.ResultType != null && left.ResultType.IsTabular;
case Kusto.Language.Editor.CompletionKind.ScalarPrefix:
case Kusto.Language.Editor.CompletionKind.Example:
return (match & Kusto.Language.Symbols.SymbolMatch.Scalar) != 0;
case Kusto.Language.Editor.CompletionKind.ScalarInfix:
return this.AnyInfixMatches(left, item.DisplayText, position);
default:
return !0
}
},
AnyInfixMatches: function(left, op, position) {
var kind = Kusto.Language.Editor.KustoCompleter.GetOperatorKind(op),
hint, parent;
if (kind === Kusto.Language.Symbols.OperatorKind.None) return !1;
for (; left != null; left = Bridge.as(left.Parent, Kusto.Language.Syntax.Expression)) {
if (position < left.End) break;
if (left.ResultType != null && (hint = Kusto.Language.Editor.CompletionHint.None, (parent = left.Parent) != null && (hint = this.GetChildHint(parent, parent.GetChildIndex(left), Kusto.Language.Editor.CompletionHint.Query)), this.HasMatchingInfixOperator(kind, left.ResultType, hint))) return !0
}
return !1
},
HasMatchingInfixOperator: function(kind, arg0Type, returnTypeHint) {
var $t, op = this.code.Globals.GetOperator(kind),
sig;
$t = Bridge.getEnumerator(op.Signatures, Kusto.Language.Symbols.Signature);
try {
while ($t.moveNext())
if (sig = $t.Current, !sig.IsHidden && Kusto.Language.Editor.KustoCompleter.ParameterMatches(System.Array.getItem(sig.Parameters, 0, Kusto.Language.Symbols.Parameter), arg0Type) && Kusto.Language.Editor.KustoCompleter.ReturnTypeMatchesContext(sig, arg0Type, returnTypeHint)) return !0
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return !1
},
GetCompletionKind: function(symbol) {
switch (symbol.Kind) {
case Kusto.Language.Symbols.SymbolKind.Cluster:
return Kusto.Language.Editor.CompletionKind.Cluster;
case Kusto.Language.Symbols.SymbolKind.Column:
return Kusto.Language.Editor.CompletionKind.Column;
case Kusto.Language.Symbols.SymbolKind.Database:
return Kusto.Language.Editor.CompletionKind.Database;
case Kusto.Language.Symbols.SymbolKind.Function:
var fn = Bridge.cast(symbol, Kusto.Language.Symbols.FunctionSymbol);
return this.code.Globals.IsAggregateFunction(fn) ? Kusto.Language.Editor.CompletionKind.AggregateFunction : this.code.Globals.IsBuiltInFunction(fn) ? Kusto.Language.Editor.CompletionKind.BuiltInFunction : this.code.Globals.IsDatabaseFunction(fn) ? Kusto.Language.Editor.CompletionKind.DatabaseFunction : Kusto.Language.Editor.CompletionKind.LocalFunction;
case Kusto.Language.Symbols.SymbolKind.Pattern:
return Kusto.Language.Editor.CompletionKind.LocalFunction;
case Kusto.Language.Symbols.SymbolKind.Operator:
return Kusto.Language.Editor.CompletionKind.BuiltInFunction;
case Kusto.Language.Symbols.SymbolKind.Variable:
return this.GetVariableCompletionKind(Bridge.cast(symbol, Kusto.Language.Symbols.VariableSymbol));
case Kusto.Language.Symbols.SymbolKind.Parameter:
return Kusto.Language.Editor.CompletionKind.Parameter;
case Kusto.Language.Symbols.SymbolKind.Table:
return Kusto.Language.Editor.CompletionKind.Table;
case Kusto.Language.Symbols.SymbolKind.MaterializedView:
return Kusto.Language.Editor.CompletionKind.MaterialiedView;
case Kusto.Language.Symbols.SymbolKind.Tuple:
case Kusto.Language.Symbols.SymbolKind.Scalar:
case Kusto.Language.Symbols.SymbolKind.Group:
case Kusto.Language.Symbols.SymbolKind.Void:
default:
return Kusto.Language.Editor.CompletionKind.Unknown
}
},
GetVariableCompletionKind: function(vs) {
switch (vs.Type.Kind) {
case Kusto.Language.Symbols.SymbolKind.Table:
case Kusto.Language.Symbols.SymbolKind.Function:
case Kusto.Language.Symbols.SymbolKind.Pattern:
return this.GetCompletionKind(vs.Type);
default:
return Kusto.Language.Editor.CompletionKind.Variable
}
}
}
});
Bridge.define("Kusto.Language.Editor.KustoCompleter.CompletionBuilder", {
$kind: "nested class",
statics: {
methods: {
GetBetterItem: function(existing, other) {
return existing.Kind === Kusto.Language.Editor.CompletionKind.Keyword && other.Kind === Kusto.Language.Editor.CompletionKind.QueryPrefix ? other : existing
}
}
},
fields: {
list: null,
indexMap: null
},
ctors: {
init: function() {
this.list = new(System.Collections.Generic.List$1(Kusto.Language.Editor.CompletionItem).ctor);
this.indexMap = new(System.Collections.Generic.Dictionary$2(System.String, System.Int32))
},
ctor: function() {
this.$initialize()
}
},
methods: {
ToList: function() {
return this.list.AsReadOnly()
},
Add: function(item) {
var existingItemIndex = {},
better;
this.indexMap.tryGetValue(item.DisplayText, existingItemIndex) ? (better = Kusto.Language.Editor.KustoCompleter.CompletionBuilder.GetBetterItem(this.list.getItem(existingItemIndex.v), item), Bridge.referenceEquals(better, item) && this.list.setItem(existingItemIndex.v, item)) : (this.indexMap.add(item.DisplayText, this.list.Count), this.list.add(item))
},
AddRange: function(items) {
var $t, item;
$t = Bridge.getEnumerator(items, Kusto.Language.Editor.CompletionItem);
try {
while ($t.moveNext()) item = $t.Current, this.Add(item)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
}
}
});
Bridge.define("Kusto.Language.Editor.KustoCompleter.CompletionMode", {
$kind: "nested enum",
statics: {
fields: {
Isolated: 0,
Combined: 1
}
}
});
Bridge.define("Kusto.Language.Editor.KustoCompleter.OrderingRank", {
$kind: "nested enum",
statics: {
fields: {
Literal: 0,
Aggregate: 1,
Column: 2,
Table: 3,
Variable: 4,
Function: 5,
MaterializedView: 6,
Keyword: 7,
StringOperator: 8,
MathOperator: 9,
Other: 10
}
}
});
Bridge.define("Kusto.Language.Editor.KustoFormatter", {
statics: {
fields: {
s_Spaces: null
},
ctors: {
init: function() {
this.s_Spaces = System.String.fromCharCount(32, 256)
}
},
methods: {
GetFormattedText: function(node, options, cursorPosition) {
var formatter = new Kusto.Language.Editor.KustoFormatter(cursorPosition, options || Kusto.Language.Editor.FormattingOptions.Default);
return formatter.Format(node), new Kusto.Language.Editor.FormattedText(formatter._builder.toString(), formatter._newCursorPosition)
},
SkipWhitespace: function(text, start) {
for (var p = start; p < text.length && Kusto.Language.Parsing.TextFacts.IsWhitespace(text.charCodeAt(p)) && !Kusto.Language.Parsing.TextFacts.IsLineBreakStart(text.charCodeAt(p));) p = p + 1 | 0;
return p
},
IsIdentifierOrKeyword: function(token) {
return token.Kind === Kusto.Language.Syntax.SyntaxKind.IdentifierToken || Kusto.Language.Syntax.SyntaxFacts.IsKeyword(token.Kind)
},
IsWildcardPart: function(token) {
return Bridge.is(token.Parent, Kusto.Language.Syntax.WildcardedName)
},
DidSpanMultipleLines$1: function(first, last, inclusive, excluded) {
if (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), first != null && last != null) {
if (inclusive && !Bridge.referenceEquals(first, excluded) && Kusto.Language.Parsing.TextFacts.HasLineBreaks(first.Trivia)) return !0;
for (var token = first.GetNextToken(); token != null;) {
if (!Bridge.referenceEquals(token, excluded) && Kusto.Language.Parsing.TextFacts.HasLineBreaks(token.Trivia)) return !0;
if (Bridge.referenceEquals(token, last)) break;
token = token.GetNextToken()
}
}
return !1
},
DidSpanMultipleLines: function(node, inclusive, excluded) {
return (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), node != null) ? Kusto.Language.Editor.KustoFormatter.DidSpanMultipleLines$1(node.GetFirstToken(), node.GetLastToken(), inclusive, excluded) : !1
}
}
},
fields: {
_options: null,
_builder: null,
_cursorPosition: 0,
_newCursorPosition: 0,
_spacingRules: null,
_alignmentRules: null,
_elementIndentations: null
},
ctors: {
init: function() {
this._spacingRules = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Syntax.SyntaxElement, Kusto.Language.Editor.KustoFormatter.SpacingRule));
this._alignmentRules = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Syntax.SyntaxElement, Kusto.Language.Editor.KustoFormatter.AlignmentRule));
this._elementIndentations = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Syntax.SyntaxElement, System.Int32))
},
ctor: function(cursorPosition, options) {
this.$initialize();
this._cursorPosition = cursorPosition;
this._newCursorPosition = -1;
this._options = options;
this._builder = new System.Text.StringBuilder
}
},
methods: {
Format: function(node) {
this.IdentifyFormattingRules(node);
this.WriteFormattedText(node, 0);
this._newCursorPosition === -1 && (this._newCursorPosition = this._cursorPosition <= 0 ? this._cursorPosition : this._cursorPosition <= node.End ? this._builder.getLength() : this._cursorPosition + (this._builder.getLength() - node.Width | 0) | 0)
},
WriteFormattedText: function(node, indentation) {
var i, child, alignment, elementIndentation, n, t2;
if (node != null)
for (i = 0; i < node.ChildCount; i = i + 1 | 0)
if (child = node.GetChild(i), child != null) {
var spacingKind = Kusto.Language.Editor.KustoFormatter.SpacingKind.AlignOnly,
childIndentation = indentation,
spacing = {};
this._spacingRules.tryGetValue(child, spacing) && (spacingKind = spacing.v.GetKind());
alignment = {};
this._alignmentRules.tryGetValue(child, alignment) && (alignment.v.RelativeToElement == null ? childIndentation = childIndentation + alignment.v.IndentationDelta | 0 : (elementIndentation = {}, this._elementIndentations.tryGetValue(alignment.v.RelativeToElement, elementIndentation) && (childIndentation = elementIndentation.v + alignment.v.IndentationDelta | 0)));
(n = Bridge.as(child, Kusto.Language.Syntax.SyntaxNode)) != null ? this.WriteFormattedText(n, childIndentation) : (t2 = Bridge.as(child, Kusto.Language.Syntax.SyntaxToken)) != null && (this.WriteToken(t2, childIndentation, spacingKind), this._elementIndentations.add(t2, childIndentation));
i === 0 && this._elementIndentations.add(node, childIndentation)
}
},
WriteToken: function(token, indentation, spacingKind) {
if (spacingKind === void 0 && (spacingKind = 2), (token.Text.length > 0 || token.Trivia.length > 0 || token.IsMissing && this._options.InsertMissingTokens) && this.WriteTrivia(token, indentation, spacingKind, token.Kind !== Kusto.Language.Syntax.SyntaxKind.EndOfTextToken), this._newCursorPosition === -1 && (this._cursorPosition >= token.TextStart && this._cursorPosition <= token.End ? this._newCursorPosition = this._builder.getLength() + (this._cursorPosition - token.TextStart | 0) | 0 : this._cursorPosition < token.TextStart && (this._newCursorPosition = this._builder.getLength())), token.IsMissing && this._options.InsertMissingTokens) {
var text = Kusto.Language.Syntax.SyntaxFacts.GetText(token.Kind);
System.String.isNullOrEmpty(text) || this._builder.append(text)
} else this._builder.append(token.Text)
},
WriteTrivia: function(token, indentation, spacingKind, hasFollowingToken) {
var trivia = token.Trivia,
cursorInTrivia = this._cursorPosition >= token.TriviaStart && this._cursorPosition < token.TextStart,
lineStart, lineEnd, whitespaceEnd, nextLineBreakStart, nextLineStart;
switch (spacingKind) {
case Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpace:
return;
case Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpace:
this._builder.append(" ");
return
}
if (spacingKind !== Kusto.Language.Editor.KustoFormatter.SpacingKind.AsIs && Kusto.Language.Parsing.TextFacts.HasLineBreaks(trivia))
for (lineStart = 0, lineEnd = 0; lineStart < trivia.length; lineStart = lineEnd) whitespaceEnd = Kusto.Language.Editor.KustoFormatter.SkipWhitespace(trivia, lineStart), lineStart === 0 ? this._builder.append(trivia, lineStart, whitespaceEnd - lineStart | 0) : this.WriteIndentation(indentation), nextLineBreakStart = Kusto.Language.Parsing.TextFacts.GetNextLineBreakStart(trivia, whitespaceEnd), nextLineStart = Kusto.Language.Parsing.TextFacts.GetNextLineStart(trivia, whitespaceEnd), lineEnd = nextLineStart >= 0 ? nextLineStart : whitespaceEnd, this._builder.append(trivia, whitespaceEnd, lineEnd - whitespaceEnd | 0), lineEnd >= trivia.length && nextLineBreakStart >= 0 && hasFollowingToken && this.WriteIndentation(indentation);
else switch (spacingKind) {
case Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpaceIfOnSameLine:
break;
case Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine:
this._builder.append(" ");
break;
case Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine:
this._builder.appendLine();
this.WriteIndentation(indentation);
break;
case Kusto.Language.Editor.KustoFormatter.SpacingKind.AsIs:
case Kusto.Language.Editor.KustoFormatter.SpacingKind.AlignOnly:
default:
this._builder.append(trivia)
}
},
WriteIndentation: function(indentation) {
while (indentation > Kusto.Language.Editor.KustoFormatter.s_Spaces.length) this._builder.append(Kusto.Language.Editor.KustoFormatter.s_Spaces), indentation = indentation - Kusto.Language.Editor.KustoFormatter.s_Spaces.length | 0;
this._builder.append(Kusto.Language.Editor.KustoFormatter.s_Spaces, 0, Math.min(indentation, Kusto.Language.Editor.KustoFormatter.s_Spaces.length))
},
IdentifyFormattingRules: function(node) {
var i, child, n, t;
if (node != null) {
for (i = 0; i < node.ChildCount; i = i + 1 | 0) child = node.GetChild(i), (n = Bridge.as(child, Kusto.Language.Syntax.SyntaxNode)) != null ? this.IdentifyFormattingRules(n) : (t = Bridge.as(child, Kusto.Language.Syntax.SyntaxToken)) != null && this.IdentifyTokenSpacing(t);
this.IdentifyNodeSpacing(node)
}
},
IdentifyTokenSpacing: function(token) {
var prev, be, pbe, pue;
if (!Kusto.Language.Parsing.TextFacts.HasLineBreaks(token.Trivia) && (prev = token.GetPreviousToken(), prev != null))
if (Kusto.Language.Editor.KustoFormatter.IsWildcardPart(token)) Bridge.referenceEquals(token.Trivia, "") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpace));
else if (Kusto.Language.Editor.KustoFormatter.IsIdentifierOrKeyword(token) && Kusto.Language.Editor.KustoFormatter.IsIdentifierOrKeyword(prev)) Bridge.referenceEquals(token.Trivia, " ") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine));
else if ((be = Bridge.as(token.Parent, Kusto.Language.Syntax.BinaryExpression)) != null && Bridge.referenceEquals(be.Operator, token) || (pbe = Bridge.as(prev.Parent, Kusto.Language.Syntax.BinaryExpression)) != null && Bridge.referenceEquals(pbe.Operator, prev)) Bridge.referenceEquals(token.Trivia, " ") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine));
else if ((pue = Bridge.as(prev.Parent, Kusto.Language.Syntax.PrefixUnaryExpression)) != null && Bridge.referenceEquals(pue.Operator, prev)) Bridge.referenceEquals(token.Trivia, "") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpaceIfOnSameLine));
else if (token.Kind !== Kusto.Language.Syntax.SyntaxKind.EndOfTextToken) {
switch (token.Kind) {
case Kusto.Language.Syntax.SyntaxKind.CloseBraceToken:
case Kusto.Language.Syntax.SyntaxKind.CloseBracketToken:
case Kusto.Language.Syntax.SyntaxKind.CloseParenToken:
case Kusto.Language.Syntax.SyntaxKind.CommaToken:
case Kusto.Language.Syntax.SyntaxKind.ColonToken:
case Kusto.Language.Syntax.SyntaxKind.SemicolonToken:
case Kusto.Language.Syntax.SyntaxKind.DotToken:
case Kusto.Language.Syntax.SyntaxKind.DotDotToken:
Bridge.referenceEquals(token.Trivia, "") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpaceIfOnSameLine));
break;
case Kusto.Language.Syntax.SyntaxKind.BarToken:
Bridge.referenceEquals(token.Trivia, " ") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine))
}
switch (prev.Kind) {
case Kusto.Language.Syntax.SyntaxKind.OpenBraceToken:
case Kusto.Language.Syntax.SyntaxKind.OpenBracketToken:
case Kusto.Language.Syntax.SyntaxKind.OpenParenToken:
case Kusto.Language.Syntax.SyntaxKind.DotDotToken:
case Kusto.Language.Syntax.SyntaxKind.DotToken:
Bridge.referenceEquals(token.Trivia, "") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpaceIfOnSameLine));
break;
case Kusto.Language.Syntax.SyntaxKind.CommaToken:
case Kusto.Language.Syntax.SyntaxKind.ColonToken:
case Kusto.Language.Syntax.SyntaxKind.BarToken:
case Kusto.Language.Syntax.SyntaxKind.SemicolonToken:
Bridge.referenceEquals(token.Trivia, " ") || this.AddRule$2(token, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine))
}
}
},
IdentifyNodeSpacing: function(n) {
var $t, $t1, pe, entirePipeExpression, opToken, firstToken, fd, letStatement, statement, firstToken1, firstToken2, se, be;
(Bridge.is(n.Parent, Kusto.Language.Syntax.Statement) && !Bridge.is(n.Parent, Kusto.Language.Syntax.ExpressionStatement) || Bridge.is(n.Parent, Kusto.Language.Syntax.QueryOperator) || Bridge.is(n.Parent, Kusto.Language.Syntax.Command)) && (n.Parent.GetChildIndex(n) > 0 && this.AddRule(n, this.IndentRule()), Bridge.is(n, Kusto.Language.Syntax.Clause) && this.AddRule$2(n.GetFirstToken(), new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, Bridge.fn.bind(this, function() {
return this.DidOrWillSpanMultipleLines(n.Parent)
}))));
do {
if (Bridge.is(n, Kusto.Language.Syntax.PipeExpression)) {
pe = {
v: Bridge.cast(n, Kusto.Language.Syntax.PipeExpression)
};
switch (this._options.PipeOperatorStyle) {
case Kusto.Language.Editor.PlacementStyle.Smart:
entirePipeExpression = {
v: pe.v.GetFirstAncestorOrSelf(Kusto.Language.Syntax.SyntaxNode, function(a) {
return !Bridge.is(a.Parent, Kusto.Language.Syntax.PipeExpression)
})
};
this.AddRule$2(pe.v.Bar, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, function($me, entirePipeExpression, pe) {
return Bridge.fn.bind($me, function() {
return this.DidOrWillSpanMultipleLines(entirePipeExpression.v, !1, pe.v.Bar)
})
}(this, entirePipeExpression, pe)));
opToken = pe.v.Operator.GetFirstToken();
this.AddRule$2(opToken, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpace));
Bridge.referenceEquals(entirePipeExpression.v, pe.v) && Bridge.is(pe.v.Parent, Kusto.Language.Syntax.ParenthesizedExpression) && (firstToken = {
v: pe.v.GetFirstToken()
}, this.AddRule$2(firstToken.v, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, function($me, entirePipeExpression, firstToken) {
return Bridge.fn.bind($me, function() {
return this.DidOrWillSpanMultipleLines(entirePipeExpression.v, !1, firstToken.v)
})
}(this, entirePipeExpression, firstToken))));
break;
case Kusto.Language.Editor.PlacementStyle.NewLine:
this.AddRule$2(pe.v.Bar, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine));
opToken = pe.v.Operator.GetFirstToken();
this.AddRule$2(opToken, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpace))
}
break
}
if (Bridge.is(n, Kusto.Language.Syntax.FunctionDeclaration)) {
fd = {
v: Bridge.cast(n, Kusto.Language.Syntax.FunctionDeclaration)
};
letStatement = fd.v.Parent;
this.AddBrackettingStyleRules(fd.v.Body.OpenBrace, fd.v.Body.CloseBrace, letStatement);
$t = Bridge.getEnumerator(fd.v.Body.Statements, "GetEnumerator$1");
try {
while ($t.moveNext()) statement = $t.Current, firstToken1 = {
v: statement.GetFirstToken()
}, this.AddRule$2(firstToken1.v, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, function($me, fd, firstToken1) {
return Bridge.fn.bind($me, function() {
return this.DidOrWillSpanMultipleLines(fd.v.Body, !0, firstToken1.v)
})
}(this, fd, firstToken1)))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
this.AddRule(fd.v.Body.Statements, this.IndentRule(letStatement));
fd.v.Body.Expression != null && (firstToken2 = {
v: fd.v.Body.Expression.GetFirstToken()
}, this.AddRule$2(firstToken2.v, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, function($me, fd, firstToken2) {
return Bridge.fn.bind($me, function() {
return this.DidOrWillSpanMultipleLines(fd.v.Body, !0, firstToken2.v)
})
}(this, fd, firstToken2))), this.AddRule(fd.v.Body.Expression, this.IndentRule(letStatement)));
break
}
if (Bridge.is(n, Kusto.Language.Syntax.SeparatedElement)) {
if (se = {
v: Bridge.cast(n, Kusto.Language.Syntax.SeparatedElement)
}, System.Nullable.eq(($t1 = se.v.Separator) != null ? $t1.Kind : null, Kusto.Language.Syntax.SyntaxKind.SemicolonToken) && Bridge.is(se.v.Element, Kusto.Language.Syntax.LetStatement)) switch (this._options.SemicolonStyle) {
case Kusto.Language.Editor.PlacementStyle.Smart:
this.AddRule$2(se.v.Separator, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, function($me, se) {
return Bridge.fn.bind($me, function() {
return this.DidOrWillSpanMultipleLines(Bridge.cast(se.v.Element, Kusto.Language.Syntax.SyntaxNode))
})
}(this, se)));
this.AddRule(se.v.Separator, this.IndentRule(se.v));
break;
case Kusto.Language.Editor.PlacementStyle.NewLine:
this.AddRule$2(se.v.Separator, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine));
this.AddRule(se.v.Separator, this.IndentRule(se.v))
}
break
}
if (Bridge.is(n, Kusto.Language.Syntax.BrackettedExpression)) {
be = Bridge.cast(n, Kusto.Language.Syntax.BrackettedExpression);
Bridge.is(be.Parent, Kusto.Language.Syntax.ElementExpression) && this.AddRule$2(be.OpenBracket, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpaceIfOnSameLine));
break
}
} while (0)
},
AddBrackettingStyleRules: function(open, close, alignedTo) {
switch (this._options.BrackettingStyle) {
case Kusto.Language.Editor.BrackettingStyle.Vertical:
this.AddRule$2(open, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, Bridge.fn.bind(this, function() {
return this.DidOrWillSpanMultipleLines$1(open, close, !0, open)
})).Otherwise(Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine)));
var next = open.GetNextToken();
next == null || Bridge.referenceEquals(next, close) || this.AddRule$2(next, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine));
this.AddRule(open, new Kusto.Language.Editor.KustoFormatter.AlignmentRule.ctor(alignedTo));
this.AddRule$2(close, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, Bridge.fn.bind(this, function() {
return this.DidOrWillSpanMultipleLines$1(open, close, !0, close)
})).Otherwise(Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine)));
this.AddRule(close, new Kusto.Language.Editor.KustoFormatter.AlignmentRule.ctor(alignedTo));
break;
case Kusto.Language.Editor.BrackettingStyle.Diagonal:
this.AddRule$2(open, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpace));
next = open.GetNextToken();
next == null || Bridge.referenceEquals(next, close) || this.AddRule$2(next, Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine));
this.AddRule$2(close, new Kusto.Language.Editor.KustoFormatter.SpacingRule(Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine, Bridge.fn.bind(this, function() {
return this.DidOrWillSpanMultipleLines$1(open, close, !0, close)
})).Otherwise(Kusto.Language.Editor.KustoFormatter.SpacingRule.From(Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpaceIfOnSameLine)));
this.AddRule(close, new Kusto.Language.Editor.KustoFormatter.AlignmentRule.ctor(alignedTo))
}
},
IndentRule: function(relativeTo) {
return relativeTo === void 0 && (relativeTo = null), new Kusto.Language.Editor.KustoFormatter.AlignmentRule.ctor(relativeTo, this._options.IndentationSize)
},
AddRule$1: function(node, rule) {
node != null && this.AddRule$2(node.GetFirstToken(), rule)
},
AddRule$2: function(token, rule) {
if (token != null) {
var existingRule = {};
this._spacingRules.tryGetValue(token, existingRule) && (rule = rule.Otherwise(existingRule.v));
this._spacingRules.set(token, rule)
}
},
AddRule: function(element, rule) {
element != null && this._alignmentRules.set(element, rule)
},
DidOrWillSpanMultipleLines$1: function(first, last, inclusive, excluded) {
return (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), Kusto.Language.Editor.KustoFormatter.DidSpanMultipleLines$1(first, last, inclusive, excluded)) ? !0 : this.WillSpanMultipleLines$1(first, last, inclusive, excluded)
},
DidOrWillSpanMultipleLines: function(node, inclusive, excluded) {
return (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), Kusto.Language.Editor.KustoFormatter.DidSpanMultipleLines(node, inclusive, excluded)) ? !0 : this.WillSpanMultipleLines(node, inclusive, excluded)
},
WillSpanMultipleLines$1: function(first, last, inclusive, excluded) {
if (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), first != null && last != null) {
if (inclusive && !Bridge.referenceEquals(first, excluded) && this.WillHaveLineBreak(first)) return !0;
for (var token = first.GetNextToken(); token != null;) {
if (!Bridge.referenceEquals(token, excluded) && this.WillHaveLineBreak(token)) return !0;
if (Bridge.referenceEquals(token, last)) break;
token = token.GetNextToken()
}
}
return !1
},
WillSpanMultipleLines: function(node, inclusive, excluded) {
if (inclusive === void 0 && (inclusive = !1), excluded === void 0 && (excluded = null), node != null) {
var first = node.GetFirstToken(),
last = node.GetLastToken();
return this.WillSpanMultipleLines$1(first, last, inclusive, excluded)
}
return !1
},
WillHaveLineBreak: function(token) {
return Kusto.Language.Parsing.TextFacts.HasLineBreaks(token.Trivia) ? !this.WillHaveLineBreakRemoved(token) : this.WillHaveLineBreakAdded(token)
},
WillHaveLineBreakAdded: function(token) {
var s = {};
return this._spacingRules.tryGetValue(token, s) ? s.v.GetKind() === Kusto.Language.Editor.KustoFormatter.SpacingKind.NewLine : !1
},
WillHaveLineBreakRemoved: function(token) {
var s = {},
kind;
return this._spacingRules.tryGetValue(token, s) ? (kind = s.v.GetKind(), kind === Kusto.Language.Editor.KustoFormatter.SpacingKind.NoSpace || kind === Kusto.Language.Editor.KustoFormatter.SpacingKind.SingleSpace) : !1
}
}
});
Bridge.define("Kusto.Language.Editor.KustoFormatter.AlignmentRule", {
$kind: "nested class",
props: {
RelativeToElement: null,
IndentationDelta: 0
},
ctors: {
ctor: function(relativeTo, indentationDelta) {
indentationDelta === void 0 && (indentationDelta = 0);
this.$initialize();
this.RelativeToElement = relativeTo;
this.IndentationDelta = indentationDelta
},
$ctor1: function(indentationDelta) {
Kusto.Language.Editor.KustoFormatter.AlignmentRule.ctor.call(this, null, indentationDelta)
}
}
});
Bridge.define("Kusto.Language.Editor.KustoFormatter.ComputationState", {
$kind: "nested enum",
statics: {
fields: {
Uncomputed: 0,
Computing: 1,
Computed: 2
}
}
});
Bridge.define("Kusto.Language.Editor.KustoFormatter.SpacingKind", {
$kind: "nested enum",
statics: {
fields: {
Unknown: 0,
AsIs: 2,
AlignOnly: 4,
NoSpace: 8,
NoSpaceIfOnSameLine: 16,
SingleSpace: 32,
SingleSpaceIfOnSameLine: 64,
NewLine: 128
}
},
$flags: !0
});
Bridge.define("Kusto.Language.Editor.KustoFormatter.SpacingRule", {
$kind: "nested class",
statics: {
fields: {
s_spacings: null
},
ctors: {
ctor: function() {
var nSpacings = 129,
i;
for (Kusto.Language.Editor.KustoFormatter.SpacingRule.s_spacings = System.Array.init(nSpacings, null, Kusto.Language.Editor.KustoFormatter.SpacingRule), i = 0; i < nSpacings; i = i + 1 | 0) Kusto.Language.Editor.KustoFormatter.SpacingRule.s_spacings[System.Array.index(i, Kusto.Language.Editor.KustoFormatter.SpacingRule.s_spacings)] = new Kusto.Language.Editor.KustoFormatter.SpacingRule(i, null, null)
}
},
methods: {
From: function(kind) {
return Kusto.Language.Editor.KustoFormatter.SpacingRule.s_spacings[System.Array.index(kind, Kusto.Language.Editor.KustoFormatter.SpacingRule.s_spacings)]
}
}
},
fields: {
_kind: 0,
_otherwise: null,
_condition: null,
_computeState: 0,
_computedKind: 0
},
ctors: {
ctor: function(kind, condition, otherwise) {
otherwise === void 0 && (otherwise = null);
this.$initialize();
this._kind = kind;
this._otherwise = otherwise;
this._condition = condition
}
},
methods: {
GetKind: function() {
if (Bridge.staticEquals(this._condition, null)) return this._kind;
switch (this._computeState) {
case Kusto.Language.Editor.KustoFormatter.ComputationState.Computing:
return this.GetPossibleKinds();
case Kusto.Language.Editor.KustoFormatter.ComputationState.Uncomputed:
this._computeState = Kusto.Language.Editor.KustoFormatter.ComputationState.Computing;
this._computedKind = this._condition() ? this._kind : this._otherwise != null ? this._otherwise.GetKind() : Kusto.Language.Editor.KustoFormatter.SpacingKind.AlignOnly;
this._computeState = Kusto.Language.Editor.KustoFormatter.ComputationState.Computed
}
return this._computedKind
},
GetPossibleKinds: function() {
return Bridge.staticEquals(this._condition, null) ? this._kind : this._otherwise != null ? this._kind | this._otherwise.GetPossibleKinds() : this._kind | Kusto.Language.Editor.KustoFormatter.SpacingKind.AlignOnly
},
Otherwise: function(rule) {
return Bridge.staticEquals(this._condition, null) ? this : this._otherwise == null ? new Kusto.Language.Editor.KustoFormatter.SpacingRule(this._kind, this._condition, rule) : Bridge.staticEquals(this._otherwise._condition, null) && !Bridge.staticEquals(rule._condition, null) ? new Kusto.Language.Editor.KustoFormatter.SpacingRule(this._kind, this._condition, rule.Otherwise(this._otherwise)) : new Kusto.Language.Editor.KustoFormatter.SpacingRule(this._kind, this._condition, this._otherwise.Otherwise(rule))
}
}
});
Bridge.define("Kusto.Language.Editor.KustoQuickInfoBuilder", {
statics: {
methods: {
GetQuickInfoKind: function(severity) {
switch (severity) {
case Kusto.Language.DiagnosticSeverity.Error:
return Kusto.Language.Editor.QuickInfoKind.Error;
case Kusto.Language.DiagnosticSeverity.Warning:
return Kusto.Language.Editor.QuickInfoKind.Warning;
case Kusto.Language.DiagnosticSeverity.Suggestion:
return Kusto.Language.Editor.QuickInfoKind.Suggestion;
default:
return Kusto.Language.Editor.QuickInfoKind.Text
}
}
}
},
fields: {
_service: null,
_code: null
},
ctors: {
ctor: function(service, code) {
this.$initialize();
this._service = service;
this._code = code
}
},
methods: {
GetQuickInfo: function(position, cancellationToken) {
if (this._code.HasSemantics) {
var builder = new System.Text.StringBuilder,
symbolInfo = this.GetSymbolInfo$1(position) || this.GetSyntaxInfo(position),
diagnosticInfo = this.GetDiagnosticInfo(position, cancellationToken);
if (symbolInfo != null) return diagnosticInfo != null ? new Kusto.Language.Editor.QuickInfo.ctor([symbolInfo, diagnosticInfo]) : new Kusto.Language.Editor.QuickInfo.ctor([symbolInfo]);
if (diagnosticInfo != null) return new Kusto.Language.Editor.QuickInfo.ctor([diagnosticInfo])
}
return Kusto.Language.Editor.QuickInfo.Empty
},
GetSymbolInfo$1: function(position) {
var token = this._code.Syntax.GetTokenAt(position),
node, expr, br;
if (token != null && position >= token.TextStart && (node = token.Parent) != null)
if (expr = node.GetFirstAncestorOrSelf(Kusto.Language.Syntax.Expression), node.ReferencedSymbol == null || Bridge.referenceEquals(expr, node)) {
if (expr != null) {
if (expr.IsLiteral)
if ((br = Bridge.as(expr.Parent, Kusto.Language.Syntax.BrackettedExpression)) != null) expr = br;
else if (expr.ResultType != null && expr.ResultType.IsScalar) return this.GetSymbolInfo(expr.ResultType, expr.ResultType, Kusto.Language.Editor.QuickInfoKind.Literal);
return this.GetSymbolInfo(expr.ReferencedSymbol, expr.ResultType)
}
} else return this.GetSymbolInfo(node.ReferencedSymbol, null);
return null
},
GetSymbolInfo: function(symbol, type, itemKind) {
if (itemKind === void 0 && (itemKind = null), symbol != null) {
var texts = new(System.Collections.Generic.List$1(Kusto.Language.Editor.ClassifiedText).ctor);
return Kusto.Language.Editor.SymbolDisplay.GetSymbolDisplay(symbol, type, texts), itemKind == null && (itemKind = this.GetItemKind(symbol)), new Kusto.Language.Editor.QuickInfoItem.$ctor1(System.Nullable.getValue(itemKind), texts)
}
return null
},
GetItemKind: function(symbol) {
var _discard1, _discard2, _discard3, f, _discard4, _discard5, _discard6, _discard7, v, s, cs;
do return Bridge.is(symbol, Kusto.Language.Symbols.ClusterSymbol) ? (_discard1 = Bridge.cast(symbol, Kusto.Language.Symbols.ClusterSymbol), Kusto.Language.Editor.QuickInfoKind.Cluster) : Bridge.is(symbol, Kusto.Language.Symbols.ColumnSymbol) ? (_discard2 = Bridge.cast(symbol, Kusto.Language.Symbols.ColumnSymbol), Kusto.Language.Editor.QuickInfoKind.Column) : Bridge.is(symbol, Kusto.Language.Symbols.DatabaseSymbol) ? (_discard3 = Bridge.cast(symbol, Kusto.Language.Symbols.DatabaseSymbol), Kusto.Language.Editor.QuickInfoKind.Database) : Bridge.is(symbol, Kusto.Language.Symbols.FunctionSymbol) ? (f = Bridge.cast(symbol, Kusto.Language.Symbols.FunctionSymbol), this._code.Globals.IsBuiltInFunction(f) ? Kusto.Language.Editor.QuickInfoKind.BuiltInFunction : this._code.Globals.IsDatabaseFunction(f) ? Kusto.Language.Editor.QuickInfoKind.DatabaseFunction : Kusto.Language.Editor.QuickInfoKind.LocalFunction) : Bridge.is(symbol, Kusto.Language.Symbols.OperatorSymbol) ? (_discard4 = Bridge.cast(symbol, Kusto.Language.Symbols.OperatorSymbol), Kusto.Language.Editor.QuickInfoKind.Operator) : Bridge.is(symbol, Kusto.Language.Symbols.ParameterSymbol) ? (_discard5 = Bridge.cast(symbol, Kusto.Language.Symbols.ParameterSymbol), Kusto.Language.Editor.QuickInfoKind.Parameter) : Bridge.is(symbol, Kusto.Language.Symbols.PatternSymbol) ? (_discard6 = Bridge.cast(symbol, Kusto.Language.Symbols.PatternSymbol), Kusto.Language.Editor.QuickInfoKind.Pattern) : Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol) ? (_discard7 = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol), Kusto.Language.Editor.QuickInfoKind.Table) : Bridge.is(symbol, Kusto.Language.Symbols.VariableSymbol) ? (v = Bridge.cast(symbol, Kusto.Language.Symbols.VariableSymbol), Bridge.is(v.Type, Kusto.Language.Symbols.FunctionSymbol) || Bridge.is(v.Type, Kusto.Language.Symbols.PatternSymbol) || Bridge.is(v.Type, Kusto.Language.Symbols.TableSymbol) || Bridge.is(v.Type, Kusto.Language.Symbols.ScalarSymbol) ? this.GetItemKind(v.Type) : Kusto.Language.Editor.QuickInfoKind.Variable) : Bridge.is(symbol, Kusto.Language.Symbols.ScalarSymbol) ? (s = Bridge.cast(symbol, Kusto.Language.Symbols.ScalarSymbol), Kusto.Language.Editor.QuickInfoKind.Type) : Bridge.is(symbol, Kusto.Language.Symbols.CommandSymbol) ? (cs = Bridge.cast(symbol, Kusto.Language.Symbols.CommandSymbol), Kusto.Language.Editor.QuickInfoKind.Command) : Kusto.Language.Editor.QuickInfoKind.Text; while (0)
},
GetSyntaxInfo: function() {
return null
},
GetBestGrammarAtPosition: function(position) {
var offset = this.GetTokenIndex(position),
source = new(Kusto.Language.Parsing.ArraySource$1(Kusto.Language.Parsing.LexicalToken))(this._code.LexerTokens),
bestGrammar = null,
bestLength = -1;
return this._code.Grammar.Search(source, function(_parser, _source, _start) {
if (_start === offset && _parser.Tag != null) {
var scanLength = _parser.Scan(source, _start);
scanLength > bestLength && (bestGrammar = _parser, bestLength = scanLength)
}
}), bestGrammar
},
GetTokenIndex: function(position) {
if (System.Array.getCount(this._code.LexerTokens, Kusto.Language.Parsing.LexicalToken) === 0) return 0;
if (position >= System.Array.getItem(this._code.LexerTokens, System.Array.getCount(this._code.LexerTokens, Kusto.Language.Parsing.LexicalToken) - 1 | 0, Kusto.Language.Parsing.LexicalToken).End) return System.Array.getCount(this._code.LexerTokens, Kusto.Language.Parsing.LexicalToken) - 1 | 0;
var offset = Kusto.Language.Utils.ListExtensions.BinarySearch(Bridge.global.Kusto.Language.Parsing.LexicalToken, this._code.LexerTokens, function(t) {
return position < t.TriviaStart ? 1 : position >= t.End ? -1 : 0
});
return offset >= 0 ? offset : 0
},
GetDiagnosticInfo: function(position, cancellationToken) {
var $t, diagnostics = System.Linq.Enumerable.from(this._service.GetDiagnostics(!1, cancellationToken)).concat(this._service.GetExtendedDiagnostics(!1, cancellationToken)),
bestDx = null,
d, end;
$t = Bridge.getEnumerator(diagnostics);
try {
while ($t.moveNext()) d = $t.Current, end = d.End > d.Start ? d.End : d.End + 1 | 0, position >= d.Start && position < end && (bestDx == null || d.Start > bestDx.Start) && (bestDx = d)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return bestDx != null ? new Kusto.Language.Editor.QuickInfoItem.$ctor2(Kusto.Language.Editor.KustoQuickInfoBuilder.GetQuickInfoKind(bestDx.Severity), bestDx.Message) : null
}
}
});
Bridge.define("Kusto.Language.Editor.KustoRelatedElementFinder", {
statics: {
methods: {
AreSymbolsEqual: function(symbol, element, options) {
var canSee = (options & Kusto.Language.Editor.FindRelatedOptions.SeeThroughVariables) != 0,
n, d;
return (n = Bridge.as(element, Kusto.Language.Syntax.NameReference)) != null && (Bridge.referenceEquals(n.ReferencedSymbol, symbol) || canSee && Bridge.referenceEquals(n.ReferencedSymbol, Kusto.Language.Symbols.Symbol.GetExpressionResultType(symbol))) || (d = Bridge.as(element, Kusto.Language.Syntax.NameDeclaration)) != null && (Bridge.referenceEquals(d.ReferencedSymbol, symbol) || canSee && Bridge.referenceEquals(Kusto.Language.Symbols.Symbol.GetExpressionResultType(d.ReferencedSymbol), symbol))
}
}
},
fields: {
_code: null
},
ctors: {
ctor: function(code) {
this.$initialize();
this._code = code
}
},
methods: {
FindRelatedElements: function(position, options) {
var token, prev, elements, current, currentIndex;
return (options === void 0 && (options = 0), token = this._code.Syntax.GetTokenAt(position), token == null || position > token.TriviaStart && position < (token.TextStart - 1 | 0)) ? Kusto.Language.Editor.RelatedInfo.Empty : (prev = token != null ? token.GetPreviousToken() : null, position === token.TriviaStart && (token.Trivia.length > 0 || prev != null && this.IsRelatable(prev) && !this.IsRelatable(token)) && (token = token.GetPreviousToken()), token == null) ? Kusto.Language.Editor.RelatedInfo.Empty : (elements = new(System.Collections.Generic.List$1(Kusto.Language.Editor.RelatedElement).ctor), this.IsBracket(token) ? this.GetRelatedBrackets(token, elements) : this.IsNameReferenceOrDeclaration(token) && this.GetRelatedNameReferencesAndDeclarations(token, elements, options), elements.Count > 1 && (current = System.Linq.Enumerable.from(elements).firstOrDefault(function(r) {
return r.Start === token.TextStart
}, null), current != null)) ? (currentIndex = elements.indexOf(current), new Kusto.Language.Editor.RelatedInfo(elements, currentIndex)) : Kusto.Language.Editor.RelatedInfo.Empty
},
IsRelatable: function(token) {
return this.IsBracket(token) || this.IsNameReferenceOrDeclaration(token)
},
IsBracket: function(token) {
switch (token.Text) {
case "{":
case "}":
case "[":
case "]":
case "(":
case ")":
return !0;
default:
return !1
}
},
GetRelatedBrackets: function(token, elements) {
switch (token.Text) {
case "{":
this.GetNextTokenReference(token, "}", elements);
break;
case "}":
this.GetPreviousTokenReference(token, "{", elements);
break;
case "(":
this.GetNextTokenReference(token, ")", elements);
break;
case ")":
this.GetPreviousTokenReference(token, "(", elements);
break;
case "[":
this.GetNextTokenReference(token, "]", elements);
break;
case "]":
this.GetPreviousTokenReference(token, "[", elements)
}
},
GetNextTokenReference: function(token, matchingText, elements) {
for (var child, t, parent = token.Parent, index = parent.GetChildIndex(token), i = index + 1 | 0; i < parent.ChildCount; i = i + 1 | 0)
if (child = parent.GetChild(i), (t = Bridge.as(child, Kusto.Language.Syntax.SyntaxToken)) != null && Bridge.referenceEquals(t.Text, matchingText)) {
elements.add(new Kusto.Language.Editor.RelatedElement.ctor(token.TextStart, token.Text.length, Kusto.Language.Editor.RelatedElementKind.Syntax));
elements.add(new Kusto.Language.Editor.RelatedElement.ctor(t.TextStart, t.Text.length, Kusto.Language.Editor.RelatedElementKind.Syntax));
return
}
},
GetPreviousTokenReference: function(token, matchingText, elements) {
for (var child, t, parent = token.Parent, index = parent.GetChildIndex(token), i = index - 1 | 0; i >= 0; i = i - 1 | 0)
if (child = parent.GetChild(i), (t = Bridge.as(child, Kusto.Language.Syntax.SyntaxToken)) != null && Bridge.referenceEquals(t.Text, matchingText)) {
elements.add(new Kusto.Language.Editor.RelatedElement.ctor(t.TextStart, t.Text.length, Kusto.Language.Editor.RelatedElementKind.Syntax));
elements.add(new Kusto.Language.Editor.RelatedElement.ctor(token.TextStart, token.Text.length, Kusto.Language.Editor.RelatedElementKind.Syntax));
return
}
},
IsNameReferenceOrDeclaration: function(token) {
var n;
return (n = Bridge.as(token.Parent, Kusto.Language.Syntax.Name)) != null && (Bridge.is(n.Parent, Kusto.Language.Syntax.NameReference) || Bridge.is(n.Parent, Kusto.Language.Syntax.NameDeclaration))
},
GetRelatedNameReferencesAndDeclarations: function(token, elements, options) {
var $t, symbol = ($t = token.Parent.GetFirstAncestorOrSelf(Kusto.Language.Syntax.SyntaxNode, function(n) {
return n.ReferencedSymbol != null
})) != null ? $t.ReferencedSymbol : null;
symbol != null && this._code.Syntax.WalkElements(function(e) {
if (Kusto.Language.Editor.KustoRelatedElementFinder.AreSymbolsEqual(symbol, e, options)) {
var kind = new Kusto.Language.Editor.RelatedElementKind;
kind = Bridge.is(e, Kusto.Language.Syntax.NameDeclaration) ? Kusto.Language.Editor.RelatedElementKind.Declaration : Bridge.is(e, Kusto.Language.Syntax.NameReference) ? Kusto.Language.Editor.RelatedElementKind.Reference : Kusto.Language.Editor.RelatedElementKind.Other;
elements.add(new Kusto.Language.Editor.RelatedElement.$ctor1(e.TextStart, e.Width, kind, e.TextStart, e.TextStart))
}
})
}
}
});
Bridge.define("Kusto.Language.Editor.MinimalTextKind", {
$kind: "enum",
statics: {
fields: {
RemoveLeadingWhitespaceAndComments: 0,
MinimizeWhitespaceAndRemoveComments: 1,
SingleLine: 2
}
}
});
Bridge.define("Kusto.Language.Editor.OutlineInfo", {
statics: {
fields: {
Empty: null
},
ctors: {
init: function() {
this.Empty = new Kusto.Language.Editor.OutlineInfo(null)
}
}
},
props: {
Ranges: null
},
ctors: {
ctor: function(ranges) {
this.$initialize();
this.Ranges = ranges || Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Editor.OutlineRange).Instance
}
}
});
Bridge.define("Kusto.Language.Editor.OutlineRange", {
props: {
Start: 0,
Length: 0,
CollapsedText: null
},
ctors: {
ctor: function(start, length, collapsedText) {
var $t;
this.$initialize();
this.Start = start;
this.Length = length;
this.CollapsedText = ($t = collapsedText, $t != null ? $t : "")
}
}
});
Bridge.define("Kusto.Language.Editor.PlacementStyle", {
$kind: "enum",
statics: {
fields: {
None: 0,
NewLine: 1,
Smart: 2
}
}
});
Bridge.define("Kusto.Language.Editor.QuickInfo", {
statics: {
fields: {
Empty: null
},
ctors: {
init: function() {
this.Empty = new Kusto.Language.Editor.QuickInfo.$ctor1(null)
}
},
methods: {
GetKindText: function(kind) {
switch (kind) {
case Kusto.Language.Editor.QuickInfoKind.Text:
default:
return null;
case Kusto.Language.Editor.QuickInfoKind.Table:
return "table";
case Kusto.Language.Editor.QuickInfoKind.Database:
return "database";
case Kusto.Language.Editor.QuickInfoKind.Cluster:
return "cluster";
case Kusto.Language.Editor.QuickInfoKind.Literal:
return "literal";
case Kusto.Language.Editor.QuickInfoKind.Type:
return "type";
case Kusto.Language.Editor.QuickInfoKind.Pattern:
return "pattern";
case Kusto.Language.Editor.QuickInfoKind.Parameter:
return "parameter";
case Kusto.Language.Editor.QuickInfoKind.Scalar:
return "scalar";
case Kusto.Language.Editor.QuickInfoKind.Variable:
return "variable";
case Kusto.Language.Editor.QuickInfoKind.LocalFunction:
case Kusto.Language.Editor.QuickInfoKind.BuiltInFunction:
case Kusto.Language.Editor.QuickInfoKind.DatabaseFunction:
return "function";
case Kusto.Language.Editor.QuickInfoKind.Operator:
return "operator"
}
}
}
},
fields: {
_text: null
},
props: {
Items: null,
Text: {
get: function() {
return this._text == null && (this._text = this.BuildText()), this._text
}
}
},
ctors: {
$ctor2: function(text) {
this.$initialize();
this._text = text;
this.Items = System.Array.init([new Kusto.Language.Editor.QuickInfoItem.$ctor2(Kusto.Language.Editor.QuickInfoKind.Text, text)], Kusto.Language.Editor.QuickInfoItem)
},
ctor: function(items) {
items === void 0 && (items = []);
Kusto.Language.Editor.QuickInfo.$ctor1.call(this, Bridge.cast(items, System.Collections.Generic.IEnumerable$1(Kusto.Language.Editor.QuickInfoItem)))
},
$ctor1: function(items) {
this.$initialize();
this.Items = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Editor.QuickInfoItem, items)
}
},
methods: {
BuildText: function() {
var $t, sb = new System.Text.StringBuilder,
item, kindText;
$t = Bridge.getEnumerator(this.Items, Kusto.Language.Editor.QuickInfoItem);
try {
while ($t.moveNext()) item = $t.Current, sb.getLength() > 0 && sb.append("\n\n"), kindText = Kusto.Language.Editor.QuickInfo.GetKindText(item.Kind), kindText != null && sb.append(System.String.format("({0}) ", [kindText])), sb.append(item.Text)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return sb.toString()
}
}
});
Bridge.define("Kusto.Language.Editor.QuickInfoItem", {
fields: {
_text: null
},
props: {
Kind: 0,
Parts: null,
Text: {
get: function() {
return this._text == null && (this._text = System.String.concat(Bridge.toArray(System.Linq.Enumerable.from(this.Parts).select(function(s) {
return s.Text
})))), this._text
}
}
},
ctors: {
$ctor2: function(kind, text) {
Kusto.Language.Editor.QuickInfoItem.ctor.call(this, kind, [new Kusto.Language.Editor.ClassifiedText.$ctor1(text)])
},
ctor: function(kind, parts) {
parts === void 0 && (parts = []);
Kusto.Language.Editor.QuickInfoItem.$ctor1.call(this, kind, Bridge.cast(parts, System.Collections.Generic.IEnumerable$1(Kusto.Language.Editor.ClassifiedText)))
},
$ctor1: function(kind, parts) {
this.$initialize();
this.Kind = kind;
this.Parts = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Editor.ClassifiedText, parts)
}
}
});
Bridge.define("Kusto.Language.Editor.QuickInfoKind", {
$kind: "enum",
statics: {
fields: {
Text: 0,
Error: 1,
Warning: 2,
Suggestion: 3,
Column: 4,
Table: 5,
Database: 6,
Cluster: 7,
Literal: 8,
Type: 9,
Pattern: 10,
Parameter: 11,
Scalar: 12,
Variable: 13,
LocalFunction: 14,
BuiltInFunction: 15,
DatabaseFunction: 16,
Operator: 17,
Command: 18
}
}
});
Bridge.define("Kusto.Language.Editor.RelatedElementKind", {
$kind: "enum",
statics: {
fields: {
Syntax: 0,
Reference: 1,
Declaration: 2,
Other: 3
}
}
});
Bridge.define("Kusto.Language.Editor.RelatedInfo", {
statics: {
fields: {
Empty: null
},
ctors: {
init: function() {
this.Empty = new Kusto.Language.Editor.RelatedInfo(Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Editor.RelatedElement).Instance, 0)
}
}
},
props: {
Elements: null,
CurrentIndex: 0
},
ctors: {
ctor: function(elements, currentIndex) {
this.$initialize();
this.Elements = elements;
this.CurrentIndex = currentIndex
}
},
methods: {
GetNextIndex: function(index) {
return index < (System.Array.getCount(this.Elements, Kusto.Language.Editor.RelatedElement) - 1 | 0) ? index + 1 | 0 : 0
},
GetPreviousIndex: function(index) {
return index > 0 ? index - 1 | 0 : System.Array.getCount(this.Elements, Kusto.Language.Editor.RelatedElement) - 1 | 0
}
}
});
Bridge.define("Kusto.Language.Editor.SymbolDisplay", {
statics: {
fields: {
MaxColumns: 0
},
ctors: {
init: function() {
this.MaxColumns = 7
}
},
methods: {
GetSymbolDisplay: function(symbol, type, texts) {
var gs, i, subsym, v, nameKind, fs, vs, description;
if ((gs = Bridge.as(symbol, Kusto.Language.Symbols.GroupSymbol)) != null)
for (i = 0; i < System.Array.getCount(gs.Members, Kusto.Language.Symbols.Symbol); i = i + 1 | 0) subsym = System.Array.getItem(gs.Members, i, Kusto.Language.Symbols.Symbol), i > 0 && texts.add(new Kusto.Language.Editor.ClassifiedText.$ctor1("\n")), Kusto.Language.Editor.SymbolDisplay.GetSymbolDisplay(subsym, null, texts);
else Bridge.is(symbol, Kusto.Language.Symbols.ScalarSymbol) ? texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Identifier, symbol.Name)) : (v = Bridge.as(symbol, Kusto.Language.Symbols.VariableSymbol)) != null && (Bridge.is(v.Type, Kusto.Language.Symbols.FunctionSymbol) || Bridge.is(v.Type, Kusto.Language.Symbols.PatternSymbol)) ? Kusto.Language.Editor.SymbolDisplay.GetSymbolDisplay(v.Type, type, texts) : symbol != null && (nameKind = Kusto.Language.Editor.SymbolDisplay.GetNameClassificationKind(symbol), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(nameKind, symbol.Name)), (fs = Bridge.as(symbol, Kusto.Language.Symbols.FunctionSymbol)) != null && Kusto.Language.Editor.SymbolDisplay.GetSignatureDisplay(System.Array.getItem(fs.Signatures, 0, Kusto.Language.Symbols.Signature), texts), type == null && (vs = Bridge.as(symbol, Kusto.Language.Symbols.VariableSymbol)) != null && (type = vs.Type), type == null || Bridge.referenceEquals(type, Kusto.Language.Symbols.ScalarTypes.Unknown) || type.IsError || (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ": ")), Kusto.Language.Editor.SymbolDisplay.GetTypeDisplay(type, texts)), description = Kusto.Language.Editor.SymbolDisplay.GetDescription(symbol), System.String.isNullOrEmpty(description) || texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Comment, "\n\n" + (description || ""))))
},
GetDescription: function(symbol) {
var t, c, p, f;
do return Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol) ? (t = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol), t.Description) : Bridge.is(symbol, Kusto.Language.Symbols.ColumnSymbol) ? (c = Bridge.cast(symbol, Kusto.Language.Symbols.ColumnSymbol), c.Description) : Bridge.is(symbol, Kusto.Language.Symbols.ParameterSymbol) ? (p = Bridge.cast(symbol, Kusto.Language.Symbols.ParameterSymbol), p.Description) : Bridge.is(symbol, Kusto.Language.Symbols.FunctionSymbol) ? (f = Bridge.cast(symbol, Kusto.Language.Symbols.FunctionSymbol), f.Description) : ""; while (0)
},
GetNameClassificationKind: function(symbol) {
var _discard8, _discard9, _discard10, _discard11, _discard12, _discard13, _discard14, _discard15, _discard16, s;
do return Bridge.is(symbol, Kusto.Language.Symbols.ColumnSymbol) ? (_discard8 = Bridge.cast(symbol, Kusto.Language.Symbols.ColumnSymbol), Kusto.Language.Editor.ClassificationKind.Column) : Bridge.is(symbol, Kusto.Language.Symbols.DatabaseSymbol) ? (_discard9 = Bridge.cast(symbol, Kusto.Language.Symbols.DatabaseSymbol), Kusto.Language.Editor.ClassificationKind.Database) : Bridge.is(symbol, Kusto.Language.Symbols.FunctionSymbol) ? (_discard10 = Bridge.cast(symbol, Kusto.Language.Symbols.FunctionSymbol), Kusto.Language.Editor.ClassificationKind.Function) : Bridge.is(symbol, Kusto.Language.Symbols.OperatorSymbol) ? (_discard11 = Bridge.cast(symbol, Kusto.Language.Symbols.OperatorSymbol), Kusto.Language.Editor.ClassificationKind.MathOperator) : Bridge.is(symbol, Kusto.Language.Symbols.ParameterSymbol) ? (_discard12 = Bridge.cast(symbol, Kusto.Language.Symbols.ParameterSymbol), Kusto.Language.Editor.ClassificationKind.Parameter) : Bridge.is(symbol, Kusto.Language.Symbols.PatternSymbol) ? (_discard13 = Bridge.cast(symbol, Kusto.Language.Symbols.PatternSymbol), Kusto.Language.Editor.ClassificationKind.Function) : Bridge.is(symbol, Kusto.Language.Symbols.TableSymbol) ? (_discard14 = Bridge.cast(symbol, Kusto.Language.Symbols.TableSymbol), Kusto.Language.Editor.ClassificationKind.Table) : Bridge.is(symbol, Kusto.Language.Symbols.VariableSymbol) ? (_discard15 = Bridge.cast(symbol, Kusto.Language.Symbols.VariableSymbol), Kusto.Language.Editor.ClassificationKind.Variable) : Bridge.is(symbol, Kusto.Language.Symbols.CommandSymbol) ? (_discard16 = Bridge.cast(symbol, Kusto.Language.Symbols.CommandSymbol), Kusto.Language.Editor.ClassificationKind.Command) : Bridge.is(symbol, Kusto.Language.Symbols.ScalarSymbol) ? (s = Bridge.cast(symbol, Kusto.Language.Symbols.ScalarSymbol), Bridge.referenceEquals(s, Kusto.Language.Symbols.ScalarTypes.String) ? Kusto.Language.Editor.ClassificationKind.StringLiteral : Kusto.Language.Editor.ClassificationKind.Literal) : Kusto.Language.Editor.ClassificationKind.PlainText; while (0)
},
GetSignatureDisplay: function(sig, texts) {
var i, p;
for (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "(")), i = 0; i < System.Array.getCount(sig.Parameters, Kusto.Language.Symbols.Parameter); i = i + 1 | 0) i > 0 && texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), p = System.Array.getItem(sig.Parameters, i, Kusto.Language.Symbols.Parameter), p.IsOptional ? (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "[")), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.SignatureParameter, p.Name)), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "]"))) : texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.SignatureParameter, p.Name));
sig.HasRepeatableParameters && (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "...")));
texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ")"))
},
GetTypeDisplay: function(type, texts, useName) {
var ts, maxCol, i, col, tus, maxCol1, i1, col1, cs, db;
if (useName === void 0 && (useName = !1), (ts = Bridge.as(type, Kusto.Language.Symbols.TableSymbol)) != null)
if (useName && !System.String.isNullOrEmpty(ts.Name)) texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Table, ts.Name));
else {
for (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "(")), maxCol = Math.min(Kusto.Language.Editor.SymbolDisplay.MaxColumns, System.Array.getCount(ts.Columns, Kusto.Language.Symbols.ColumnSymbol)), i = 0; i < maxCol; i = i + 1 | 0) i > 0 && texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), col = System.Array.getItem(ts.Columns, i, Kusto.Language.Symbols.ColumnSymbol), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.SchemaMember, col.Name));
maxCol < System.Array.getCount(ts.Columns, Kusto.Language.Symbols.ColumnSymbol) && (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "...")));
texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ")"))
}
else if ((tus = Bridge.as(type, Kusto.Language.Symbols.TupleSymbol)) != null) {
for (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "{")), maxCol1 = Math.min(Kusto.Language.Editor.SymbolDisplay.MaxColumns, System.Array.getCount(tus.Columns, Kusto.Language.Symbols.ColumnSymbol)), i1 = 0; i1 < maxCol1; i1 = i1 + 1 | 0) i1 > 0 && texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), col1 = System.Array.getItem(tus.Columns, i1, Kusto.Language.Symbols.ColumnSymbol), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Column, col1.Name));
maxCol1 < System.Array.getCount(tus.Columns, Kusto.Language.Symbols.ColumnSymbol) && (texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, ", ")), texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "...")));
texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Punctuation, "}"))
} else(cs = Bridge.as(type, Kusto.Language.Symbols.ClusterSymbol)) != null ? texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Type, System.String.format("cluster('{0}')", [cs.Name]))) : (db = Bridge.as(type, Kusto.Language.Symbols.DatabaseSymbol)) != null ? texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Type, System.String.format("database('{0}')", [db.Name]))) : type != null && texts.add(new Kusto.Language.Editor.ClassifiedText.ctor(Kusto.Language.Editor.ClassificationKind.Type, type.Display))
}
}
}
});
Bridge.define("Kusto.Language.EngineCommands", {
statics: {
fields: {
ShowDatabaseResults: null,
ShowDatabaseDetailsResults: null,
ShowDatabase: null,
ShowDatabaseDetails: null,
ShowDatabaseIdentity: null,
ShowDatabasePolicies: null,
ShowDatabaseDataStats: null,
ShowClusterDatabases: null,
ShowClusterDatabasesDetails: null,
ShowClusterDatabasesIdentity: null,
ShowClusterDatabasesPolicies: null,
ShowClusterDatabasesDataStats: null,
CreateDatabasePersist: null,
CreateDatabaseVolatile: null,
AttachDatabase: null,
DetachDatabase: null,
AlterDatabasePrettyName: null,
DropDatabasePrettyName: null,
AlterDatabasePersistMetadata: null,
SetAccess: null,
ShowDatabaseSchemaResults: null,
ShowDatabaseSchema: null,
ShowDatabaseSchemaAsJson: null,
ShowDatabasesSchema: null,
ShowDatabasesSchemaAsJson: null,
ShowTablesResult: null,
ShowTablesDetailsResult: null,
ShowTableSchemaResult: null,
ShowTables: null,
ShowTable: null,
ShowTablesDetails: null,
ShowTableDetails: null,
ShowTableCslSchema: null,
ShowTableSchemaAsJson: null,
TableSchema: null,
TableProperties: null,
CreateTable: null,
CreateMergeTable: null,
CreateTables: null,
AlterTable: null,
AlterMergeTable: null,
AlterTableDocString: null,
AlterTableFolder: null,
RenameTable: null,
RenameTables: null,
DropTable: null,
UndoDropTable: null,
TableNameList: null,
DropTables: null,
TableIngestionMappingResult: null,
CreateTableIngestionMapping: null,
AlterTableIngestionMapping: null,
ShowTableIngestionMappings: null,
ShowTableIngestionMapping: null,
DropTableIngestionMapping: null,
RenameColumn: null,
RenameColumns: null,
AlterColumnType: null,
DropColumn: null,
DropTableColumns: null,
AlterTableColumnDocStrings: null,
AlterMergeTableColumnDocStrings: null,
FunctionResult: null,
ShowFunctions: null,
ShowFunction: null,
CreateFunction: null,
AlterFunction: null,
CreateOrAlterFunction: null,
DropFunction: null,
AlterFunctionDocString: null,
AlterFunctionFolder: null,
ExternalTableResult: null,
ExternalTableSchemaResult: null,
ExternalTableArtifactsResult: null,
ExternalTableFullResult: null,
ShowExternalTables: null,
ShowExternalTable: null,
ShowExternalTableCslSchema: null,
ShowExternalTableSchema: null,
ShowExternalTableArtifacts: null,
DropExternalTable: null,
CreateOrAlterExternalTableGrammar: null,
CreateExternalTable: null,
AlterExternalTable: null,
CreateExternalTableMapping: null,
AlterExternalTableMapping: null,
ShowExternalTableMappings: null,
ShowExternalTableMapping: null,
DropExternalTableMapping: null,
PolicyResult: null,
ShowDatabasePolicyCaching: null,
ShowTablePolicyCaching: null,
AlterDatabasePolicyCaching: null,
AlterTablePolicyCaching: null,
AlterClusterPolicyCaching: null,
DeleteTablePolicyCaching: null,
ShowTablePolicyIngestionTime: null,
AlterTablePolicyIngestionTime: null,
AlterTablesPolicyIngestionTime: null,
DeleteTablePolicyIngestionTime: null,
ShowTablePolicyRetention: null,
ShowDatabasePolicyRetention: null,
AlterTablePolicyRetention: null,
AlterDatabasePolicyRetention: null,
AlterTablesPolicyRetention: null,
AlterMergeTablePolicyRetention: null,
AlterMergeDatabasePolicyRetention: null,
DeleteTablePolicyRetention: null,
DeleteDatabasePolicyRetention: null,
ShowTablePolicyRowLevelSecurity: null,
AlterTablePolicyRowLevelSecurity: null,
DeleteTablePolicyRowLevelSecurity: null,
ShowTablePolicyRowOrder: null,
AlterTablePolicyRowOrder: null,
AlterTablesPolicyRowOrder: null,
AlterMergeTablePolicyRowOrder: null,
DeleteTablePolicyRowOrder: null,
ShowTablePolicyUpdate: null,
AlterTablePolicyUpdate: null,
AlterMergeTablePolicyUpdate: null,
DeleteTablePolicyUpdate: null,
ShowDatabasePolicyIngestionBatching: null,
ShowTablePolicyIngestionBatching: null,
AlterDatabasePolicyIngestionBatching: null,
AlterTablePolicyIngestionBatching: null,
AlterTablesPolicyIngestionBatching: null,
DeleteDatabasePolicyIngestionBatching: null,
DeleteTablePolicyIngestionBatching: null,
ShowDatabasePolicyEncoding: null,
ShowTablePolicyEncoding: null,
ShowColumnPolicyEncoding: null,
AlterDatabasePolicyEncoding: null,
AlterTablePolicyEncoding: null,
AlterColumnPolicyEncoding: null,
AlterColumnPolicyEncodingType: null,
AlterMergeDatabasePolicyEncoding: null,
AlterMergeTablePolicyEncoding: null,
AlterMergeColumnPolicyEncoding: null,
DeleteDatabasePolicyEncoding: null,
DeleteTablePolicyEncoding: null,
DeleteColumnPolicyEncoding: null,
ShowDatabasePolicyMerge: null,
ShowTablePolicyMerge: null,
AlterDatabasePolicyMerge: null,
AlterTablePolicyMerge: null,
AlterMergeDatabasePolicyMerge: null,
AlterMergeTablePolicyMerge: null,
DeleteDatabasePolicyMerge: null,
DeleteTablePolicyMerge: null,
ShowTablePolicyPartitioning: null,
AlterTablePolicyPartitioning: null,
AlterMergeTablePolicyPartitioning: null,
DeleteTablePolicyPartitioning: null,
ShowTablePolicyRestrictedViewAccess: null,
AlterTablePolicyRestrictedViewAccess: null,
AlterTablesPolicyRestrictedViewAccess: null,
DeleteTablePolicyRestrictedViewAccess: null,
ShowClusterPolicyRowStore: null,
AlterClusterPolicyRowStore: null,
AlterMergeClusterPolicyRowStore: null,
ShowClusterPolicySandbox: null,
AlterClusterPolicySandbox: null,
ShowDatabasePolicySharding: null,
ShowTablePolicySharding: null,
AlterDatabasePolicySharding: null,
AlterTablePolicySharding: null,
AlterMergeDatabasePolicySharding: null,
AlterMergeTablePolicySharding: null,
DeleteDatabasePolicySharding: null,
DeleteTablePolicySharding: null,
ShowDatabasePolicyStreamingIngestion: null,
ShowTablePolicyStreamingIngestion: null,
ShowClusterPolicyStreamingIngestion: null,
AlterDatabasePolicyStreamingIngestion: null,
AlterTablePolicyStreamingIngestion: null,
AlterClusterPolicyStreamingIngestion: null,
DeleteDatabasePolicyStreamingIngestion: null,
DeleteTablePolicyStreamingIngestion: null,
DeleteClusterPolicyStreamingIngestion: null,
ShowClusterPolicyCallout: null,
AlterClusterPolicyCallout: null,
AlterMergeClusterPolicyCallout: null,
DeleteClusterPolicyCallout: null,
ShowClusterPolicyCapacity: null,
AlterClusterPolicyCapacity: null,
AlterMergeClusterPolicyCapacity: null,
ShowClusterPolicyQueryThrottling: null,
AlterClusterPolicyQueryThrottling: null,
DeleteClusterPolicyQueryThrottling: null,
ShowClusterPolicyQueryLimit: null,
AlterClusterPolicyQueryLimit: null,
ShowClusterPolicyMultiDatabaseAdmins: null,
AlterClusterPolicyMultiDatabaseAdmins: null,
AlterMergeClusterPolicyMultiDatabaseAdmins: null,
ShowPrincipalRoles: null,
ShowPrincipalsResult: null,
ShowClusterPrincipals: null,
ShowDatabasePrincipals: null,
ShowTablePrincipals: null,
ShowFunctionPrincipals: null,
ClusterRole: null,
DatabaseRole: null,
TableRole: null,
FunctionRole: null,
PrincipalsClause: null,
PrincipalsOrNoneClause: null,
AddClusterRole: null,
DropClusterRole: null,
SetClusterRole: null,
AddDatabaseRole: null,
DropDatabaseRole: null,
SetDatabaseRole: null,
AddTableRole: null,
DropTableRole: null,
SetTableRole: null,
AddFunctionRole: null,
DropFunctionRole: null,
SetFunctionRole: null,
BlockedPrincipalsResult: null,
ShowClusterBlockedPrincipals: null,
AddClusterBlockedPrincipals: null,
DropClusterBlockedPrincipals: null,
SourceDataLocatorList: null,
PropertyList: null,
IngestIntoTable: null,
IngestInlineIntoTable: null,
DataIngestionSetAppendResult: null,
SetTable: null,
AppendTable: null,
SetOrAppendTable: null,
SetOrReplaceTable: null,
DataConnectionStringList: null,
ExportToStorage: null,
ExportToSqlTable: null,
ExportToExternalTable: null,
OverClause: null,
CreateOrAlterContinuousExport: null,
ShowContinuousExportResult: null,
ShowContinuousExport: null,
ShowContinuousExports: null,
ShowContinuousExportExportedArtifacts: null,
ShowContinuousExportFailures: null,
DropContinuousExport: null,
EnableContinuousExport: null,
DisableContinuousExport: null,
ShowCluster: null,
ShowDiagnostics: null,
ShowCapacity: null,
ShowOperations: null,
ShowOperationDetails: null,
JournalResult: null,
ShowJournal: null,
ShowDatabaseJournal: null,
ShowClusterJournal: null,
QueryResults: null,
ShowQueries: null,
ShowRunningQueries: null,
CancelQuery: null,
ShowQueryPlan: null,
ShowBasicAuthUsers: null,
ShowCache: null,
ShowCommands: null,
ShowCommandsAndQueries: null,
ShowIngestionFailures: null,
ShowExtentsResults: null,
ShowClusterExtents: null,
ExtentIdList: null,
TagWhereClause: null,
ShowDatabaseExtents: null,
ShowTableExtents: null,
ShowTablesExtents: null,
MergeExtentsResult: null,
GuidList: null,
MergeExtents: null,
MergeExtentsDryrun: null,
MoveExtentsResult: null,
MoveExtentsFrom: null,
MoveExtentsQuery: null,
DropExtentResult: null,
DropExtent: null,
DropProperties: null,
DropExtents: null,
DropPretendExtentsByProperties: null,
ShowVersion: null,
ClearTableData: null,
TableStreamingIngestionSchemaCacheClear: null
},
props: {
All: null
},
ctors: {
init: function() {
this.ShowDatabaseResults = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ReservedSlot1", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("InTransitionTo", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowDatabaseDetailsResults = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AuthorizedPrincipals", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RetentionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MergePolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CachingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ShardingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StreamingIngestionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IngestionBatchingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid)]);
this.ShowDatabase = new Kusto.Language.Symbols.CommandSymbol.ctor("show database", Kusto.Language.EngineCommands.ShowDatabaseResults);
this.ShowDatabaseDetails = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database details", "show database details", Kusto.Language.EngineCommands.ShowDatabaseDetailsResults);
this.ShowDatabaseIdentity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database identity", "show database identity", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.ShowDatabasePolicies = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policies", "show database policies", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("AuthorizedPrincipals", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RetentionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MergePolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CachingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ShardingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StreamingIngestionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IngestionBatchingPolicy", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowDatabaseDataStats = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database datastats", "show database datastats", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("OriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("ExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("CompressedSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IndexSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("RowCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("HotOriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotCompressedSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotIndexSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotRowCount", Kusto.Language.Symbols.ScalarTypes.Long)]));
this.ShowClusterDatabases = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster databases", "show cluster databases ['(' { <database>:DatabaseName, ',' }+ ')']", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.ShowClusterDatabasesDetails = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster databases details", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AuthorizedPrincipals", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RetentionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MergePolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CachingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ShardingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StreamingIngestionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IngestionBatchingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.ShowClusterDatabasesIdentity = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster databases identity", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.ShowClusterDatabasesPolicies = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster databases policies", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("AuthorizedPrincipals", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RetentionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MergePolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CachingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ShardingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StreamingIngestionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IngestionBatchingPolicy", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowClusterDatabasesDataStats = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster databases datastats", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentStorage", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsCurrent", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseAccessMode", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CurrentUseIsUnrestrictedViewer", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DatabaseId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("OriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("ExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("CompressedSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IndexSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("RowCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("HotOriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotCompressedSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotIndexSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotRowCount", Kusto.Language.Symbols.ScalarTypes.Long)]));
this.CreateDatabasePersist = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create database persist", "create database <name>:DatabaseName persist '(' { <string>:Container, ',' }+ ')' [ifnotexists]", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentPath", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Created", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("StoresMetadata", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("StoresData", Kusto.Language.Symbols.ScalarTypes.Bool)]));
this.CreateDatabaseVolatile = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create database volatile", "create database <name>:DatabaseName volatile [ifnotexists]", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PersistentPath", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Created", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("StoresMetadata", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("StoresData", Kusto.Language.Symbols.ScalarTypes.Bool)]));
this.AttachDatabase = new Kusto.Language.Symbols.CommandSymbol.$ctor1("attach database", "attach database [metadata] <database>:DatabaseName from (<string>:BlobContainerUrl ';' <string>:StorageAccountKey | <string>:Path)", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Step", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.String)]));
this.DetachDatabase = new Kusto.Language.Symbols.CommandSymbol.$ctor1("detach database", "detach database <database>:DatabaseName", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Table", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("NumberOfRemovedExtents", Kusto.Language.Symbols.ScalarTypes.String)]));
this.AlterDatabasePrettyName = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database prettyname", "alter database <database>:DatabaseName prettyname <string>:DatabasePrettyName", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String)]));
this.DropDatabasePrettyName = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop database prettyname", "drop database <database>:DatabaseName prettyname", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String)]));
this.AlterDatabasePersistMetadata = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database persist metadata", "alter database <database>:DatabaseName persist metadata (<string>:BlobContainerUrl ';' <string>:StorageAccountKey | <string>:Path)", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Moniker", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("Url", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("State", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CreatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("MaxDateTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("IsRecyclable", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("StoresDatabaseMetadata", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("HardDeletePeriod", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]));
this.SetAccess = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set access", "set access <database>:DatabaseName to (readonly | readwrite):AccessMode", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AccessMode", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowDatabaseSchemaResults = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ColumnName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ColumnType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsDefaultTable", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("IsDefaultColumn", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("PrettyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Version", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowDatabaseSchema = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database schema", "show database (schema | <database>:DatabaseName schema) [details] [if_later_than <string>:Version]", Kusto.Language.EngineCommands.ShowDatabaseSchemaResults);
this.ShowDatabaseSchemaAsJson = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database schema as json", "show database (schema | <database>:DatabaseName schema) [if_later_than <string>:Version] as json", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseSchema", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowDatabasesSchema = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show databases schema", "show databases '(' { <database>:DatabaseName [if_later_than <string>:Version], ',' }+ ')' schema [details]", Kusto.Language.EngineCommands.ShowDatabaseSchemaResults);
this.ShowDatabasesSchemaAsJson = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show databases schema as json", "show databases '(' { <database>:DatabaseName [if_later_than <string>:Version], ',' }+ ')' schema as json", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("DatabaseSchema", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowTablesResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowTablesDetailsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalExtents", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("TotalExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("TotalOriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("TotalRowCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("HotExtents", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("HotExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotOriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("HotRowCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("AuthorizedPrincipals", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RetentionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CachingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ShardingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MergePolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StreamingIngestionPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IngestionBatchingPolicy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MinExtentsCreationTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("MaxExtentsCreationTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("RowOrderPolicy", Kusto.Language.Symbols.ScalarTypes.DateTime)]);
this.ShowTableSchemaResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Schema", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowTables = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show tables", "show tables ['(' { <table>:TableName, ',' }+ ')']", Kusto.Language.EngineCommands.ShowTablesResult);
this.ShowTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table", "show table <table>:TableName", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("AttributeName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AttributeType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ExtentSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("CompressionRatio", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IndexSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("IndexSizePercent", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("OriginalSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("AttributeId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("SharedIndexSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("StorageEngineVersion", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowTablesDetails = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show tables details", "show tables ['(' { <table>:TableName, ',' }+ ')'] details", Kusto.Language.EngineCommands.ShowTablesDetailsResult);
this.ShowTableDetails = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table details", "show table <table>:TableName details", Kusto.Language.EngineCommands.ShowTablesDetailsResult);
this.ShowTableCslSchema = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table cslschema", "show table <table>:TableName cslschema", Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.ShowTableSchemaAsJson = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table schema as json", "show table <table>:TableName schema as json", Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.TableSchema = "('(' { <name>:ColumnName ':'! <type>:ColumnType, ',' }+ ')')";
this.TableProperties = "with '(' docstring '=' <string>:Documentation [',' folder! '=' <string>:FolderName] ')'";
this.CreateTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create table", System.String.format("create table <name>:TableName {0} [{1}]", Kusto.Language.EngineCommands.TableSchema, Kusto.Language.EngineCommands.TableProperties), Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.CreateMergeTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create-merge table", System.String.format("create-merge table <name>:TableName {0}", [Kusto.Language.EngineCommands.TableSchema]), Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.CreateTables = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create tables", System.String.format("create tables {{ <name>:TableName {0}, ',' }}+", [Kusto.Language.EngineCommands.TableSchema]), Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.AlterTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table", System.String.format("alter table <table> {0} [{1}]", Kusto.Language.EngineCommands.TableSchema, Kusto.Language.EngineCommands.TableProperties), Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.AlterMergeTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table", System.String.format("alter-merge table <table> {0} [{1}]", Kusto.Language.EngineCommands.TableSchema, Kusto.Language.EngineCommands.TableProperties), Kusto.Language.EngineCommands.ShowTableSchemaResult);
this.AlterTableDocString = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table docstring", "alter table <table>:TableName docstring <string>:Documentation", Kusto.Language.EngineCommands.ShowTablesResult);
this.AlterTableFolder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table folder", "alter table <table>:TableName folder <string>:Folder", Kusto.Language.EngineCommands.ShowTablesResult);
this.RenameTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("rename table", "rename table <table>:TableName to <name>:NewTableName");
this.RenameTables = new Kusto.Language.Symbols.CommandSymbol.$ctor1("rename tables", "rename tables { <name>:NewTableName '='! <table>:TableName, ',' }+");
this.DropTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop table", "drop table <table>:TableName [ifexists]", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String)]));
this.UndoDropTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("undo drop table", "undo drop table <name> [as <name>:TableName] version '=' <string>:Version", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("NumberOfRecords", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("Status", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailureReason", Kusto.Language.Symbols.ScalarTypes.String)]));
this.TableNameList = "'(' { <table>:TableName, ',' }+ ')'";
this.DropTables = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop tables", System.String.format("drop tables {0} [ifexists]", [Kusto.Language.EngineCommands.TableNameList]), new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String)]));
this.TableIngestionMappingResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Kind", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Mapping", Kusto.Language.Symbols.ScalarTypes.String)]);
this.CreateTableIngestionMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create table ingestion mapping", "create table <name>:TableName ingestion! (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName <string>:MappingFormat", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.AlterTableIngestionMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table ingestion mapping", "alter table <table>:TableName ingestion (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName <string>:MappingFormat", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.ShowTableIngestionMappings = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table ingestion mappings", "show table <table>:TableName ingestion (csv | json | avro | parquet | orc):MappingKind mappings", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.ShowTableIngestionMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table ingestion mapping", "show table <table>:TableName ingestion (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.DropTableIngestionMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop table ingestion mapping", "drop table <table>:TableName ingestion (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName");
this.RenameColumn = new Kusto.Language.Symbols.CommandSymbol.$ctor1("rename column", "rename column <database_table_column>:ColumnName to <name>:NewColumnName");
this.RenameColumns = new Kusto.Language.Symbols.CommandSymbol.$ctor1("rename columns", "rename columns { <name>:NewColumnName '='! <database_table_column>:ColumnName, ',' }+");
this.AlterColumnType = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter column type", "alter column <database_table_column>:ColumnName type '=' <type>:ColumnType");
this.DropColumn = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop column", "drop column <table_column>:ColumnName");
this.DropTableColumns = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop table columns", "drop table <table>:TableName columns '(' { <column>:ColumnName, ',' }+ ')'");
this.AlterTableColumnDocStrings = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table column-docstrings", "alter table <table>:TableName column-docstrings '(' { <column>:ColumnName ':'! <string>:DocString, ',' }+ ')'");
this.AlterMergeTableColumnDocStrings = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table column-docstrings", "alter-merge table <table>:TableName column-docstrings '(' { <column>:ColumnName ':'! <string>:DocString, ',' }+ ')'");
this.FunctionResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Parameters", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Body", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowFunctions = new Kusto.Language.Symbols.CommandSymbol.ctor("show functions", Kusto.Language.EngineCommands.FunctionResult);
this.ShowFunction = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show function", "show function <function>:FunctionName", Kusto.Language.EngineCommands.FunctionResult);
this.CreateFunction = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create function", "create function [ifnotexists] [with '('! { <name>:PropertyName '='! <value>:Value, ',' } ')'!] <name>:FunctionName <function_declaration>", Kusto.Language.EngineCommands.FunctionResult);
this.AlterFunction = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter function", "alter function [with '('! { <name>:PropertyName '='! <value>:Value, ',' }+ ')'!] <function>:FunctionName <function_declaration>", Kusto.Language.EngineCommands.FunctionResult);
this.CreateOrAlterFunction = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create-or-alter function", "create-or-alter function [with '('! { <name>:PropertyName '='! <value>:Value, ',' }+ ')'!] <name>:FunctionName <function_declaration>", Kusto.Language.EngineCommands.FunctionResult);
this.DropFunction = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop function", "drop function <function>:FunctionName", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String)]));
this.AlterFunctionDocString = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter function docstring", "alter function <function> docstring <string>:Documentation", Kusto.Language.EngineCommands.FunctionResult);
this.AlterFunctionFolder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter function folder", "alter function <function>:FunctionName folder <string>:Folder", Kusto.Language.EngineCommands.FunctionResult);
this.ExternalTableResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TableType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Properties", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ConnectionStrings", Kusto.Language.Symbols.ScalarTypes.Dynamic)]);
this.ExternalTableSchemaResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Schema", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ExternalTableArtifactsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Uri", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ExternalTableFullResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TableType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Folder", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DocString", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Schema", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Properties", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowExternalTables = new Kusto.Language.Symbols.CommandSymbol.ctor("show external tables", Kusto.Language.EngineCommands.ExternalTableResult);
this.ShowExternalTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table", "show external table <name>:TableName", Kusto.Language.EngineCommands.ExternalTableResult);
this.ShowExternalTableCslSchema = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table cslschema", "show external table <name>:TableName cslschema", Kusto.Language.EngineCommands.ExternalTableSchemaResult);
this.ShowExternalTableSchema = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table schema", "show external table <name>:TableName schema as (json | csl)", Kusto.Language.EngineCommands.ExternalTableSchemaResult);
this.ShowExternalTableArtifacts = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table artifacts", "show external table <name>:TableName artifacts [limit <long>:LimitCount]", Kusto.Language.EngineCommands.ExternalTableArtifactsResult);
this.DropExternalTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop external table", "drop external table <name>:TableName", Kusto.Language.EngineCommands.ExternalTableFullResult);
this.CreateOrAlterExternalTableGrammar = "external table <name>:TableName '(' { <name>:ColumnName ':'! <type>:ColumnType, ',' }+ ')'\r\n kind '='! (blob | adl):TableKind\r\n [partition by!\r\n (\r\n {(format_datetime '='! <string>:DateTimeFormat bin '('! <name>:DateTimeColumn ',' <timespan>:BinValue ')'\r\n | bin '('! <name>:DateTimeColumn ',' <timespan>:BinValue ')'\r\n | [<string>:StringPartitionPrefix] (<name>:StringColumn | hash '('! <name>:StringColumn ',' <long>:HashMod ')') [<string>:StringPartitionSuffix]), ','}+\r\n |\r\n '('\r\n {<name>:PartitionName ':'!\r\n (string:PartitionType ['=' <name>:StringColumn]\r\n | datetime:PartitionType ['=' \r\n (<name>:DateTimeColumn \r\n | bin:PartitionFunction '('! <name>:DateTimeColumn ',' <timespan>:BinValue ')'\r\n | (startofday | startofweek | startofmonth | startofyear):PartitionFunction '('! <name>:DateTimeColumn ')')]\r\n | long:PartitionType '='! hash:PartitionFunction '(' <name>:StringColumn ',' <long>:HashMod ')'), ','}+\r\n ')'\r\n [pathformat '='! '(' \r\n [<string>:PathSeparator]\r\n { (<name>:PartitionName | datetime_pattern '('! <string>:DateTimeFormat ',' <name>:PartitionName ')')\r\n [<string>:PathSeparator] }+ ')']\r\n )\r\n ]\r\n dataformat '='! (avro | apacheavro | csv | json | multijson | parquet | psv | raw | scsv | sohsv | sstream | tsv | tsve | txt | w3clogfile):DataFormatKind\r\n '(' { <string>:StorageConnectionString, ',' }+ ')'\r\n [with '('! { <name>:PropertyName '='! <value>:Value, ',' }+ ')']";
this.CreateExternalTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create external table", "create " + (Kusto.Language.EngineCommands.CreateOrAlterExternalTableGrammar || ""), Kusto.Language.EngineCommands.ExternalTableFullResult);
this.AlterExternalTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter external table", "alter " + (Kusto.Language.EngineCommands.CreateOrAlterExternalTableGrammar || ""), Kusto.Language.EngineCommands.ExternalTableFullResult);
this.CreateExternalTableMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create external table mapping", "create external table <name>:TableName (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName <string>:MappingFormat", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.AlterExternalTableMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter external table mapping", "alter external table <table>:TableName (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName <string>:MappingFormat", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.ShowExternalTableMappings = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table mappings", "show external table <table>:TableName (csv | json | avro | parquet | orc):MappingKind mappings", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.ShowExternalTableMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show external table mapping", "show external table <table>:TableName (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName", Kusto.Language.EngineCommands.TableIngestionMappingResult);
this.DropExternalTableMapping = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop external table mapping", "drop external table <table>:TableName (csv | json | avro | parquet | orc):MappingKind mapping <string>:MappingName");
this.PolicyResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("PolicyName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("EntityName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Policy", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ChildEntities", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("EntityType", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowDatabasePolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy caching", "show database (<database> | '*'):DatabaseName policy caching", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy caching", "show table (<database_table> | '*'):TableName policy caching", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy caching", "alter database <database> policy caching hot '=' <timespan>:Timespan", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy caching", "alter table <database_table> policy caching hot '=' <timespan>:Timespan", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy caching", "alter cluster policy caching hot '=' <timespan>:Timespan");
this.DeleteTablePolicyCaching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy caching", "delete table <database_table> policy caching");
this.ShowTablePolicyIngestionTime = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy ingestiontime", "show table (<table> | '*'):TableName policy ingestiontime", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyIngestionTime = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy ingestiontime", "alter table <table>:TableName policy ingestiontime true", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablesPolicyIngestionTime = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter tables policy ingestiontime", "alter tables '(' { <table>:TableName, ',' }+ ')' policy ingestiontime true", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyIngestionTime = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy ingestiontime", "delete table <table>:TableName policy ingestiontime");
this.ShowTablePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy retention", "show table (<database_table> | '*'):TableName policy retention", Kusto.Language.EngineCommands.PolicyResult);
this.ShowDatabasePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy retention", "show database (<database> | '*'):DatabaseName policy retention", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy retention", "alter table <database_table>:TableName policy retention <string>:RetentionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy retention", "alter database <database>:DatabaseName policy retention <string>:RetentionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablesPolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter tables policy retention", "alter tables '(' { <table>:TableName, ',' }+ ')' policy retention <string>:RetentionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy retention", "alter-merge table <database_table>:TableName policy retention (<string>:RetentionPolicy | softdelete '='! <timespan>:SoftDeleteValue [recoverability '='! (disabled|enabled):RecoverabilityValue] | recoverability '='! (disabled|enabled):RecoverabilityValue)", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeDatabasePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge database policy retention", "alter-merge database <database>:DatabaseName policy retention (<string>:RetentionPolicy | softdelete '='! <timespan>:SoftDeleteValue [recoverability '='! (disabled|enabled):RecoverabilityValue] | recoverability '='! (disabled|enabled):RecoverabilityValue)", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy retention", "delete table <database_table>:TableName policy retention");
this.DeleteDatabasePolicyRetention = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy retention", "delete database <database>:DatabaseName policy retention");
this.ShowTablePolicyRowLevelSecurity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy row_level_security", "show table (<table> | '*'):TableName policy row_level_security", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyRowLevelSecurity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy row_level_security", "alter table <table>:TableName policy row_level_security (enable | disable) <string>:Query", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyRowLevelSecurity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy row_level_security", "delete table <table>:TableName policy row_level_security");
this.ShowTablePolicyRowOrder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy roworder", "show table (<database_table> | '*'):TableName policy roworder", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyRowOrder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy roworder", "alter table <database_table>:TableName policy roworder '('! { <column>:ColumnName (asc|desc)!, ',' }+ ')'!", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablesPolicyRowOrder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter tables policy roworder", "alter tables '(' { <table>:TableName, ',' }+ ')' policy roworder '(' { <name>:ColumnName (asc|desc)!, ',' }+ ')'", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyRowOrder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy roworder", "alter-merge table <database_table>:TableName policy roworder '(' { <column>:ColumnName (asc|desc)!, ',' }+ ')'", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyRowOrder = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy roworder", "delete table <database_table>:TableName policy roworder");
this.ShowTablePolicyUpdate = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy update", "show table (<database_table> | '*'):TableName policy update", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyUpdate = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy update", "alter table <database_table>:TableName policy update <string>:UpdatePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyUpdate = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy update", "alter-merge table <database_table>:TableName policy update <string>:UpdatePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyUpdate = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy update", "delete table <database_table>:TableName policy update");
this.ShowDatabasePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy ingestionbatching", "show database (<database> | '*'):DatabaseName policy ingestionbatching", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy ingestionbatching", "show table (<database_table> | '*'):TableName policy ingestionbatching", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy ingestionbatching", "alter database <database>:DatabaseName policy ingestionbatching <string>:IngestionBatchingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy ingestionbatching", "alter table <database_table>:TableName policy ingestionbatching <string>:IngestionBatchingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablesPolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter tables policy ingestionbatching", "alter tables '(' { <table>:TableName, ',' }+ ')' policy ingestionbatching <string>:IngestionBatchingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteDatabasePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy ingestionbatching", "delete database <database>:DatabaseName policy ingestionbatching");
this.DeleteTablePolicyIngestionBatching = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy ingestionbatching", "delete table <database_table>:TableName policy ingestionbatching");
this.ShowDatabasePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy encoding", "show database <database>:DatabaseName policy encoding", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy encoding", "show table <database_table>:TableName policy encoding", Kusto.Language.EngineCommands.PolicyResult);
this.ShowColumnPolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show column policy encoding", "show column <table_column>:ColumnName policy encoding", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy encoding", "alter database <database>:DatabaseName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy encoding", "alter table <database_table>:TableName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterColumnPolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter column policy encoding", "alter column <table_column>:ColumnName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterColumnPolicyEncodingType = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter column policy encoding type", "alter column <table_column>:ColumnName policy encoding type '=' <string>:EncodingPolicyType", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeDatabasePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge database policy encoding", "alter-merge database <database>:DatabaseName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy encoding", "alter-merge table <database_table>:TableName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeColumnPolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge column policy encoding", "alter-merge column <table_column>:ColumnName policy encoding <string>:EncodingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteDatabasePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy encoding", "delete database <database>:DatabaseName policy encoding");
this.DeleteTablePolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy encoding", "delete table <database_table>:TableName policy encoding");
this.DeleteColumnPolicyEncoding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete column policy encoding", "delete column <table_column>:ColumnName policy encoding");
this.ShowDatabasePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy merge", "show database (<database> | '*'):DatabaseName policy merge", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy merge", "show table (<database_table> | '*'):TableName policy merge", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy merge", "alter database <database>:DatabaseName policy merge <string>:MergePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy merge", "alter table <database_table>:TableName policy merge <string>:MergePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeDatabasePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge database policy merge", "alter-merge database <database>:DatabaseName policy merge <string>:MergePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy merge", "alter-merge table <database_table>:TableName policy merge <string>:MergePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteDatabasePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy merge", "delete database <database>:DatabaseName policy merge");
this.DeleteTablePolicyMerge = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy merge", "delete table <database_table>:TableName policy merge");
this.ShowTablePolicyPartitioning = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy partitioning", "show table (<database_table> | '*'):TableName policy partitioning", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyPartitioning = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy partitioning", "alter table <table>:TableName policy partitioning <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicyPartitioning = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy partitioning", "alter-merge table <table>:TableName policy partitioning <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyPartitioning = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy partitioning", "delete table <table>:TableName policy partitioning", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyRestrictedViewAccess = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy restricted_view_access", "show table (<database_table> | '*'):TableName policy restricted_view_access", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyRestrictedViewAccess = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy restricted_view_access", "alter table <database_table>:TableName policy restricted_view_access (true | false)", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablesPolicyRestrictedViewAccess = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter tables policy restricted_view_access", "alter tables '(' { <table>:TableName, ',' }+ ')' policy restricted_view_access (true | false)", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteTablePolicyRestrictedViewAccess = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy restricted_view_access", "delete table <database_table>:TableName policy restricted_view_access");
this.ShowClusterPolicyRowStore = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster policy rowstore", "show cluster policy rowstore", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyRowStore = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy rowstore", "alter cluster policy rowstore <string>:RowStorePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeClusterPolicyRowStore = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge cluster policy rowstore", "alter-merge cluster policy! rowstore <string>:RowStorePolicy", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicySandbox = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster policy sandbox", "show cluster policy sandbox", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicySandbox = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy sandbox", "alter cluster policy sandbox <string>:SandboxPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.ShowDatabasePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy sharding", "show database (<database> | '*'):DatabaseName policy sharding", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy sharding", "show table (<database_table> | '*'):TableName policy sharding", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy sharding", "alter database <database>:DatabaseName policy sharding <string>:ShardingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy sharding", "alter table <database_table>:TableName policy sharding <string>:ShardingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeDatabasePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge database policy sharding", "alter-merge database <database>:DatabaseName policy sharding <string>:ShardingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeTablePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge table policy sharding", "alter-merge table <database_table>:TableName policy sharding <string>:ShardingPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteDatabasePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy sharding", "delete database <database>:DatabaseName policy sharding");
this.DeleteTablePolicySharding = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy sharding", "delete table <database_table>:TableName policy sharding");
this.ShowDatabasePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database policy streamingingestion", "show database <database>:DatabaseName policy streamingingestion", Kusto.Language.EngineCommands.PolicyResult);
this.ShowTablePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table policy streamingingestion", "show table <database_table>:TableName policy streamingingestion", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster policy streamingingestion", "show cluster policy streamingingestion", Kusto.Language.EngineCommands.PolicyResult);
this.AlterDatabasePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter database policy streamingingestion", "alter database <database>:DatabaseName policy streamingingestion <string>:StreamingIngestionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterTablePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter table policy streamingingestion", "alter table <database_table>:TableName policy streamingingestion <string>:StreamingIngestionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy streamingingestion", "alter cluster policy streamingingestion <string>:StreamingIngestionPolicy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteDatabasePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete database policy streamingingestion", "delete database <database>:DatabaseName policy streamingingestion");
this.DeleteTablePolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete table policy streamingingestion", "delete table <database_table>:TableName policy streamingingestion");
this.DeleteClusterPolicyStreamingIngestion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("delete cluster policy streamingingestion", "delete cluster policy streamingingestion");
this.ShowClusterPolicyCallout = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster policy callout", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyCallout = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy callout", "alter cluster policy callout <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeClusterPolicyCallout = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge cluster policy callout", "alter-merge cluster policy callout <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteClusterPolicyCallout = new Kusto.Language.Symbols.CommandSymbol.ctor("delete cluster policy callout", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicyCapacity = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster policy capacity", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyCapacity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy capacity", "alter cluster policy capacity <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeClusterPolicyCapacity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge cluster policy capacity", "alter-merge cluster policy capacity <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicyQueryThrottling = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster policy querythrottling", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyQueryThrottling = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy querythrottling", "alter cluster policy querythrottling <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.DeleteClusterPolicyQueryThrottling = new Kusto.Language.Symbols.CommandSymbol.ctor("delete cluster policy querythrottling", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicyQueryLimit = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster policy querylimit", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyQueryLimit = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy querylimit", "alter cluster policy querylimit <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.ShowClusterPolicyMultiDatabaseAdmins = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster policy multidatabaseadmins", Kusto.Language.EngineCommands.PolicyResult);
this.AlterClusterPolicyMultiDatabaseAdmins = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter cluster policy multidatabaseadmins", "alter cluster policy multidatabaseadmins <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.AlterMergeClusterPolicyMultiDatabaseAdmins = new Kusto.Language.Symbols.CommandSymbol.$ctor1("alter-merge cluster policy multidatabaseadmins", "alter-merge cluster policy multidatabaseadmins <string>:Policy", Kusto.Language.EngineCommands.PolicyResult);
this.ShowPrincipalRoles = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show principal roles", "show principal [<string>:Principal] roles", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Scope", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DisplayName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AADObjectID", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Role", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowPrincipalsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Role", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalDisplayName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalObjectId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalFQN", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Notes", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowClusterPrincipals = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster principals", Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.ShowDatabasePrincipals = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database principals", System.String.format("show database <database>:DatabaseName principals", null), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.ShowTablePrincipals = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table principals", System.String.format("show table <table>:TableName principals", null), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.ShowFunctionPrincipals = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show function principals", System.String.format("show function <function>:FunctionName principals", null), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.ClusterRole = "(admins | databasecreators | users | viewers):Role";
this.DatabaseRole = "(admins | ingestors | monitors | unrestrictedviewers | users | viewers):Role";
this.TableRole = "(admins | ingestors):Role";
this.FunctionRole = "admins:Role";
this.PrincipalsClause = "'(' { <string>:Principal, ',' }+ ')' [skip-results:SkipResults] [<string>:Notes]";
this.PrincipalsOrNoneClause = System.String.format("(none [skip-results:SkipResults] | {0})", [Kusto.Language.EngineCommands.PrincipalsClause]);
this.AddClusterRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("add cluster role", System.String.format("add cluster {0} {1}", Kusto.Language.EngineCommands.ClusterRole, Kusto.Language.EngineCommands.PrincipalsClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.DropClusterRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop cluster role", System.String.format("drop cluster {0} {1}", Kusto.Language.EngineCommands.ClusterRole, Kusto.Language.EngineCommands.PrincipalsClause));
this.SetClusterRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set cluster role", System.String.format("set cluster {0} {1}", Kusto.Language.EngineCommands.ClusterRole, Kusto.Language.EngineCommands.PrincipalsOrNoneClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.AddDatabaseRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("add database role", System.String.format("add database <database>:DatabaseName {0} {1}", Kusto.Language.EngineCommands.DatabaseRole, Kusto.Language.EngineCommands.PrincipalsClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.DropDatabaseRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop database role", System.String.format("drop database <database>:DatabaseName {0} {1}", Kusto.Language.EngineCommands.DatabaseRole, Kusto.Language.EngineCommands.PrincipalsClause));
this.SetDatabaseRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set database role", System.String.format("set database <database>:DatabaseName {0} {1}", Kusto.Language.EngineCommands.DatabaseRole, Kusto.Language.EngineCommands.PrincipalsOrNoneClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.AddTableRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("add table role", System.String.format("add table <table>:TableName {0} {1}", Kusto.Language.EngineCommands.TableRole, Kusto.Language.EngineCommands.PrincipalsClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.DropTableRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop table role", System.String.format("drop table <table>:TableName {0} {1}", Kusto.Language.EngineCommands.TableRole, Kusto.Language.EngineCommands.PrincipalsClause));
this.SetTableRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set table role", System.String.format("set table <table>:TableName {0} {1}", Kusto.Language.EngineCommands.TableRole, Kusto.Language.EngineCommands.PrincipalsOrNoneClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.AddFunctionRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("add function role", System.String.format("add function <function>:FunctionName {0} {1}", Kusto.Language.EngineCommands.FunctionRole, Kusto.Language.EngineCommands.PrincipalsClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.DropFunctionRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop function role", System.String.format("drop function <function>:FunctionName {0} {1}", Kusto.Language.EngineCommands.FunctionRole, Kusto.Language.EngineCommands.PrincipalsClause));
this.SetFunctionRole = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set function role", System.String.format("set function <function>:FunctionName {0} {1}", Kusto.Language.EngineCommands.FunctionRole, Kusto.Language.EngineCommands.PrincipalsOrNoneClause), Kusto.Language.EngineCommands.ShowPrincipalsResult);
this.BlockedPrincipalsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("PrincipalType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalDisplayName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalObjectId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("PrincipalFQN", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Application", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("BlockedUntil", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Reason", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowClusterBlockedPrincipals = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster blockedprincipals", Kusto.Language.EngineCommands.BlockedPrincipalsResult);
this.AddClusterBlockedPrincipals = new Kusto.Language.Symbols.CommandSymbol.$ctor1("add cluster blockedprincipals", "add cluster blockedprincipals <string>:Principal [application <string>:AppName] [user <string>:UserName] [period <timespan>:Period] [reason <string>:Reason]", Kusto.Language.EngineCommands.BlockedPrincipalsResult);
this.DropClusterBlockedPrincipals = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop cluster blockedprincipals", "drop cluster blockedprincipals <string>:Principal [application <string>:AppName] [user <string>:UserName]");
this.SourceDataLocatorList = "'(' { <string>:SourceDataLocator, ',' }+ ')'";
this.PropertyList = "with '('! { <name>:PropertyName '='! <value>:PropertyValue, ',' }+ ')'";
this.IngestIntoTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("ingest into table", System.String.format("ingest [async] into table! <table>:TableName {0} [{1}]", Kusto.Language.EngineCommands.SourceDataLocatorList, Kusto.Language.EngineCommands.PropertyList), new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("ItemLoaded", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("HasErrors", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("OperationId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.IngestInlineIntoTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("ingest inline into table", System.String.format("ingest inline into! table <name>:TableName ('[' <bracketted_input_data>:Data ']' | {0} '<|'! <input_data>:Data | '<|' <input_data>:Data)", [Kusto.Language.EngineCommands.PropertyList]), new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.Guid)]));
this.DataIngestionSetAppendResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("OriginalSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("ExtentSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("ColumnSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("IndexSize", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("RowCount", Kusto.Language.Symbols.ScalarTypes.Long)]);
this.SetTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set table", System.String.format("set [async] <name>:TableName [{0}] '<|' <input_query>:QueryOrCommand", [Kusto.Language.EngineCommands.PropertyList]), Kusto.Language.EngineCommands.DataIngestionSetAppendResult);
this.AppendTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("append table", System.String.format("append [async] <table>:TableName [{0}] '<|' <input_query>:QueryOrCommand", [Kusto.Language.EngineCommands.PropertyList]), Kusto.Language.EngineCommands.DataIngestionSetAppendResult);
this.SetOrAppendTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set-or-append table", System.String.format("set-or-append [async] <name>:TableName [{0}] '<|' <input_query>:QueryOrCommand", [Kusto.Language.EngineCommands.PropertyList]), Kusto.Language.EngineCommands.DataIngestionSetAppendResult);
this.SetOrReplaceTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("set-or-replace table", System.String.format("set-or-replace [async] <name>:TableName [{0}] '<|' <input_query>:QueryOrCommand", [Kusto.Language.EngineCommands.PropertyList]), Kusto.Language.EngineCommands.DataIngestionSetAppendResult);
this.DataConnectionStringList = "'(' { <string>:DataConnectionString, ',' }+ ')'";
this.ExportToStorage = new Kusto.Language.Symbols.CommandSymbol.$ctor1("export to storage", System.String.format("export [async] [compressed] to (csv|tsv|json|parquet) {0} [{1}] '<|' <input_query>:Query", Kusto.Language.EngineCommands.DataConnectionStringList, Kusto.Language.EngineCommands.PropertyList));
this.ExportToSqlTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("export to sql table", System.String.format("export [async] to sql <name>:SqlTableName <string>:SqlConnectionString [{0}] '<|' <input_query>:Query", [Kusto.Language.EngineCommands.PropertyList]));
this.ExportToExternalTable = new Kusto.Language.Symbols.CommandSymbol.$ctor1("export to external table", System.String.format("export [async] to table <name>:ExternalTableName [{0}] '<|' <input_query>:Query", [Kusto.Language.EngineCommands.PropertyList]));
this.OverClause = "over '('! { <name>:TableName, ',' }+ ')'";
this.CreateOrAlterContinuousExport = new Kusto.Language.Symbols.CommandSymbol.$ctor1("create-or-alter continuous-export", System.String.format("create-or-alter continuous-export <name>:ContinuousExportName [{0}] to table <name>:ExternalTableName [{1}] '<|' <input_query>:Query", Kusto.Language.EngineCommands.OverClause, Kusto.Language.EngineCommands.PropertyList));
this.ShowContinuousExportResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ExternalTableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Query", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ForcedLatency", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("IntervalBetweenRuns", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("CursorScopedTables", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ExportProperties", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("LastRunTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("StartCursor", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsDisabled", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("LastRunResult", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ExportedTo", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("IsRunning", Kusto.Language.Symbols.ScalarTypes.Bool)]);
this.ShowContinuousExport = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show continuous-export", "show continuous-export <name>:ContinuousExportName", Kusto.Language.EngineCommands.ShowContinuousExportResult);
this.ShowContinuousExports = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show continuous-exports", "show continuous-exports", Kusto.Language.EngineCommands.ShowContinuousExportResult);
this.ShowContinuousExportExportedArtifacts = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show continuous-export exported-artifacts", "show continuous-export <name>:ContinuousExportName exported-artifacts", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Timestamp", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("ExternalTableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Path", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("NumRecords", Kusto.Language.Symbols.ScalarTypes.Long)]));
this.ShowContinuousExportFailures = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show continuous-export failures", "show continuous-export <name>:ContinuousExportName failures", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Timestamp", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("OperationId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("LastSuccessRun", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("FailureKind", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Details", Kusto.Language.Symbols.ScalarTypes.String)]));
this.DropContinuousExport = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop continuous-export", "drop continuous-export <name>:ContinousExportName", Kusto.Language.EngineCommands.ShowContinuousExportResult);
this.EnableContinuousExport = new Kusto.Language.Symbols.CommandSymbol.$ctor1("enable continuous-export", "enable continuous-export <name>:ContinousExportName", Kusto.Language.EngineCommands.ShowContinuousExportResult);
this.DisableContinuousExport = new Kusto.Language.Symbols.CommandSymbol.$ctor1("disable continuous-export", "disable continuous-export <name>:ContinousExportName", Kusto.Language.EngineCommands.ShowContinuousExportResult);
this.ShowCluster = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster", "show cluster", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("NodeId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Address", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StartTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("IsAdmin", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("MachineTotalMemory", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MachineAvailableMemory", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("ProcessorCount", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("EnvironmentDescription", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowDiagnostics = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show diagnostics", "show diagnostics", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("IsHealthy", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("EnvironmentDescription", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsScaleOutRequired", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("MachinesTotal", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("MachinesOffline", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("NodeLastRestartedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("AdminLastElectedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("ExtentsTotal", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("DiskColdAllocationPercentage", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("InstancesTargetBasedOnDataCapacity", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("TotalOriginalDataSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("TotalExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IngestionsLoadFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IngestionsInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("IngestionsSuccessRate", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("MergesInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("BuildVersion", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("BuildTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("ClusterDataCapacityFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IsDataWarmingRequired", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("DataWarmingLastRunOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("MergesSuccessRate", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("NotHealthyReason", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("IsAttentionRequired", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("AttentionRequiredReason", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ProductVersion", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailedIngestOperations", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("FailedMergeOperations", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("MaxExtentsInSingleTable", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("TableWithMaxExtents", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("WarmExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("NumberOfDatabases", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("PurgeExtentsRebuildLoadFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("PurgeExtentsRebuildInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("PurgesInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MaxSoftRetentionPolicyViolation", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("RowStoreLocalStorageCapacityFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("ExportsLoadFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("ExportsInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("PendingContinuousExports", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MaxContinuousExportLatenessMinutes", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("RowStoreSealsInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("IsRowStoreUnhealthy", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("MachinesSuspended", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.ColumnSymbol("DataPartitioningLoadFactor", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("DataPartitioningOperationsInProgress", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MinPartitioningPercentageInSingleTable", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("TableWithMinPartitioningPercentage", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowCapacity = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show capacity", "show capacity", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Resource", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Total", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("Consumed", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("Remaining", Kusto.Language.Symbols.ScalarTypes.Long)]));
this.ShowOperations = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show operations", "show operations [(<guid>:OperationId | '(' { <guid>:OperationId, ',' }+ ')')]", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("OperationId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("Operation", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("NodeId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StartedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("LastUpdatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("State", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Status", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("ShouldRetry", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Principal", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("AdminEpochStartTime", Kusto.Language.Symbols.ScalarTypes.DateTime)]));
this.ShowOperationDetails = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show operation details", "show operation <guid>:OperationId details", (new Kusto.Language.Symbols.TableSymbol.ctor).WithIsOpen(!0));
this.JournalResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Event", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("EventTimestamp", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("EntityName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("UpdatedEntityName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("EntityVersion", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("EntityContainerName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("OriginalEntityState", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("UpdatedEntityState", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ChangeCommand", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Principal", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("ClientRequestId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("OriginalEntityVersion", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowJournal = new Kusto.Language.Symbols.CommandSymbol.ctor("show journal", Kusto.Language.EngineCommands.JournalResult);
this.ShowDatabaseJournal = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database journal", "show database <database>:DatabaseName journal", Kusto.Language.EngineCommands.JournalResult);
this.ShowClusterJournal = new Kusto.Language.Symbols.CommandSymbol.ctor("show cluster journal", Kusto.Language.EngineCommands.JournalResult);
this.QueryResults = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ClientActivityId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Text", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StartedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("LastUpdatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("State", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailureReason", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalCpu", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("CacheStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("Application", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MemoryPeak", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("ScannedExtentsStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("Principal", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ClientRequestProperties", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("ResultSetStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic)]);
this.ShowQueries = new Kusto.Language.Symbols.CommandSymbol.ctor("show queries", Kusto.Language.EngineCommands.QueryResults);
this.ShowRunningQueries = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show running queries", "show running queries [by (user <string>:UserName | '*')]", Kusto.Language.EngineCommands.QueryResults);
this.CancelQuery = new Kusto.Language.Symbols.CommandSymbol.$ctor1("cancel query", "cancel query <string>:ClientRequestId");
this.ShowQueryPlan = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show queryplan", "show queryplan '<|' <input_query>:Query", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ResultType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RelopTree", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("QueryPlan", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Stat", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowBasicAuthUsers = new Kusto.Language.Symbols.CommandSymbol.ctor("show basicauth users", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("UserName", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowCache = new Kusto.Language.Symbols.CommandSymbol.ctor("show cache", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("NodeId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalMemoryCapacity", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MemoryCacheCapacity", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MemoryCacheInUse", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MemoryCacheHitCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("TotalDiskCapacity", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("DiskCacheCapacity", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("DiskCacheInUse", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("DiskCacheHitCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("DiskCacheMissCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MemoryCacheDetails", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("DiskCacheDetails", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ShowCommands = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show commands", "show commands", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ClientActivityId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CommandType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Text", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StartedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("LastUpdatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("State", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailureReason", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Application", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Principal", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TotalCpu", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("ResourcesUtilization", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("ClientRequestProperties", Kusto.Language.Symbols.ScalarTypes.Dynamic)]));
this.ShowCommandsAndQueries = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show commands-and-queries", "show commands-and-queries", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ClientActivityId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CommandType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Text", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("StartedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("LastUpdatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("State", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailureReason", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("User", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Application", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Principal", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ClientRequestProperties", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("TotalCpu", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.ColumnSymbol("MemoryPeak", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("CacheStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("ScannedExtentsStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("ResultSetStatistics", Kusto.Language.Symbols.ScalarTypes.Dynamic)]));
this.ShowIngestionFailures = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show ingestion failures", "show ingestion failures [with '(' OperationId '=' <guid>:OperationId ')']", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("OperationId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Database", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Table", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("IngestionSourcePath", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Details", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("FailureKind", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RootActivityId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("OperationKind", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("OriginatesFromUpdatePolicy", Kusto.Language.Symbols.ScalarTypes.Bool)]));
this.ShowExtentsResults = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.Guid), new Kusto.Language.Symbols.ColumnSymbol("DatabaseName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("MaxCreatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("OriginalSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("ExtentSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("CompressedSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("IndexSize", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("Blocks", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("Segments", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("AssignedDataNodes", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("LoadedDataNodes", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ExtentContainerId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("RowCount", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("MinCreatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("Tags", Kusto.Language.Symbols.ScalarTypes.String)]);
this.ShowClusterExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show cluster extents", "show cluster extents [hot]", Kusto.Language.EngineCommands.ShowExtentsResults);
this.ExtentIdList = "'(' {<guid>:ExtentId, ','}+ ')'";
this.TagWhereClause = "where { tags (has | contains | '!has' | '!contains')! <string>:Tag, and }+";
this.ShowDatabaseExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show database extents", System.String.format("show database <database>:DatabaseName extents [{0}] [hot] [{1}]", Kusto.Language.EngineCommands.ExtentIdList, Kusto.Language.EngineCommands.TagWhereClause), Kusto.Language.EngineCommands.ShowExtentsResults);
this.ShowTableExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show table extents", System.String.format("show table <table>:TableName extents [{0}] [hot] [{1}]", Kusto.Language.EngineCommands.ExtentIdList, Kusto.Language.EngineCommands.TagWhereClause), Kusto.Language.EngineCommands.ShowExtentsResults);
this.ShowTablesExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show tables extents", System.String.format("show tables {0} extents [{1}] [hot] [{2}]", Kusto.Language.EngineCommands.TableNameList, Kusto.Language.EngineCommands.ExtentIdList, Kusto.Language.EngineCommands.TagWhereClause), Kusto.Language.EngineCommands.ShowExtentsResults);
this.MergeExtentsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("OriginalExtentId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ResultExtentId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Duration", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]);
this.GuidList = "'(' {<guid>:GUID, ','}+ ')'";
this.MergeExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("merge extents", System.String.format("merge [async] <table>:TableName {0} [with '(' rebuild '=' true ')']", [Kusto.Language.EngineCommands.GuidList]), Kusto.Language.EngineCommands.MergeExtentsResult);
this.MergeExtentsDryrun = new Kusto.Language.Symbols.CommandSymbol.$ctor1("merge extents dryrun", System.String.format("merge dryrun <table>:TableName {0}", [Kusto.Language.EngineCommands.GuidList]), Kusto.Language.EngineCommands.MergeExtentsResult);
this.MoveExtentsResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("OriginalExtentId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ResultExtentId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("Details", Kusto.Language.Symbols.ScalarTypes.String)]);
this.MoveExtentsFrom = new Kusto.Language.Symbols.CommandSymbol.$ctor1("move extents from", System.String.format("move [async] extents (all | {0}) from table <table>:SourceTableName to table <table>:DestinationTableName", [Kusto.Language.EngineCommands.GuidList]), Kusto.Language.EngineCommands.MoveExtentsResult);
this.MoveExtentsQuery = new Kusto.Language.Symbols.CommandSymbol.$ctor1("move extents query", System.String.format("move [async] extents to table <table>:DestinationTableName '<|' <input_query>:Query", null), Kusto.Language.EngineCommands.MoveExtentsResult);
this.DropExtentResult = new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ExtentId", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("TableName", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("CreatedOn", Kusto.Language.Symbols.ScalarTypes.DateTime)]);
this.DropExtent = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop extent", "drop extent <guid>:ExtentId [from <table>:TableName]", Kusto.Language.EngineCommands.DropExtentResult);
this.DropProperties = "[older <long>:Older (days | hours)] from (all tables! | <table>:TableName) [trim by! (extentsize | datasize) <long>:TrimSize (MB | GB | bytes)] [limit <long>:LimitCount]";
this.DropExtents = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop extents", "drop extents \r\n ('(' { <guid>:ExtentId, ',' }+ ')' [from <table>:TableName]\r\n | whatif '<|'! <input_query>:Query\r\n | '<|' <input_query>:Query\r\n | older <long>:Older (days | hours) from (all tables! | <table>:TableName) [trim by! (extentsize | datasize)! <long>:TrimSize (MB | GB | bytes)] [limit <long>:LimitCount]\r\n | from (all tables! | <table>:TableName) [trim by! (extentsize | datasize) <long>:TrimSize (MB | GB | bytes)] [limit <long>:LimitCount]\r\n )", Kusto.Language.EngineCommands.DropExtentResult);
this.DropPretendExtentsByProperties = new Kusto.Language.Symbols.CommandSymbol.$ctor1("drop-pretend extents by properties", System.String.format("drop-pretend extents {0}", [Kusto.Language.EngineCommands.DropProperties]), Kusto.Language.EngineCommands.DropExtentResult);
this.ShowVersion = new Kusto.Language.Symbols.CommandSymbol.$ctor1("show version", "show version", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("BuildVersion", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("BuildTime", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.ColumnSymbol("ServiceType", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.ColumnSymbol("ProductVersion", Kusto.Language.Symbols.ScalarTypes.String)]));
this.ClearTableData = new Kusto.Language.Symbols.CommandSymbol.$ctor1("clear table data", "clear [async] table <table>:TableName data", new Kusto.Language.Symbols.TableSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("Status", Kusto.Language.Symbols.ScalarTypes.String)]));
this.TableStreamingIngestionSchemaCacheClear = new Kusto.Language.Symbols.CommandSymbol.$ctor1("clear table cache streamingingestion schema", "clear table <table>:TableName cache streamingingestion schema");
this.All = System.Array.init([Kusto.Language.EngineCommands.ShowDatabase, Kusto.Language.EngineCommands.ShowDatabaseDetails, Kusto.Language.EngineCommands.ShowDatabaseIdentity, Kusto.Language.EngineCommands.ShowDatabasePolicies, Kusto.Language.EngineCommands.ShowClusterDatabases, Kusto.Language.EngineCommands.ShowClusterDatabasesDetails, Kusto.Language.EngineCommands.ShowClusterDatabasesIdentity, Kusto.Language.EngineCommands.ShowClusterDatabasesPolicies, Kusto.Language.EngineCommands.ShowClusterDatabasesDataStats, Kusto.Language.EngineCommands.CreateDatabasePersist, Kusto.Language.EngineCommands.CreateDatabaseVolatile, Kusto.Language.EngineCommands.AttachDatabase, Kusto.Language.EngineCommands.DetachDatabase, Kusto.Language.EngineCommands.AlterDatabasePrettyName, Kusto.Language.EngineCommands.DropDatabasePrettyName, Kusto.Language.EngineCommands.AlterDatabasePersistMetadata, Kusto.Language.EngineCommands.SetAccess, Kusto.Language.EngineCommands.ShowDatabaseSchema, Kusto.Language.EngineCommands.ShowDatabaseSchemaAsJson, Kusto.Language.EngineCommands.ShowDatabasesSchema, Kusto.Language.EngineCommands.ShowDatabasesSchemaAsJson, Kusto.Language.EngineCommands.ShowTables, Kusto.Language.EngineCommands.ShowTable, Kusto.Language.EngineCommands.ShowTablesDetails, Kusto.Language.EngineCommands.ShowTableDetails, Kusto.Language.EngineCommands.ShowTableCslSchema, Kusto.Language.EngineCommands.ShowTableSchemaAsJson, Kusto.Language.EngineCommands.CreateTable, Kusto.Language.EngineCommands.CreateMergeTable, Kusto.Language.EngineCommands.CreateTables, Kusto.Language.EngineCommands.AlterTable, Kusto.Language.EngineCommands.AlterMergeTable, Kusto.Language.EngineCommands.RenameTable, Kusto.Language.EngineCommands.RenameTables, Kusto.Language.EngineCommands.DropTable, Kusto.Language.EngineCommands.UndoDropTable, Kusto.Language.EngineCommands.DropTables, Kusto.Language.EngineCommands.CreateTableIngestionMapping, Kusto.Language.EngineCommands.AlterTableIngestionMapping, Kusto.Language.EngineCommands.ShowTableIngestionMappings, Kusto.Language.EngineCommands.ShowTableIngestionMapping, Kusto.Language.EngineCommands.DropTableIngestionMapping, Kusto.Language.EngineCommands.AlterTableDocString, Kusto.Language.EngineCommands.AlterTableFolder, Kusto.Language.EngineCommands.RenameColumn, Kusto.Language.EngineCommands.RenameColumns, Kusto.Language.EngineCommands.AlterColumnType, Kusto.Language.EngineCommands.DropColumn, Kusto.Language.EngineCommands.DropTableColumns, Kusto.Language.EngineCommands.AlterTableColumnDocStrings, Kusto.Language.EngineCommands.AlterMergeTableColumnDocStrings, Kusto.Language.EngineCommands.ShowFunctions, Kusto.Language.EngineCommands.ShowFunction, Kusto.Language.EngineCommands.DropFunction, Kusto.Language.EngineCommands.AlterFunctionDocString, Kusto.Language.EngineCommands.AlterFunctionFolder, Kusto.Language.EngineCommands.CreateFunction, Kusto.Language.EngineCommands.AlterFunction, Kusto.Language.EngineCommands.CreateOrAlterFunction, Kusto.Language.EngineCommands.ShowExternalTables, Kusto.Language.EngineCommands.ShowExternalTable, Kusto.Language.EngineCommands.ShowExternalTableCslSchema, Kusto.Language.EngineCommands.ShowExternalTableSchema, Kusto.Language.EngineCommands.ShowExternalTableArtifacts, Kusto.Language.EngineCommands.DropExternalTable, Kusto.Language.EngineCommands.CreateExternalTable, Kusto.Language.EngineCommands.AlterExternalTable, Kusto.Language.EngineCommands.CreateExternalTableMapping, Kusto.Language.EngineCommands.AlterExternalTableMapping, Kusto.Language.EngineCommands.ShowExternalTableMapping, Kusto.Language.EngineCommands.ShowExternalTableMappings, Kusto.Language.EngineCommands.DropExternalTableMapping, Kusto.Language.EngineCommands.ShowDatabasePolicyCaching, Kusto.Language.EngineCommands.AlterDatabasePolicyCaching, Kusto.Language.EngineCommands.ShowTablePolicyCaching, Kusto.Language.EngineCommands.AlterTablePolicyCaching, Kusto.Language.EngineCommands.AlterClusterPolicyCaching, Kusto.Language.EngineCommands.DeleteTablePolicyCaching, Kusto.Language.EngineCommands.AlterTablePolicyIngestionTime, Kusto.Language.EngineCommands.AlterTablesPolicyIngestionTime, Kusto.Language.EngineCommands.ShowTablePolicyIngestionTime, Kusto.Language.EngineCommands.DeleteTablePolicyIngestionTime, Kusto.Language.EngineCommands.ShowTablePolicyRowLevelSecurity, Kusto.Language.EngineCommands.AlterTablePolicyRowLevelSecurity, Kusto.Language.EngineCommands.DeleteTablePolicyRowLevelSecurity, Kusto.Language.EngineCommands.ShowTablePolicyRetention, Kusto.Language.EngineCommands.ShowDatabasePolicyRetention, Kusto.Language.EngineCommands.DeleteTablePolicyRetention, Kusto.Language.EngineCommands.DeleteDatabasePolicyRetention, Kusto.Language.EngineCommands.AlterTablePolicyRetention, Kusto.Language.EngineCommands.AlterTablesPolicyRetention, Kusto.Language.EngineCommands.AlterDatabasePolicyRetention, Kusto.Language.EngineCommands.AlterMergeTablePolicyRetention, Kusto.Language.EngineCommands.AlterMergeDatabasePolicyRetention, Kusto.Language.EngineCommands.ShowTablePolicyRowOrder, Kusto.Language.EngineCommands.DeleteTablePolicyRowOrder, Kusto.Language.EngineCommands.AlterTablePolicyRowOrder, Kusto.Language.EngineCommands.AlterTablesPolicyRowOrder, Kusto.Language.EngineCommands.AlterMergeTablePolicyRowOrder, Kusto.Language.EngineCommands.ShowTablePolicyUpdate, Kusto.Language.EngineCommands.AlterTablePolicyUpdate, Kusto.Language.EngineCommands.AlterMergeTablePolicyUpdate, Kusto.Language.EngineCommands.DeleteTablePolicyUpdate, Kusto.Language.EngineCommands.ShowDatabasePolicyIngestionBatching, Kusto.Language.EngineCommands.ShowTablePolicyIngestionBatching, Kusto.Language.EngineCommands.AlterDatabasePolicyIngestionBatching, Kusto.Language.EngineCommands.AlterTablePolicyIngestionBatching, Kusto.Language.EngineCommands.AlterTablesPolicyIngestionBatching, Kusto.Language.EngineCommands.DeleteDatabasePolicyIngestionBatching, Kusto.Language.EngineCommands.DeleteTablePolicyIngestionBatching, Kusto.Language.EngineCommands.ShowDatabasePolicyEncoding, Kusto.Language.EngineCommands.ShowTablePolicyEncoding, Kusto.Language.EngineCommands.ShowColumnPolicyEncoding, Kusto.Language.EngineCommands.AlterDatabasePolicyEncoding, Kusto.Language.EngineCommands.AlterTablePolicyEncoding, Kusto.Language.EngineCommands.AlterColumnPolicyEncoding, Kusto.Language.EngineCommands.AlterColumnPolicyEncodingType, Kusto.Language.EngineCommands.AlterMergeDatabasePolicyEncoding, Kusto.Language.EngineCommands.AlterMergeTablePolicyEncoding, Kusto.Language.EngineCommands.AlterMergeColumnPolicyEncoding, Kusto.Language.EngineCommands.DeleteDatabasePolicyEncoding, Kusto.Language.EngineCommands.DeleteTablePolicyEncoding, Kusto.Language.EngineCommands.DeleteColumnPolicyEncoding, Kusto.Language.EngineCommands.ShowDatabasePolicyMerge, Kusto.Language.EngineCommands.ShowTablePolicyMerge, Kusto.Language.EngineCommands.AlterDatabasePolicyMerge, Kusto.Language.EngineCommands.AlterTablePolicyMerge, Kusto.Language.EngineCommands.AlterMergeDatabasePolicyMerge, Kusto.Language.EngineCommands.AlterMergeTablePolicyMerge, Kusto.Language.EngineCommands.DeleteDatabasePolicyMerge, Kusto.Language.EngineCommands.DeleteTablePolicyMerge, Kusto.Language.EngineCommands.ShowTablePolicyPartitioning, Kusto.Language.EngineCommands.AlterTablePolicyPartitioning, Kusto.Language.EngineCommands.AlterMergeTablePolicyPartitioning, Kusto.Language.EngineCommands.DeleteTablePolicyPartitioning, Kusto.Language.EngineCommands.ShowTablePolicyRestrictedViewAccess, Kusto.Language.EngineCommands.AlterTablePolicyRestrictedViewAccess, Kusto.Language.EngineCommands.AlterTablesPolicyRestrictedViewAccess, Kusto.Language.EngineCommands.DeleteTablePolicyRestrictedViewAccess, Kusto.Language.EngineCommands.ShowClusterPolicyRowStore, Kusto.Language.EngineCommands.AlterClusterPolicyRowStore, Kusto.Language.EngineCommands.AlterMergeClusterPolicyRowStore, Kusto.Language.EngineCommands.ShowClusterPolicySandbox, Kusto.Language.EngineCommands.AlterClusterPolicySandbox, Kusto.Language.EngineCommands.ShowDatabasePolicySharding, Kusto.Language.EngineCommands.ShowTablePolicySharding, Kusto.Language.EngineCommands.AlterDatabasePolicySharding, Kusto.Language.EngineCommands.AlterTablePolicySharding, Kusto.Language.EngineCommands.AlterMergeDatabasePolicySharding, Kusto.Language.EngineCommands.AlterMergeTablePolicySharding, Kusto.Language.EngineCommands.DeleteDatabasePolicySharding, Kusto.Language.EngineCommands.DeleteTablePolicySharding, Kusto.Language.EngineCommands.ShowDatabasePolicyStreamingIngestion, Kusto.Language.EngineCommands.ShowTablePolicyStreamingIngestion, Kusto.Language.EngineCommands.ShowClusterPolicyStreamingIngestion, Kusto.Language.EngineCommands.AlterDatabasePolicyStreamingIngestion, Kusto.Language.EngineCommands.AlterTablePolicyStreamingIngestion, Kusto.Language.EngineCommands.AlterClusterPolicyStreamingIngestion, Kusto.Language.EngineCommands.DeleteDatabasePolicyStreamingIngestion, Kusto.Language.EngineCommands.DeleteTablePolicyStreamingIngestion, Kusto.Language.EngineCommands.DeleteClusterPolicyStreamingIngestion, Kusto.Language.EngineCommands.ShowClusterPolicyCallout, Kusto.Language.EngineCommands.AlterClusterPolicyCallout, Kusto.Language.EngineCommands.AlterMergeClusterPolicyCallout, Kusto.Language.EngineCommands.DeleteClusterPolicyCallout, Kusto.Language.EngineCommands.ShowClusterPolicyCapacity, Kusto.Language.EngineCommands.AlterClusterPolicyCapacity, Kusto.Language.EngineCommands.AlterMergeClusterPolicyCapacity, Kusto.Language.EngineCommands.ShowClusterPolicyQueryThrottling, Kusto.Language.EngineCommands.AlterClusterPolicyQueryThrottling, Kusto.Language.EngineCommands.DeleteClusterPolicyQueryThrottling, Kusto.Language.EngineCommands.ShowClusterPolicyQueryLimit, Kusto.Language.EngineCommands.AlterClusterPolicyQueryLimit, Kusto.Language.EngineCommands.ShowClusterPolicyMultiDatabaseAdmins, Kusto.Language.EngineCommands.AlterClusterPolicyMultiDatabaseAdmins, Kusto.Language.EngineCommands.AlterMergeClusterPolicyMultiDatabaseAdmins, Kusto.Language.EngineCommands.ShowPrincipalRoles, Kusto.Language.EngineCommands.ShowClusterPrincipals, Kusto.Language.EngineCommands.ShowDatabasePrincipals, Kusto.Language.EngineCommands.ShowTablePrincipals, Kusto.Language.EngineCommands.ShowFunctionPrincipals, Kusto.Language.EngineCommands.AddClusterRole, Kusto.Language.EngineCommands.DropClusterRole, Kusto.Language.EngineCommands.SetClusterRole, Kusto.Language.EngineCommands.AddDatabaseRole, Kusto.Language.EngineCommands.DropDatabaseRole, Kusto.Language.EngineCommands.SetDatabaseRole, Kusto.Language.EngineCommands.AddTableRole, Kusto.Language.EngineCommands.DropTableRole, Kusto.Language.EngineCommands.SetTableRole, Kusto.Language.EngineCommands.AddFunctionRole, Kusto.Language.EngineCommands.DropFunctionRole, Kusto.Language.EngineCommands.SetFunctionRole, Kusto.Language.EngineCommands.ShowClusterBlockedPrincipals, Kusto.Language.EngineCommands.AddClusterBlockedPrincipals, Kusto.Language.EngineCommands.DropClusterBlockedPrincipals, Kusto.Language.EngineCommands.IngestInlineIntoTable, Kusto.Language.EngineCommands.IngestIntoTable, Kusto.Language.EngineCommands.SetTable, Kusto.Language.EngineCommands.AppendTable, Kusto.Language.EngineCommands.SetOrAppendTable, Kusto.Language.EngineCommands.SetOrReplaceTable, Kusto.Language.EngineCommands.ExportToStorage, Kusto.Language.EngineCommands.ExportToSqlTable, Kusto.Language.EngineCommands.ExportToExternalTable, Kusto.Language.EngineCommands.CreateOrAlterContinuousExport, Kusto.Language.EngineCommands.ShowContinuousExport, Kusto.Language.EngineCommands.ShowContinuousExports, Kusto.Language.EngineCommands.ShowContinuousExportExportedArtifacts, Kusto.Language.EngineCommands.ShowContinuousExportFailures, Kusto.Language.EngineCommands.DropContinuousExport, Kusto.Language.EngineCommands.EnableContinuousExport, Kusto.Language.EngineCommands.DisableContinuousExport, Kusto.Language.EngineCommands.ShowCluster, Kusto.Language.EngineCommands.ShowDiagnostics, Kusto.Language.EngineCommands.ShowCapacity, Kusto.Language.EngineCommands.ShowOperations, Kusto.Language.EngineCommands.ShowOperationDetails, Kusto.Language.EngineCommands.ShowJournal, Kusto.Language.EngineCommands.ShowDatabaseJournal, Kusto.Language.EngineCommands.ShowClusterJournal, Kusto.Language.EngineCommands.ShowQueries, Kusto.Language.EngineCommands.ShowRunningQueries, Kusto.Language.EngineCommands.CancelQuery, Kusto.Language.EngineCommands.ShowQueryPlan, Kusto.Language.EngineCommands.ShowBasicAuthUsers, Kusto.Language.EngineCommands.ShowCache, Kusto.Language.EngineCommands.ShowCommands, Kusto.Language.EngineCommands.ShowCommandsAndQueries, Kusto.Language.EngineCommands.ShowIngestionFailures, Kusto.Language.EngineCommands.ShowClusterExtents, Kusto.Language.EngineCommands.ShowDatabaseExtents, Kusto.Language.EngineCommands.ShowTableExtents, Kusto.Language.EngineCommands.ShowTablesExtents, Kusto.Language.EngineCommands.MergeExtentsDryrun, Kusto.Language.EngineCommands.MergeExtents, Kusto.Language.EngineCommands.MoveExtentsFrom, Kusto.Language.EngineCommands.MoveExtentsQuery, Kusto.Language.EngineCommands.DropExtent, Kusto.Language.EngineCommands.DropExtents, Kusto.Language.EngineCommands.DropPretendExtentsByProperties, Kusto.Language.EngineCommands.ShowVersion, Kusto.Language.EngineCommands.ClearTableData, Kusto.Language.EngineCommands.TableStreamingIngestionSchemaCacheClear], Kusto.Language.Symbols.CommandSymbol)
}
}
}
});
Bridge.define("Kusto.Language.FunctionHelpers", {
statics: {
fields: {
MaxRepeat: 0
},
ctors: {
init: function() {
this.MaxRepeat = 32767
}
},
methods: {
MakePrefixedTuple: function(signature, parameterName, args, baseTuple) {
var $t, $t1, $t2, functionPrefix = ($t = Bridge.cast(signature.Symbol, Kusto.Language.Symbols.FunctionSymbol).ResultNamePrefix, $t != null ? $t : signature.Symbol.Name),
argumentPrefix = ($t1 = ($t2 = Kusto.Language.FunctionHelpers.GetReferencedColumn(signature, parameterName, args)) != null ? $t2.Name : null, $t1 != null ? $t1 : "");
return new Kusto.Language.Symbols.TupleSymbol.$ctor1(System.Linq.Enumerable.from(baseTuple.Columns).select(function(c) {
return new Kusto.Language.Symbols.ColumnSymbol(Kusto.Language.FunctionHelpers.GetPrefixedName(functionPrefix, argumentPrefix, c.Name), c.Type)
}))
},
GetPrefixedName: function(functionPrefix, argumentPrefix, name) {
return functionPrefix != null && argumentPrefix != null ? System.String.format("{0}_{1}_{2}", functionPrefix, argumentPrefix, name) : functionPrefix != null ? System.String.format("{0}_{1}", functionPrefix, name) : argumentPrefix != null ? System.String.format("{0}_{1}", argumentPrefix, name) : name
},
GetArgumentRange: function(argumentParameters, parameter, start, length) {
if (start.v = argumentParameters.indexOf(parameter), start.v >= 0) {
for (var end = start.v + 1 | 0; end < argumentParameters.Count && Bridge.referenceEquals(argumentParameters.getItem(end), parameter);) end = end + 1 | 0;
length.v = end - start.v | 0
} else length.v = 0
},
AddReferencedColumns: function(columns, signature, parameterName, args, type) {
var argIndex, arg, c;
type === void 0 && (type = null);
var parameter = signature.GetParameter(parameterName),
argumentParameters = signature.GetArgumentParameters(args),
start = {},
length = {};
for (Kusto.Language.FunctionHelpers.GetArgumentRange(argumentParameters, parameter, start, length), argIndex = start.v; argIndex >= 0 && argIndex < (start.v + length.v | 0); argIndex = argIndex + 1 | 0) arg = System.Array.getItem(args, argIndex, Kusto.Language.Syntax.Expression), (c = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null && (type == null || Bridge.referenceEquals(c.Type, type) || (c = new Kusto.Language.Symbols.ColumnSymbol(c.Name, type)), columns.add(c))
},
AddReferencedColumn: function(columns, signature, parameterName, args, name, type) {
var arg, c;
name === void 0 && (name = null);
type === void 0 && (type = null);
var parameter = signature.GetParameter(parameterName),
argumentParameters = signature.GetArgumentParameters(args),
argIndex = argumentParameters.indexOf(parameter);
argIndex >= 0 && argIndex < System.Array.getCount(args, Kusto.Language.Syntax.Expression) && (arg = System.Array.getItem(args, argIndex, Kusto.Language.Syntax.Expression), (c = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null && (type == null || Bridge.referenceEquals(c.Type, type) || (c = new Kusto.Language.Symbols.ColumnSymbol(c.Name, type)), name == null || Bridge.referenceEquals(c.Name, name) || (c = new Kusto.Language.Symbols.ColumnSymbol(name, c.Type)), columns.add(c)))
},
GetReferencedColumn: function(signature, parameterName, args) {
var parameter = signature.GetParameter(parameterName),
argumentParameters = signature.GetArgumentParameters(args),
argIndex = argumentParameters.indexOf(parameter),
arg, c;
return argIndex >= 0 && argIndex < System.Array.getCount(args, Kusto.Language.Syntax.Expression) && (arg = System.Array.getItem(args, argIndex, Kusto.Language.Syntax.Expression), (c = Bridge.as(arg.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null) ? c : null
},
GetArgument: function(args, signature, parameterName) {
var p = signature.GetParameter(parameterName),
argumentParameters, argIndex;
return p != null && (argumentParameters = signature.GetArgumentParameters(args), argIndex = argumentParameters.indexOf(p), argIndex >= 0 && argIndex < System.Array.getCount(args, Kusto.Language.Syntax.Expression)) ? System.Array.getItem(args, argIndex, Kusto.Language.Syntax.Expression) : null
},
GetExpressionResultName: function(expr, defaultName, rowScope) {
return defaultName === void 0 && (defaultName = ""), rowScope === void 0 && (rowScope = null), Kusto.Language.Binding.Binder.GetExpressionResultName(expr, defaultName, rowScope)
},
GetLiteralValue: function(expr) {
var $t, $t1;
return $t = ($t1 = expr.LiteralValue) != null ? Bridge.toString($t1) : null, $t != null ? $t : ""
},
MakeValidNameFragment: function(text) {
return System.Linq.Enumerable.from(text).all(function(c) {
return System.Char.isDigit(c) || System.Char.isLetter(c)
}) ? text : System.String.fromCharArray(System.Linq.Enumerable.from(text).select(function(c) {
return System.Char.isDigit(c) || System.Char.isLetter(c) ? c : 95
}).ToArray(System.Char))
},
GetSummarizeByColumns: function(args) {
if (System.Array.getCount(args, Kusto.Language.Syntax.Expression) > 0) {
var op = System.Array.getItem(args, 0, Kusto.Language.Syntax.Expression).GetFirstAncestorOrSelf(Kusto.Language.Syntax.SummarizeOperator);
if (op != null && op.ByClause != null) return Kusto.Language.FunctionHelpers.GetColumnSymbols(op.ByClause.Expressions)
}
return Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.ColumnSymbol).Instance
},
GetColumnSymbols: function(exprs) {
for (var expr, sn, c, symbols = null, i = 0; i < exprs.Count; i = i + 1 | 0) expr = exprs.getItem$1(i).Element$1, (sn = Bridge.as(expr, Kusto.Language.Syntax.SimpleNamedExpression)) != null && (expr = sn.Expression), (c = Bridge.as(expr.ReferencedSymbol, Kusto.Language.Symbols.ColumnSymbol)) != null && (symbols == null && (symbols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ColumnSymbol).ctor)), symbols.add(c));
return symbols || Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.ColumnSymbol).Instance
}
}
}
});
Bridge.define("Kusto.Language.Functions", {
statics: {
fields: {
Cluster: null,
Database: null,
Table: null,
ExternalTable: null,
MaterializedView: null,
Strcat: null,
StrcatArray: null,
ArrayStrcat: null,
StrcatDelim: null,
Strcmp: null,
Strrep: null,
Strlen: null,
StringSize: null,
ToUpper: null,
ToLower: null,
ToUtf8: null,
Substring: null,
IndexOf: null,
IndexOfRegex: null,
Reverse: null,
Split: null,
ParseCommandLine: null,
Extract: null,
ExtractAll_Depricated: null,
ExtractAll: null,
ExtractJson: null,
Replace: null,
TrimStart: null,
TrimEnd: null,
Trim: null,
CountOf: null,
Translate: null,
MakeString: null,
DateTimeToLocaleString: null,
NumberToLocaleString: null,
ToString: null,
ToHex: null,
ToDynamic_: null,
ToObject_Depricated: null,
ToLong: null,
ToInt: null,
ToReal: null,
ToDouble: null,
ToDateTime: null,
ToTimespan: null,
ToTime: null,
ToBool: null,
ToBoolean: null,
ToDecimal: null,
ToGuid: null,
GetType: null,
UrlEncode: null,
UrlEncode_Component: null,
UrlDecode: null,
Base64EncodeString: null,
Base64EncodeToString: null,
Base64DecodeString: null,
Base64DecodeToString: null,
Base64DecodeToArray: null,
Base64EncodeFromArray: null,
ParseCsv: null,
ParseJson_Depricated: null,
ParseJson: null,
ParseXml: null,
ParseUrl_Depricated: null,
ParseUrl: null,
ParseUrlQuery_Depricated: null,
ParseUrlQuery: null,
ParseIPV4: null,
ParseIPV4Mask: null,
Ipv4Compare: null,
Ipv4IsMatch: null,
ParseIPV6: null,
ParseIPV6Mask: null,
Ipv6Compare: null,
Ipv6IsMatch: null,
ParsePath: null,
ParseUserAgent: null,
ParseVersion: null,
FormatDatetime: null,
FormatTimespan: null,
MakeDatetime: null,
MakeTimespan: null,
s_dateDiffLiteralValues: null,
s_datePartLiteralValues: null,
DatetimeAdd: null,
DatetimeDiff: null,
DayOfWeek: null,
DayOfMonth: null,
DayOfYear: null,
HourOfDay: null,
WeekOfYear: null,
WeekOfYearISO: null,
MonthOfYear: null,
StartOfDay: null,
StartOfWeek: null,
StartOfMonth: null,
StartOfYear: null,
EndOfDay: null,
EndOfWeek: null,
EndOfMonth: null,
EndOfYear: null,
GetYear: null,
GetMonth: null,
DatePart: null,
DatetimePart: null,
Now: null,
Ago: null,
UnixTimeSecondsToDateTime: null,
UnixTimeMillisecondsToDateTime: null,
UnixTimeMicrosecondsToDateTime: null,
UnixTimeNanosecondsToDateTime: null,
HashCrc32: null,
HashManyCrc32: null,
HashDjb2: null,
HashXXH64: null,
Hash: null,
HashSha256: null,
HashMd5: null,
HashCombine: null,
HashMany: null,
Iif: null,
Iff: null,
Case: null,
Assert: null,
Bin: null,
Floor: null,
BinAt: null,
BinAuto: null,
Not: null,
NotNull_Depricated: null,
IsNotNull: null,
IsNull: null,
NotEmpty_Depricated: null,
IsNotEmpty: null,
IsEmpty: null,
IsAscii: null,
IsUtf8: null,
IsColumnExists: null,
ColumnIfExists_Depricated: null,
ColumnIfExists: null,
BinaryAnd: null,
BinaryOr: null,
BinaryXor: null,
BinaryNot: null,
BinaryShiftRight: null,
BinaryShiftLeft: null,
BitsetCountOnes: null,
TreePath: null,
Repeat: null,
Arraylength_Depricated: null,
ArrayLength: null,
Range: null,
ArrayConcat: null,
ArrayIff: null,
ArrayIif: null,
ArrayIndexOf: null,
SetHasElement: null,
ArraySlice: null,
ArraySplit: null,
ArrayShiftLeft: null,
ArrayShiftRight: null,
ArrayRotateLeft: null,
ArrayRotateRight: null,
BagKeys: null,
Zip: null,
Pack: null,
PackDictionary: null,
PackAll: null,
PackArray: null,
SetUnion: null,
SetIntersect: null,
SetDifference: null,
BagMerge: null,
PercentileTDigest: null,
PercentRankTDigest: null,
RankTDigest: null,
TDigestMerge: null,
MergeTDigests: null,
HllMerge: null,
DCountHll: null,
SeriesFir: null,
SeriesStats: null,
SeriesStatsDynamic: null,
SeriesFitLine: null,
SeriesFitLineDynamic: null,
SeriesFit2Lines: null,
SeriesFit2LinesDynamic: null,
SeriesOutliers: null,
SeriesIIR: null,
SeriesPeriodsDetect: null,
SeriesPeriodsValidate: null,
SeriesFillBackwards: null,
SeriesFillForward: null,
SeriesFillConst: null,
SeriesFillLinear: null,
SeriesAdd: null,
SeriesSubtract: null,
SeriesMultiply: null,
SeriesDivide: null,
SeriesGreater: null,
SeriesGreaterEquals: null,
SeriesLess: null,
SeriesLessEquals: null,
SeriesEquals: null,
SeriesNotEquals: null,
SeriesSeasonal: null,
SeriesDecompose: null,
SeriesDecomposeForecast: null,
SeriesDecomposeAnomalies: null,
SeriesPearsonCorrelation: null,
Round: null,
Ceiling: null,
Pow: null,
Sqrt: null,
Log: null,
Log2: null,
Log10: null,
Exp: null,
Exp2: null,
Exp10: null,
PI: null,
Cos: null,
Sin: null,
Tan: null,
Acos: null,
Asin: null,
Atan: null,
Atan2: null,
Abs: null,
Cot: null,
Degrees: null,
Radians: null,
Sign: null,
Rand: null,
BetaCdf: null,
BetaInv: null,
BetaPdf: null,
Gamma: null,
LogGamma: null,
IsNan: null,
IsInf: null,
IsFinite: null,
Coalesce: null,
MaxOf: null,
MinOf: null,
WelchTest: null,
GeoDistance2Points: null,
GeoDistancePointToLine: null,
GeoPointInCircle: null,
GeoPointInPolygon: null,
GeoPolygonToS2Cells: null,
GeoPolygonValidate: null,
GeoPointToGeohash: null,
GeohashToCentralPoint: null,
GeoPointToS2Cell: null,
S2CellToCentralPoint: null,
CurrentClusterEndpoint: null,
CurrentDatabase: null,
CurrentPrincipal: null,
CurrentPrincipalDetails: null,
CurrentPrincipalIsMemberOf: null,
ExtentId: null,
ExtentId2: null,
ExtentTags: null,
CurrentNodeId: null,
IngestionTime: null,
CursorAfter: null,
CursorBeforeOrAt: null,
CursorCurrent: null,
CursorCurrent2: null,
FormatBytes: null,
RowNumber: null,
RowCumSum: null,
RowWindowSession: null,
Prev: null,
Next: null,
RowstoreOrdinalRange: null,
EstimateDataSize: null,
NewGuid: null,
InternalFunnelCompletion: null
},
props: {
All: null
},
ctors: {
init: function() {
this.Cluster = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("cluster", Kusto.Language.Symbols.ReturnTypeKind.Parameter0Cluster, [new Kusto.Language.Symbols.Parameter.$ctor2("name", Kusto.Language.Symbols.ScalarTypes.String)]);
this.Database = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("database", Kusto.Language.Symbols.ReturnTypeKind.Parameter0Database, [new Kusto.Language.Symbols.Parameter.$ctor2("name", Kusto.Language.Symbols.ScalarTypes.String)]);
this.Table = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("table", Kusto.Language.Symbols.ReturnTypeKind.Parameter0Table, [new Kusto.Language.Symbols.Parameter.$ctor2("name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("query_data_scope", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]);
this.ExternalTable = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("external_table", Kusto.Language.Symbols.ReturnTypeKind.Parameter0ExternalTable, [new Kusto.Language.Symbols.Parameter.$ctor2("name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("mapping", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]);
this.MaterializedView = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("materialized_view", Kusto.Language.Symbols.ReturnTypeKind.Parameter0MaterializedView, [new Kusto.Language.Symbols.Parameter.$ctor2("name", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("max_age", Kusto.Language.Symbols.ScalarTypes.TimeSpan, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]);
this.Strcat = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strcat", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.StrcatArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strcat_array", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("delimiter", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayStrcat = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_strcat", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("delimiter", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.StrcatDelim = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strcat_delim", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("delimiter", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Strcmp = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strcmp", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("s1", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("s2", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable();
this.Strrep = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strrep", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("multiplier", Kusto.Language.Symbols.ScalarTypes.Long)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Strlen = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("strlen", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("string", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.NameAndFirstArgument).ConstantFoldable();
this.StringSize = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("string_size", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("string", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.NameAndFirstArgument).ConstantFoldable();
this.ToUpper = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toupper", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ToLower = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tolower", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ToUtf8 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("to_utf8", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Substring = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("substring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("string", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("length", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.IndexOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("indexof", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("string", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("match", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("length", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("occurence", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.IndexOfRegex = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("indexof_regex", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("string", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("match", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("length", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("occurence", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Reverse = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("reverse", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Split = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("split", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("delimiter", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.ctor("requestedIndex", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseCommandLine = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_command_line", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("command", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("parser", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.Extract = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("extract", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("captureGroup", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.ParameterNLiteral, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("captureGroup", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("typeLiteral", Kusto.Language.Symbols.ScalarTypes.Type, Kusto.Language.Symbols.ArgumentKind.Literal)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ExtractAll_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("extractall", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("captureGroups", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.ExtractAll = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("extract_all", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("captureGroups", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ExtractJson = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("extractjson", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("jsonPath", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("jsonText", Kusto.Language.Symbols.ScalarTypes.String)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.ParameterNLiteral, [new Kusto.Language.Symbols.Parameter.$ctor2("jsonPath", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("jsonText", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("type", Kusto.Language.Symbols.ScalarTypes.Type, Kusto.Language.Symbols.ArgumentKind.Literal)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Replace = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("replace", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("rewrite", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.TrimStart = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("trim_start", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.TrimEnd = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("trim_end", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Trim = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("trim", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("regex", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.CountOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("countof", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("search", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("kind", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Literal, System.Array.init(["normal", "regex"], System.Object), void 0, !0, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Translate = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("translate", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor3("searchList", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Constant), new Kusto.Language.Symbols.Parameter.$ctor3("replacementList", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Constant), new Kusto.Language.Symbols.Parameter.$ctor2("text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.MakeString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("make_string", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.IntegerOrDynamic, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.DateTimeToLocaleString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("datetime_to_locale_string", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("culture", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("options", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable().Hide();
this.NumberToLocaleString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("number_to_locale_string", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("culture", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("options", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable().Hide();
this.ToString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tostring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToHex = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tohex", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToDynamic_ = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("todynamic", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToObject_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toobject", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).Hide();
this.ToLong = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tolong", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToInt = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toint", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToReal = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toreal", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToDouble = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("todouble", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToDateTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("todatetime", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToTimespan = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("totimespan", Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("totime", Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).Hide().ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToBool = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tobool", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToBoolean = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toboolean", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToDecimal = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("todecimal", Kusto.Language.Symbols.ScalarTypes.Decimal, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.ToGuid = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("toguid", Kusto.Language.Symbols.ScalarTypes.Guid, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.GetType = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("gettype", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("type");
this.UrlEncode = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("url_encode", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("url", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UrlEncode_Component = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("url_encode_component", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("url", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UrlDecode = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("url_decode", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("encoded_url", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64EncodeString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_encodestring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("string", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().Hide().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64EncodeToString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_encode_tostring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("string", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64DecodeString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_decodestring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("base64_string", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().Hide().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64DecodeToString = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_decode_tostring", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("base64_string", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64DecodeToArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_decode_toarray", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("base64_string", Kusto.Language.Symbols.ScalarTypes.String)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Base64EncodeFromArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("base64_encode_fromarray", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("base64_string_decodced_as_array", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.ParseCsv = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_csv", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("csv_text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.ParseJson_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parsejson", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("json_text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable().Hide();
this.ParseJson = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_json", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("json_text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.ParseXml = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_xml", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("xml_text", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.ParseUrl_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parseurl", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("url", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.ParseUrl = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_url", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("url", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseUrlQuery_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parseurlquery", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("query", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.ParseUrlQuery = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_urlquery", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("query", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseIPV4 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_ipv4", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("ip", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseIPV4Mask = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_ipv4_mask", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("ip", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("prefix", Kusto.Language.Symbols.ScalarTypes.Long)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Ipv4Compare = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ipv4_compare", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("ip1", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("ip2", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("prefix", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Ipv4IsMatch = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ipv4_is_match", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("ip1", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("ip2", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("prefix", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseIPV6 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_ipv6", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("ip", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseIPV6Mask = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_ipv6_mask", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("ip", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("prefix", Kusto.Language.Symbols.ScalarTypes.Long)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Ipv6Compare = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ipv6_compare", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("ip1", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("ip2", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("prefix", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Ipv6IsMatch = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ipv6_is_match", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("ip1", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("ip2", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor3("prefix", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParsePath = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_path", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("path", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseUserAgent = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_user_agent", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("user_agent", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.ctor("look_for", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ParseVersion = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("parse_version", Kusto.Language.Symbols.ScalarTypes.Decimal, [new Kusto.Language.Symbols.Parameter.$ctor2("version", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.FormatDatetime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("format_datetime", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("format", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.LiteralNotEmpty)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.FormatTimespan = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("format_timespan", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("timespan", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor3("format", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.LiteralNotEmpty)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.MakeDatetime = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("make_datetime", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("dateTime", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("year", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("month", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("day", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("hour", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("minute", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("second", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)])]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.OnlyArgument);
this.MakeTimespan = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("make_timespan", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("timespan", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("hours", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("minutes", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("seconds", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("days", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("hours", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("minutes", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("seconds", Kusto.Language.Symbols.ParameterTypeKind.Integer)])]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.OnlyArgument);
this.s_dateDiffLiteralValues = System.Array.init(["Year", "Quarter", "Month", "Week", "Day", "Hour", "Minute", "Second", "Millisecond", "Microsecond", "Nanosecond"], System.String);
this.s_datePartLiteralValues = System.Array.init(["Year", "Quarter", "Month", "WeekOfYear", "Day", "DayOfYear", "Hour", "Minute", "Second", "Millisecond", "Microsecond", "Nanosecond"], System.String);
this.DatetimeAdd = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("datetime_add", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor3("part", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Literal, Kusto.Language.Functions.s_dateDiffLiteralValues), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.$ctor2("datetime", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.DatetimeDiff = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("datetime_diff", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor3("part", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Literal, Kusto.Language.Functions.s_dateDiffLiteralValues), new Kusto.Language.Symbols.Parameter.$ctor2("datetime1", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("datetime2", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.DayOfWeek = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dayofweek", Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.DayOfMonth = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dayofmonth", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.DayOfYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dayofyear", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.HourOfDay = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hourofday", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.WeekOfYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("weekofyear", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.WeekOfYearISO = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("week_of_year", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.MonthOfYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("monthofyear", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.StartOfDay = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("startofday", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.StartOfWeek = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("startofweek", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.StartOfMonth = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("startofmonth", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.StartOfYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("startofyear", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.EndOfDay = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("endofday", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.EndOfWeek = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("endofweek", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.EndOfMonth = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("endofmonth", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.EndOfYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("endofyear", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.GetYear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("getyear", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.GetMonth = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("getmonth", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.DatePart = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("datepart", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor3("part", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Literal, Kusto.Language.Functions.s_datePartLiteralValues), new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.DatetimePart = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("datetime_part", Kusto.Language.Symbols.ScalarTypes.Int, [new Kusto.Language.Symbols.Parameter.$ctor3("part", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Literal, Kusto.Language.Functions.s_datePartLiteralValues), new Kusto.Language.Symbols.Parameter.$ctor2("date", Kusto.Language.Symbols.ScalarTypes.DateTime)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Now = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("now", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.TimeSpan, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Ago = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ago", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor3("timespan", Kusto.Language.Symbols.ScalarTypes.TimeSpan, 0, void 0, Kusto.Language.KustoFacts.AgoExamples, !1, void 0, 1, 1, void 0, void 0)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UnixTimeSecondsToDateTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("unixtime_seconds_todatetime", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UnixTimeMillisecondsToDateTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("unixtime_milliseconds_todatetime", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UnixTimeMicrosecondsToDateTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("unixtime_microseconds_todatetime", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.UnixTimeNanosecondsToDateTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("unixtime_nanoseconds_todatetime", Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable().WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.HashCrc32 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__hash_crc32", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic), new Kusto.Language.Symbols.Parameter.ctor("mod", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("seed", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).ConstantFoldable().Hide();
this.HashManyCrc32 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__hash_many_crc32", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 2, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.HashDjb2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__hash_djb2", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic), new Kusto.Language.Symbols.Parameter.ctor("mod", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.HashXXH64 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__hash_xxh64", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic), new Kusto.Language.Symbols.Parameter.ctor("mod", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("seed", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).ConstantFoldable().Hide();
this.Hash = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hash", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic), new Kusto.Language.Symbols.Parameter.ctor("mod", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.HashSha256 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hash_sha256", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.HashMd5 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hash_md5", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.HashCombine = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hash_combine", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 2, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.HashMany = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hash_many", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("source", Kusto.Language.Symbols.ParameterTypeKind.NotDynamic, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Iif = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("iif", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.$ctor2("if", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("then", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("else", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic)]);
this.Iff = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("iff", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.$ctor2("if", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("then", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("else", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic)]);
this.Case = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("case", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.$ctor3("predicate", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("then", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("else", Kusto.Language.Symbols.ParameterTypeKind.CommonScalarOrDynamic)]);
this.Assert = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("assert", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("predicate", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.$ctor2("message", Kusto.Language.Symbols.ScalarTypes.String)]);
this.Bin = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("bin", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("roundTo", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.TimeSpan)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Floor = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("floor", [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("roundTo", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("roundTo", Kusto.Language.Symbols.ScalarTypes.TimeSpan)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinAt = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("bin_at", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("bin_size", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("fixed_point", Kusto.Language.Symbols.ParameterTypeKind.Integer)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("bin_size", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("fixed_point", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.ctor("bin_size", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("fixed_point", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("bin_size", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("fixed_point", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.ctor("bin_size", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.$ctor2("fixed_point", Kusto.Language.Symbols.ScalarTypes.DateTime)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinAuto = new Kusto.Language.Symbols.FunctionSymbol.$ctor14("bin_auto", "bin_at(value, query_bin_auto_size, query_bin_auto_at)", Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Summable)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable().Hide();
this.Not = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("not", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("expression", Kusto.Language.Symbols.ScalarTypes.Bool)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.NotNull_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("notnull", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("expression", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.IsNotNull = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isnotnull", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("expression", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.IsNull = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isnull", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("expression", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.NotEmpty_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("notempty", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.IsNotEmpty = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isnotempty", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.IsEmpty = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isempty", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.IsAscii = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isascii", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.IsUtf8 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isutf8", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.IsColumnExists = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("iscolumnexists", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor3("column_name", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Constant)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.ColumnIfExists_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("columnifexists", Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor3("column_name", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Constant), new Kusto.Language.Symbols.Parameter.ctor("defaultValue", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgumentValueIfColumn).Hide();
this.ColumnIfExists = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("column_ifexists", Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor3("column_name", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.Constant), new Kusto.Language.Symbols.Parameter.ctor("defaultValue", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgumentValueIfColumn);
this.BinaryAnd = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_and", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value1", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("value2", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinaryOr = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_or", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value1", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("value2", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinaryXor = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_xor", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value1", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("value2", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinaryNot = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_not", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinaryShiftRight = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_shift_right", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("shift", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BinaryShiftLeft = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("binary_shift_left", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("shift", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BitsetCountOnes = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("bitset_count_ones", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.TreePath = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("treepath", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("object", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("tree").ConstantFoldable();
this.Repeat = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("repeat", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.$ctor2("count", Kusto.Language.Symbols.ScalarTypes.Long)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixAndFirstArgument).WithResultNamePrefix("repeat").ConstantFoldable();
this.Arraylength_Depricated = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("arraylength", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.ArrayLength = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_length", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Range = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("range", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("stop", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("step", Kusto.Language.Symbols.ParameterTypeKind.Summable, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayConcat = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_concat", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("array", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 1, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayIff = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_iff", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("condition_array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("when_true", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("when_false", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayIif = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_iif", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("condition_array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("when_true", Kusto.Language.Symbols.ParameterTypeKind.Scalar), new Kusto.Language.Symbols.Parameter.ctor("when_false", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable().Hide();
this.ArrayIndexOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_index_of", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable();
this.SetHasElement = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("set_has_element", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("set", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).ConstantFoldable();
this.ArraySlice = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_slice", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArraySplit = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("array_split", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("index", Kusto.Language.Symbols.ParameterTypeKind.Integer)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("indices", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayShiftLeft = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_shift_left", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("shift_count", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("default_value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayShiftRight = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_shift_right", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("shift_count", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("default_value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayRotateLeft = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_rotate_left", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("rotate_count", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.ArrayRotateRight = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("array_rotate_right", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("rotate_count", Kusto.Language.Symbols.ParameterTypeKind.Integer)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.BagKeys = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("bag_keys", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("object", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Zip = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("zip", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("array", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Pack = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pack", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("key", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.PackDictionary = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pack_dictionary", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("key", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.PackAll = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pack_all", Kusto.Language.Symbols.ScalarTypes.Dynamic).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.PackArray = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pack_array", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.SetUnion = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("set_union", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("set", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.SetIntersect = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("set_intersect", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("set", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.SetDifference = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("set_difference", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("set", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.BagMerge = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("bag_merge", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("bag", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.PercentileTDigest = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("percentile_tdigest", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("percentile1", Kusto.Language.Symbols.ScalarTypes.Real)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.ParameterNLiteral, [new Kusto.Language.Symbols.Parameter.$ctor2("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("percentile1", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.Parameter.$ctor3("type", Kusto.Language.Symbols.ScalarTypes.Type, Kusto.Language.Symbols.ArgumentKind.Literal)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.NameAndFirstArgument);
this.PercentRankTDigest = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("percentrank_tdigest", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("digest", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.RankTDigest = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("rank_tdigest", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("digest", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.TDigestMerge = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tdigest_merge", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 16, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixOnly).WithResultNamePrefix("tdigests_merge_result");
this.MergeTDigests = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("merge_tdigests", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("tdigest", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 16, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixOnly).WithResultNamePrefix("tdigests_merge_result");
this.HllMerge = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("hll_merge", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor3("hll", Kusto.Language.Symbols.ScalarTypes.Dynamic, 0, void 0, void 0, !1, void 0, 2, 16, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixOnly).WithResultNamePrefix("hll_merged_result");
this.DCountHll = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("dcount_hll", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("hll", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.NameAndFirstArgument);
this.SeriesFir = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fir", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("filter", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor3("normalize", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("center", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesStats = new Kusto.Language.Symbols.FunctionSymbol.ctor("series_stats", function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("min", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("min_idx", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("max", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("max_idx", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("avg", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("stdev", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("variance", Kusto.Language.Symbols.ScalarTypes.Real)]))
}, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor3("ignore_nonfinite", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]);
this.SeriesStatsDynamic = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_stats_dynamic", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor3("ignore_nonfinite", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesFitLine = new Kusto.Language.Symbols.FunctionSymbol.ctor("series_fit_line", function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("rsquare", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("slope", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("variance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("rvariance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("interception", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("line_fit", Kusto.Language.Symbols.ScalarTypes.Dynamic)]))
}, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic)]);
this.SeriesFitLineDynamic = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fit_line_dynamic", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesFit2Lines = new Kusto.Language.Symbols.FunctionSymbol.ctor("series_fit_2lines", function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "array", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("rsquare", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("split_idx", Kusto.Language.Symbols.ScalarTypes.Long), new Kusto.Language.Symbols.ColumnSymbol("variance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("rvariance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("line_fit", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("right_rsquare", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("right_slope", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("right_interception", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("right_variance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("right_rvariance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("left_rsquare", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("left_slope", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("left_interception", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("left_variance", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.ColumnSymbol("left_rvariance", Kusto.Language.Symbols.ScalarTypes.Real)]))
}, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("array", Kusto.Language.Symbols.ScalarTypes.Dynamic)]);
this.SeriesFit2LinesDynamic = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fit_2lines_dynamic", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesOutliers = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("series_outliers", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor3("kind", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("ignore_val", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("kind", Kusto.Language.Symbols.ScalarTypes.String), new Kusto.Language.Symbols.Parameter.$ctor2("ignore_val", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.Parameter.$ctor2("min_percentile", Kusto.Language.Symbols.ScalarTypes.Real), new Kusto.Language.Symbols.Parameter.$ctor3("max_percentile", Kusto.Language.Symbols.ScalarTypes.Real, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("test_points", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesIIR = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_iir", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("numerators", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("denominators", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesPeriodsDetect = new Kusto.Language.Symbols.FunctionSymbol.ctor("series_periods_detect", function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("periods", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("scores", Kusto.Language.Symbols.ScalarTypes.Dynamic)]))
}, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("min_period", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("max_period", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("num_periods", Kusto.Language.Symbols.ScalarTypes.Long)]);
this.SeriesPeriodsValidate = new Kusto.Language.Symbols.FunctionSymbol.ctor("series_periods_validate", function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("periods", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("scores", Kusto.Language.Symbols.ScalarTypes.Dynamic)]))
}, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 1, 16, void 0, void 0)]);
this.SeriesFillBackwards = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fill_backward", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("missing_value_placeholder", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesFillForward = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fill_forward", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("missing_value_placeholder", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesFillConst = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fill_const", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("constant_value", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("missing_value_placeholder", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesFillLinear = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_fill_linear", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("missing_value_placeholder", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("fill_edges", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("constant_value", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.SeriesAdd = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_add", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesSubtract = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_subtract", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesMultiply = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_multiply", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesDivide = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_divide", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesGreater = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_greater", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesGreaterEquals = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_greater_equals", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesLess = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_less", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesLessEquals = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_less_equals", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesEquals = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_equals", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesNotEquals = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_not_equals", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesSeasonal = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("series_seasonal", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Integer)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("test_points", Kusto.Language.Symbols.ParameterTypeKind.Integer)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.SeriesDecompose = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("series_decompose", [new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Functions.SeriesDecomposeResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("trend", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("test_points", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("seasonality_threshold", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)])]);
this.SeriesDecomposeForecast = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("series_decompose_forecast", [new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Functions.SeriesDecomposeResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("test_points", Kusto.Language.Symbols.ParameterTypeKind.Integer), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("trend", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("seasonality_threshold", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)])]);
this.SeriesDecomposeAnomalies = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("series_decompose_anomalies", [new Kusto.Language.Symbols.Signature.ctor(Kusto.Language.Functions.SeriesDecomposeAnomaliesResult, Kusto.Language.Symbols.Tabularity.Scalar, [new Kusto.Language.Symbols.Parameter.$ctor2("series", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("threshold", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("period", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("trend", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("test_points", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("method", Kusto.Language.Symbols.ScalarTypes.String, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("seasonality_threshold", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)])]);
this.SeriesPearsonCorrelation = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("series_pearson_correlation", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("series1", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("series2", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Round = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("round", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor3("precision", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Ceiling = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("ceiling", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Pow = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pow", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("base", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("exponent", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Sqrt = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("sqrt", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Log = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("log", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Log2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("log2", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Log10 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("log10", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Exp = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("exp", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Exp2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("exp2", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Exp10 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("exp10", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.PI = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("pi", Kusto.Language.Symbols.ScalarTypes.Real).ConstantFoldable();
this.Cos = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cos", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Sin = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("sin", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Tan = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("tan", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Acos = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("acos", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Asin = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("asin", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Atan = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("atan", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Atan2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("atan2", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("y", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("x", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Abs = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("abs", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Integer)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.RealOrDecimal)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.Cot = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cot", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Degrees = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("degrees", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("radians", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Radians = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("radians", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("degrees", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Sign = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("sign", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Rand = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("rand", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Integer, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.BetaCdf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("beta_cdf", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("x", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("alpha", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("beta", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable();
this.BetaInv = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("beta_inv", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("probability", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("alpha", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("beta", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable();
this.BetaPdf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("beta_pdf", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("x", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("alpha", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("beta", Kusto.Language.Symbols.ParameterTypeKind.Number)]).ConstantFoldable();
this.Gamma = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("gamma", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.LogGamma = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("loggamma", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("number", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument).ConstantFoldable();
this.IsNan = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isnan", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("number", Kusto.Language.Symbols.ScalarTypes.Real)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.IsInf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isinf", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("number", Kusto.Language.Symbols.ScalarTypes.Real)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.IsFinite = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("isfinite", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("number", Kusto.Language.Symbols.ScalarTypes.Real)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.Coalesce = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("coalesce", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.CommonScalar, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.MaxOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("max_of", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.CommonSummable, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.MinOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("min_of", Kusto.Language.Symbols.ReturnTypeKind.Common, [new Kusto.Language.Symbols.Parameter.ctor("arg", Kusto.Language.Symbols.ParameterTypeKind.CommonSummable, 0, void 0, void 0, !1, void 0, 2, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.WelchTest = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("welch_test", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("mean1", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("variance1", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("count1", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("mean2", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("variance2", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("count2", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.GeoDistance2Points = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_distance_2points", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("p1_longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("p1_latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("p2_longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("p2_latitude", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoDistancePointToLine = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_distance_point_to_line", Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.ctor("longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("lineString", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoPointInCircle = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_point_in_circle", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("p_longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("p_latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("pc_longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("pc_latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("c_radius", Kusto.Language.Symbols.ParameterTypeKind.Number)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoPointInPolygon = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_point_in_polygon", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("polygon", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoPolygonToS2Cells = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_polygon_to_s2cells", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("polygon", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("level", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoPolygonValidate = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__geo_polygon_validate", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("polygon", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable().Hide();
this.GeoPointToGeohash = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_point_to_geohash", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("accuracy", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeohashToCentralPoint = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_geohash_to_central_point", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("geohash", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.GeoPointToS2Cell = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_point_to_s2cell", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("longitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("latitude", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("level", Kusto.Language.Symbols.ParameterTypeKind.Number, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.S2CellToCentralPoint = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("geo_s2cell_to_central_point", Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("s2cell", Kusto.Language.Symbols.ScalarTypes.String)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).ConstantFoldable();
this.CurrentClusterEndpoint = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_cluster_endpoint", Kusto.Language.Symbols.ScalarTypes.String);
this.CurrentDatabase = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_database", Kusto.Language.Symbols.ScalarTypes.String);
this.CurrentPrincipal = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_principal", Kusto.Language.Symbols.ScalarTypes.String);
this.CurrentPrincipalDetails = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_principal_details", Kusto.Language.Symbols.ScalarTypes.Dynamic).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.CurrentPrincipalIsMemberOf = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_principal_is_member_of", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("group", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic, 0, void 0, void 0, !1, void 0, 1, 64, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.ExtentId = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("extent_id", Kusto.Language.Symbols.ScalarTypes.Guid).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.ExtentId2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("extentid", Kusto.Language.Symbols.ScalarTypes.Guid).Hide();
this.ExtentTags = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("extent_tags", Kusto.Language.Symbols.ScalarTypes.Dynamic).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.CurrentNodeId = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_node_id", Kusto.Language.Symbols.ScalarTypes.String).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.IngestionTime = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("ingestion_time", Kusto.Language.Symbols.ScalarTypes.DateTime).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.PrefixOnly).WithResultNamePrefix("$IngestionTime");
this.CursorAfter = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cursor_after", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("cursor", Kusto.Language.Symbols.ScalarTypes.String)]);
this.CursorBeforeOrAt = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cursor_before_or_at", Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("cursor", Kusto.Language.Symbols.ScalarTypes.String)]);
this.CursorCurrent = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("cursor_current", Kusto.Language.Symbols.ScalarTypes.String);
this.CursorCurrent2 = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("current_cursor", Kusto.Language.Symbols.ScalarTypes.String).Hide();
this.FormatBytes = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("format_bytes", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.ctor("size", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor3("precision", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("format", Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ArgumentKind.LiteralNotEmpty, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.FirstArgument);
this.RowNumber = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("row_number", Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor3("startingIndex", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.$ctor3("restart", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.RowCumSum = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("row_cumsum", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("term", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor3("restart", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.RowWindowSession = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("row_window_session", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor2("expr", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("maxDistanceFromFirst", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("minDistanceBetweenNeighbors", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor3("restart", Kusto.Language.Symbols.ScalarTypes.Bool, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Prev = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("prev", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("column", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Column), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("default_value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Constant, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.Next = new Kusto.Language.Symbols.FunctionSymbol.$ctor4("next", Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("column", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Column), new Kusto.Language.Symbols.Parameter.$ctor3("offset", Kusto.Language.Symbols.ScalarTypes.Long, 0, void 0, void 0, !1, void 0, 0, 1, void 0, void 0), new Kusto.Language.Symbols.Parameter.ctor("default_value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Constant, void 0, void 0, !1, void 0, 0, 1, void 0, void 0)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.RowstoreOrdinalRange = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("rowstore_ordinal_range", Kusto.Language.Symbols.ScalarTypes.Dynamic).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.EstimateDataSize = new Kusto.Language.Symbols.FunctionSymbol.$ctor6("estimate_data_size", [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("column", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Column, void 0, void 0, !1, void 0, 1, Kusto.Language.FunctionHelpers.MaxRepeat, void 0, void 0)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.ctor("column", Kusto.Language.Symbols.ParameterTypeKind.Scalar, Kusto.Language.Symbols.ArgumentKind.Star)])]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.NewGuid = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("new_guid", Kusto.Language.Symbols.ScalarTypes.Guid).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None);
this.InternalFunnelCompletion = new Kusto.Language.Symbols.FunctionSymbol.$ctor7("__funnel_completion", Kusto.Language.Symbols.ScalarTypes.String, [new Kusto.Language.Symbols.Parameter.$ctor2("events", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("times", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("sequence", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("periods", Kusto.Language.Symbols.ScalarTypes.Dynamic)]).WithResultNameKind(Kusto.Language.Symbols.ResultNameKind.None).Hide();
this.All = System.Array.init([Kusto.Language.Functions.Cluster, Kusto.Language.Functions.Database, Kusto.Language.Functions.Table, Kusto.Language.Functions.ExternalTable, Kusto.Language.Functions.MaterializedView, Kusto.Language.Functions.Strcat, Kusto.Language.Functions.StrcatArray, Kusto.Language.Functions.ArrayStrcat, Kusto.Language.Functions.StrcatDelim, Kusto.Language.Functions.Strcmp, Kusto.Language.Functions.Strrep, Kusto.Language.Functions.Strlen, Kusto.Language.Functions.StringSize, Kusto.Language.Functions.ToUpper, Kusto.Language.Functions.ToLower, Kusto.Language.Functions.ToUtf8, Kusto.Language.Functions.Substring, Kusto.Language.Functions.IndexOf, Kusto.Language.Functions.IndexOfRegex, Kusto.Language.Functions.Reverse, Kusto.Language.Functions.Split, Kusto.Language.Functions.ParseCommandLine, Kusto.Language.Functions.Extract, Kusto.Language.Functions.ExtractAll_Depricated, Kusto.Language.Functions.ExtractAll, Kusto.Language.Functions.ExtractJson, Kusto.Language.Functions.Replace, Kusto.Language.Functions.TrimStart, Kusto.Language.Functions.TrimEnd, Kusto.Language.Functions.Trim, Kusto.Language.Functions.CountOf, Kusto.Language.Functions.Translate, Kusto.Language.Functions.MakeString, Kusto.Language.Functions.DateTimeToLocaleString, Kusto.Language.Functions.NumberToLocaleString, Kusto.Language.Functions.ToString, Kusto.Language.Functions.ToHex, Kusto.Language.Functions.ToDynamic_, Kusto.Language.Functions.ToObject_Depricated, Kusto.Language.Functions.ToLong, Kusto.Language.Functions.ToInt, Kusto.Language.Functions.ToReal, Kusto.Language.Functions.ToDouble, Kusto.Language.Functions.ToDateTime, Kusto.Language.Functions.ToTimespan, Kusto.Language.Functions.ToTime, Kusto.Language.Functions.ToBool, Kusto.Language.Functions.ToBoolean, Kusto.Language.Functions.ToDecimal, Kusto.Language.Functions.ToGuid, Kusto.Language.Functions.GetType, Kusto.Language.Functions.UrlEncode, Kusto.Language.Functions.UrlEncode_Component, Kusto.Language.Functions.UrlDecode, Kusto.Language.Functions.Base64EncodeString, Kusto.Language.Functions.Base64EncodeToString, Kusto.Language.Functions.Base64DecodeToArray, Kusto.Language.Functions.Base64EncodeFromArray, Kusto.Language.Functions.Base64DecodeString, Kusto.Language.Functions.Base64DecodeToString, Kusto.Language.Functions.ParseCsv, Kusto.Language.Functions.ParseJson_Depricated, Kusto.Language.Functions.ParseJson, Kusto.Language.Functions.ParseXml, Kusto.Language.Functions.ParseUrl_Depricated, Kusto.Language.Functions.ParseUrl, Kusto.Language.Functions.ParseUrlQuery_Depricated, Kusto.Language.Functions.ParseUrlQuery, Kusto.Language.Functions.ParseIPV4, Kusto.Language.Functions.ParseIPV4Mask, Kusto.Language.Functions.ParseIPV6, Kusto.Language.Functions.ParseIPV6Mask, Kusto.Language.Functions.ParsePath, Kusto.Language.Functions.ParseUserAgent, Kusto.Language.Functions.ParseVersion, Kusto.Language.Functions.FormatDatetime, Kusto.Language.Functions.FormatTimespan, Kusto.Language.Functions.MakeDatetime, Kusto.Language.Functions.MakeTimespan, Kusto.Language.Functions.DatetimeAdd, Kusto.Language.Functions.DatetimeDiff, Kusto.Language.Functions.DayOfWeek, Kusto.Language.Functions.DayOfMonth, Kusto.Language.Functions.DayOfYear, Kusto.Language.Functions.HourOfDay, Kusto.Language.Functions.WeekOfYear, Kusto.Language.Functions.WeekOfYearISO, Kusto.Language.Functions.MonthOfYear, Kusto.Language.Functions.StartOfDay, Kusto.Language.Functions.StartOfWeek, Kusto.Language.Functions.StartOfMonth, Kusto.Language.Functions.StartOfYear, Kusto.Language.Functions.EndOfDay, Kusto.Language.Functions.EndOfWeek, Kusto.Language.Functions.EndOfMonth, Kusto.Language.Functions.EndOfYear, Kusto.Language.Functions.GetYear, Kusto.Language.Functions.GetMonth, Kusto.Language.Functions.DatePart, Kusto.Language.Functions.DatetimePart, Kusto.Language.Functions.Now, Kusto.Language.Functions.Ago, Kusto.Language.Functions.UnixTimeSecondsToDateTime, Kusto.Language.Functions.UnixTimeMillisecondsToDateTime, Kusto.Language.Functions.UnixTimeMicrosecondsToDateTime, Kusto.Language.Functions.UnixTimeNanosecondsToDateTime, Kusto.Language.Functions.HashCrc32, Kusto.Language.Functions.HashDjb2, Kusto.Language.Functions.Hash, Kusto.Language.Functions.HashSha256, Kusto.Language.Functions.HashMd5, Kusto.Language.Functions.HashXXH64, Kusto.Language.Functions.HashCombine, Kusto.Language.Functions.HashMany, Kusto.Language.Functions.HashManyCrc32, Kusto.Language.Functions.Iif, Kusto.Language.Functions.Iff, Kusto.Language.Functions.Case, Kusto.Language.Functions.Assert, Kusto.Language.Functions.Bin, Kusto.Language.Functions.Floor, Kusto.Language.Functions.BinAt, Kusto.Language.Functions.BinAuto, Kusto.Language.Functions.Not, Kusto.Language.Functions.NotNull_Depricated, Kusto.Language.Functions.IsNotNull, Kusto.Language.Functions.IsNull, Kusto.Language.Functions.NotEmpty_Depricated, Kusto.Language.Functions.IsColumnExists, Kusto.Language.Functions.IsAscii, Kusto.Language.Functions.IsUtf8, Kusto.Language.Functions.IsNotEmpty, Kusto.Language.Functions.IsEmpty, Kusto.Language.Functions.ColumnIfExists_Depricated, Kusto.Language.Functions.ColumnIfExists, Kusto.Language.Functions.BinaryAnd, Kusto.Language.Functions.BinaryOr, Kusto.Language.Functions.BinaryXor, Kusto.Language.Functions.BinaryNot, Kusto.Language.Functions.BinaryShiftRight, Kusto.Language.Functions.BinaryShiftLeft, Kusto.Language.Functions.BitsetCountOnes, Kusto.Language.Functions.TreePath, Kusto.Language.Functions.Repeat, Kusto.Language.Functions.Arraylength_Depricated, Kusto.Language.Functions.ArrayLength, Kusto.Language.Functions.Range, Kusto.Language.Functions.ArrayConcat, Kusto.Language.Functions.ArrayIif, Kusto.Language.Functions.ArrayIff, Kusto.Language.Functions.ArrayIndexOf, Kusto.Language.Functions.ArraySlice, Kusto.Language.Functions.ArraySplit, Kusto.Language.Functions.ArrayShiftLeft, Kusto.Language.Functions.ArrayShiftRight, Kusto.Language.Functions.ArrayRotateLeft, Kusto.Language.Functions.ArrayRotateRight, Kusto.Language.Functions.BagKeys, Kusto.Language.Functions.Zip, Kusto.Language.Functions.Pack, Kusto.Language.Functions.PackDictionary, Kusto.Language.Functions.PackAll, Kusto.Language.Functions.PackArray, Kusto.Language.Functions.SetHasElement, Kusto.Language.Functions.SetUnion, Kusto.Language.Functions.SetIntersect, Kusto.Language.Functions.SetDifference, Kusto.Language.Functions.BagMerge, Kusto.Language.Functions.PercentileTDigest, Kusto.Language.Functions.PercentRankTDigest, Kusto.Language.Functions.RankTDigest, Kusto.Language.Functions.TDigestMerge, Kusto.Language.Functions.MergeTDigests, Kusto.Language.Functions.HllMerge, Kusto.Language.Functions.DCountHll, Kusto.Language.Functions.SeriesFir, Kusto.Language.Functions.SeriesStats, Kusto.Language.Functions.SeriesStatsDynamic, Kusto.Language.Functions.SeriesFitLine, Kusto.Language.Functions.SeriesFitLineDynamic, Kusto.Language.Functions.SeriesFit2Lines, Kusto.Language.Functions.SeriesFit2LinesDynamic, Kusto.Language.Functions.SeriesOutliers, Kusto.Language.Functions.SeriesIIR, Kusto.Language.Functions.SeriesPeriodsDetect, Kusto.Language.Functions.SeriesPeriodsValidate, Kusto.Language.Functions.SeriesFillBackwards, Kusto.Language.Functions.SeriesFillForward, Kusto.Language.Functions.SeriesFillConst, Kusto.Language.Functions.SeriesFillLinear, Kusto.Language.Functions.SeriesAdd, Kusto.Language.Functions.SeriesSubtract, Kusto.Language.Functions.SeriesMultiply, Kusto.Language.Functions.SeriesDivide, Kusto.Language.Functions.SeriesGreater, Kusto.Language.Functions.SeriesGreaterEquals, Kusto.Language.Functions.SeriesLess, Kusto.Language.Functions.SeriesLessEquals, Kusto.Language.Functions.SeriesEquals, Kusto.Language.Functions.SeriesNotEquals, Kusto.Language.Functions.SeriesSeasonal, Kusto.Language.Functions.SeriesDecompose, Kusto.Language.Functions.SeriesDecomposeForecast, Kusto.Language.Functions.SeriesDecomposeAnomalies, Kusto.Language.Functions.SeriesPearsonCorrelation, Kusto.Language.Functions.Round, Kusto.Language.Functions.Ceiling, Kusto.Language.Functions.Pow, Kusto.Language.Functions.Sqrt, Kusto.Language.Functions.Log, Kusto.Language.Functions.Log2, Kusto.Language.Functions.Log10, Kusto.Language.Functions.Exp, Kusto.Language.Functions.Exp2, Kusto.Language.Functions.Exp10, Kusto.Language.Functions.PI, Kusto.Language.Functions.Cos, Kusto.Language.Functions.Sin, Kusto.Language.Functions.Tan, Kusto.Language.Functions.Acos, Kusto.Language.Functions.Asin, Kusto.Language.Functions.Atan, Kusto.Language.Functions.Atan2, Kusto.Language.Functions.Abs, Kusto.Language.Functions.Cot, Kusto.Language.Functions.Degrees, Kusto.Language.Functions.Radians, Kusto.Language.Functions.Sign, Kusto.Language.Functions.Rand, Kusto.Language.Functions.BetaCdf, Kusto.Language.Functions.BetaInv, Kusto.Language.Functions.BetaPdf, Kusto.Language.Functions.Gamma, Kusto.Language.Functions.LogGamma, Kusto.Language.Functions.IsNan, Kusto.Language.Functions.IsInf, Kusto.Language.Functions.IsFinite, Kusto.Language.Functions.Coalesce, Kusto.Language.Functions.MaxOf, Kusto.Language.Functions.MinOf, Kusto.Language.Functions.WelchTest, Kusto.Language.Functions.GeoDistance2Points, Kusto.Language.Functions.GeoDistancePointToLine, Kusto.Language.Functions.GeoPointInCircle, Kusto.Language.Functions.GeoPointInPolygon, Kusto.Language.Functions.GeoPolygonToS2Cells, Kusto.Language.Functions.GeoPolygonValidate, Kusto.Language.Functions.GeoPointToGeohash, Kusto.Language.Functions.GeohashToCentralPoint, Kusto.Language.Functions.GeoPointToS2Cell, Kusto.Language.Functions.S2CellToCentralPoint, Kusto.Language.Functions.Ipv4Compare, Kusto.Language.Functions.Ipv4IsMatch, Kusto.Language.Functions.Ipv6Compare, Kusto.Language.Functions.Ipv6IsMatch, Kusto.Language.Functions.CurrentClusterEndpoint, Kusto.Language.Functions.CurrentDatabase, Kusto.Language.Functions.CurrentPrincipal, Kusto.Language.Functions.CurrentPrincipalDetails, Kusto.Language.Functions.CurrentPrincipalIsMemberOf, Kusto.Language.Functions.ExtentId, Kusto.Language.Functions.ExtentId2, Kusto.Language.Functions.ExtentTags, Kusto.Language.Functions.CurrentNodeId, Kusto.Language.Functions.IngestionTime, Kusto.Language.Functions.CursorAfter, Kusto.Language.Functions.CursorBeforeOrAt, Kusto.Language.Functions.CursorCurrent, Kusto.Language.Functions.CursorCurrent2, Kusto.Language.Functions.FormatBytes, Kusto.Language.Functions.InternalFunnelCompletion, Kusto.Language.Functions.RowNumber, Kusto.Language.Functions.RowCumSum, Kusto.Language.Functions.RowWindowSession, Kusto.Language.Functions.Prev, Kusto.Language.Functions.Next, Kusto.Language.Functions.RowstoreOrdinalRange, Kusto.Language.Functions.EstimateDataSize, Kusto.Language.Functions.NewGuid], Kusto.Language.Symbols.FunctionSymbol)
}
},
methods: {
SeriesDecomposeResult: function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("baseline", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("seasonal", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("trend", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("residual", Kusto.Language.Symbols.ScalarTypes.Dynamic)]))
},
SeriesDecomposeAnomaliesResult: function(table, args, sig) {
return Kusto.Language.FunctionHelpers.MakePrefixedTuple(sig, "series", args, new Kusto.Language.Symbols.TupleSymbol.ctor([new Kusto.Language.Symbols.ColumnSymbol("ad_flag", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("ad_score", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.ColumnSymbol("baseline", Kusto.Language.Symbols.ScalarTypes.Dynamic)]))
}
}
}
});
Bridge.define("Kusto.Language.GlobalState", {
statics: {
fields: {
NoClusters: null,
NoCommands: null,
NoParameters: null,
s_default: null
},
props: {
Default: {
get: function() {
return Kusto.Language.GlobalState.s_default == null && Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.Kusto.Language.GlobalState, Bridge.ref(Kusto.Language.GlobalState, "s_default"), new Kusto.Language.GlobalState(Kusto.Language.GlobalState.NoClusters, null, null, Kusto.Language.Functions.All, null, Kusto.Language.Aggregates.All, null, Kusto.Language.PlugIns.All, null, Kusto.Language.Operators.All, null, Kusto.Language.EngineCommands.All, null, null, Kusto.Language.GlobalState.NoParameters), null), Kusto.Language.GlobalState.s_default
}
}
},
ctors: {
init: function() {
this.NoClusters = Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.ClusterSymbol).Instance;
this.NoCommands = Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.CommandSymbol).Instance;
this.NoParameters = Kusto.Language.Utils.EmptyReadOnlyList$1(Kusto.Language.Symbols.ParameterSymbol).Instance
}
},
methods: {
Optional: function(T, value) {
return new(Kusto.Language.Utils.Optional$1(T).$ctor1)(value)
}
}
},
fields: {
aggregatesMap: null,
functionsMap: null,
pluginMap: null,
operatorMap: null,
commandMap: null,
commandListMap: null,
reverseClusterMap: null,
reverseDatabaseMap: null,
reverseTableMap: null,
cache: null
},
props: {
Clusters: null,
Cluster: null,
Database: null,
Functions: null,
Aggregates: null,
PlugIns: null,
Operators: null,
Commands: null,
Parameters: null,
Cache: {
get: function() {
return this.cache == null && Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.Kusto.Language.KustoCache, Bridge.ref(this, "cache"), new Kusto.Language.KustoCache, null), this.cache
}
}
},
ctors: {
ctor: function(clusters, cluster, database, functions, functionMap, aggregates, aggregateMap, plugins, pluginMap, operators, operatorMap, commands, commandMap, commandListMap, parameters) {
this.$initialize();
this.Clusters = clusters;
this.Cluster = cluster || new Kusto.Language.Symbols.ClusterSymbol.$ctor1("", null, !0);
this.Database = database || new Kusto.Language.Symbols.DatabaseSymbol.$ctor1("", null, !0);
this.Functions = functions;
this.Aggregates = aggregates;
this.PlugIns = plugins;
this.Operators = operators;
this.Commands = commands;
this.commandMap = commandMap;
this.commandListMap = commandListMap;
this.Parameters = Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.ParameterSymbol, parameters)
}
},
methods: {
With: function(clusters, cluster, database, functions, aggregates, plugins, operators, commands, parameters) {
clusters === void 0 && (clusters = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ClusterSymbol))));
cluster === void 0 && (cluster = new(Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.ClusterSymbol)));
database === void 0 && (database = new(Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.DatabaseSymbol)));
functions === void 0 && (functions = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol))));
aggregates === void 0 && (aggregates = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol))));
plugins === void 0 && (plugins = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol))));
operators === void 0 && (operators = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.OperatorSymbol))));
commands === void 0 && (commands = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.CommandSymbol))));
parameters === void 0 && (parameters = new(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ParameterSymbol))));
var useClusters = clusters.HasValue ? clusters.Value : this.Clusters,
useCluster = cluster.HasValue ? cluster.Value : this.Cluster,
useDatabase = database.HasValue ? database.Value : this.Database,
useFunctions = functions.HasValue ? functions.Value : this.Functions,
useAggregates = aggregates.HasValue ? aggregates.Value : this.Aggregates,
usePlugins = plugins.HasValue ? plugins.Value : this.PlugIns,
useOperators = operators.HasValue ? operators.Value : this.Operators,
useCommands = commands.HasValue ? commands.Value : this.Commands,
useParameters = parameters.HasValue ? parameters.Value : this.Parameters;
return Bridge.referenceEquals(useClusters, this.Clusters) && Bridge.referenceEquals(useCluster, this.Cluster) && Bridge.referenceEquals(useDatabase, this.Database) && Bridge.referenceEquals(useFunctions, this.Functions) && Bridge.referenceEquals(useAggregates, this.Aggregates) && Bridge.referenceEquals(usePlugins, this.PlugIns) && Bridge.referenceEquals(useOperators, this.Operators) && Bridge.referenceEquals(useCommands, this.Commands) && Bridge.referenceEquals(useParameters, this.Parameters) ? this : new Kusto.Language.GlobalState(useClusters, useCluster, useDatabase, useFunctions, Bridge.referenceEquals(useFunctions, this.Functions) ? this.functionsMap : null, useAggregates, Bridge.referenceEquals(useAggregates, this.Aggregates) ? this.aggregatesMap : null, usePlugins, Bridge.referenceEquals(usePlugins, this.PlugIns) ? this.pluginMap : null, useOperators, Bridge.referenceEquals(useOperators, this.Operators) ? this.operatorMap : null, useCommands, Bridge.referenceEquals(useCommands, this.Commands) ? this.commandMap : null, Bridge.referenceEquals(useCommands, this.Commands) ? this.commandListMap : null, useParameters)
},
WithClusterList: function(clusters) {
return this.With(Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ClusterSymbol), clusters), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0)
},
WithCluster: function(cluster) {
if (System.Linq.Enumerable.from(this.Clusters).contains(cluster)) return this.With(void 0, Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.ClusterSymbol).op_Implicit(cluster), void 0, void 0, void 0, void 0, void 0, void 0, void 0);
var newClusters = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.ClusterSymbol).$ctor1)(this.Clusters);
return newClusters.add(cluster), this.With(Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ClusterSymbol)).op_Implicit(newClusters), Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.ClusterSymbol).op_Implicit(cluster), void 0, void 0, void 0, void 0, void 0, void 0, void 0)
},
WithDatabase: function(database) {
var existingCluster, cluster;
return this.Cluster != null && System.Linq.Enumerable.from(this.Cluster.Databases).contains(database) ? this.With(void 0, void 0, Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.DatabaseSymbol).op_Implicit(database), void 0, void 0, void 0, void 0, void 0, void 0) : (existingCluster = this.GetCluster(database), existingCluster != null ? this.With(void 0, Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.ClusterSymbol).op_Implicit(existingCluster), Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.DatabaseSymbol).op_Implicit(database), void 0, void 0, void 0, void 0, void 0, void 0) : (cluster = new Kusto.Language.Symbols.ClusterSymbol.ctor((database.Name || "") + ":cluster", [database]), this.WithCluster(cluster).With(void 0, void 0, Kusto.Language.Utils.Optional$1(Kusto.Language.Symbols.DatabaseSymbol).op_Implicit(database), void 0, void 0, void 0, void 0, void 0, void 0)))
},
IsDatabaseTable: function(table) {
return this.GetDatabase$1(table) != null
},
IsDatabaseFunction: function($function) {
return this.GetDatabase($function) != null
},
WithFunctions: function(functions) {
return this.With(void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol), functions), void 0, void 0, void 0, void 0, void 0)
},
AddOrUpdateCluster: function(newCluster) {
var clusterInList = System.Linq.Enumerable.from(this.Clusters).firstOrDefault(function(c) {
return Bridge.referenceEquals(c.Name, newCluster.Name)
}, null),
newList, newGlobals, oldCurrentDatabase, newDatabase;
return clusterInList == null ? this.WithClusterList(System.Linq.Enumerable.from(this.Clusters).concat(System.Array.init([newCluster], Kusto.Language.Symbols.ClusterSymbol)).toList(Kusto.Language.Symbols.ClusterSymbol)) : Bridge.referenceEquals(clusterInList, newCluster) ? this : (newList = System.Linq.Enumerable.from(this.Clusters).select(function(c) {
return Bridge.referenceEquals(c, clusterInList) ? newCluster : c
}).ToArray(Kusto.Language.Symbols.ClusterSymbol), newGlobals = this.WithClusterList(newList), Bridge.referenceEquals(this.Cluster, clusterInList) && (newGlobals = newGlobals.WithCluster(newCluster)), oldCurrentDatabase = System.Linq.Enumerable.from(clusterInList.Databases).firstOrDefault(Bridge.fn.bind(this, function(d) {
return Bridge.referenceEquals(d, this.Database)
}), null), oldCurrentDatabase != null && (newDatabase = System.Linq.Enumerable.from(newCluster.Databases).firstOrDefault(function(d) {
return Bridge.referenceEquals(d.Name, oldCurrentDatabase.Name)
}, null), newDatabase != null && (newGlobals = newGlobals.WithDatabase(newDatabase))), newGlobals)
},
GetCluster$1: function(name) {
var $t;
return (name = ($t = Kusto.Language.KustoFacts.GetHostName(name), $t != null ? $t : name), Kusto.Language.KustoFacts.IsClusterHostName(name, this.Cluster.Name) || Kusto.Language.KustoFacts.IsClusterShortName(name, this.Cluster.Name) && Kusto.Language.KustoFacts.IsKustoWindowsNet(this.Cluster.Name)) ? this.Cluster : System.Linq.Enumerable.from(this.Clusters).firstOrDefault(function(c) {
return Kusto.Language.KustoFacts.IsClusterHostName(name, c.Name)
}, null) || System.Linq.Enumerable.from(this.Clusters).firstOrDefault(function(c) {
return Kusto.Language.KustoFacts.IsClusterShortName(name, c.Name) && Kusto.Language.KustoFacts.IsKustoWindowsNet(c.Name)
}, null) || System.Linq.Enumerable.from(this.Clusters).firstOrDefault(function(c) {
return Kusto.Language.KustoFacts.IsClusterShortName(name, c.Name)
}, null)
},
GetCluster: function(database) {
var $t, $t1, map, cluster, member, result;
if (database == null) return null;
if (this.reverseClusterMap == null) {
map = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.ClusterSymbol));
$t = Bridge.getEnumerator(this.Clusters, Kusto.Language.Symbols.ClusterSymbol);
try {
while ($t.moveNext()) {
cluster = $t.Current;
$t1 = Bridge.getEnumerator(cluster.Members, Kusto.Language.Symbols.Symbol);
try {
while ($t1.moveNext()) member = $t1.Current, map.set(member, cluster)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.ClusterSymbol), Bridge.ref(this, "reverseClusterMap"), map, null)
}
return result = {}, this.reverseClusterMap.tryGetValue(database, result), result.v
},
GetDatabase$1: function(table) {
return this.GetDatabase$2(Bridge.cast(table, Kusto.Language.Symbols.Symbol))
},
GetDatabase: function($function) {
return this.GetDatabase$2(Bridge.cast($function, Kusto.Language.Symbols.Symbol))
},
GetDatabase$2: function(symbol) {
var $t, $t1, map, database, member, result;
if (symbol == null) return null;
if (this.reverseDatabaseMap == null) {
map = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.DatabaseSymbol));
$t = Bridge.getEnumerator(System.Linq.Enumerable.from(this.Clusters).selectMany(function(c) {
return c.Databases
}));
try {
while ($t.moveNext()) {
database = $t.Current;
$t1 = Bridge.getEnumerator(database.Members, Kusto.Language.Symbols.Symbol);
try {
while ($t1.moveNext()) member = $t1.Current, map.set(member, database)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.DatabaseSymbol), Bridge.ref(this, "reverseDatabaseMap"), map, null)
}
return result = {}, this.reverseDatabaseMap.tryGetValue(symbol, result), result.v
},
GetTable: function(column) {
var $t, $t1, map, table, col, result;
if (column == null) return null;
if (this.reverseTableMap == null) {
map = new(System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.TableSymbol));
$t = Bridge.getEnumerator(System.Linq.Enumerable.from(this.Clusters).selectMany(function(c) {
return c.Databases
}).selectMany(function(d) {
return d.Tables
}));
try {
while ($t.moveNext()) {
table = $t.Current;
$t1 = Bridge.getEnumerator(table.Columns, Kusto.Language.Symbols.ColumnSymbol);
try {
while ($t1.moveNext()) col = $t1.Current, map.set(col, table)
} finally {
Bridge.is($t1, System.IDisposable) && $t1.System$IDisposable$Dispose()
}
}
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(Kusto.Language.Symbols.Symbol, Kusto.Language.Symbols.TableSymbol), Bridge.ref(this, "reverseTableMap"), map, null)
}
return result = {}, this.reverseTableMap.tryGetValue(column, result), result.v
},
GetFunction: function(name) {
var map, fn;
return this.functionsMap == null && (map = System.Linq.Enumerable.from(this.Functions).toDictionary(function(f) {
return f.Name
}, null, System.String, Bridge.global.Kusto.Language.Symbols.FunctionSymbol), Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.FunctionSymbol), Bridge.ref(this, "functionsMap"), map, null)), fn = {}, this.functionsMap.tryGetValue(name, fn), fn.v
},
WithAggregates: function(aggregates) {
return this.With(void 0, void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol), aggregates), void 0, void 0, void 0, void 0)
},
GetAggregate: function(name) {
var map, fn;
return this.aggregatesMap == null && (map = System.Linq.Enumerable.from(this.Aggregates).toDictionary(function(f) {
return f.Name
}, null, System.String, Bridge.global.Kusto.Language.Symbols.FunctionSymbol), Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.FunctionSymbol), Bridge.ref(this, "aggregatesMap"), map, null)), fn = {}, this.aggregatesMap.tryGetValue(name, fn), fn.v
},
WithPlugIns: function(plugins) {
return this.With(void 0, void 0, void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.FunctionSymbol), plugins), void 0, void 0, void 0)
},
GetPlugIn: function(name) {
var map, fn;
return this.pluginMap == null && (map = System.Linq.Enumerable.from(this.PlugIns).toDictionary(function(f) {
return f.Name
}, null, System.String, Bridge.global.Kusto.Language.Symbols.FunctionSymbol), Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.FunctionSymbol), Bridge.ref(this, "pluginMap"), map, null)), fn = {}, this.pluginMap.tryGetValue(name, fn), fn.v
},
IsAggregateFunction: function(fn) {
return Bridge.referenceEquals(this.GetAggregate(fn.Name), fn)
},
IsBuiltInFunction: function(fn) {
return Bridge.referenceEquals(this.GetFunction(fn.Name), fn) || Bridge.referenceEquals(this.GetAggregate(fn.Name), fn) || Bridge.referenceEquals(this.GetPlugIn(fn.Name), fn)
},
WithOperators: function(operators) {
return this.With(void 0, void 0, void 0, void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.OperatorSymbol), operators), void 0, void 0)
},
GetOperator: function(kind) {
this.operatorMap == null && (this.operatorMap = System.Linq.Enumerable.from(this.Operators).toDictionary(function(o) {
return o.OperatorKind
}, null, Bridge.global.Kusto.Language.Symbols.OperatorKind, Bridge.global.Kusto.Language.Symbols.OperatorSymbol));
var op = {};
return this.operatorMap.tryGetValue(kind, op) ? op.v : null
},
WithCommands: function(commands) {
return this.With(void 0, void 0, void 0, void 0, void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.CommandSymbol), commands), void 0)
},
AddCommands$1: function(additionalCommands) {
return this.With(void 0, void 0, void 0, void 0, void 0, void 0, void 0, Kusto.Language.Utils.Optional$1(System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.CommandSymbol)).op_Implicit(System.Linq.Enumerable.from(this.Commands).concat(additionalCommands).toList(Kusto.Language.Symbols.CommandSymbol)), void 0)
},
AddCommands: function(additionalCommands) {
return additionalCommands === void 0 && (additionalCommands = []), this.AddCommands$1(Bridge.cast(additionalCommands, System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.CommandSymbol)))
},
GetCommand: function(name) {
var $t, map, c, command;
if (this.commandMap == null) {
map = new(System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.CommandSymbol));
$t = Bridge.getEnumerator(this.Commands, Kusto.Language.Symbols.CommandSymbol);
try {
while ($t.moveNext()) c = $t.Current, map.set(c.Name, c)
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.Dictionary$2(System.String, Kusto.Language.Symbols.CommandSymbol), Bridge.ref(this, "commandMap"), map, null)
}
return command = {}, this.commandMap.tryGetValue(name, command), command.v
},
WithParameters: function(parameters) {
return this.With(void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, Kusto.Language.GlobalState.Optional(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ParameterSymbol), parameters))
},
AddParameters$1: function(parameters) {
return this.WithParameters(System.Linq.Enumerable.from(this.Parameters).concat(parameters).toList(Kusto.Language.Symbols.ParameterSymbol))
},
AddParameters: function(parameters) {
return parameters === void 0 && (parameters = []), this.WithParameters(Bridge.cast(parameters, System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Symbols.ParameterSymbol)))
}
}
});
Bridge.define("Kusto.Language.IncludeFunctionKind", {
$kind: "enum",
statics: {
fields: {
BuiltInFunctions: 1,
DatabaseFunctions: 2,
LocalFunctions: 4,
None: 0,
All: 7
}
},
$flags: !0
});
Bridge.define("Kusto.Language.KustoCache", {
fields: {
m_cache: null
},
ctors: {
init: function() {
this.m_cache = new(System.Collections.Generic.Dictionary$2(Function, System.Object))
},
ctor: function() {
this.$initialize()
}
},
methods: {
GetOrCreate: function(T) {
var value = {};
return this.m_cache.tryGetValue(T, value) || (value.v = Bridge.createInstance(T), this.m_cache.add(T, value.v)), Bridge.cast(Bridge.unbox(value.v), T)
},
GetOrCreate$1: function(T, creator) {
var value = {};
return this.m_cache.tryGetValue(T, value) || (value.v = creator(), this.m_cache.add(T, value.v)), Bridge.cast(Bridge.unbox(value.v), T)
},
TryGetValue: function(T, value) {
var obj = {};
return this.m_cache.tryGetValue(T, obj) ? (value.v = Bridge.cast(Bridge.unbox(obj.v), T), !0) : (value.v = Bridge.getDefaultValue(T), !1)
}
}
});
Bridge.define("Kusto.Language.KustoCode", {
statics: {
fields: {
MaxAnalyzableSyntaxDepth: 0
},
ctors: {
init: function() {
this.MaxAnalyzableSyntaxDepth = 500
}
},
methods: {
Parse: function(text, globals) {
if (globals === void 0 && (globals = null), text == null) throw new System.ArgumentNullException.$ctor1("text");
var tokens = Kusto.Language.Parsing.LexicalGrammar.GetTokens(text, !0);
return Kusto.Language.KustoCode.Create(text, globals || Kusto.Language.GlobalState.Default, tokens, !1, Bridge.getDefaultValue(Kusto.Language.Utils.CancellationToken))
},
ParseAndAnalyze: function(text, globals, cancellationToken) {
if (globals === void 0 && (globals = null), cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), text == null) throw new System.ArgumentNullException.$ctor1("text");
var tokens = Kusto.Language.Parsing.LexicalGrammar.GetTokens(text, !0);
return Kusto.Language.KustoCode.Create(text, globals || Kusto.Language.GlobalState.Default, tokens, !0, cancellationToken)
},
Create: function(text, globals, tokens, analyze, cancellationToken) {
var grammar, syntax, kind = Kusto.Language.KustoCode.GetKind(text),
commandBlock, queryBlock, maxDepth, isAnalyzable, localCache;
switch (kind) {
case Kusto.Language.Editor.CodeKinds.Command:
commandBlock = Kusto.Language.Parsing.CommandGrammar.From(globals).CommandBlock;
grammar = commandBlock;
syntax = Kusto.Language.Parsing.SyntaxParsers.ParseFirst$1(Bridge.global.Kusto.Language.Syntax.CommandBlock, commandBlock, tokens);
break;
case Kusto.Language.Editor.CodeKinds.Directive:
grammar = Kusto.Language.Parsing.DirectiveGrammar.DirectiveBlock;
syntax = Kusto.Language.Parsing.SyntaxParsers.ParseFirst$1(Bridge.global.Kusto.Language.Syntax.DirectiveBlock, Kusto.Language.Parsing.DirectiveGrammar.DirectiveBlock, tokens);
break;
case Kusto.Language.Editor.CodeKinds.Query:
default:
queryBlock = Kusto.Language.Parsing.QueryGrammar.From(globals).QueryBlock;
grammar = queryBlock;
syntax = Kusto.Language.Parsing.SyntaxParsers.ParseFirst$1(Bridge.global.Kusto.Language.Syntax.QueryBlock, queryBlock, tokens)
}
return maxDepth = Kusto.Language.KustoCode.ComputeMaxDepth(syntax), isAnalyzable = maxDepth <= Kusto.Language.KustoCode.MaxAnalyzableSyntaxDepth, syntax.InitializeTriviaStarts(), localCache = null, analyze && isAnalyzable && (cancellationToken.ThrowIfCancellationRequested(), localCache = new Kusto.Language.Binding.LocalBindingCache, Kusto.Language.Binding.Binder.Bind(syntax, globals, localCache, null, cancellationToken)), new Kusto.Language.KustoCode(text, kind, globals, grammar, syntax, analyze && isAnalyzable, tokens, localCache, maxDepth)
},
ComputeMaxDepth: function(root) {
var maxDepth = 0,
depth = 0;
return Kusto.Language.Syntax.SyntaxElement.Walk(root, function() {
depth = depth + 1 | 0;
depth > maxDepth && (maxDepth = depth)
}, function() {
Bridge.identity(depth, depth = depth - 1 | 0)
}, void 0), maxDepth
},
GetKind: function(text) {
var token = Kusto.Language.Parsing.LexicalGrammar.GetFirstToken(text);
if (token != null) {
if (token.Kind === Kusto.Language.Syntax.SyntaxKind.DotToken) return Kusto.Language.Editor.CodeKinds.Command;
if (token.Kind === Kusto.Language.Syntax.SyntaxKind.DirectiveToken) return Kusto.Language.Editor.CodeKinds.Directive
}
return Kusto.Language.Editor.CodeKinds.Query
}
}
},
fields: {
lexerTokens: null,
localCache: null,
diagnostics: null,
syntaxDiagnostics: null,
lineStarts: null
},
props: {
Text: null,
Kind: null,
Syntax: null,
Grammar: null,
HasSemantics: !1,
Globals: null,
MaxDepth: 0,
LexerTokens: {
get: function() {
return this.lexerTokens
}
}
},
ctors: {
ctor: function(text, kind, globals, grammar, syntax, hasSemantics, lexerTokens, localCache, maxDepth) {
this.$initialize();
this.Text = text;
this.Kind = kind;
this.Globals = globals;
this.Grammar = grammar;
this.Syntax = syntax;
this.HasSemantics = hasSemantics;
this.lexerTokens = lexerTokens;
this.localCache = localCache;
this.MaxDepth = maxDepth
}
},
methods: {
Analyze: function(globals, cancellationToken) {
return globals === void 0 && (globals = null), cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), globals == null && (globals = this.Globals), this.HasSemantics && Bridge.referenceEquals(this.Globals, globals) ? this : Kusto.Language.KustoCode.Create(this.Text, this.Globals, this.lexerTokens, !0, cancellationToken)
},
WithGlobals: function(globals, cancellationToken) {
return cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), Bridge.referenceEquals(this.Globals, globals) ? this : Kusto.Language.KustoCode.Create(this.Text, globals, this.lexerTokens, this.HasSemantics, cancellationToken)
},
GetDiagnostics: function(cancellationToken) {
if (cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), this.diagnostics == null) {
var diagnostics = this.Syntax.GetContainedDiagnostics(3, cancellationToken);
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Diagnostic), Bridge.ref(this, "diagnostics"), diagnostics, null)
}
return this.diagnostics
},
GetSyntaxDiagnostics: function(cancellationToken) {
if (cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken), this.syntaxDiagnostics == null) {
var diagnostics = this.Syntax.GetContainedSyntaxDiagnostics();
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.IReadOnlyList$1(Kusto.Language.Diagnostic), Bridge.ref(this, "syntaxDiagnostics"), diagnostics, null)
}
return this.syntaxDiagnostics
},
GetSymbolsInScope: function(position, match, include, cancellationToken) {
match === void 0 && (match = 1019);
include === void 0 && (include = 7);
cancellationToken === void 0 && (cancellationToken = new Kusto.Language.Utils.CancellationToken);
var symbols = new(System.Collections.Generic.List$1(Kusto.Language.Symbols.Symbol).ctor);
return this.HasSemantics && Kusto.Language.Binding.Binder.GetSymbolsInScope(this.Syntax, position, this.Globals, match, include, symbols, cancellationToken), Kusto.Language.Utils.ListExtensions.ToReadOnly(Bridge.global.Kusto.Language.Symbols.Symbol, symbols)
},
TryGetLineAndOffset: function(position, line, lineOffset) {
if (this.lineStarts == null) {
var tmp = new(System.Collections.Generic.List$1(System.Int32).ctor);
Kusto.Language.Parsing.TextFacts.GetLineStarts(this.Text, tmp);
Kusto.Language.Utils.Interlocked.CompareExchange(Bridge.global.System.Collections.Generic.List$1(System.Int32), Bridge.ref(this, "lineStarts"), tmp, null)
}
return Kusto.Language.Parsing.TextFacts.TryGetLineAndOffset(this.Text, position, this.lineStarts, line, lineOffset)
}
}
});
Bridge.define("Kusto.Language.KustoFacts", {
statics: {
fields: {
ParamTypes: null,
ExtendedParamTypes: null,
StorageTypes: null,
ChartTypes: null,
HiddenChartTypes: null,
VisibleChartTypes: null,
ChartProperties: null,
ChartKinds: null,
ChartLegends: null,
ChartAxis: null,
ChartYSplit: null,
JoinKinds: null,
JoinHintRemotes: null,
JoinHintStrategies: null,
SummarizeHintStrategies: null,
DistributionHintStrategies: null,
FindWithSourceProperty: null,
SearchKinds: null,
MvExpandBagExpansionProperty: null,
MvExpandBagExpansions: null,
MvExpandWithItemIndexProperty: null,
MvApplyWithItemIndexProperty: null,
ReduceByKinds: null,
UnionWithSourceProperties: null,
UnionKinds: null,
ParseKinds: null,
DataScopeValues: null,
ToScalarKinds: null,
ToTableKinds: null,
LimitExamples: null,
TopExamples: null,
AgoExamples: null,
ForkOperatorKinds: null,
PartitionOperatorKinds: null,
ScanOperatorKinds: null,
ScanOperatorWithMatchIdProperty: null,
ScanOperatorWithStepNameProperty: null,
singleQuoteStringEscapes: null,
doubleQuoteStringEscapes: null,
HostNamePrefix: null,
KustoWindowsNet: null
},
props: {
UnionIsFuzzyProperty: {
get: function() {
return Kusto.Language.Syntax.SyntaxFacts.GetText(Kusto.Language.Syntax.SyntaxKind.IsFuzzyKeyword)
}
}
},
ctors: {
init: function() {
this.ParamTypes = System.Array.init(["bool", "boolean", "date", "datetime", "decimal", "double", "dynamic", "guid", "int", "int64", "int8", "long", "real", "string", "time", "timespan", "uniqueid"], System.String);
this.ExtendedParamTypes = System.Array.init(["bool", "boolean", "date", "datetime", "decimal", "double", "dynamic", "float", "guid", "int", "int16", "int32", "int64", "int8", "long", "real", "decimal", "single", "time", "timespan", "uint", "uint16", "uint32", "uint64", "uint8", "ulong", "uniqueid"], System.String);
this.StorageTypes = Kusto.Language.KustoFacts.ExtendedParamTypes;
this.ChartTypes = System.Array.init(["table", "list", "barchart", "piechart", "ladderchart", "timechart", "linechart", "anomalychart", "pivotchart", "areachart", "stackedareachart", "scatterchart", "timepivot", "columnchart", "timeline", "3Dchart", "card"], System.String);
this.HiddenChartTypes = System.Array.init(["3Dchart"], System.String);
this.VisibleChartTypes = System.Linq.Enumerable.from(Kusto.Language.KustoFacts.ChartTypes).where(function(c) {
return !System.Linq.Enumerable.from(Kusto.Language.KustoFacts.HiddenChartTypes).contains(c)
}).ToArray(System.String);
this.ChartProperties = System.Array.init(["title", "xcolumn", "series", "ycolumns", "anomalycolumns", "kind", "xtitle", "ytitle", "xaxis", "yaxis", "legend", "ysplit", "accumulate", "ymin", "ymax"], System.String);
this.ChartKinds = System.Array.init(["default", "unstacked", "stacked", "stacked100", "map"], System.String);
this.ChartLegends = System.Array.init(["visible", "hidden"], System.String);
this.ChartAxis = System.Array.init(["linear", "log"], System.String);
this.ChartYSplit = System.Array.init(["none", "axes", "panels"], System.String);
this.JoinKinds = System.Array.init(["inner", "fullouter", "innerunique", "leftanti", "leftantisemi", "anti", "leftouter", "leftsemi", "rightanti", "rightouter", "rightsemi"], System.String);
this.JoinHintRemotes = System.Array.init(["auto", "left", "local", "right"], System.String);
this.JoinHintStrategies = System.Array.init(["broadcast", "centralized", "shuffle"], System.String);
this.SummarizeHintStrategies = System.Array.init(["shuffle"], System.String);
this.DistributionHintStrategies = System.Array.init(["single", "per_node", "per_shard", "default"], System.String);
this.FindWithSourceProperty = "withsource";
this.SearchKinds = System.Array.init(["default", "case_insensitive", "case_sensitive"], System.String);
this.MvExpandBagExpansionProperty = "bagexpansion";
this.MvExpandBagExpansions = System.Array.init(["bag", "array"], System.String);
this.MvExpandWithItemIndexProperty = "with_itemindex";
this.MvApplyWithItemIndexProperty = "with_itemindex";
this.ReduceByKinds = System.Array.init(["source"], System.String);
this.UnionWithSourceProperties = System.Array.init(["withsource", "with_source"], System.String);
this.UnionKinds = System.Array.init(["inner", "outer"], System.String);
this.ParseKinds = System.Array.init(["simple", "regex", "relaxed"], System.String);
this.DataScopeValues = System.Array.init(["all", "hotcache"], System.String);
this.ToScalarKinds = System.Array.init(["nooptimization"], System.String);
this.ToTableKinds = System.Array.init(["nooptimization"], System.String);
this.LimitExamples = System.Array.init(["10", "100", "1000"], System.String);
this.TopExamples = System.Array.init(["10", "100", "1000"], System.String);
this.AgoExamples = System.Array.init(["30min", "1h", "1d"], System.String);
this.ForkOperatorKinds = System.Array.init([Kusto.Language.Syntax.SyntaxKind.CountOperator, Kusto.Language.Syntax.SyntaxKind.ExtendOperator, Kusto.Language.Syntax.SyntaxKind.FilterOperator, Kusto.Language.Syntax.SyntaxKind.ParseOperator, Kusto.Language.Syntax.SyntaxKind.ParseWhereOperator, Kusto.Language.Syntax.SyntaxKind.TakeOperator, Kusto.Language.Syntax.SyntaxKind.TopNestedOperator, Kusto.Language.Syntax.SyntaxKind.ProjectOperator, Kusto.Language.Syntax.SyntaxKind.ProjectAwayOperator, Kusto.Language.Syntax.SyntaxKind.ProjectRenameOperator, Kusto.Language.Syntax.SyntaxKind.ProjectReorderOperator, Kusto.Language.Syntax.SyntaxKind.SummarizeOperator, Kusto.Language.Syntax.SyntaxKind.DistinctOperator, Kusto.Language.Syntax.SyntaxKind.TopHittersOperator, Kusto.Language.Syntax.SyntaxKind.TopOperator, Kusto.Language.Syntax.SyntaxKind.SortOperator, Kusto.Language.Syntax.SyntaxKind.MvExpandOperator, Kusto.Language.Syntax.SyntaxKind.MvApplyOperator, Kusto.Language.Syntax.SyntaxKind.ReduceByOperator, Kusto.Language.Syntax.SyntaxKind.SampleOperator, Kusto.Language.Syntax.SyntaxKind.SampleDistinctOperator, Kusto.Language.Syntax.SyntaxKind.AsOperator, Kusto.Language.Syntax.SyntaxKind.InvokeOperator, Kusto.Language.Syntax.SyntaxKind.ExecuteAndCacheOperator], Kusto.Language.Syntax.SyntaxKind);
this.PartitionOperatorKinds = System.Array.init([Kusto.Language.Syntax.SyntaxKind.CountOperator, Kusto.Language.Syntax.SyntaxKind.ExtendOperator, Kusto.Language.Syntax.SyntaxKind.FilterOperator, Kusto.Language.Syntax.SyntaxKind.ParseOperator, Kusto.Language.Syntax.SyntaxKind.ParseWhereOperator, Kusto.Language.Syntax.SyntaxKind.TakeOperator, Kusto.Language.Syntax.SyntaxKind.TopNestedOperator, Kusto.Language.Syntax.SyntaxKind.ProjectOperator, Kusto.Language.Syntax.SyntaxKind.ProjectAwayOperator, Kusto.Language.Syntax.SyntaxKind.ProjectRenameOperator, Kusto.Language.Syntax.SyntaxKind.ProjectReorderOperator, Kusto.Language.Syntax.SyntaxKind.SummarizeOperator, Kusto.Language.Syntax.SyntaxKind.DistinctOperator, Kusto.Language.Syntax.SyntaxKind.TopHittersOperator, Kusto.Language.Syntax.SyntaxKind.TopOperator, Kusto.Language.Syntax.SyntaxKind.SortOperator, Kusto.Language.Syntax.SyntaxKind.MakeSeriesOperator, Kusto.Language.Syntax.SyntaxKind.MvExpandOperator, Kusto.Language.Syntax.SyntaxKind.MvApplyOperator, Kusto.Language.Syntax.SyntaxKind.ReduceByOperator, Kusto.Language.Syntax.SyntaxKind.SampleOperator, Kusto.Language.Syntax.SyntaxKind.SampleDistinctOperator, Kusto.Language.Syntax.SyntaxKind.AsOperator, Kusto.Language.Syntax.SyntaxKind.InvokeOperator, Kusto.Language.Syntax.SyntaxKind.ExecuteAndCacheOperator], Kusto.Language.Syntax.SyntaxKind);
this.ScanOperatorKinds = System.Array.init(["partial", "full"], System.String);
this.ScanOperatorWithMatchIdProperty = "with_match_id";
this.ScanOperatorWithStepNameProperty = "with_step_name";
this.singleQuoteStringEscapes = function(_o1) {
return _o1.add(39, "\\'"), _o1.add(92, "\\\\"), _o1.add(7, "\\a"), _o1.add(8, "\\b"), _o1.add(12, "\\f"), _o1.add(10, "\\n"), _o1.add(13, "\\r"), _o1.add(9, "\\t"), _o1
}(new(System.Collections.Generic.Dictionary$2(System.Char, System.String)));
this.doubleQuoteStringEscapes = function(_o2) {
return _o2.add(34, '\\"'), _o2.add(92, "\\\\"), _o2.add(7, "\\a"), _o2.add(8, "\\b"), _o2.add(12, "\\f"), _o2.add(10, "\\n"), _o2.add(13, "\\r"), _o2.add(9, "\\t"), _o2
}(new(System.Collections.Generic.Dictionary$2(System.Char, System.String)));
this.HostNamePrefix = "://";
this.KustoWindowsNet = ".kusto.windows.net"
}
},
methods: {
CanBeIdentifier: function(text) {
return !Kusto.Language.KustoFacts.IsKeyword(text) && Kusto.Language.Parsing.ScannerExtensions.Matches(Kusto.Language.Parsing.LexicalGrammar.Identifier, text)
},
IsKeyword: function(text) {
var kind = {
v: new Kusto.Language.Syntax.SyntaxKind
};
return Kusto.Language.Syntax.SyntaxFacts.TryGetKind(text, kind) && Kusto.Language.Syntax.SyntaxFacts.GetCategory(kind.v) === Kusto.Language.Syntax.SyntaxCategory.Keyword
},
IsKeywordThatCanBeIdentifier: function(text) {
var kind = {
v: new Kusto.Language.Syntax.SyntaxKind
};
return Kusto.Language.Syntax.SyntaxFacts.TryGetKind(text, kind) && Kusto.Language.Syntax.SyntaxFacts.GetCategory(kind.v) === Kusto.Language.Syntax.SyntaxCategory.Keyword && Kusto.Language.Syntax.SyntaxFacts.CanBeIdentifier(kind.v)
},
BracketNameIfNecessary: function(name) {
return Kusto.Language.KustoFacts.CanBeIdentifier(name) ? name : Kusto.Language.KustoFacts.GetBrackettedName(name)
},
GetBrackettedName: function(name) {
return "[" + (Kusto.Language.KustoFacts.GetStringLiteral(name) || "") + "]"
},
GetStringLiteral: function(text) {
return System.String.contains(text, "'") ? Kusto.Language.KustoFacts.GetDoubleQuotedStringLiteral(text) : Kusto.Language.KustoFacts.GetSingleQuotedStringLiteral(text)
},
GetSingleQuotedStringLiteral: function(text) {
return "'" + (Kusto.Language.KustoFacts.GetEscapedString(text, Kusto.Language.KustoFacts.singleQuoteStringEscapes) || "") + "'"
},
GetDoubleQuotedStringLiteral: function(text) {
return '"' + (Kusto.Language.KustoFacts.GetEscapedString(text, Kusto.Language.KustoFacts.doubleQuoteStringEscapes) || "") + '"'
},
GetEscapedString: function(text, escapes) {
var $t, builder = new System.Text.StringBuilder,
ch, escape;
$t = Bridge.getEnumerator(text);
try {
while ($t.moveNext()) ch = $t.Current, escape = {}, escapes.System$Collections$Generic$IReadOnlyDictionary$2$System$Char$System$String$tryGetValue(ch, escape) ? builder.append(escape.v) : builder.append(String.fromCharCode(ch))
} finally {
Bridge.is($t, System.IDisposable) && $t.System$IDisposable$Dispose()
}
return builder.toString()
},
GetExpressionResultName: function(expr, defaultName, rowScope) {
return defaultName === void 0 && (defaultName = ""), rowScope === void 0 && (rowScope = null), Kusto.Language.Binding.Binder.GetExpressionResultName(expr, defaultName, rowScope)
},
GetStringLiteralValue: function(text) {
var start = 0,
end = text.length,
verbatim = !1,
quote;
return end === 0 ? "" : ((text.charCodeAt(0) === 104 || text.charCodeAt(0) === 72) && (start = start + 1 | 0), start < text.length && text.charCodeAt(start) === 64 && (verbatim = !0, start = start + 1 | 0), start >= text.length) ? "" : (quote = text.charCodeAt(start), start = start + 1 | 0, end > 0 && text.charCodeAt(end - 1 | 0) === quote && (end = end - 1 | 0), end <= start ? "" : !verbatim && System.String.indexOf(text, String.fromCharCode(92), start) >= start ? Kusto.Language.KustoFacts.DecodeEscapes(text, start, end - start | 0) : verbatim && Kusto.Language.KustoFacts.HasInteriorQuote(text, start, end, quote) ? Kusto.Language.KustoFacts.DecodeDoubleQuotes(text, start, end - start | 0, quote) : start > 0 || end < text.length ? text.substr(start, end - start | 0) : text)
},
HasInteriorQuote: function(text, start, end, quote) {
var position = System.String.indexOf(text, String.fromCharCode(quote));
return position >= 0 && position < end
},
DecodeEscapes: function(text, start, length) {
for (var ch, ch2, builder = new System.Text.StringBuilder, i = {
v: start
}, end = start + length | 0; i.v < end; i.v = i.v + 1 | 0)
if (ch = text.charCodeAt(i.v), ch === 92 && (i.v + 1 | 0) < end) {
ch2 = text.charCodeAt(i.v + 1 | 0);
switch (ch2) {
case 39:
case 34:
case 92:
builder.append(String.fromCharCode(ch2));
i.v = i.v + 1 | 0;
break;
case 97:
builder.append(String.fromCharCode(7));
i.v = i.v + 1 | 0;
break;
case 98:
builder.append(String.fromCharCode(8));
i.v = i.v + 1 | 0;
break;
case 102:
builder.append(String.fromCharCode(12));
i.v = i.v + 1 | 0;
break;
case 110:
builder.append(String.fromCharCode(10));
i.v = i.v + 1 | 0;
break;
case 114:
builder.append(String.fromCharCode(13));
i.v = i.v + 1 | 0;
break;
case 116:
builder.append(String.fromCharCode(9));
i.v = i.v + 1 | 0;
break;
case 118:
builder.append(String.fromCharCode(11));
i.v = i.v + 1 | 0;
break;
case 117:
case 85:
case 120:
builder.append(String.fromCharCode(Kusto.Language.KustoFacts.DecodeHex(text, i)));
break;
default:
builder.append(String.fromCharCode(Kusto.Language.KustoFacts.DecodeOctal(text, i)))
}
} else builder.append(String.fromCharCode(ch));
return builder.toString()
},
DecodeOctal: function(text, index) {
for (var value = System.Int64(0); index.v < text.length && System.Char.isDigit(text.charCodeAt(index.v)); index.v = index.v + 1 | 0) value = value.shl(3).add(System.Int64(text.charCodeAt(index.v) - 48 | 0));
return System.Int64.clipu16(value)
},
DecodeHex: function(text, index) {
for (var value = System.Int64(0), ch; index.v < text.length; index.v = index.v + 1 | 0)
if (ch = text.charCodeAt(index.v), ch >= 97 && ch <= 102) value = value.shl(4).add(System.Int64(ch - 97 | 0));
else if (ch >= 65 && ch <= 70) value = value.shl(4).add(System.Int64(ch - 65 | 0));
else if (ch >= 48 && ch <= 57) value = value.shl(4).add(System.Int64(ch - 48 | 0));
else break;
return System.Int64.clipu16(value)
},
DecodeDoubleQuotes: function(text, start, length, quote) {
for (var ch, builder = new System.Text.StringBuilder, i = start, end = start + length | 0; i < end; i = i + 1 | 0) ch = text.charCodeAt(i), ch === quote && (i + 1 | 0) < end && text.charCodeAt(i + 1 | 0) === quote && (i = i + 1 | 0), builder.append(String.fromCharCode(ch));
return builder.toString()
},
IsClusterHostName: function(name, hostName) {
return System.String.compare(name, hostName, !0) === 0
},
IsKustoWindowsNet: function(hostname) {
return System.String.endsWith(hostname, Kusto.Language.KustoFacts.KustoWindowsNet, 5)
},
IsClusterShortName: function(name, hostName) {
return !System.String.contains(name, ".") && System.String.startsWith(hostName, (name || "") + ".", 5)
},
GetHostName: function(clusterUriOrName) {
var start = 0,
end = clusterUriOrName.length,
hostNamePrefixStart = System.String.indexOf(clusterUriOrName, Kusto.Language.KustoFacts.HostNamePrefix),
colon;
return hostNamePrefixStart > 0 && (start = hostNamePrefixStart + Kusto.Language.KustoFacts.HostNamePrefix.length | 0, colon = System.String.indexOf(clusterUriOrName, String.fromCharCode(58), start), colon >= 0 && (end = colon)), start === 0 && end === clusterUriOrName.length ? clusterUriOrName : clusterUriOrName.substr(start, end - start | 0)
},
Matches: function(pattern, text) {
if (pattern == null) throw new System.ArgumentNullException.$ctor1("pattern");
if (text == null) throw new System.ArgumentNullException.$ctor1("text");
return pattern.length === 0 ? !1 : Kusto.Language.KustoFacts.Matches$1(pattern, 0, text, 0)
},
Matches$1: function(pattern, patternSegmentStart, text, textPosition) {
for (var asteriskPosition = System.String.indexOf(pattern, String.fromCharCode(42), patternSegmentStart), sawAsterisk = asteriskPosition >= 0, patternSegmentEnd = sawAsterisk ? asteriskPosition : pattern.length, nextPatternStart, patternSegmentLength, matchesPosition; sawAsterisk && (asteriskPosition + 1 | 0) < pattern.length && pattern.charCodeAt(asteriskPosition + 1 | 0) === 42;) asteriskPosition = asteriskPosition + 1 | 0;
return nextPatternStart = sawAsterisk ? asteriskPosition + 1 | 0 : pattern.length, patternSegmentLength = patternSegmentEnd - patternSegmentStart | 0, patternSegmentLength === 0 ? patternSegmentStart >= pattern.length ? !0 : Kusto.Language.KustoFacts.Matches$1(pattern, nextPatternStart, text, textPosition) : patternSegmentStart === 0 ? sawAsterisk ? patternSegmentLength > text.length || System.String.compare(text.substr(0, patternSegmentLength), pattern.substr(0, patternSegmentLength)) !== 0 ? !1 : Kusto.Language.KustoFacts.Matches$1(pattern, nextPatternStart, text, patternSegmentLength) : text.length === patternSegmentLength && System.String.compare(text.substr(0, patternSegmentLength), pattern.substr(0, patternSegmentLength)) === 0 : sawAsterisk ? (matchesPosition = Kusto.Language.KustoFacts.IndexOf(text, textPosition, pattern, patternSegmentStart, patternSegmentLength), matchesPosition === -1) ? !1 : Kusto.Language.KustoFacts.Matches$1(pattern, nextPatternStart, text, matchesPosition + patternSegmentLength | 0) : patternSegmentLength <= (text.length - textPosition | 0) && System.String.compare(text.substr(text.length - patternSegmentLength | 0, patternSegmentLength), pattern.substr(patternSegmentStart, patternSegmentLength)) === 0
},
IndexOf: function(text, textStart, value, valueStart, valueLength) {
for (var firstChar = value.charCodeAt(valueStart), firstCharPosition;;) {
if (firstCharPosition = System.String.indexOf(text, String.fromCharCode(firstChar), textStart), firstCharPosition < textStart || (firstCharPosition + valueLength | 0) > text.length) return -1;
if (System.String.compare(text.substr(firstCharPosition, valueLength), value.substr(valueStart, valueLength)) === 0) return firstCharPosition;
textStart = firstCharPosition + 1 | 0
}
}
}
}
});
Bridge.define("Kusto.Language.Operators", {
statics: {
fields: {
DateAndTimespan: null,
StringOrDynamic: null,
DynamicAddable: null,
UnaryMinus: null,
UnaryPlus: null,
And: null,
Or: null,
Add: null,
Subtract: null,
Multiply: null,
Divide: null,
Modulo: null,
LessThan: null,
LessThanOrEqual: null,
GreaterThan: null,
GreaterThanOrEqual: null,
Equal: null,
NotEqual: null,
EqualTilde: null,
BangTilde: null,
Has: null,
HasCs: null,
NotHas: null,
NotHasCs: null,
HasPrefix: null,
HasPrefixCs: null,
NotHasPrefix: null,
NotHasPrefixCs: null,
HasSuffix: null,
HasSuffixCs: null,
NotHasSuffix: null,
NotHasSuffixCs: null,
Like: null,
LikeCs: null,
NotLike: null,
NotLikeCs: null,
Contains: null,
ContainsCs: null,
NotContains: null,
NotContainsCs: null,
StartsWith: null,
StartsWithCs: null,
NotStartsWith: null,
NotStartsWithCs: null,
EndsWith: null,
EndsWithCs: null,
NotEndsWith: null,
NotEndsWithCs: null,
MatchRegex: null,
Search: null,
In: null,
HasAny: null,
InCs: null,
NotIn: null,
NotInCs: null,
Between: null,
NotBetween: null
},
props: {
All: null
},
ctors: {
init: function() {
this.DateAndTimespan = System.Array.init([Kusto.Language.Symbols.ScalarTypes.DateTime, Kusto.Language.Symbols.ScalarTypes.TimeSpan], Kusto.Language.Symbols.ScalarSymbol);
this.StringOrDynamic = System.Array.init([Kusto.Language.Symbols.ScalarTypes.String, Kusto.Language.Symbols.ScalarTypes.Dynamic], Kusto.Language.Symbols.ScalarSymbol);
this.DynamicAddable = System.Array.init([Kusto.Language.Symbols.ScalarTypes.Int, Kusto.Language.Symbols.ScalarTypes.Long, Kusto.Language.Symbols.ScalarTypes.Real, Kusto.Language.Symbols.ScalarTypes.Decimal, Kusto.Language.Symbols.ScalarTypes.TimeSpan, Kusto.Language.Symbols.ScalarTypes.DateTime], Kusto.Language.Symbols.ScalarSymbol);
this.UnaryMinus = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.UnaryMinus, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("operand", Kusto.Language.Symbols.ParameterTypeKind.Summable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("operand", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.UnaryPlus = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.UnaryPlus, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("operand", Kusto.Language.Symbols.ParameterTypeKind.Summable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("operand", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.And = Kusto.Language.Operators.Binary(Kusto.Language.Symbols.OperatorKind.And, Kusto.Language.Symbols.ScalarTypes.Bool, Kusto.Language.Symbols.ScalarTypes.Bool, Kusto.Language.Symbols.ScalarTypes.Bool);
this.Or = Kusto.Language.Operators.Binary(Kusto.Language.Symbols.OperatorKind.Or, Kusto.Language.Symbols.ScalarTypes.Bool, Kusto.Language.Symbols.ScalarTypes.Bool, Kusto.Language.Symbols.ScalarTypes.Bool);
this.Add = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Add, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Widest, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor4("left", Kusto.Language.Operators.DateAndTimespan), new Kusto.Language.Symbols.Parameter.$ctor4("right", Kusto.Language.Operators.DateAndTimespan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Int)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor4("right", Kusto.Language.Operators.DynamicAddable)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor4("left", Kusto.Language.Operators.DynamicAddable), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Subtract = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Subtract, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Widest, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Int)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor4("right", Kusto.Language.Operators.DynamicAddable)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.$ctor4("left", Kusto.Language.Operators.DynamicAddable), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Multiply = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Multiply, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Widest, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Int)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Divide = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Divide, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Widest, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Real, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Int)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Modulo = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Modulo, [new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Widest, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.TimeSpan, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.DateTime, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Dynamic, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Int)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Long, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Int), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter1, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor4(Kusto.Language.Symbols.ReturnTypeKind.Parameter0, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.LessThan = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.LessThan, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.LessThanOrEqual = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.LessThanOrEqual, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.GreaterThan = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.GreaterThan, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.GreaterThanOrEqual = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.GreaterThanOrEqual, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.TimeSpan), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.DateTime)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.Dynamic)])]);
this.Equal = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Equal, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.NotBool, Kusto.Language.Symbols.ArgumentKind.Star), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Scalar)])]);
this.NotEqual = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.NotEqual, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("left", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Scalar)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("right", Kusto.Language.Symbols.ParameterTypeKind.Scalar)])]);
this.EqualTilde = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.EqualTilde);
this.BangTilde = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.BangTilde);
this.Has = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.Has);
this.HasCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.HasCs);
this.NotHas = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHas);
this.NotHasCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHasCs);
this.HasPrefix = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.HasPrefix);
this.HasPrefixCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.HasPrefixCs);
this.NotHasPrefix = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHasPrefix);
this.NotHasPrefixCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHasPrefixCs);
this.HasSuffix = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.HasSuffix);
this.HasSuffixCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.HasSuffixCs);
this.NotHasSuffix = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHasSuffix);
this.NotHasSuffixCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotHasSuffixCs);
this.Like = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.Like);
this.LikeCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.LikeCs);
this.NotLike = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotLike);
this.NotLikeCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotLikeCs);
this.Contains = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.Contains);
this.ContainsCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.ContainsCs);
this.NotContains = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotContains);
this.NotContainsCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotContainsCs);
this.StartsWith = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.StartsWith);
this.StartsWithCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.StartsWithCs);
this.NotStartsWith = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotStartsWith);
this.NotStartsWithCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotStartsWithCs);
this.EndsWith = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.EndsWith);
this.EndsWithCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.EndsWithCs);
this.NotEndsWith = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotEndsWith);
this.NotEndsWithCs = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.NotEndsWithCs);
this.MatchRegex = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.MatchRegex);
this.Search = Kusto.Language.Operators.StringBinary(Kusto.Language.Symbols.OperatorKind.Search);
this.In = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.In, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)])]);
this.HasAny = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.HasAny, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)])]);
this.InCs = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.InCs, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)])]);
this.NotIn = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.NotIn, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Bool), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)]).Hide(), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.NotBool), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)])]);
this.NotInCs = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.NotInCs, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("table", Kusto.Language.Symbols.ParameterTypeKind.SingleColumnTable)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor4("value", Kusto.Language.Operators.StringOrDynamic), new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Scalar, 0, void 0, void 0, !1, void 0, 1, 32767, void 0, void 0)])]);
this.Between = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.Between, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Parameter0), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter0)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("start", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("end", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("start", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter1)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter1)])]);
this.NotBetween = new Kusto.Language.Symbols.OperatorSymbol.ctor(Kusto.Language.Symbols.OperatorKind.NotBetween, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Number)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Summable), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Parameter0), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter0)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("start", Kusto.Language.Symbols.ScalarTypes.DateTime), new Kusto.Language.Symbols.Parameter.$ctor2("end", Kusto.Language.Symbols.ScalarTypes.TimeSpan)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("value", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.$ctor2("start", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter1)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.$ctor2("value", Kusto.Language.Symbols.ScalarTypes.Dynamic), new Kusto.Language.Symbols.Parameter.ctor("start", Kusto.Language.Symbols.ParameterTypeKind.Number), new Kusto.Language.Symbols.Parameter.ctor("end", Kusto.Language.Symbols.ParameterTypeKind.Parameter1)])]);
this.All = System.Array.init([Kusto.Language.Operators.UnaryMinus, Kusto.Language.Operators.UnaryPlus, Kusto.Language.Operators.And, Kusto.Language.Operators.Or, Kusto.Language.Operators.Add, Kusto.Language.Operators.Subtract, Kusto.Language.Operators.Multiply, Kusto.Language.Operators.Divide, Kusto.Language.Operators.Modulo, Kusto.Language.Operators.LessThan, Kusto.Language.Operators.LessThanOrEqual, Kusto.Language.Operators.GreaterThan, Kusto.Language.Operators.GreaterThanOrEqual, Kusto.Language.Operators.Equal, Kusto.Language.Operators.NotEqual, Kusto.Language.Operators.EqualTilde, Kusto.Language.Operators.BangTilde, Kusto.Language.Operators.Has, Kusto.Language.Operators.HasCs, Kusto.Language.Operators.NotHas, Kusto.Language.Operators.NotHasCs, Kusto.Language.Operators.HasPrefix, Kusto.Language.Operators.HasPrefixCs, Kusto.Language.Operators.NotHasPrefix, Kusto.Language.Operators.NotHasPrefixCs, Kusto.Language.Operators.HasSuffix, Kusto.Language.Operators.HasSuffixCs, Kusto.Language.Operators.NotHasSuffix, Kusto.Language.Operators.NotHasSuffixCs, Kusto.Language.Operators.Like, Kusto.Language.Operators.LikeCs, Kusto.Language.Operators.NotLike, Kusto.Language.Operators.NotLikeCs, Kusto.Language.Operators.Contains, Kusto.Language.Operators.ContainsCs, Kusto.Language.Operators.NotContains, Kusto.Language.Operators.NotContainsCs, Kusto.Language.Operators.StartsWith, Kusto.Language.Operators.StartsWithCs, Kusto.Language.Operators.NotStartsWith, Kusto.Language.Operators.NotStartsWithCs, Kusto.Language.Operators.EndsWith, Kusto.Language.Operators.EndsWithCs, Kusto.Language.Operators.NotEndsWith, Kusto.Language.Operators.NotEndsWithCs, Kusto.Language.Operators.MatchRegex, Kusto.Language.Operators.Search, Kusto.Language.Operators.In, Kusto.Language.Operators.InCs, Kusto.Language.Operators.NotIn, Kusto.Language.Operators.NotInCs, Kusto.Language.Operators.Between, Kusto.Language.Operators.NotBetween, Kusto.Language.Operators.HasAny], Kusto.Language.Symbols.OperatorSymbol)
}
},
methods: {
Binary: function(kind, left, right, result) {
return new Kusto.Language.Symbols.OperatorSymbol.ctor(kind, [new Kusto.Language.Symbols.Signature.$ctor7(result, [new Kusto.Language.Symbols.Parameter.$ctor2("left", left), new Kusto.Language.Symbols.Parameter.$ctor2("right", right)])])
},
StringBinary: function(kind) {
return new Kusto.Language.Symbols.OperatorSymbol.ctor(kind, [new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.String)]), new Kusto.Language.Symbols.Signature.$ctor7(Kusto.Language.Symbols.ScalarTypes.Bool, [new Kusto.Language.Symbols.Parameter.ctor("left", Kusto.Language.Symbols.ParameterTypeKind.StringOrDynamic, Kusto.Language.Symbols.ArgumentKind.Star), new Kusto.Language.Symbols.Parameter.$ctor2("right", Kusto.Language.Symbols.ScalarTypes.String)])])
}
}
}
});
Bridge.define("Kusto.Language.Parsing.ApplyKind", {
$kind: "enum",
statics: {
fields: {
One: 0,
ZeroOrOne: 1,
ZeroOrMore: 2
}
}
});
Bridge.define("Kusto.Language.Parsing.Parser$1", function(TInput) {
return {
fields: {
description: null
},
props: {
Tag: null,
Annotations: null,
Description: {
get: function() {
return this.description == null && (this.description = System.String.isNullOrEmpty(this.Tag) ? Kusto.Language.Parsing.GrammarBuilder.BuildGrammar(TInput, this) : System.String.format("{0}: {1}", this.Tag, Kusto.Language.Parsing.GrammarBuilder.BuildGrammar(TInput, this.WithTag(null)))), this.description
}
},
IsHidden: !1,
IsOptional: {
get: function() {
return !1
}
}
},
ctors: {
init: function() {
this.Tag = "";
this.Annotations = Kusto.Language.Utils.EmptyReadOnlyList$1(System.Object).Instance;
this.IsHidden = !1
}
},
methods: {
WithTag: function(tag) {
var $t, clone;
return tag = ($t = tag, $t != null ? $t : ""), Bridge.referenceEquals(tag, this.Tag) ? this : (clone = this.Clone(), clone.Tag = tag, clone.Annotations = this.Annotations, clone.IsHidden = this.IsHidden, clone)
},
WithAnnotations: function(annotations) {
var list = Kusto.Language.Utils.ListExtensions.ToReadOnly(System.Object, annotations),
clone;
return Bridge.referenceEquals(this.Annotations, list) ? this : (clone = this.Clone(), clone.Annotations = list, clone.Tag = this.Tag, clone.IsHidden = this.IsHidden, clone)
},
WithIsHidden: function(isHidden) {
if (isHidden !== this.IsHidden) {
var clone = this.Clone();
return clone.IsHidden = isHidden, clone.Tag = this.Tag, clone.Annotations = this.Annotations, clone
}
return this
},
Hide: function() {
return this.WithIsHidden(!0)
},
Search$1: function(input, inputStart, prevWasMissing, beforeAction, afterAction) {
return afterAction === void 0 && (afterAction = null), Kusto.Language.Parsing.SafeSearcher.SearchSafe(TInput, this, input, inputStart, prevWasMissing, beforeAction, afterAction)
},
Search: function(input, beforeAction, afterAction) {
return afterAction === void 0 && (afterAction = null), this.Search$1(input, 0, !1, beforeAction, afterAction)
}
}
}
});
Bridge.define("Kusto.Language.Parsing.Source$1", function() {
return {}
});
Bridge.define("Kusto.Language.Parsing.CharScanners", {
statics: {
fields: {
Letter: null,
Digit: null,
HexDigit: null,
Whitespace: null,
LineBreak: null
},
ctors: {
init: function() {
this.Letter = Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(Kusto.Language.Parsing.TextFacts.IsLetter).WithTag("<letter>");
this.Digit = Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(Kusto.Language.Parsing.TextFacts.IsDigit).WithTag("<digit>");
this.HexDigit = Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(Kusto.Language.Parsing.TextFacts.IsHexDigit).WithTag("<hex-digit>");
this.Whitespace = Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(Kusto.Language.Parsing.TextFacts.IsWhitespace).WithTag("<whitespace>");
this.LineBreak = Kusto.Language.Parsing.Parsers$1(System.Char).Or([Kusto.Language.Parsing.Parsers$1(System.Char).And([Kusto.Language.Parsing.CharScanners.Char(13), Kusto.Language.Parsing.Parsers$1(System.Char).Optional(Kusto.Language.Parsing.CharScanners.Char(10))]), Kusto.Language.Parsing.CharScanners.Char(10), Kusto.Language.Parsing.CharScanners.Char(8232), Kusto.Language.Parsing.CharScanners.Char(8233)]).WithTag("<line-break>")
}
},
methods: {
Chars: function(text, ignoreCase) {
if (ignoreCase === void 0 && (ignoreCase = !1), text.length === 1) return Kusto.Language.Parsing.CharScanners.Char(text.charCodeAt(0), ignoreCase);
if (ignoreCase) {
var lower = text.toLowerCase(),
upper = text.toUpperCase();
return Kusto.Language.Parsing.Parsers$1(System.Char).Match(function(source, start) {
var textSource = Bridge.as(source, Kusto.Language.Parsing.TextSource),
ts, i, ch;
if ((ts = Bridge.as(source, Kusto.Language.Parsing.TextSource)) != null) return ts.Matches$1(start, text, !0) ? text.length : -1;
for (i = 0; i < text.length; i = i + 1 | 0)
if (ch = source.Peek(start + i | 0), ch !== lower.charCodeAt(i) && ch !== upper.charCodeAt(i)) return -1;
return text.length
}).WithTag(System.String.format("'{0}'", [text]))
}
return Kusto.Language.Parsing.Parsers$1(System.Char).Match(function(source, start) {
var textSource = Bridge.as(source, Kusto.Language.Parsing.TextSource),
ts, i;
if ((ts = Bridge.as(source, Kusto.Language.Parsing.TextSource)) != null) return ts.Matches(start, text) ? text.length : -1;
for (i = 0; i < text.length; i = i + 1 | 0)
if (source.Peek(start + i | 0) !== text.charCodeAt(i)) return -1;
return text.length
}).WithTag(System.String.format("'{0}'", [text]))
},
Char: function(ch, ignoreCase) {
return ignoreCase === void 0 && (ignoreCase = !1), ignoreCase ? Kusto.Language.Parsing.CharScanners.MatchCharIgnoreCase(ch, String.fromCharCode(ch).toUpperCase().charCodeAt(0), String.fromCharCode(ch).toLowerCase().charCodeAt(0)).WithTag(System.String.format("'{0}'", [String.fromCharCode(ch)])) : Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(function(c) {
return c === ch
}).WithTag(System.String.format("'{0}'", [String.fromCharCode(ch)]))
},
MatchCharIgnoreCase: function(ch, chUpper, chLower) {
return Kusto.Language.Parsing.Parsers$1(System.Char).Match$1(function(c) {
return c === ch || c === chUpper || c === chLower
})
}
}
}
});
Bridge.define("Kusto.Language.Parsing.CommandGrammar", {
statics: {
fields: {
MissingCommandStatementNode: null,
MissingCommandStatement: null
},
ctors: {
init: function() {
this.MissingCommandStatementNode = new Kusto.Language.Syntax.ExpressionStatement(new Kusto.Language.Syntax.BadCommand(Kusto.Language.Syntax.SyntaxToken.Missing(Kusto.Language.Syntax.SyntaxKind.DotToken), System.Array.init([Kusto.Language.DiagnosticFacts.GetMissingCommand()], Kusto.Language.Diagnostic)));
this.MissingCommandStatement = function() {
return Bridge.cast(Kusto.Language.Parsing.CommandGrammar.MissingCommandStatementNode.Clone$1(), Kusto.Language.Syntax.Statement)
}
}
},
methods: {
From: function(globals) {
var grammar = {};
return globals.Cache.TryGetValue(Kusto.Language.Parsing.CommandGrammar, grammar) || (grammar.v = globals.Cache.GetOrCreate$1(Bridge.global.Kusto.Language.Parsing.CommandGrammar, function() {
return Kusto.Language.Parsing.CommandGrammar.Create(globals)
})), grammar.v
},
Create: function(globals) {
var q = Kusto.Language.Parsing.QueryGrammar.From(globals),
commandCore = null,
command = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Forward(Bridge.global.Kusto.Language.Syntax.Command, function() {
return commandCore
}).WithTag$1("<command>"),
unknownCommandToken = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).If$1(Bridge.global.Kusto.Language.Syntax.SyntaxToken, Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Not(Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).First$1(Bridge.global.Kusto.Language.Syntax.SyntaxToken, [Kusto.Language.Parsing.SyntaxParsers.Token$1(Kusto.Language.Syntax.SyntaxKind.BarToken), Kusto.Language.Parsing.SyntaxParsers.Token$1(Kusto.Language.Syntax.SyntaxKind.LessThanBarToken), Kusto.Language.Parsing.SyntaxParsers.Token$1(Kusto.Language.Syntax.SyntaxKind.EndOfTextToken)])), Kusto.Language.Parsing.SyntaxParsers.AnyToken),
unknownCommand = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Rule$1(Bridge.global.Kusto.Language.Syntax.SyntaxToken, Bridge.global.Kusto.Language.Syntax.SyntaxList$1(Kusto.Language.Syntax.SyntaxToken), Bridge.global.Kusto.Language.Syntax.Command, Kusto.Language.Parsing.SyntaxParsers.Token$1(Kusto.Language.Syntax.SyntaxKind.DotToken), Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).OneOrMore$1(Bridge.global.Kusto.Language.Syntax.SyntaxToken, Bridge.global.Kusto.Language.Syntax.SyntaxList$1(Kusto.Language.Syntax.SyntaxToken), unknownCommandToken, function(tokens) {
return new(Kusto.Language.Syntax.SyntaxList$1(Kusto.Language.Syntax.SyntaxToken).$ctor1)(tokens)
}), function(dot, parts) {
return Bridge.cast(new Kusto.Language.Syntax.UnknownCommand(dot, parts), Kusto.Language.Syntax.Command)
}).WithTag$1("<unknown-command>"),
badCommand = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Rule(Bridge.global.Kusto.Language.Syntax.SyntaxToken, Bridge.global.Kusto.Language.Syntax.Command, Kusto.Language.Parsing.SyntaxParsers.Token$1(Kusto.Language.Syntax.SyntaxKind.DotToken), function(dot) {
return Bridge.cast(new Kusto.Language.Syntax.BadCommand(dot, System.Array.init([Kusto.Language.DiagnosticFacts.GetMissingCommand()], Kusto.Language.Diagnostic)), Kusto.Language.Syntax.Command)
}).WithTag$1("<bad-command>"),
grammarParser = Kusto.Language.Parsing.CommandGrammar.CreateCommandGrammarParser(globals, command),
commandParsers = System.Linq.Enumerable.from(globals.Commands).select(function(c) {
return Kusto.Language.Parsing.CommandGrammar.CreateCommandParser(c, grammarParser)
}).ToArray(Kusto.Language.Parsing.Parser$2(Kusto.Language.Parsing.LexicalToken, Kusto.Language.Syntax.Command)),
map = System.Linq.Enumerable.range(0, commandParsers.length).toDictionary(function(i) {
return System.Array.getItem(globals.Commands, i, Kusto.Language.Symbols.CommandSymbol)
}, function(i) {
return commandParsers[System.Array.index(i, commandParsers)]
}, Bridge.global.Kusto.Language.Symbols.CommandSymbol, Bridge.global.Kusto.Language.Parsing.Parser$2(Kusto.Language.Parsing.LexicalToken, Kusto.Language.Syntax.Command)),
bestCommandParsers = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Best$2(Bridge.global.Kusto.Language.Syntax.Command, commandParsers, function(command1, command2) {
if (!command1.ContainsSyntaxDiagnostics && !command2.ContainsSyntaxDiagnostics) return 0;
if (command1.ContainsSyntaxDiagnostics && !command2.ContainsSyntaxDiagnostics) return -1;
if (!command1.ContainsSyntaxDiagnostics && command2.ContainsSyntaxDiagnostics) return 1;
var dx1 = command1.GetContainedSyntaxDiagnostics(),
dx2 = command2.GetContainedSyntaxDiagnostics();
return System.Array.getItem(dx1, 0, Kusto.Language.Diagnostic).Start > System.Array.getItem(dx2, 0, Kusto.Language.Diagnostic).Start ? 1 : System.Array.getItem(dx1, 0, Kusto.Language.Diagnostic).Start < System.Array.getItem(dx2, 0, Kusto.Language.Diagnostic).Start ? -1 : 0
});
commandCore = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).First$1(Bridge.global.Kusto.Language.Syntax.Command, [bestCommandParsers, unknownCommand, badCommand]).WithTag$1("<command>");
var commandOutputPipeExpression = Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).ApplyZeroOrMore(Bridge.global.Kusto.Language.Syntax.Expression, command.Cast(Kusto.Language.Syntax.Expression), function(_left) {
return Kusto.Language.Parsing.Parsers$1(Kusto.Language.Parsing.LexicalToken).Rule$11(Bridge.global.Kusto.Language.Syntax.Expression, Bridge.global.Kusto.Language.Syntax.SyntaxToken, Bridge.global.Kusto.Language.Syntax.QueryOperator, Bridge.global.Kusto.Language.Syntax.Expression, _left, Kusto.Language.Pa
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment