added support for group by statement

Author: Robert Gelb

Conversion/SqlToElasticSearchConversion.cs

@@ -1,5 +1,6 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using SqlToElasticSearchConverter.Helpers;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -17,6 +18,58 @@ public SqlToElasticSearchConversion(string sqlQuery) {
         private void ProcessSqlQuery(string sqlQuery) {
             TSQLSelectStatement statement = TSQLStatementReader.ParseStatements(sqlQuery)[0] as TSQLSelectStatement;
 
+            if (statement.GroupBy == null) {
+                HandleSelectStatement(statement);
+            } else {
+                HandleGroupByStatement(statement);
+            }
+        }
+
+        private void HandleGroupByStatement(TSQLSelectStatement statement) {
+
+            var table = statement.From.Table().Index;
+            var conditions = statement.Where.Conditions();
+            var fields = statement.Select.Fields();
+
+            string tableStatement = $"GET {table}/_search";
+
+            #region Build Group By Statement
+            string groupByStatement = string.Empty;
+            const string nextAggregationMarker = "(addNextAggregationHere)";
+
+            foreach (var field in fields) {
+                string template = Templates.GroupBy.Replace("(column)", field.Column);
+
+                if (field == fields.Last()) {
+                    template = template.Replace("(additionalAggregation)", "");
+                } else {
+                    template = template.Replace("(additionalAggregation)", nextAggregationMarker);
+                }
+
+                if (groupByStatement.Contains(nextAggregationMarker)) {
+                    groupByStatement = groupByStatement.Replace(nextAggregationMarker, "," + Environment.NewLine + template);
+                } else {
+                    groupByStatement = template;
+                }
+            }
+            #endregion
+
+            List<string> conditionsList = GetConditionStatement(conditions);
+            string conditionsStatement = Templates.Conditions.Replace("(conditions)", string.Join(",", conditionsList));
+
+            string sizeStatement = Templates.SizeZero;
+
+            string jsonPortion = $@"{{
+                {sizeStatement},
+                {groupByStatement},
+                {conditionsStatement}
+            }}".PrettyJson();
+
+            // set module level variable
+            ElasticQuery = $"{tableStatement}{Environment.NewLine}{jsonPortion}";
+        }
+
+        private void HandleSelectStatement(TSQLSelectStatement statement) {
             var table = statement.From.Table().Index;
             var conditions = statement.Where.Conditions();
             var fields = statement.Select.Fields();
@@ -33,6 +86,22 @@ private void ProcessSqlQuery(string sqlQuery) {
                 fieldStatement = ", \"_source\": [" + fieldStatement + "]";
             }
 
+            List<string> conditionsList = GetConditionStatement(conditions);
+            string conditionsStatement = Templates.Conditions.Replace("(conditions)", string.Join(",", conditionsList));
+
+            string jsonPortion = $@"{{
+                {conditionsStatement}
+                {fieldStatement}
+            }}";
+
+            // format JSON
+            jsonPortion = JToken.Parse(jsonPortion).ToString(Formatting.Indented);
+
+            // set module level variable
+            ElasticQuery = $"{tableStatement}{Environment.NewLine}{jsonPortion}";
+        }
+
+        private static List<string> GetConditionStatement(List<WhereCondition> conditions) {
             // get the conditions statement
             string conditionText = string.Empty;
             var conditionsList = new List<string>();
@@ -87,25 +156,15 @@ private void ProcessSqlQuery(string sqlQuery) {
                                                     .Replace("(value)", condition.SingularValue.Replace("%", "*").ToLower());
 
                         break;
-                            
+
                     case WhereCondition.OperatorType.Unknown:
                         break;
                 }
 
                 conditionsList.Add(conditionText);
             }
-            string conditionsStatement = Templates.Conditions.Replace("(conditions)", string.Join(",", conditionsList));
 
-            string jsonPortion = $@"{{
-                {conditionsStatement}
-                {fieldStatement}
-            }}";
-
-            // format JSON
-            jsonPortion = JToken.Parse(jsonPortion).ToString(Formatting.Indented);
-
-            // set module level variable
-            ElasticQuery = $"{tableStatement}{Environment.NewLine}{jsonPortion}";
+            return conditionsList;
         }
 
         public string ElasticQuery { get; set; } = string.Empty;

Conversion/Templates.cs

@@ -62,5 +62,14 @@ public class Templates {
                     ]
                 }
             }";
+
+        public const string GroupBy = @"
+              ""aggregations"": {
+                ""(column)"": {
+                  ""terms"": { ""field"": ""(column).keyword"" }(additionalAggregation)
+                }
+              }";
+
+        public static string SizeZero => @"""size"": 0";
     }
 }

Helpers/Extentions.cs

@@ -0,0 +1,12 @@
+using Newtonsoft.Json;
+
+namespace SqlToElasticSearchConverter.Helpers
+{
+    public static class Extentions
+    {
+        public static string PrettyJson(this string jsonString) {
+            dynamic parsedJson = JsonConvert.DeserializeObject(jsonString);
+            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
+        }
+    }
+}

README.md

@@ -7,10 +7,11 @@
 This quickie app converts SQL statements into ElasticSearch equivalent queries.  Note that the converter is very much a work in progress, and as such, doesn't support great many things.
 
 ## What works
-At the moment the application supports SELECT, FROM, WHERE statements.  
+At the moment the application supports SELECT, FROM, WHERE, GROUP BY statements.  
 For SELECT, you can either place * or specify column names.
 The FROM statement works with either aliases or indexes.  
-The WHERE conditions support a subset of operators: =, >, >=, <, <=, IN, BETWEEN 
+The WHERE conditions support a subset of operators: =, >, >=, <, <=, IN, BETWEEN
+The GROUP BY statement only supports column names.  Functions such as COUNT(*) will cause the translation to fail
 
 Examples:
 ```sql
@@ -30,11 +31,16 @@ FROM Planets
 WHERE SpacecraftWithinKilometers < 10000
 ```
 
+```sql
+SELECT SolarSystem, Galaxy
+FROM Planets
+WHERE SpacecraftWithinKilometers < 10000
+GROUP BY SolarSystem, Galaxy
+```
 
 ## What doesn't work yet
 + Inequality operator (!=)
 + LIKE operator
-+ Grouping and Aggregations
 + Sorting
 + Joins (because ElasticSearch doesn't support them)
 + Common SQL functions like GetDate, DateDiff, etc are not supported yet