Feature/5820 dataframe extend groupby

src/Microsoft.Data.Analysis/DataFrame.cs

@@ -367,6 +367,28 @@ public GroupBy GroupBy(string columnName)
             DataFrameColumn column = _columnCollection[columnIndex];
             return column.GroupBy(columnIndex, this);
         }
+
+        /// <summary>
+        /// Groups the rows of the <see cref="DataFrame"/> by unique values in the <paramref name="columnName"/> column.
+        /// </summary>
+        /// <typeparam name="TKey">Type of column used for grouping</typeparam>
+        /// <param name="columnName">The column used to group unique values</param>
+        /// <returns>A GroupBy object that stores the group information.</returns>
+        public GroupBy<TKey> GroupBy<TKey>(string columnName)
+        {
+            int columnIndex = _columnCollection.IndexOf(columnName);
+            if (columnIndex == -1)
+                throw new ArgumentException(String.Format(Strings.InvalidColumnName, columnName), nameof(columnName));
+
+            DataFrameColumn column = _columnCollection[columnIndex];
+
+            var group = column.GroupBy(columnIndex, this) as GroupBy<TKey>;
+
+            if (group == null)
+                throw new InvalidCastException(String.Format(Strings.BadColumnCast, columnName, column.DataType, typeof(TKey)));
+
+            return group;
+        }
 
         // In GroupBy and ReadCsv calls, columns get resized. We need to set the RowCount to reflect the true Length of the DataFrame. This does internal validation
         internal void SetTableRowCount(long rowCount)

src/Microsoft.Data.Analysis/GroupBy.cs

@@ -3,7 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Microsoft.Data.Analysis
 {
@@ -70,7 +72,7 @@ public abstract class GroupBy
         public abstract DataFrame Mean(params string[] columnNames);
     }
 
-    public class GroupBy<TKey> : GroupBy
+    public class GroupBy<TKey> : GroupBy 
     {
         private int _groupByColumnIndex;
         private IDictionary<TKey, ICollection<long>> _keyToRowIndicesMap;
@@ -464,5 +466,12 @@ public override DataFrame Mean(params string[] columnNames)
             return ret;
         }
 
+        public IEnumerable<IGrouping<TKey, DataFrameRow>> Groupings
+        {
+            get 
+            {
+                return _keyToRowIndicesMap.Select(kvp => new Grouping<TKey>(kvp.Key, kvp.Value.Select(index => _dataFrame.Rows[index]).ToArray()));
+            }
+        }
     }
 }

src/Microsoft.Data.Analysis/Grouping.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Microsoft.Data.Analysis
+{
+    public class Grouping<TKey> : IGrouping<TKey, DataFrameRow>
+    {
+        private readonly TKey _key;
+        private readonly ICollection<DataFrameRow> _rows;
+
+        public Grouping(TKey key, ICollection<DataFrameRow> rows)
+        {
+            _key = key;
+            _rows = rows;
+        }
+
+        public TKey Key => _key;
+
+        public IEnumerator<DataFrameRow> GetEnumerator()
+        {
+            return _rows.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _rows.GetEnumerator();
+        }
+    }
+}

src/Microsoft.Data.Analysis/Strings.resx

@@ -120,6 +120,9 @@
   <data name="BadColumnCast" xml:space="preserve">
     <value>Cannot cast column holding {0} values to type {1}</value>
   </data>
+  <data name="BadColumnCastDuringGrouping" xml:space="preserve">
+    <value>Cannot cast elements of column '{0}' type of {1} to type {2} used as TKey in grouping </value>
+  </data>
   <data name="CannotParseWithDelimiters" xml:space="preserve">
     <value>Line {0} cannot be parsed with the current Delimiters.</value>
   </data>

test/Microsoft.Data.Analysis.Tests/DataFrameGroupByTests.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace Microsoft.Data.Analysis.Tests
+{
+    public class DataFrameGroupByTests
+    {
+        [Fact]
+        public void TestGroupingWithTKeyTypeofString()
+        {
+            int lenght = 11;
+
+            //Create test dataframe (numbers starting from 0 up to lenght)
+            DataFrame df = MakeTestDataFrame(lenght);
+
+            var grouping = df.GroupBy<string>("Parity").Groupings;
+
+            //Check groups count
+            Assert.Equal(2, grouping.Count());
+
+            //Check number of elements in each group
+            var oddGroup = grouping.Where(gr => gr.Key == "odd").FirstOrDefault();
+            Assert.NotNull(oddGroup);
+            Assert.Equal(lenght/2, oddGroup.Count());
+
+            var evenGroup = grouping.Where(gr => gr.Key == "even").FirstOrDefault();
+            Assert.NotNull(evenGroup);
+            Assert.Equal(lenght / 2 + lenght % 2, evenGroup.Count());
+
+            //Check corner cases
+            lenght = 0;
+            df = MakeTestDataFrame(lenght);
+            grouping = df.GroupBy<string>("Parity").Groupings;
+            Assert.Empty(grouping);
+
+            lenght = 1;
+            df = MakeTestDataFrame(lenght);
+            grouping = df.GroupBy<string>("Parity").Groupings;
+            Assert.Single(grouping);
+            Assert.Equal("even", grouping.First().Key);
+        }
+
+        [Fact]
+        public void TestGroupingWithTKeyPrimitiveType()
+        {
+            const int lenght = 55;
+
+            //Create test dataframe (numbers starting from 0 up to lenght)
+            DataFrame df = MakeTestDataFrame(lenght);
+
+            //Group elements by int column, that contain the amount of full tens in each int
+            var groupings = df.GroupBy<int>("Tens").Groupings.ToDictionary(g => g.Key, g => g.ToList());
+
+            //Get the amount of all number based columns
+            int numberColumnsCount = df.Columns.Count - 2; //except "Parity" and "Tens" columns
+
+            //Check each group
+            for (int i = 0; i < lenght / 10; i++)
+            {
+                Assert.Equal(10, groupings[i].Count());
+
+                var rows = groupings[i];
+                for (int colIndex = 0; colIndex < numberColumnsCount; colIndex++)
+                {
+                    var values = rows.Select(row => Convert.ToInt32(row[colIndex]));
+
+                    for (int j = 0; j < 10; j++)
+                    {
+                        Assert.Contains(i * 10 + j, values);
+                    }
+                }
+            }
+
+            //Last group should contain smaller amount of items
+            Assert.Equal(lenght % 10, groupings[lenght / 10].Count());
+        }
+
+        [Fact]
+        public void TestGroupingWithTKeyOfWrongType()
+        {
+            const int lenght = 5;
+
+            var message = string.Empty;
+
+            //Create test dataframe (numbers starting from 0 up to lenght)
+            DataFrame df = MakeTestDataFrame(lenght);
+
+            //Use wrong type for grouping
+            Assert.Throws<InvalidCastException>(() => df.GroupBy<double>("Tens"));
+        }
+
+
+        private DataFrame MakeTestDataFrame(int length)
+        {
+            DataFrame df = DataFrameTests.MakeDataFrameWithNumericColumns(length, false);
+            DataFrameColumn parityColumn = new StringDataFrameColumn("Parity", Enumerable.Range(0, length).Select(x => x % 2 == 0 ? "even" : "odd"));
+            DataFrameColumn tensColumn = new Int32DataFrameColumn("Tens", Enumerable.Range(0, length).Select(x => x / 10));
+            df.Columns.Insert(df.Columns.Count, parityColumn);
+            df.Columns.Insert(df.Columns.Count, tensColumn);
+
+            return df;
+        }
+    }
+}