Fix.

Author: ueshin

databricks/koalas/frame.py

@@ -649,8 +649,8 @@ def _reduce_for_stat_function(self, sfun, name, axis=None, numeric_only=True, mi
 
                     if min_count > 0:
                         scol = F.when(
-                            Frame._count_expr(spark_column, spark_type) < min_count, F.lit(np.nan)
-                        ).otherwise(scol)
+                            Frame._count_expr(spark_column, spark_type) >= min_count, scol
+                        )
 
                     exprs.append(scol.alias(name_like_string(label)))
                     new_column_labels.append(label)

databricks/koalas/generic.py

@@ -1211,7 +1211,7 @@ def sum(spark_column, spark_type):
                 spark_column = spark_column.cast(LongType())
             elif not isinstance(spark_type, NumericType):
                 raise TypeError("Could not convert {} to numeric".format(spark_type.simpleString()))
-            return F.sum(spark_column)
+            return F.coalesce(F.sum(spark_column), F.lit(0))
 
         return self._reduce_for_stat_function(
             sum, name="sum", axis=axis, numeric_only=numeric_only, min_count=min_count

databricks/koalas/series.py

@@ -5859,11 +5859,10 @@ def _reduce_for_stat_function(self, sfun, name, axis=None, numeric_only=None, mi
             scol = sfun(spark_column, spark_type)
 
         if min_count > 0:
-            scol = F.when(
-                Frame._count_expr(spark_column, spark_type) < min_count, F.lit(np.nan)
-            ).otherwise(scol)
+            scol = F.when(Frame._count_expr(spark_column, spark_type) >= min_count, scol)
 
-        return unpack_scalar(self._internal.spark_frame.select(scol))
+        result = unpack_scalar(self._internal.spark_frame.select(scol))
+        return result if result is not None else np.nan
 
     def __getitem__(self, key):
         try:

databricks/koalas/testing/utils.py

@@ -264,6 +264,8 @@ def assert_eq(self, left, right, check_exact=True, almost=False):
             self.assertTrue(len(left) == len(right))
             for litem, ritem in zip(left, right):
                 self.assert_eq(litem, ritem, check_exact=check_exact, almost=almost)
+        elif (lobj is not None and pd.isna(lobj)) and (robj is not None and pd.isna(robj)):
+            pass
         else:
             if almost:
                 self.assertAlmostEqual(lobj, robj)

databricks/koalas/tests/test_stats.py

@@ -53,6 +53,10 @@ def test_stat_functions(self):
         self._test_stat_functions(pdf.A, kdf.A)
         self._test_stat_functions(pdf, kdf)
 
+        # empty
+        self._test_stat_functions(pdf.A.loc[[]], kdf.A.loc[[]])
+        self._test_stat_functions(pdf.loc[[]], kdf.loc[[]])
+
     def test_stat_functions_multiindex_column(self):
         arrays = [np.array(["A", "A", "B", "B"]), np.array(["one", "two", "one", "two"])]
         pdf = pd.DataFrame(np.random.randn(3, 4), index=["A", "B", "C"], columns=arrays)
@@ -70,6 +74,23 @@ def test_stat_functions_with_no_numeric_columns(self):
         kdf = ks.from_pandas(pdf)
         self._test_stat_functions(pdf, kdf)
 
+    def test_sum(self):
+        pdf = pd.DataFrame({"a": [1, 2, 3, np.nan], "b": [0.1, np.nan, 0.3, np.nan]})
+        kdf = ks.from_pandas(pdf)
+
+        self.assert_eq(kdf.sum(), pdf.sum())
+        self.assert_eq(kdf.sum(axis=1), pdf.sum(axis=1))
+        self.assert_eq(kdf.sum(min_count=3), pdf.sum(min_count=3))
+        self.assert_eq(kdf.sum(axis=1, min_count=1), pdf.sum(axis=1, min_count=1))
+        self.assert_eq(kdf.loc[[]].sum(), pdf.loc[[]].sum())
+        self.assert_eq(kdf.loc[[]].sum(min_count=1), pdf.loc[[]].sum(min_count=1))
+
+        self.assert_eq(kdf["a"].sum(), pdf["a"].sum())
+        self.assert_eq(kdf["a"].sum(min_count=3), pdf["a"].sum(min_count=3))
+        self.assert_eq(kdf["b"].sum(min_count=3), pdf["b"].sum(min_count=3))
+        self.assert_eq(kdf["a"].loc[[]].sum(), pdf["a"].loc[[]].sum())
+        self.assert_eq(kdf["a"].loc[[]].sum(min_count=1), pdf["a"].loc[[]].sum(min_count=1))
+
     def test_abs(self):
         pdf = pd.DataFrame(
             {