add validation for different precisions

Author: gridnevvvit

ydb/core/kqp/ut/query/kqp_query_ut.cpp

@@ -74,6 +74,58 @@ Y_UNIT_TEST_SUITE(KqpQuery) {
         UNIT_ASSERT_VALUES_EQUAL(counters.RecompileRequestGet()->Val(), 1);
     }
 
+    Y_UNIT_TEST_QUAD(DecimalOutOfPrecision, UseOltpSink, EnableParameterizedDecimal) {
+        TKikimrSettings serverSettings;
+        serverSettings.AppConfig.MutableTableServiceConfig()->SetEnableOltpSink(UseOltpSink);
+        serverSettings.FeatureFlags.SetEnableParameterizedDecimal(EnableParameterizedDecimal);
+        serverSettings.WithSampleTables = false;
+
+        TKikimrRunner kikimr(serverSettings);
+        auto client = kikimr.GetQueryClient();
+
+        {
+            auto ddlResult = client.ExecuteQuery(R"(
+                CREATE TABLE DecTest (
+                    Key Int32 NOT NULL,
+                    Value Decimal(22, 9) NOT NULL,
+                    PRIMARY KEY (Key)
+                );
+            )", NYdb::NQuery::TTxControl::NoTx()).ExtractValueSync();
+            UNIT_ASSERT_C(ddlResult.IsSuccess(), ddlResult.GetIssues().ToString());
+        }
+
+        // 10000000000000 in Decimal(35, 9), invalid for Decimal(22, 9)
+        Ydb::Value value;
+        value.set_low_128(1864712049423024128);
+        value.set_high_128(542);
+        auto invalidValue = TDecimalValue(value, NYdb::TDecimalType(22, 9));
+
+        {
+            auto params = TParamsBuilder()
+                .AddParam("$value").Decimal(invalidValue).Build()
+                .Build();
+
+            auto writeResult = client.ExecuteQuery(R"(
+                UPSERT INTO DecTest (Key, Value) VALUES
+                    (1, CAST(10 AS Decimal(22,9))),
+                    (2, $value),
+                    (3, $value - CAST(1 AS Decimal(22,9)));
+            )", NYdb::NQuery::TTxControl::BeginTx().CommitTx(), params).ExtractValueSync();
+
+            // TODO: Plan A, query should fail as provided value is invalid for given type.
+            UNIT_ASSERT_C(writeResult.IsSuccess(), writeResult.GetIssues().ToString());
+
+            // TODO: Plan B, value for key 2 should be inf, as provided value is out of range
+            // for given type.
+            auto session = kikimr.GetTableClient().CreateSession().GetValueSync().GetSession();
+            auto tableYson = ReadTableToYson(session, "/Root/DecTest");
+            CompareYson(R"([
+                [[1];["10"]];
+                [[2];["inf"]];
+                [[3];["inf"]]])", tableYson);
+        }
+    }
+
     Y_UNIT_TEST(QueryCache) {
         TKikimrRunner kikimr;
         auto db = kikimr.GetTableClient();

ydb/library/mkql_proto/mkql_proto.cpp

@@ -1628,7 +1628,22 @@ Y_FORCE_INLINE NUdf::TUnboxedValue KindDataImport(const TType* type, const Ydb::
             return MakeString(value.bytes_value());
         }
         case NUdf::TDataType<NUdf::TDecimal>::Id: {
-            return NUdf::TUnboxedValuePod(NYql::NDecimal::FromHalfs(value.low_128(), value.high_128()));
+            auto data = NYql::NDecimal::FromHalfs(value.low_128(), value.high_128());
+            auto dataType = static_cast<const TDataType*>(type);
+            auto schemeType = dataType->GetSchemeType();
+            if (schemeType != NYql::NProto::TypeIds::Decimal) {
+                throw yexception() << "Expected decimal type, but found " << schemeType;
+            }
+            auto decimalType = static_cast<const TDataDecimalType *>(dataType);
+            auto params = decimalType->GetParams();
+            ui8 precision = params.first;
+            Y_ENSURE(precision <= NYql::NDecimal::MaxPrecision, "Unsupported decimal precision: " << precision);
+            if (NYql::NDecimal::IsError(data)) {
+                throw yexception() << "Invalid Decimal value";
+            }
+            Y_ENSURE(NYql::NDecimal::IsNormal(precision, data),
+                "Invalid Decimal value out of the range for specified precision: " << precision);
+            return NUdf::TUnboxedValuePod(data);
         }
         default: {
             throw yexception() << "Unsupported data type: " << dataType->GetSchemeType();

yql/essentials/public/decimal/yql_decimal.cpp

@@ -4,10 +4,50 @@
 #include <ostream>
 #include <string>
 #include <charconv>
+#include <array>
 
 namespace NYql {
 namespace NDecimal {
 
+static constexpr std::array<std::pair<TInt128, TInt128>, MaxPrecision + 1> DecimalBounds = {
+    GetBounds<0>(),
+    GetBounds<1>(),
+    GetBounds<2>(),
+    GetBounds<3>(),
+    GetBounds<4>(),
+    GetBounds<5>(),
+    GetBounds<6>(),
+    GetBounds<7>(),
+    GetBounds<8>(),
+    GetBounds<9>(),
+    GetBounds<10>(),
+    GetBounds<11>(),
+    GetBounds<12>(),
+    GetBounds<13>(),
+    GetBounds<14>(),
+    GetBounds<15>(),
+    GetBounds<16>(),
+    GetBounds<17>(),
+    GetBounds<18>(),
+    GetBounds<19>(),
+    GetBounds<20>(),
+    GetBounds<21>(),
+    GetBounds<22>(),
+    GetBounds<23>(),
+    GetBounds<24>(),
+    GetBounds<25>(),
+    GetBounds<26>(),
+    GetBounds<27>(),
+    GetBounds<28>(),
+    GetBounds<29>(),
+    GetBounds<30>(),
+    GetBounds<31>(),
+    GetBounds<32>(),
+    GetBounds<33>(),
+    GetBounds<34>(),
+    GetBounds<35>(),
+};
+
 static const TUint128 Ten(10U);
 
 TUint128 GetDivider(ui8 scale) {
@@ -459,5 +499,12 @@ TInt128 MulAndDivNormalDivider(TInt128 a, TInt128 b, TInt128 c) {
     return Normalize(Div<false>(WidenMul(a, b), TInt256(c)));
 }
 
+bool IsNormal(ui8 precision, TInt128 v) {
+    if (precision >= DecimalBounds.size())
+        return false;
+    const auto& db = DecimalBounds[precision];
+    return v > db.first && v < db.second;
+}
+
 }
 }

yql/essentials/public/decimal/yql_decimal.h

@@ -73,6 +73,8 @@ inline bool IsNormal(TInt128 v) {
     return v > b.first && v < b.second;
 }
 
+inline bool IsNormal(ui8 precision, TInt128 v);
+
 const char* ToString(TInt128 v, ui8 precision, ui8 scale = 0);
 TInt128 FromString(const TStringBuf& str, ui8 precision, ui8 scale = 0);