Feature/various improvements (#61)

* Fixed calling method with shortened syntax: found in query: select * from #flat.file('some/path') where Contains(Line, 'import') * Update test results badge [skip ci] 1. Reworked characters escaping 2. Add new string methods RegexReplace, StartsWith, EndsWith * Update test results badge [skip ci] * raised up libs --------- Co-authored-by: github-actions <github-actions@github.com>
Puchaczov · Jul 19, 2024 · 35c368f · 35c368f
1 parent 41a3f31
commit 35c368f
Show file tree

Hide file tree

Showing 17 changed files with 936 additions and 312 deletions.
diff --git a/Musoq.Converter/Musoq.Converter.csproj b/Musoq.Converter/Musoq.Converter.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <Version>3.0.1</Version>
+    <Version>3.0.2</Version>
     <Authors>Jakub Puchała</Authors>
     <Product>Musoq</Product>
     <PackageProjectUrl>https://github.com/Puchaczov/Musoq</PackageProjectUrl>

diff --git a/Musoq.Evaluator.Tests/ColumnsTests.cs b/Musoq.Evaluator.Tests/ColumnsTests.cs
@@ -224,7 +224,7 @@ public void WhenObjectIsNotArrayAndIndexIsNotNumber_ShouldPass()
         var table = vm.Run();
 
         Assert.AreEqual(1, table.Columns.Count());
-        Assert.AreEqual("Self.Dictionary['AA']", table.Columns.ElementAt(0).ColumnName);
+        Assert.AreEqual("Self.Dictionary[AA]", table.Columns.ElementAt(0).ColumnName);
 
         Assert.AreEqual(1, table.Count);
 

diff --git a/Musoq.Evaluator.Tests/CreateTableTests.cs b/Musoq.Evaluator.Tests/CreateTableTests.cs
diff --git a/Musoq.Evaluator.Tests/JoinTests.cs b/Musoq.Evaluator.Tests/JoinTests.cs
@@ -251,7 +251,7 @@ public void JoinWithCaseWhenTest()
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(0).ColumnType);
             Assert.AreEqual(0, table.Columns.ElementAt(0).ColumnIndex);
 
-            Assert.AreEqual("case when population.Population >= 500 then 'big' else 'low' end", table.Columns.ElementAt(1).ColumnName);
+            Assert.AreEqual("case when population.Population >= 500 then big else low end", table.Columns.ElementAt(1).ColumnName);
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(1).ColumnType);
             Assert.AreEqual(1, table.Columns.ElementAt(1).ColumnIndex);
 

diff --git a/Musoq.Evaluator.Tests/MethodInvocationTests.cs b/Musoq.Evaluator.Tests/MethodInvocationTests.cs
@@ -35,4 +35,178 @@ public void MethodInvocationOnAliasFinishedWithNumber_ShouldPass()
         Assert.AreEqual(250m, table[3].Values[0]);
         Assert.AreEqual(350m, table[4].Values[0]);
     }
+
+    [TestMethod]
+    public void WhenNullableBooleanFieldWithFullSyntaxApplied_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W') = true";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
+
+    [TestMethod]
+    public void WhenNullableBooleanFieldWithShortenedSyntaxApplied_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W')";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
+
+    [TestMethod]
+    public void WhenNullableBooleanFields_ForBinaryOperator_WithFullSyntaxApplied_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W') = true and Contains(City, 'A') = true";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
+
+    [TestMethod]
+    public void WhenNullableBooleanFields_ForBinaryOperator_WithShortenedSyntaxApplied_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W') and Contains(City, 'A')";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
+
+    [TestMethod]
+    public void WhenNullableBooleanFields_ForBinaryOperator_WithMixedSyntaxApplied_FirstExpression_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W') = true and Contains(City, 'A')";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
+
+    [TestMethod]
+    public void WhenNullableBooleanFields_ForBinaryOperator_WithMixedSyntaxApplied_SecondExpression_ShouldPass()
+    {
+        var query = "select City from #A.entities() population2 where Contains(City, 'W') and Contains(City, 'A') = true";
+
+        var sources = new Dictionary<string, IEnumerable<BasicEntity>>
+        {
+            {
+                "#A", new[]
+                {
+                    new BasicEntity("WARSAW", "POLAND", 500),
+                    new BasicEntity("CZESTOCHOWA", "POLAND", 400),
+                    new BasicEntity("KATOWICE", "POLAND", 250),
+                    new BasicEntity("BERLIN", "GERMANY", 250),
+                    new BasicEntity("MUNICH", "GERMANY", 350)
+                }
+            }
+        };
+
+        var vm = CreateAndRunVirtualMachine(query, sources);
+        var table = vm.Run();
+
+        Assert.AreEqual(3, table.Count);
+
+        Assert.AreEqual("WARSAW", table[0].Values[0]);
+        Assert.AreEqual("CZESTOCHOWA", table[1].Values[0]);
+        Assert.AreEqual("KATOWICE", table[2].Values[0]);
+    }
 }
diff --git a/Musoq.Evaluator.Tests/SingleSchemaEvaluatorTests.cs b/Musoq.Evaluator.Tests/SingleSchemaEvaluatorTests.cs
@@ -299,7 +299,7 @@ public void CaseWhenWithEmptyStringTest()
             var table = vm.Run();
 
             Assert.AreEqual(1, table.Columns.Count());
-            Assert.AreEqual("case when 1 = 2 then 'test' else '' end", table.Columns.ElementAt(0).ColumnName);
+            Assert.AreEqual("case when 1 = 2 then test else  end", table.Columns.ElementAt(0).ColumnName);
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(0).ColumnType);
 
             Assert.AreEqual(string.Empty, table[0][0]);
@@ -325,7 +325,7 @@ public void CaseWhenWithNullTest()
             var table = vm.Run();
 
             Assert.AreEqual(1, table.Columns.Count());
-            Assert.AreEqual("case when 1 = 2 then 'test' else null end", table.Columns.ElementAt(0).ColumnName);
+            Assert.AreEqual("case when 1 = 2 then test else null end", table.Columns.ElementAt(0).ColumnName);
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(0).ColumnType);
 
             Assert.AreEqual(null, table[0][0]);
@@ -425,7 +425,7 @@ public void AddOperatorWithStringsTurnsIntoConcatTest()
             var table = vm.Run();
 
             Assert.AreEqual(1, table.Columns.Count());
-            Assert.AreEqual("'abc' + 'cda'", table.Columns.ElementAt(0).ColumnName);
+            Assert.AreEqual("abc + cda", table.Columns.ElementAt(0).ColumnName);
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(0).ColumnType);
 
             Assert.AreEqual(1, table.Count);
@@ -915,7 +915,7 @@ public void ColumnNamesSimpleTest()
             Assert.AreEqual("TestColumn", table.Columns.ElementAt(2).ColumnName);
             Assert.AreEqual(typeof(decimal), table.Columns.ElementAt(2).ColumnType);
 
-            Assert.AreEqual("GetTwo(4, 'test')", table.Columns.ElementAt(3).ColumnName);
+            Assert.AreEqual("GetTwo(4, test)", table.Columns.ElementAt(3).ColumnName);
             Assert.AreEqual(typeof(string), table.Columns.ElementAt(3).ColumnType);
         }