feat: support some linq string functions in where conditions, fixes i…

…nfluxdata#499
jogibear9988 · Jul 14, 2023 · 4c6f9f2 · 4c6f9f2
1 parent 44574e0
commit 4c6f9f2
Show file tree

Hide file tree

Showing 11 changed files with 306 additions and 1 deletion.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,7 +1,8 @@
 ## 4.13.0 [unreleased]
 
 ### Features
-1. [#528](https://github.com/influxdata/influxdb-client-csharp/pull/528): Add HttpClient as a part of InfluxDBClientOptions
+  - [#528](https://github.com/influxdata/influxdb-client-csharp/pull/528): Add HttpClient as a part of InfluxDBClientOptions
+  - [#500](https://github.com/influxdata/influxdb-client-csharp/pull/500): Support String functions in Linq
 
 ### Dependencies
 Update dependencies:

diff --git a/Client.Linq.Test/InfluxDBQueryVisitorTest.cs b/Client.Linq.Test/InfluxDBQueryVisitorTest.cs
@@ -38,6 +38,48 @@ public void InitQueryApi()
             _queryApi = new Mock<QueryApiSync>(options, queryService.Object, new FluxResultMapper()).Object;
         }
 
+        [Test]
+        public void StringFunctionsQuery()
+        {
+            var query = from s in InfluxDBQueryable<Sensor>.Queryable("my-bucket", "my-org", _queryApi)
+                where s.SensorId.ToLower().Contains("aaa")
+                select s;
+            var visitor = BuildQueryVisitor(query);
+
+            const string expected =
+                "import \"strings\"\nstart_shifted = int(v: time(v: p2))\n\nfrom(bucket: p1) |> range(start: time(v: start_shifted)) |> filter(fn: (r) => strings.containsStr(v: strings.toLower(v: r[\"sensor_id\"]), substr: p3)) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\") |> drop(columns: [\"_start\", \"_stop\", \"_measurement\"]) |> filter(fn: (r) => strings.containsStr(v: strings.toLower(v: r[\"sensor_id\"]), substr: p3))";
+            var qry = visitor.BuildFluxQuery();
+            Assert.AreEqual(expected, visitor.BuildFluxQuery());
+        }
+
+        [Test]
+        public void ToStringFunctionQuery()
+        {
+            var query = from s in InfluxDBQueryable<Sensor>.Queryable("my-bucket", "my-org", _queryApi)
+                where s.Value.ToString() == "3"
+                select s;
+            var visitor = BuildQueryVisitor(query);
+
+            const string expected =
+                "start_shifted = int(v: time(v: p2))\n\nfrom(bucket: p1) |> range(start: time(v: start_shifted)) |> filter(fn: (r) => (string(v: r[\"data\"]) == p3)) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\") |> drop(columns: [\"_start\", \"_stop\", \"_measurement\"]) |> filter(fn: (r) => (string(v: r[\"data\"]) == p3))";
+            var qry = visitor.BuildFluxQuery();
+            Assert.AreEqual(expected, visitor.BuildFluxQuery());
+        }
+
+        [Test]
+        public void ReplaceAllFunctionQuery()
+        {
+            var query = from s in InfluxDBQueryable<Sensor>.Queryable("my-bucket", "my-org", _queryApi)
+                where s.SensorId.ToLower().Replace("a", "b") == "b"
+                select s;
+            var visitor = BuildQueryVisitor(query);
+
+            const string expected =
+                "import \"strings\"\nstart_shifted = int(v: time(v: p2))\n\nfrom(bucket: p1) |> range(start: time(v: start_shifted)) |> filter(fn: (r) => (strings.replaceAll(v: strings.toLower(v: r[\"sensor_id\"]), t: p3, u: p4) == p5)) |> pivot(rowKey:[\"_time\"], columnKey: [\"_field\"], valueColumn: \"_value\") |> drop(columns: [\"_start\", \"_stop\", \"_measurement\"]) |> filter(fn: (r) => (strings.replaceAll(v: strings.toLower(v: r[\"sensor_id\"]), t: p3, u: p4) == p5))";
+            var qry = visitor.BuildFluxQuery();
+            Assert.AreEqual(expected, visitor.BuildFluxQuery());
+        }
+
         [Test]
         public void DefaultQuery()
         {

diff --git a/Client.Linq/Internal/Expressions/String/Contains.cs b/Client.Linq/Internal/Expressions/String/Contains.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class Contains : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+        private readonly IEnumerable<IExpressionPart> expressionParts2;
+
+        internal Contains(IEnumerable<IExpressionPart> expressionParts, IEnumerable<IExpressionPart> expressionParts2)
+        {
+            this.expressionParts = expressionParts;
+            this.expressionParts2 = expressionParts2;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.containsStr(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(", substr: ");
+            foreach (var expressionPart in expressionParts2) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/EndsWith.cs b/Client.Linq/Internal/Expressions/String/EndsWith.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class EndsWith : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+        private readonly IEnumerable<IExpressionPart> expressionParts2;
+
+        internal EndsWith(IEnumerable<IExpressionPart> expressionParts, IEnumerable<IExpressionPart> expressionParts2)
+        {
+            this.expressionParts = expressionParts;
+            this.expressionParts2 = expressionParts2;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.hasSuffix(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(", suffix: ");
+            foreach (var expressionPart in expressionParts2) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/Replace.cs b/Client.Linq/Internal/Expressions/String/Replace.cs
@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class Replace : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+        private readonly IEnumerable<IExpressionPart> expressionParts2;
+        private readonly IEnumerable<IExpressionPart> expressionParts3;
+
+        internal Replace(IEnumerable<IExpressionPart> expressionParts, IEnumerable<IExpressionPart> expressionParts2,
+            IEnumerable<IExpressionPart> expressionParts3)
+        {
+            this.expressionParts = expressionParts;
+            this.expressionParts2 = expressionParts2;
+            this.expressionParts3 = expressionParts3;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.replaceAll(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(", t: ");
+            foreach (var expressionPart in expressionParts2) expressionPart.AppendFlux(builder);
+            builder.Append(", u: ");
+            foreach (var expressionPart in expressionParts3) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/StartsWith.cs b/Client.Linq/Internal/Expressions/String/StartsWith.cs
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class StartsWith : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+        private readonly IEnumerable<IExpressionPart> expressionParts2;
+
+        internal StartsWith(IEnumerable<IExpressionPart> expressionParts, IEnumerable<IExpressionPart> expressionParts2)
+        {
+            this.expressionParts = expressionParts;
+            this.expressionParts2 = expressionParts2;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.hasPrefix(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(", prefix: ");
+            foreach (var expressionPart in expressionParts2) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/ToLower.cs b/Client.Linq/Internal/Expressions/String/ToLower.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class ToLower : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+
+        internal ToLower(IEnumerable<IExpressionPart> expressionParts)
+        {
+            this.expressionParts = expressionParts;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.toLower(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/ToString.cs b/Client.Linq/Internal/Expressions/String/ToString.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class ToString : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+
+        internal ToString(IEnumerable<IExpressionPart> expressionParts)
+        {
+            this.expressionParts = expressionParts;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("string(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/Expressions/String/ToUpper.cs b/Client.Linq/Internal/Expressions/String/ToUpper.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace InfluxDB.Client.Linq.Internal.Expressions.String
+{
+    internal class ToUpper : IExpressionPart
+    {
+        private readonly IEnumerable<IExpressionPart> expressionParts;
+
+        internal ToUpper(IEnumerable<IExpressionPart> expressionParts)
+        {
+            this.expressionParts = expressionParts;
+        }
+
+        public void AppendFlux(StringBuilder builder)
+        {
+            builder.Append("strings.toUpper(v: ");
+            foreach (var expressionPart in expressionParts) expressionPart.AppendFlux(builder);
+            builder.Append(")");
+        }
+    }
+}
diff --git a/Client.Linq/Internal/QueryAggregator.cs b/Client.Linq/Internal/QueryAggregator.cs
@@ -65,6 +65,7 @@ internal class QueryAggregator
         private ResultFunction _resultFunction;
         private readonly List<string> _filterByTags;
         private readonly List<string> _filterByFields;
+        private HashSet<string> _imports;
         private readonly List<(string, string, bool, string)> _orders;
         private (string Every, string Period, string Fn)? _aggregateWindow;
 
@@ -74,6 +75,7 @@ internal QueryAggregator()
             _limitTailNOffsetAssignments = new List<LimitOffsetAssignment>();
             _filterByTags = new List<string>();
             _filterByFields = new List<string>();
+            _imports = null;
             _orders = new List<(string, string, bool, string)>();
             _aggregateWindow = null;
         }
@@ -83,6 +85,16 @@ internal void AddBucket(string bucket)
             _bucketAssignment = bucket;
         }
 
+        internal void AddImport(string import)
+        {
+            if (_imports == null)
+            {
+                _imports = new HashSet<string>();
+            }
+
+            _imports.Add(import);
+        }
+
         internal void AddRangeStart(string rangeStart, RangeExpressionType expressionType)
         {
             _rangeStartAssignment = rangeStart;
@@ -219,6 +231,7 @@ internal string BuildFluxQuery(QueryableOptimizerSettings settings)
 
             var query = new StringBuilder();
 
+            query.Append(BuildImports());
             query.Append(JoinList(transforms, "\n"));
             query.Append("\n\n");
             query.Append(JoinList(parts, " |> "));
@@ -334,6 +347,16 @@ private string BuildFilter(IEnumerable<string> filterBy)
             return filter.ToString();
         }
 
+        private string BuildImports()
+        {
+            if (_imports != null)
+            {
+                return string.Join("", _imports.Select(x => "import \"" + x + "\"\n"));
+            }
+
+            return string.Empty;
+        }
+
         private string BuildOperator(string operatorName, params object[] variables)
         {
             var builderVariables = new StringBuilder();

diff --git a/Client.Linq/Internal/QueryExpressionTreeVisitor.cs b/Client.Linq/Internal/QueryExpressionTreeVisitor.cs
@@ -5,6 +5,7 @@
 using InfluxDB.Client.Api.Domain;
 using InfluxDB.Client.Core;
 using InfluxDB.Client.Linq.Internal.Expressions;
+using InfluxDB.Client.Linq.Internal.Expressions.String;
 using Remotion.Linq.Clauses;
 using Remotion.Linq.Clauses.Expressions;
 using Remotion.Linq.Clauses.ResultOperators;
@@ -187,6 +188,62 @@ protected override Expression VisitMethodCall(MethodCallExpression expression)
                 return expression;
             }
 
+            if (expression.Method.DeclaringType == typeof(string))
+            {
+                _context.QueryAggregator.AddImport("strings");
+                var partsCount = _expressionParts.Count;
+                Visit(expression.Object);
+                var part = GetAndRemoveExpressionParts(partsCount, _expressionParts.Count);
+                IEnumerable<IExpressionPart> part2 = null;
+                IEnumerable<IExpressionPart> part3 = null;
+                if (expression.Arguments.Count > 0)
+                {
+                    partsCount = _expressionParts.Count;
+                    Visit(expression.Arguments[0]);
+                    part2 = GetAndRemoveExpressionParts(partsCount, _expressionParts.Count);
+                }
+
+                if (expression.Arguments.Count > 1)
+                {
+                    partsCount = _expressionParts.Count;
+                    Visit(expression.Arguments[1]);
+                    part3 = GetAndRemoveExpressionParts(partsCount, _expressionParts.Count);
+                }
+
+                switch (expression.Method.Name)
+                {
+                    case "ToLower":
+                        _expressionParts.Add(new ToLower(part));
+                        return expression;
+                    case "ToUpper":
+                        _expressionParts.Add(new ToUpper(part));
+                        return expression;
+                    case "Contains":
+                        _expressionParts.Add(new Contains(part, part2));
+                        return expression;
+                    case "StartsWith":
+                        _expressionParts.Add(new StartsWith(part, part2));
+                        return expression;
+                    case "EndsWith":
+                        _expressionParts.Add(new EndsWith(part, part2));
+                        return expression;
+                    case "Replace":
+                        _expressionParts.Add(new Replace(part, part2, part3));
+                        return expression;
+                }
+
+                throw new NotSupportedException(expression.Method.Name + " of String class is not yet supported.");
+            }
+
+            if (expression.Method.Name.Equals("ToString"))
+            {
+                var partsCount = _expressionParts.Count;
+                Visit(expression.Object);
+                var part = GetAndRemoveExpressionParts(partsCount, _expressionParts.Count);
+                _expressionParts.Add(new ToString(part));
+                return expression;
+            }
+
             return base.VisitMethodCall(expression);
         }
 
@@ -294,6 +351,13 @@ private void NormalizeNamedFieldValue()
             NormalizeNamedFieldValue();
         }
 
+        private IEnumerable<IExpressionPart> GetAndRemoveExpressionParts(int start, int end)
+        {
+            var parts = _expressionParts.GetRange(start, end - start);
+            for (var i = start; i < end; i++) _expressionParts.RemoveAt(i);
+            return parts;
+        }
+
         /// <summary>
         /// Mark variables that are use to filter by tag by tag as tag.
         /// </summary>