Trim up Decimal comparison

datatypes/mcs_decimal.cpp

@@ -15,13 +15,10 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
    MA 02110-1301, USA. */
 
-#include <functional>
 #include <string>
 
 #include "utils/common/branchpred.h"
 #include "mcs_decimal.h"
-#include "exceptclasses.h"
-#include "dataconvert.h"
 
 namespace datatypes
 {
@@ -31,19 +28,16 @@ namespace datatypes
         int128_t quot;
         int128_t rem;
         lldiv_t_128() : quot(0), rem(0) {}
+        lldiv_t_128(const int128_t& a_quot, const int128_t& a_rem)
+            : quot(a_quot), rem(a_rem) {}
     };
 
     inline lldiv_t_128 lldiv128(const int128_t& dividend, const int128_t& divisor)
     {
-        lldiv_t_128 res;
-
         if (UNLIKELY(divisor == 0) || UNLIKELY(dividend == 0))
-            return res;
+            return lldiv_t_128();
 
-        res.quot = dividend / divisor;
+        return lldiv_t_128(dividend / divisor, dividend % divisor);
-        res.rem = dividend % divisor;
-
-        return res;
     }
 
     template<typename BinaryOperation,

datatypes/mcs_decimal.h

@@ -21,6 +21,7 @@
 #include <cstdint>
 #include <cfloat>
 #include <limits>
+#include <functional>
 #include "mcs_basic_types.h"
 #include "exceptclasses.h"
 #include "widedecimalutils.h"
@@ -441,226 +442,97 @@ class Decimal: public TSInt128
             return (std::get<0>(integralFractionalDivisor) % div.getValue()) * std::get<2>(integralFractionalDivisor) + std::get<1>(integralFractionalDivisor);
         }
 
-        bool operator==(const Decimal& rhs) const
+        template<typename Op128, typename Op64>
+        bool cmpOperatorTemplate(const Decimal& rhs) const
         {
+            Op128 op128;
+            Op64 op64;
             if (precision > datatypes::INT64MAXPRECISION &&
                 rhs.precision > datatypes::INT64MAXPRECISION)
             {
                 if (scale == rhs.scale)
-                    return s128Value == rhs.s128Value;
+                    return op128(s128Value, rhs.s128Value);
                 else
-                    return (datatypes::Decimal::compare(*this, rhs) == 0);
+                    return op64(datatypes::Decimal::compare(*this, rhs), 0);
             }
             else if (precision > datatypes::INT64MAXPRECISION &&
                      rhs.precision <= datatypes::INT64MAXPRECISION)
             {
-                const_cast<Decimal&>(rhs).s128Value = rhs.value;
 
                 if (scale == rhs.scale)
-                    return s128Value == rhs.s128Value;
+                {
+                    return op128(s128Value, rhs.s128Value);
+                }
                 else
-                    return (datatypes::Decimal::compare(*this, rhs) == 0);
+                {
+                    // comp_op<int64>(compare(l,r),0)
+                    return op64(datatypes::Decimal::compare(
+                                    *this, 
+                                    Decimal(TSInt128(rhs.value),
+                                            rhs.scale,
+                                            rhs.precision)),
+                           0);
+                }
             }
             else if (precision <= datatypes::INT64MAXPRECISION &&
                      rhs.precision > datatypes::INT64MAXPRECISION)
             {
                 if (scale == rhs.scale)
-                    return (int128_t) value == rhs.s128Value;
+                {
+                    return op128((int128_t) value, rhs.s128Value);
+                }
                 else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) == 0);
+                {
+                    // comp_op<int64>(compare(l,r),0)
+                    return op64(datatypes::Decimal::compare(
+                                    Decimal(
+                                        TSInt128(value),
+                                        scale,
+                                        precision),
+                                    rhs),
+                           0);
+                }
             }
             else
             {
                 if (scale == rhs.scale)
-                    return value == rhs.value;
+                    return op64(value, rhs.value);
                 else
-                    return (decimalComp(rhs) == 0);
+                    return op64(decimalComp(rhs), 0);
             }
         }
 
+        bool operator==(const Decimal& rhs) const
+        {
+            return cmpOperatorTemplate<std::equal_to<int128_t>,
+                                       std::equal_to<int64_t>>(rhs);
+        }
+
         bool operator>(const Decimal& rhs) const
         {
-            if (precision > datatypes::INT64MAXPRECISION &&
+            return cmpOperatorTemplate<std::greater<int128_t>,
-                rhs.precision > datatypes::INT64MAXPRECISION)
+                                       std::greater<int64_t>>(rhs);
-            {
-                if (scale == rhs.scale)
-                    return s128Value > rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhs) > 0);
-            }
-            else if (precision > datatypes::INT64MAXPRECISION &&
-                     rhs.precision <= datatypes::INT64MAXPRECISION)
-            {
-                Decimal rhstmp(0, rhs.scale, rhs.precision, (int128_t) rhs.value);
-
-                if (scale == rhstmp.scale)
-                    return s128Value > rhstmp.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhstmp) > 0);
-            }
-            else if (precision <= datatypes::INT64MAXPRECISION &&
-                     rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return (int128_t) value > rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) > 0);
-            }
-            else
-            {
-                if (scale == rhs.scale)
-                    return value > rhs.value;
-                else
-                    return (decimalComp(rhs) > 0);
-            }
-        }
-
-        bool operator<(const Decimal& rhs) const
-        {
-            if (precision > datatypes::INT64MAXPRECISION &&
-                rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return s128Value < rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhs) < 0);
-            }
-            else if (precision > datatypes::INT64MAXPRECISION &&
-                     rhs.precision <= datatypes::INT64MAXPRECISION)
-            {
-                Decimal rhstmp(0, rhs.scale, rhs.precision, (int128_t) rhs.value);
-
-                if (scale == rhstmp.scale)
-                    return s128Value < rhstmp.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhstmp) < 0);
-            }
-            else if (precision <= datatypes::INT64MAXPRECISION &&
-                     rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return (int128_t) value < rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) < 0);
-            }
-            else
-            {
-                if (scale == rhs.scale)
-                    return value < rhs.value;
-                else
-                    return (decimalComp(rhs) < 0);
-            }
         }
 
         bool operator>=(const Decimal& rhs) const
         {
-            if (precision > datatypes::INT64MAXPRECISION &&
+            return cmpOperatorTemplate<std::greater_equal<int128_t>,
-                rhs.precision > datatypes::INT64MAXPRECISION)
+                                       std::greater_equal<int64_t>>(rhs);
-            {
+        }
-                if (scale == rhs.scale)
-                    return s128Value >= rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhs) >= 0);
-            }
-            else if (precision > datatypes::INT64MAXPRECISION &&
-                     rhs.precision <= datatypes::INT64MAXPRECISION)
-            {
-                Decimal rhstmp(0, rhs.scale, rhs.precision, (int128_t) rhs.value);
 
-                if (scale == rhstmp.scale)
+        bool operator<(const Decimal& rhs) const
-                    return s128Value >= rhstmp.s128Value;
+        {
-                else
+            return !this->operator>=(rhs);
-                    return (datatypes::Decimal::compare(*this, rhstmp) >= 0);
-            }
-            else if (precision <= datatypes::INT64MAXPRECISION &&
-                     rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return (int128_t) value >= rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) >= 0);
-            }
-            else
-            {
-                if (scale == rhs.scale)
-                    return value >= rhs.value;
-                else
-                    return (decimalComp(rhs) >= 0);
-            }
         }
 
         bool operator<=(const Decimal& rhs) const
         {
-            if (precision > datatypes::INT64MAXPRECISION &&
+            return !this->operator>(rhs);
-                rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return s128Value <= rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhs) <= 0);
-            }
-            else if (precision > datatypes::INT64MAXPRECISION &&
-                     rhs.precision <= datatypes::INT64MAXPRECISION)
-            {
-                Decimal rhstmp(0, rhs.scale, rhs.precision, (int128_t) rhs.value);
-
-                if (scale == rhstmp.scale)
-                    return s128Value <= rhstmp.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhstmp) <= 0);
-            }
-            else if (precision <= datatypes::INT64MAXPRECISION &&
-                     rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return (int128_t) value <= rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) <= 0);
-            }
-            else
-            {
-                if (scale == rhs.scale)
-                    return value <= rhs.value;
-                else
-                    return (decimalComp(rhs) <= 0);
-            }
         }
 
         bool operator!=(const Decimal& rhs) const
         {
-            if (precision > datatypes::INT64MAXPRECISION &&
+            return !this->operator==(rhs);
-                rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return s128Value != rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhs) != 0);
-            }
-            else if (precision > datatypes::INT64MAXPRECISION &&
-                     rhs.precision <= datatypes::INT64MAXPRECISION)
-            {
-                Decimal rhstmp(0, rhs.scale, rhs.precision, (int128_t) rhs.value);
-
-                if (scale == rhstmp.scale)
-                    return s128Value != rhstmp.s128Value;
-                else
-                    return (datatypes::Decimal::compare(*this, rhstmp) != 0);
-            }
-            else if (precision <= datatypes::INT64MAXPRECISION &&
-                     rhs.precision > datatypes::INT64MAXPRECISION)
-            {
-                if (scale == rhs.scale)
-                    return (int128_t) value != rhs.s128Value;
-                else
-                    return (datatypes::Decimal::compare(Decimal(0, scale, precision, (int128_t) value), rhs) != 0);
-            }
-            else
-            {
-                if (scale == rhs.scale)
-                    return value != rhs.value;
-                else
-                    return (decimalComp(rhs) != 0);
-            }
         }
 
         inline bool isTSInt128ByPrecision() const

tests/mcs_decimal-tests.cpp

@@ -23,63 +23,514 @@
 #include "mcs_decimal.h"
 #include "dataconvert.h"
 
-TEST(Decimal, compareCheck)
+TEST(Decimal, compareCheckInt64)
 {
-    // L values = R value, L scale < R scale
+    // remainder-based checks
-    execplan::IDB_Decimal l, r;
+    // Equality checks
-    l.scale = 20;
+    // l value = r value, L scale = R scale
-    l.precision = 38;
+    {
-    l.s128Value = 42;
+        datatypes::Decimal l(420, 10, 18);
+        datatypes::Decimal r(420, 10, 18);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
 
-    r.scale = 21;
+    // l value > r value, L scale < R scale
-    l.precision = 38;
+    {
-    r.s128Value = 420;
+        datatypes::Decimal l(420, 11, 18);
-    EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal r(42, 10, 18);
-    // L values = R value, L scale > R scale
+        EXPECT_TRUE(l == r);
-    l.scale = 21;
+        EXPECT_TRUE(l >= r);
-    l.precision = 38;
+    }
-    l.s128Value = 420;
 
-    r.scale = 20;
+    // l value < r value, L scale > R scale
-    l.precision = 38;
+    {
-    r.s128Value = 42;
+        datatypes::Decimal l(42, 10, 18);
-    EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal r(420, 11, 18);
-    // L values > R value, L scale < R scale
+        EXPECT_TRUE(l == r);
-    l.scale = 20;
+        EXPECT_TRUE(l >= r);
-    l.precision = 38;
+    }
-    l.s128Value = 999999;
 
-    r.scale = 21;
+    // Inequality checks
-    l.precision = 38;
+    // l value = r value, L scale < R scale
-    r.s128Value = 420;
+    {
-    EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal l(42, 10, 18);
-    // L values > R value, L scale > R scale
+        datatypes::Decimal r(42, 13, 18);
-    l.scale = 21;
+        EXPECT_TRUE(l > r);
-    l.precision = 38;
+        EXPECT_TRUE(l >= r);
-    l.s128Value = 99999999;
+        EXPECT_FALSE(l == r);
+    }
 
-    r.scale = 20;
+    // l value = r value, L scale < R scale
-    l.precision = 38;
+    {
-    r.s128Value = 420;
+        datatypes::Decimal l(42, 13, 18);
-    EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal r(42, 10, 18);
-    // L values < R value, L scale < R scale
+        EXPECT_FALSE(l > r);
-    l.scale = 20;
+        EXPECT_FALSE(l >= r);
-    l.precision = 38;
+        EXPECT_FALSE(l == r);
-    l.s128Value = 99;
+    }
 
-    r.scale = 21;
+    // l value > r value, L scale > R scale
-    l.precision = 38;
+    {
-    r.s128Value = 42000;
+        datatypes::Decimal l(420, 13, 18);
-    EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal r(42, 10, 18);
-    // L values < R value, L scale > R scale
+        EXPECT_FALSE(l > r);
-    l.scale = 21;
+        EXPECT_FALSE(l >= r);
-    l.precision = 38;
+        EXPECT_FALSE(l == r);
-    l.s128Value = 99;
+    }
 
-    r.scale = 20;
+    // l value > r value, L scale < R scale
-    l.precision = 38;
+    {
-    r.s128Value = 420;
+        datatypes::Decimal l(4200, 11, 18);
-    EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        datatypes::Decimal r(42, 12, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(99, 10, 18);
+        datatypes::Decimal r(420, 11, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(42, 10, 18);
+        datatypes::Decimal r(420, 13, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // quotinent-based checks
+    // l value = r value, L scale = R scale
+    {
+        datatypes::Decimal l(420, 1, 18);
+        datatypes::Decimal r(420, 1, 18);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(4200, 2, 18);
+        datatypes::Decimal r(420, 1, 18);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value < r value, L scale > R scale
+    {
+        datatypes::Decimal l(42, 0, 18);
+        datatypes::Decimal r(420, 1, 18);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // Inequality checks
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(42000, 0, 18);
+        datatypes::Decimal r(42000, 3, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(420000, 3, 18);
+        datatypes::Decimal r(420000, 0, 18);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale > R scale
+    {
+        datatypes::Decimal l(420000, 3, 18);
+        datatypes::Decimal r(42000, 0, 18);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(420000, 1, 18);
+        datatypes::Decimal r(4200, 2, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(990, 0, 18);
+        datatypes::Decimal r(4200, 1, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(420, 0, 18);
+        datatypes::Decimal r(4200, 3, 18);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+}
+
+TEST(Decimal, compareCheckInt128)
+{
+    // remainer-based checks
+    // Equality checks
+    // l value = r value, L scale = R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420), 20, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 20, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420), 21, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42), 20, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value < r value, L scale > R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42), 20, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 21, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // Inequality checks
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42), 20, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42), 23, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42), 23, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42), 20, 38);
+        EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale > R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420), 23, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42), 20, 38);
+        EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(4200), 21, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42), 22, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(99), 20, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 21, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42), 20, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 23, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // quotinent-based checks
+    // l value = r value, L scale = R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420), 1, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(4200), 2, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value < r value, L scale > R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42), 0, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_EQ(0, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // Inequality checks
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(42000), 0, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42000), 3, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420000), 3, 38);
+        datatypes::Decimal r(datatypes::TSInt128(420000), 0, 38);
+        EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale > R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420000), 3, 38);
+        datatypes::Decimal r(datatypes::TSInt128(42000), 0, 38);
+        EXPECT_EQ(-1, datatypes::Decimal::compare(l, r));
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420000), 1, 38);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 2, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(990), 0, 38);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 1, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(datatypes::TSInt128(420), 0, 38);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 3, 38);
+        EXPECT_EQ(1, datatypes::Decimal::compare(l, r));
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+}
+
+TEST(Decimal, compareCheckInt64_Int128)
+{
+    // remainer-based checks
+    // Equality checks
+    // l value = r value, L scale = R scale
+    {
+        datatypes::Decimal l(420, 10, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 10, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(420, 11, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42), 10, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value < r value, L scale > R scale
+    {
+        datatypes::Decimal l(42, 10, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 11, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // Inequality checks
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(42, 10, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42), 13, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(42, 13, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42), 10, 38);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale > R scale
+    {
+        datatypes::Decimal l(420, 13, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42), 10, 38);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(4200, 11, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42), 12, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(99, 10, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 11, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(42, 10, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 13, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // quotinent-based checks
+    // l value = r value, L scale = R scale
+    {
+        datatypes::Decimal l(420, 1, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(4200, 2, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // l value < r value, L scale > R scale
+    {
+        datatypes::Decimal l(42, 0, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420), 1, 38);
+        EXPECT_TRUE(l == r);
+        EXPECT_TRUE(l >= r);
+    }
+
+    // Inequality checks
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(42000, 0, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42000), 3, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value = r value, L scale < R scale
+    {
+        datatypes::Decimal l(420000, 3, 18);
+        datatypes::Decimal r(datatypes::TSInt128(420000), 0, 38);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale > R scale
+    {
+        datatypes::Decimal l(420000, 3, 18);
+        datatypes::Decimal r(datatypes::TSInt128(42000), 0, 38);
+        EXPECT_FALSE(l > r);
+        EXPECT_FALSE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value > r value, L scale < R scale
+    {
+        datatypes::Decimal l(420000, 1, 18);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 2, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(990, 0, 18);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 1, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
+
+    // l value < r value, L scale < R scale
+    {
+        datatypes::Decimal l(420, 0, 18);
+        datatypes::Decimal r(datatypes::TSInt128(4200), 3, 38);
+        EXPECT_TRUE(l > r);
+        EXPECT_TRUE(l >= r);
+        EXPECT_FALSE(l == r);
+    }
 }
 
 TEST(Decimal, additionNoOverflowCheck)