Replay cached timestamp & randoms (#9403)

Author: vitstn

ydb/library/yql/core/services/yql_eval_expr.cpp

@@ -973,7 +973,20 @@ IGraphTransformer::TStatus EvaluateExpression(const TExprNode::TPtr& input, TExp
             clonedArg = ctx.NewCallable(clonedArg->Pos(), "SerializeCode", { clonedArg });
         }
 
+        TString key;
         NYT::TNode ysonNode;
+        if (types.QContext) {
+            key = MakeCacheKey(*clonedArg);
+            if (types.QContext.CanRead()) {
+                auto item = types.QContext.GetReader()->Get({EvaluationComponent, key}).GetValueSync();
+                if (!item) {
+                    throw yexception() << "Missing replay data";
+                }
+
+                ysonNode = NYT::NodeFromYsonString(item->Value);
+            }
+        }
+
         do {
             calcProvider.Clear();
             calcWorldRoot.Drop();
@@ -997,6 +1010,10 @@ IGraphTransformer::TStatus EvaluateExpression(const TExprNode::TPtr& input, TExp
                 return nullptr;
             }
 
+            if (types.QContext.CanRead()) {
+                break;
+            }
+
             IDataProvider::TFillSettings fillSettings;
             auto delegatedNode = Build<TResult>(ctx, node->Pos())
                 .Input(clonedArg)
@@ -1031,29 +1048,13 @@ IGraphTransformer::TStatus EvaluateExpression(const TExprNode::TPtr& input, TExp
 
             delegatedNode->SetTypeAnn(atomType);
             delegatedNode->SetState(TExprNode::EState::ConstrComplete);
-            TString yson;
-            TString key;
-            if (types.QContext) {
-                key = MakeCacheKey(*clonedArg);
-            }
-
-            if (types.QContext.CanRead()) {
-                auto item = types.QContext.GetReader()->Get({EvaluationComponent, key}).GetValueSync();
-                if (!item) {
-                    throw yexception() << "Missing replay data";
-                }
-
-                yson = item->Value;
-            } else {
-                auto& transformer = calcTransfomer ? *calcTransfomer : (*calcProvider.Get())->GetCallableExecutionTransformer();
-                status = SyncTransform(transformer, delegatedNode, ctx);
-                if (status.Level == IGraphTransformer::TStatus::Error) {
-                    return nullptr;
-                }
-
-                yson = delegatedNode->GetResult().Content();
+            auto& transformer = calcTransfomer ? *calcTransfomer : (*calcProvider.Get())->GetCallableExecutionTransformer();
+            status = SyncTransform(transformer, delegatedNode, ctx);
+            if (status.Level == IGraphTransformer::TStatus::Error) {
+                return nullptr;
             }
 
+            TString yson{delegatedNode->GetResult().Content()};
             ysonNode = NYT::NodeFromYsonString(yson);
             if (ysonNode.HasKey("FallbackProvider")) {
                 nextProvider = ysonNode["FallbackProvider"].AsString();

ydb/library/yql/core/ut/yql_qplayer_ut.cpp

@@ -54,6 +54,7 @@ struct TRunSettings {
     THashMap<TString, TString> Tables;
     TMaybe<TString> ParametersYson;
     THashMap<TString, TString> StaticFiles, DynamicFiles;
+    bool ChangeTime = false;
 };
 
 TUserDataTable MakeUserTables(const THashMap<TString, TString>& map) {
@@ -91,7 +92,7 @@ bool RunProgram(bool replay, const TString& query, const TQContext& qContext, co
     }
     TExprContext::TFreezeGuard freezeGuard(modulesCtx);
 
-    TProgramFactory factory(true, functionRegistry.Get(), 0ULL, dataProvidersInit, "ut");
+    TProgramFactory factory(!runSettings.ChangeTime, functionRegistry.Get(), 0ULL, dataProvidersInit, "ut");
     factory.SetUdfResolver(NCommon::CreateSimpleUdfResolver(functionRegistry.Get()));
     factory.SetModules(moduleResolver);
 
@@ -281,4 +282,11 @@ SELECT State FROM plato.WalkFolders(``, $postHandler AS PostHandler);
             CheckProgram(s, runSettings);
         });
     }
+
+    Y_UNIT_TEST(EvaluateNow) {
+        auto s = "select EvaluateExpr(CurrentUtcDate())";
+        TRunSettings runSettings;
+        runSettings.ChangeTime = true;
+        CheckProgram(s, runSettings);
+    }
 }

ydb/library/yql/core/yql_type_annotation.h

@@ -280,6 +280,40 @@ struct TUdfCachedInfo {
     bool IsStrict = false;
 };
 
+const TString TypeAnnotationContextComponent = "TypeAnnotationContext";
+const TString NowKey = "Now";
+const TString RandomKey = "Random";
+const TString RandomNumberKey = "RandomNumber";
+const TString RandomUuidKey = "RandomUuid";
+
+template <typename T>
+inline TString SerializeBinary(const T& value) {
+    return TString((const char*)&value, sizeof(T));
+}
+
+template <typename T>
+inline T DeserializeBinary(const TString& value) {
+    return *(const T*)value.Data();
+}
+
+template <typename T>
+inline TString GetRandomKey();
+
+template <>
+inline TString GetRandomKey<ui64>() {
+    return RandomNumberKey;
+}
+
+template <>
+inline TString GetRandomKey<double>() {
+    return RandomKey;
+}
+
+template <>
+inline TString GetRandomKey<TGUID>() {
+    return RandomUuidKey;
+}
+
 struct TTypeAnnotationContext: public TThrRefBase {
     THashMap<TString, TIntrusivePtr<TOptimizerStatistics::TColumnStatMap>> ColumnStatisticsByTableName;
     THashMap<ui64, std::shared_ptr<TOptimizerStatistics>> StatisticsMap;
@@ -369,17 +403,41 @@ struct TTypeAnnotationContext: public TThrRefBase {
     T GetRandom() const noexcept;
 
     template <typename T>
-    T GetCachedRandom() noexcept {
+    T GetCachedRandom() {
         auto& cached = std::get<std::optional<T>>(CachedRandom);
         if (!cached) {
-            cached = GetRandom<T>();
+            if (QContext.CanRead()) {
+                auto item = QContext.GetReader()->Get({TypeAnnotationContextComponent, GetRandomKey<T>()}).GetValueSync();
+                if (!item) {
+                    throw yexception() << "Missing replay data";
+                }
+
+                cached = DeserializeBinary<T>(item->Value);
+            } else {
+                cached = GetRandom<T>();
+                if (QContext.CanWrite()) {
+                    QContext.GetWriter()->Put({TypeAnnotationContextComponent, GetRandomKey<T>()}, SerializeBinary<T>(*cached)).GetValueSync();
+                }
+            }
         }
         return *cached;
     }
 
-    ui64 GetCachedNow() noexcept {
+    ui64 GetCachedNow() {
         if (!CachedNow) {
-            CachedNow = TimeProvider->Now().GetValue();
+            if (QContext.CanRead()) {
+                auto item = QContext.GetReader()->Get({TypeAnnotationContextComponent, NowKey}).GetValueSync();
+                if (!item) {
+                    throw yexception() << "Missing replay data";
+                }
+
+                CachedNow = DeserializeBinary<ui64>(item->Value);
+            } else {
+                CachedNow = TimeProvider->Now().GetValue();
+                if (QContext.CanWrite()) {
+                    QContext.GetWriter()->Put({TypeAnnotationContextComponent, NowKey}, SerializeBinary<ui64>(*CachedNow)).GetValueSync();
+                }
+            }
         }
         return *CachedNow;
     }