diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index dcc4345..824fe7a 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -19,7 +19,7 @@ jobs: - name: "Git Fetch Tags" run: git fetch --tags - name: "Install .NET" - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@v6 with: dotnet-version: '10.0.x' - name: Restore diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index c6151df..f28d8f0 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -59,7 +59,7 @@ jobs: # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@v3 + uses: github/codeql-action/init@v4 with: languages: ${{ matrix.language }} build-mode: ${{ matrix.build-mode }} @@ -87,6 +87,6 @@ jobs: exit 1 - name: Perform CodeQL Analysis - uses: github/codeql-action/analyze@v3 + uses: github/codeql-action/analyze@v4 with: category: "/language:${{matrix.language}}" diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 0ee0810..39c36d3 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -39,7 +39,7 @@ jobs: git tag "v$VERSION" # Local only, so MinVer picks it up; fails if the tag already exists - name: "Install .NET" - uses: actions/setup-dotnet@v4 + uses: actions/setup-dotnet@v6 with: dotnet-version: '10.0.x' diff --git a/Source/DynamicODataToSQL/ColumnNameResolver.cs b/Source/DynamicODataToSQL/ColumnNameResolver.cs index cc55ef5..a53698d 100644 --- a/Source/DynamicODataToSQL/ColumnNameResolver.cs +++ b/Source/DynamicODataToSQL/ColumnNameResolver.cs @@ -50,6 +50,11 @@ public string GetColumnName(QueryNode node, bool wrap = false) column = (node as SingleValueOpenPropertyAccessNode).Name.Trim(); } + if (column.Length == 0) + { + throw new NotSupportedException($"Expected a property, found '{node.Kind}'"); + } + if (wrap) { table = compiler.WrapValue(table); diff --git a/Source/DynamicODataToSQL/FilterClauseBuilder.cs b/Source/DynamicODataToSQL/FilterClauseBuilder.cs index 6938b30..0b0e349 100644 --- a/Source/DynamicODataToSQL/FilterClauseBuilder.cs +++ b/Source/DynamicODataToSQL/FilterClauseBuilder.cs @@ -74,45 +74,29 @@ public override Query Visit(BinaryOperatorNode nodeIn) case BinaryOperatorKind.GreaterThanOrEqual: case BinaryOperatorKind.LessThan: case BinaryOperatorKind.LessThanOrEqual: - var op = GetOperatorString(nodeIn.OperatorKind); - if (left.Kind == QueryNodeKind.UnaryOperator) + var operatorKind = nodeIn.OperatorKind; + if (left.Kind == QueryNodeKind.Constant && right.Kind != QueryNodeKind.Constant) { - _query = _query.Where(q => - { - var lb = new FilterClauseBuilder(q, _tryToParseDates, columnNameResolver); - return left.Accept(lb); - }); - left = (left as UnaryOperatorNode).Operand; + (left, right) = (right, left); + operatorKind = Mirror(operatorKind); } + + var op = GetOperatorString(operatorKind); if (right.Kind == QueryNodeKind.Constant) { var value = GetConstantValue(right); - if (left.Kind == QueryNodeKind.SingleValueFunctionCall) - { - var functionNode = left as SingleValueFunctionCallNode; - _query = ApplyFunction(_query, functionNode, op, value); - } - else - { - var column = columnNameResolver.GetColumnName(left); - _query = _query.Where(column, op, value); - } + _query = left.Kind == QueryNodeKind.SingleValueFunctionCall + ? ApplyFunction(_query, (SingleValueFunctionCallNode)left, op, value) + : _query.Where(columnNameResolver.GetColumnName(left), op, value); + } + else + { + _query = _query.WhereColumns(columnNameResolver.GetColumnName(left), op, columnNameResolver.GetColumnName(right)); } break; - case BinaryOperatorKind.Add: - break; - case BinaryOperatorKind.Subtract: - break; - case BinaryOperatorKind.Multiply: - break; - case BinaryOperatorKind.Divide: - break; - case BinaryOperatorKind.Modulo: - break; - case BinaryOperatorKind.Has: - break; + default: - return _query; + throw new NotSupportedException($"Operator '{nodeIn.OperatorKind}' is not supported in $filter"); } return _query; @@ -125,11 +109,7 @@ public override Query Visit(SingleValueFunctionCallNode nodeIn) var nodes = nodeIn.Parameters.ToArray(); - var caseSensitive = true; - var columnName = columnNameResolver.GetColumnName(nodes[0]); - - // managing case where there is toupper or tolower function call inside first parameter - (caseSensitive, columnName) = GetInnerFunctionCallParameterColumn(nodes, caseSensitive, columnName); + var (caseSensitive, columnName) = ResolveFunctionColumn(nodes); switch (nodeIn.Name.ToLowerInvariant()) { @@ -159,7 +139,7 @@ public override Query Visit(SingleValueFunctionCallNode nodeIn) return _query.WhereLike(columnName, value, caseSensitive); default: - return _query; + throw new NotSupportedException($"Function '{nodeIn.Name}' is not supported as a $filter predicate"); } } @@ -168,25 +148,24 @@ public override Query Visit(UnaryOperatorNode nodeIn) { switch (nodeIn.OperatorKind) { - case UnaryOperatorKind.Not: - _query = _query.Not(); - if (nodeIn.Operand.Kind is QueryNodeKind.SingleValueFunctionCall - or QueryNodeKind.BinaryOperator - or QueryNodeKind.In) - { - return nodeIn.Operand.Accept(this); - } - - return _query; - case UnaryOperatorKind.Negate: + case UnaryOperatorKind.Not when nodeIn.Operand.Kind is QueryNodeKind.SingleValueFunctionCall + or QueryNodeKind.BinaryOperator + or QueryNodeKind.In: + // the operand emits one clause or throws, so the not flag never outlives it + var clauses = _query.GetComponents("where").Count; + var negated = nodeIn.Operand.Accept(new FilterClauseBuilder(_query.Not(), _tryToParseDates, columnNameResolver)); + if (negated.GetComponents("where").Count != clauses + 1) + throw new NotSupportedException("The operand of 'not' is not supported in $filter"); + return _query = negated; default: - return _query; + throw new NotSupportedException($"Operator '{nodeIn.OperatorKind}' is not supported in $filter"); } } private Query ApplyFunction(Query query, SingleValueFunctionCallNode leftNode, string operand, object rightValue) { - var columnName = columnNameResolver.GetColumnName(leftNode.Parameters.FirstOrDefault()); + var nodes = leftNode.Parameters.ToArray(); + var (caseSensitive, columnName) = ResolveFunctionColumn(nodes); switch (leftNode.Name.ToUpperInvariant()) { case "YEAR": @@ -207,11 +186,6 @@ private Query ApplyFunction(Query query, SingleValueFunctionCallNode leftNode, s query = query.WhereLike(columnName, rightValue, false); break; case "INDEXOF": - var nodes = leftNode.Parameters.ToArray(); - var caseSensitive = true; - - (caseSensitive, columnName) = GetInnerFunctionCallParameterColumn(nodes, caseSensitive, columnName); - if (rightValue.Equals(-1)) { query = query.WhereNotContains(columnName, (string)GetConstantValue(nodes[1]), caseSensitive); @@ -222,42 +196,19 @@ private Query ApplyFunction(Query query, SingleValueFunctionCallNode leftNode, s } break; default: - break; + throw new NotSupportedException($"Function '{leftNode.Name}' is not supported in a $filter comparison"); } return query; } - private (bool CaseSensitive, string ColumnName) GetInnerFunctionCallParameterColumn(QueryNode[] nodes, bool caseSensitive, string columnName) - { - if (nodes[0].Kind == QueryNodeKind.Convert) - { - var paramNode = (nodes[0] as ConvertNode).Source; - if (paramNode.Kind == QueryNodeKind.SingleValueFunctionCall) - { - return GetFunctionCallParameterInfo(caseSensitive, columnName, paramNode as SingleValueFunctionCallNode); - } - } - else if (nodes[0].Kind == QueryNodeKind.SingleValueFunctionCall) - { - return GetFunctionCallParameterInfo(caseSensitive, columnName, nodes[0] as SingleValueFunctionCallNode); - } - - return (caseSensitive, columnName); - } - - private (bool CaseSensitive, string ColumnName) GetFunctionCallParameterInfo(bool caseSensitive, string columnName, SingleValueFunctionCallNode paramNode) + // tolower or toupper around the first argument makes the match case insensitive + private (bool CaseSensitive, string ColumnName) ResolveFunctionColumn(QueryNode[] nodes) { - var functionNode = paramNode; - - var functionName = functionNode.Name.ToUpperInvariant(); - if (functionName is "TOUPPER" or "TOLOWER") - { - caseSensitive = false; - columnName = columnNameResolver.GetColumnName(functionNode.Parameters.FirstOrDefault()); - } - - return (caseSensitive, columnName); + var source = nodes[0] is ConvertNode convert ? convert.Source : nodes[0]; + return source is SingleValueFunctionCallNode inner && inner.Name.ToUpperInvariant() is "TOUPPER" or "TOLOWER" + ? (false, columnNameResolver.GetColumnName(inner.Parameters.First())) + : (true, columnNameResolver.GetColumnName(nodes[0])); } private static bool ConvertToDateTimeUTC(string dateTimeString, out DateTime? dateTime) @@ -311,7 +262,7 @@ private object GetConstantValue(QueryNode node) return GetCollectionConstantValues(node as CollectionConstantNode); } - return null; + throw new NotSupportedException("A $filter function argument must be a literal"); } private IEnumerable GetCollectionConstantValues(CollectionConstantNode node) => @@ -334,6 +285,15 @@ private IEnumerable GetCollectionConstantValues(CollectionConstantNode n } }); + private static BinaryOperatorKind Mirror(BinaryOperatorKind kind) => kind switch + { + BinaryOperatorKind.GreaterThan => BinaryOperatorKind.LessThan, + BinaryOperatorKind.GreaterThanOrEqual => BinaryOperatorKind.LessThanOrEqual, + BinaryOperatorKind.LessThan => BinaryOperatorKind.GreaterThan, + BinaryOperatorKind.LessThanOrEqual => BinaryOperatorKind.GreaterThanOrEqual, + _ => kind, + }; + private static string GetOperatorString(BinaryOperatorKind operatorKind) => operatorKind switch { BinaryOperatorKind.Equal => "=", diff --git a/Tests/DynamicODataToSQL.Test/FilterShapeTests.cs b/Tests/DynamicODataToSQL.Test/FilterShapeTests.cs new file mode 100644 index 0000000..ea00ad7 --- /dev/null +++ b/Tests/DynamicODataToSQL.Test/FilterShapeTests.cs @@ -0,0 +1,71 @@ +namespace DynamicODataToSQL.Test; + +using System; +using System.Collections.Generic; + +using SqlKata.Compilers; + +using Xunit; + +public class FilterShapeTests +{ + private static readonly SqlServerCompiler Compiler = new() { UseLegacyPagination = false }; + + private static (string Sql, IDictionary Params) Convert(string option, string value) => + new ODataToSqlConverter(new TestsEdmModelBuilder(), Compiler) + .ConvertToSQL("Products", new Dictionary { [option] = value }, false, true); + + [Theory] + [InlineData("'Tea' eq Name", "SELECT * FROM [Products] WHERE [Products].[Name] = @p0", "Tea")] + [InlineData("5 lt TotalInventory", "SELECT * FROM [Products] WHERE [Products].[TotalInventory] > @p0", 5)] + [InlineData("10 ge TotalInventory", "SELECT * FROM [Products] WHERE [Products].[TotalInventory] <= @p0", 10)] + [InlineData("null eq Name", "SELECT * FROM [Products] WHERE [Products].[Name] IS NULL", null)] + [InlineData("Name eq Type", "SELECT * FROM [Products] WHERE [Products].[Name] = [Products].[Type]", null)] + [InlineData("not (Name eq Type)", "SELECT * FROM [Products] WHERE NOT [Products].[Name] = [Products].[Type]", null)] + [InlineData("not (Name eq 'Tea')", "SELECT * FROM [Products] WHERE NOT ([Products].[Name] = @p0)", "Tea")] + public void SupportedShape_EmitsPredicate(string filter, string expectedSql, object? expectedParam) + { + var (sql, parameters) = Convert("filter", filter); + + Assert.Equal(expectedSql, sql, ignoreCase: true, ignoreWhiteSpaceDifferences: true); + if (expectedParam is null) + Assert.Empty(parameters); + else + Assert.Equal(expectedParam, Assert.Single(parameters).Value); + } + + [Theory] + [InlineData("1 eq 1")] + [InlineData("Name eq 'x' or 1 eq 1")] + [InlineData("not (1 eq 2)")] + [InlineData("1 add 1 eq 2")] + [InlineData("TotalInventory add 1 gt 100")] + [InlineData("-TotalInventory lt 0")] + [InlineData("not (-TotalInventory lt 0)")] + [InlineData("length('abc') eq 3")] + [InlineData("not (length('abc') eq 3)")] + [InlineData("length(Name) eq 3")] + [InlineData("trim(Name) eq 'x'")] + [InlineData("contains('abc', Name)")] + [InlineData("contains(Name, Type)")] + [InlineData("Id gt 0 and not (TotalInventory sub 1 eq 0)")] + public void UnsupportedFilter_Throws(string filter) => + Assert.Throws(() => Convert("filter", filter)); + + [Theory] + [InlineData("1")] + [InlineData("length(Name)")] + public void UnsupportedOrderBy_Throws(string orderby) => + Assert.Throws(() => Convert("orderby", orderby)); + + [Fact] + public void Not_LeavesNoNegationForLaterPredicates() + { + var query = new ODataToSqlConverter(new TestsEdmModelBuilder(), Compiler) + .ConvertToSQLKataQuery("Products", new Dictionary { ["filter"] = "not (Name eq 'Tea')" }, false, true); + + var sql = Compiler.Compile(query.Where("Products.Origin", "NL")).Sql; + + Assert.EndsWith("AND [Products].[Origin] = @p1", sql); + } +}