Auto-sync from Azure-Kusto-Service

Author: Kusto Build System

src/Kusto.Language/Binder/Binder_NodeBinder.cs

@@ -4093,6 +4093,48 @@ public override SemanticInfo VisitGraphMarkComponentsOperator(GraphMarkComponent
                 }
             }
 
+            public override SemanticInfo VisitGraphWhereNodesOperator(GraphWhereNodesOperator node)
+            {
+                var diagnostics = s_diagnosticListPool.AllocateFromPool();
+                try
+                {
+                    CheckNotFirstInPipe(node, diagnostics);
+                    _binder.CheckIsExactType(node.Condition, ScalarTypes.Bool, diagnostics);
+
+                    // get existing graph symbol from left-side of parent pipe operator
+                    var graphSymbol = (node.Parent as PipeExpression)?.Expression?.ResultType is GraphSymbol g
+                        ? new GraphSymbol(g.EdgeShape, g.NodeShape)
+                        : new GraphSymbol(this.RowScopeOrEmpty);
+
+                    return new SemanticInfo(graphSymbol, diagnostics);
+                }
+                finally
+                {
+                    s_diagnosticListPool.ReturnToPool(diagnostics);
+                }
+            }
+
+            public override SemanticInfo VisitGraphWhereEdgesOperator(GraphWhereEdgesOperator node)
+            {
+                var diagnostics = s_diagnosticListPool.AllocateFromPool();
+                try
+                {
+                    CheckNotFirstInPipe(node, diagnostics);
+                    _binder.CheckIsExactType(node.Condition, ScalarTypes.Bool, diagnostics);
+
+                    // get existing graph symbol from left-side of parent pipe operator
+                    var graphSymbol = (node.Parent as PipeExpression)?.Expression?.ResultType is GraphSymbol g
+                        ? new GraphSymbol(g.EdgeShape, g.NodeShape)
+                        : new GraphSymbol(this.RowScopeOrEmpty);
+
+                    return new SemanticInfo(graphSymbol, diagnostics);
+                }
+                finally
+                {
+                    s_diagnosticListPool.ReturnToPool(diagnostics);
+                }
+            }
+
             public override SemanticInfo VisitGraphToTableOperator(GraphToTableOperator node)
             {
                 var diagnostics = s_diagnosticListPool.AllocateFromPool();
@@ -4557,6 +4599,11 @@ public override SemanticInfo VisitDirective(Directive node)
                     s_diagnosticListPool.ReturnToPool(diagnostics);
                 }
             }
+
+            public override SemanticInfo VisitRestrictStatementWithClause(RestrictStatementWithClause node)
+            {
+                return null;
+            }
             #endregion
         }
     }

src/Kusto.Language/Parser/QueryGrammar.cs

@@ -2915,6 +2915,24 @@ Parser<LexicalToken, DataScopeClause> DataScopeClause(CompletionKind ckind) =>
                     )
                 .WithTag("<graph-mark-components>");
 
+            var GraphWhereNodesOperator =
+                Rule(
+                    Token(SyntaxKind.GraphWhereNodesKeyword, CompletionKind.QueryPrefix),
+                    Required(Expression, CreateMissingExpression),
+                    (graphWhereNodesKeyword, expression) =>
+                        (QueryOperator)new GraphWhereNodesOperator(graphWhereNodesKeyword, expression)
+                    )
+                .WithTag("<graph-where-nodes>");
+
+            var GraphWhereEdgesOperator =
+                Rule(
+                    Token(SyntaxKind.GraphWhereEdgesKeyword, CompletionKind.QueryPrefix),
+                    Required(Expression, CreateMissingExpression),
+                    (graphWhereEdgesKeyword, expression) =>
+                        (QueryOperator)new GraphWhereEdgesOperator(graphWhereEdgesKeyword, expression)
+                    )
+                .WithTag("<graph-where-edges>");
+
             var GraphToTableAsClause =
                 Rule(
                     Token(SyntaxKind.AsKeyword, CompletionKind.Keyword, CompletionPriority.Low),
@@ -3077,6 +3095,9 @@ Parser<LexicalToken, DataScopeClause> DataScopeClause(CompletionKind ckind) =>
                     GraphMatchOperator,
                     GraphShortestPathsOperator,
                     GraphMarkComponentsOperator,
+                    // currently hidden until we document this feature.
+                    GraphWhereNodesOperator.Hide(),
+                    GraphWhereEdgesOperator.Hide(),
                     GraphToTableOperator,
                     InvokeOperator,
                     JoinOperator,
@@ -3352,6 +3373,15 @@ Parser<LexicalToken, DataScopeClause> DataScopeClause(CompletionKind ckind) =>
                     SimpleNameReference)
                     .WithCompletionHint(CompletionHint.Table | CompletionHint.MaterializedView | CompletionHint.ExternalTable | CompletionHint.GraphModel);
 
+            var RestrictStatementWithClause = 
+                Rule(
+                    Token(SyntaxKind.WithKeyword),
+                    RequiredToken(SyntaxKind.OpenParenToken),
+                    QueryParameterCommaList(QueryOperatorParameters.RestrictStatementParameters),
+                    RequiredToken(SyntaxKind.CloseParenToken),
+                    (withKeyword, openParen, properties, closeParen) =>
+                        new RestrictStatementWithClause(withKeyword, openParen, properties, closeParen));
+
             var RestrictStatement =
                 Rule(
                     Token(SyntaxKind.RestrictKeyword, CompletionKind.QueryPrefix).Hide(),
@@ -3360,8 +3390,9 @@ Parser<LexicalToken, DataScopeClause> DataScopeClause(CompletionKind ckind) =>
                     RequiredToken(SyntaxKind.OpenParenToken),
                     CommaList<Expression>(Restriction, CreateMissingExpression, oneOrMore: true),
                     RequiredToken(SyntaxKind.CloseParenToken),
-                    (restrictKeyword, accessKeyword, toKeyword, openParen, list, closeParen) =>
-                        (Statement)new RestrictStatement(restrictKeyword, accessKeyword, toKeyword, openParen, list, closeParen))
+                    Optional(RestrictStatementWithClause),
+                    (restrictKeyword, accessKeyword, toKeyword, openParen, list, closeParen, withProperties) =>
+                        (Statement)new RestrictStatement(restrictKeyword, accessKeyword, toKeyword, openParen, list, closeParen, withProperties))
                 .WithTag("<restrict>");
 
             var PatternPathValue =

src/Kusto.Language/Parser/QueryParser.cs

@@ -6021,6 +6021,32 @@ private GraphMarkComponentsOperator ParseGraphMarkComponentsOperator()
         }
         #endregion
 
+        #region GraphWhereNodesOperator
+        private GraphWhereNodesOperator ParseGraphWhereNodesOperator()
+        {
+            if (ParseToken(SyntaxKind.GraphWhereNodesKeyword) is SyntaxToken keyword)
+            {
+                var expression = ParseUnnamedExpression() ?? CreateMissingExpression();
+                return new GraphWhereNodesOperator(keyword, expression);
+            }
+
+            return null;
+        }
+        #endregion
+
+        #region GraphWhereEdgesOperator
+        private GraphWhereEdgesOperator ParseGraphWhereEdgesOperator()
+        {
+            if (ParseToken(SyntaxKind.GraphWhereEdgesKeyword) is SyntaxToken keyword)
+            {
+                var expression = ParseUnnamedExpression() ?? CreateMissingExpression();
+                return new GraphWhereEdgesOperator(keyword, expression);
+            }
+
+            return null;
+        }
+        #endregion
+
         #endregion
 
         #region Query Expressions
@@ -6162,6 +6188,10 @@ private QueryOperator ParsePipedQueryOperator()
                     return ParseGraphToTableOperator();
                 case SyntaxKind.GraphMarkComponentsKeyword:
                     return ParseGraphMarkComponentsOperator();
+                case SyntaxKind.GraphWhereNodesKeyword:
+                    return ParseGraphWhereNodesOperator();
+                case SyntaxKind.GraphWhereEdgesKeyword:
+                    return ParseGraphWhereEdgesOperator();
                 case SyntaxKind.AssertSchemaKeyword:
                     return ParseAssertSchemaOperator();
                 default:
@@ -6650,7 +6680,6 @@ private QueryParametersStatement ParseQueryParametersStatement()
         #endregion
 
         #region restrict
-
         private static readonly IReadOnlyList<Func<QueryParser, Expression>> ParseRestrictExpressionParsers =
             new[]
             {
@@ -6676,12 +6705,39 @@ private RestrictStatement ParseRestrictStatement()
                 var open = ParseRequiredToken(SyntaxKind.OpenParenToken);
                 var expressions = ParseCommaList(FnParseRestrictExpression, CreateMissingExpression, FnScanCommonListEnd, oneOrMore: true);
                 var close = ParseRequiredToken(SyntaxKind.CloseParenToken);
-                return new RestrictStatement(keyword, accessKeyword, toKeyword, open, expressions, close);
+                var withClause = ParseRestrictStatementWithClause();
+                return new RestrictStatement(keyword, accessKeyword, toKeyword, open, expressions, close, withClause);
+            }
+
+            return null;
+        }
+         
+        private RestrictStatementWithClause ParseRestrictStatementWithClause()
+        {
+            var keyword = ParseToken(SyntaxKind.WithKeyword);
+            if (keyword != null)
+            {
+                var open = ParseRequiredToken(SyntaxKind.OpenParenToken);
+                var props = ParseCommaList(parser => parser.ParseRestrictProperty(), CreateMissingNamedParameter, FnScanCommonListEnd);
+                var close = ParseRequiredToken(SyntaxKind.CloseParenToken);
+                return new RestrictStatementWithClause(keyword, open, props, close);
             }
 
             return null;
         }
 
+        private NamedParameter ParseRestrictProperty()
+        {
+            var name = ParseRenameNameDeclaration();
+            if (name != null)
+            {
+                var equal = ParseRequiredToken(SyntaxKind.EqualToken);
+                var value = ParseExternalDataPropertyValue() ?? CreateMissingValue();
+                return new NamedParameter(name, equal, value);
+            }
+
+            return null;
+        }
         #endregion
 
         #region declare pattern

src/Kusto.Language/QueryOperatorParameters.cs

@@ -112,6 +112,9 @@ public static class QueryOperatorParameters
         public static readonly QueryOperatorParameter ShortestPathsOutputs =
             new QueryOperatorParameter("output", QueryOperatorParameterValueKind.Word, values: KustoFacts.ShortestPathsOutputs);
 
+        public static readonly QueryOperatorParameter ManagedIdentityAuthEnabled =
+            new QueryOperatorParameter("AllowManagedIdentityAuthentication", QueryOperatorParameterValueKind.BoolLiteral, isRepeatable: false);
+
         /// <summary>
         /// All query operator parameters.
         /// Does not include parameters used for other syntax clauses (like render with properties)
@@ -210,6 +213,11 @@ public static class QueryOperatorParameters
             Output.WithValues(KustoFacts.ShortestPathsOutputs),
         }.ToReadOnly();
 
+        public static readonly IReadOnlyList<QueryOperatorParameter> RestrictStatementParameters = new QueryOperatorParameter[]
+        {
+            ManagedIdentityAuthEnabled
+        }.ToReadOnly();
+
 
         public static readonly IReadOnlyList<QueryOperatorParameter> JoinParameters = new QueryOperatorParameter[]
         {