Make Group work with Iterable and IterableWithSize (#7)

Author: tkilias

.gitignore

@@ -130,3 +130,6 @@ dmypy.json
 
 # Poetry
 poetry.lock
+
+# PyCharm
+.idea

exasol_udf_mock_python/group.py

@@ -1,16 +1,65 @@
-from typing import List, Tuple
+import collections.abc
+from abc import abstractmethod
+from typing import List, Tuple, Iterable, Set, Iterator
 
 
-class Group:
+class IterableWithSize(collections.abc.Iterable):
+    @abstractmethod
+    def __len__(self):
+        return None
+
+
+class Group(collections.abc.Iterable):
     """
-    Reperesents a Group (SET Function) or a Batch (Scalar Function) of rows
+    Represents a Group (SET Function) or a Batch (Scalar Function) of rows
     """
 
-    def __init__(self, rows:List[Tuple]):
-        self.rows = rows
+    def __init__(self, rows: Iterable[Tuple]):
+        self._rows = rows
+
+    def __iter__(self):
+        return iter(self._rows)
+
+    def __len__(self):
+        if isinstance(self._rows, (List, Set, Tuple, IterableWithSize)):
+            return len(self._rows)
+        else:
+            return sum(1 for _ in self._rows)
+
+    @property
+    def rows(self) -> List[Tuple]:
+        """
+        This property transforms the Iterable of rows into a List
+        None: This can potentially can cause the materialization of a large list.
+        :return: The rows of this group as a list
+        """
+        return list(iter(self._rows))
 
     def __repr__(self):
         return str(self.__class__) + ": " + str(self.__dict__)
 
-    def __eq__(self, other):
-        return self.__dict__ == other.__dict__
+    def __eq__(self, other: "Group"):
+        if not isinstance(other, Group):
+            return False
+        self_iter = iter(self)
+        other_iter = iter(other)
+        return self._compare_iter(self_iter, other_iter)
+
+    def _compare_iter(self, self_iter: Iterator[Tuple], other_iter: Iterator[Tuple]):
+        self_at_end = False
+        try:
+            while True:
+                try:
+                    self_row = next(self_iter)
+                except StopIteration as e:
+                    self_at_end = True
+                    break
+                other_row = next(other_iter)
+                if self_row != other_row:
+                    return False
+            other_row = next(other_iter)
+        except StopIteration as e:
+            if self_at_end:
+                return True
+            else:
+                return False

exasol_udf_mock_python/mock_context.py

@@ -14,8 +14,10 @@ def __init__(self, input_groups: Iterator[Group], metadata: MockMetaData):
         self._input_groups = input_groups
         self._output_groups = []
         self._input_group = None  # type: Group
+        self._output_group_list = None # type: List
         self._output_group = None  # type: Group
         self._iter = None  # type: Iterator[Tuple]
+        self._len = None # type: int
         self._metadata = metadata
         self._name_position_map = \
             {column.name: position
@@ -27,19 +29,25 @@ def _next_group(self):
             self._input_group = next(self._input_groups)
         except StopIteration as e:
             self._data = None
+            self._output_group_list = None
             self._output_group = None
             self._input_group = None
             self._iter = None
+            self._len = None
             return False
-        if len(self._input_group.rows) == 0:
+        self._len = len(self._input_group)
+        if self._len == 0:
             self._data = None
+            self._output_group_list = None
             self._output_group = None
             self._input_group = None
             self._iter = None
+            self._len = None
             raise RuntimeError("Empty input groups are not allowd")
-        self._output_group = Group([])
+        self._output_group_list = []
+        self._output_group = Group(self._output_group_list)
         self._output_groups.append(self._output_group)
-        self._iter = iter(self._input_group.rows)
+        self._iter = iter(self._input_group)
         self.next()
         return True
 
@@ -80,10 +88,10 @@ def next(self, reset:bool = False):
                 return False
 
     def size(self):
-        return len(self._input_group.rows)
+        return self._len
 
     def reset(self):
-        self._iter = iter(self._input_group.rows)
+        self._iter = iter(self._input_group)
         self.next()
 
     def emit(self, *args):
@@ -93,7 +101,7 @@ def emit(self, *args):
             tuples = [args]
         for row in tuples:
             self.validate_tuples(row, self._metadata.output_columns)
-        self._output_group.rows.extend(tuples)
+        self._output_group_list.extend(tuples)
         return
 
     def validate_tuples(self, row: Tuple, columns: List[Column]):

exasol_udf_mock_python/udf_mock_executor.py

@@ -58,7 +58,10 @@ def _exec_init(self, exa_environment: MockExaEnvironment) -> Dict[str, Any]:
         exec(codeObject, exec_globals)
         return exec_globals
 
-    def run(self, input_groups:Union[Iterator[Group],List[Group]], exa_environment: MockExaEnvironment):
+    def run(self,
+            input_groups:Union[Iterator[Group],List[Group]],
+            exa_environment: MockExaEnvironment)\
+            ->List[Group]:
         with self._lock:
             if isinstance(input_groups,Iterator):
                 ctx = MockContext(input_groups, exa_environment.meta)

tests/test_group.py

@@ -0,0 +1,69 @@
+from collections import Iterable
+
+from exasol_udf_mock_python.group import Group, IterableWithSize
+
+
+def test_groups_are_equal():
+    group1 = Group([(1,), (2,), (3,)])
+    group2 = Group([(1,), (2,), (3,)])
+    assert group1 == group2
+
+
+def test_group_prefix_equal_but_first_group_is_longer():
+    group1 = Group([(1,), (2,), (3,), (4,)])
+    group2 = Group([(1,), (2,), (3,)])
+    assert group1 != group2
+
+
+def test_group_prefix_equal_but_second_group_is_longer():
+    group1 = Group([(1,), (2,), (3,)])
+    group2 = Group([(1,), (2,), (3,), (4,)])
+    assert group1 != group2
+
+
+def test_group_same_length_difference_in_the_middle():
+    group1 = Group([(1,), (2,), (5,), (4,)])
+    group2 = Group([(1,), (2,), (3,), (4,)])
+    assert group1 != group2
+
+
+def test_group_has_tuple_as_iterable_but_rows_is_list():
+    group = Group(((1,), (2,), (5,), (4,)))
+    assert group.rows == [(1,), (2,), (5,), (4,)]
+
+
+def test_group_len():
+    group = Group(((1,), (2,), (5,), (4,)))
+    assert len(group) == 4
+
+
+def test_group_iter():
+    group = Group(((1,), (2,), (5,), (4,)))
+    assert list(iter(group)) == [(1,), (2,), (5,), (4,)]
+
+
+class MyIterable(Iterable):
+    def __iter__(self):
+        return iter([(1,), (2,), (3,)])
+
+
+def test_group_with_custom_iterable_rows():
+    group = Group(MyIterable())
+    assert group.rows == [(1,), (2,), (3,)]
+
+
+def test_group_with_custom_iterable_len():
+    group = Group(MyIterable())
+    assert len(group) == 3
+
+
+def test_group_with_iterable_with_size_len():
+    class MyIterableWithSize(IterableWithSize):
+        def __iter__(self):
+            raise Exception("The group should use __len__ instead of __iter__ to determine the length")
+
+        def __len__(self):
+            return 3
+
+    group = Group(MyIterableWithSize())
+    assert len(group) == 3