YQL-20086 core (part1)

commit_hash:12dbda4defcaef8dd708a69552fc19eba832ce2f

Author: vitstn

yql/essentials/core/arrow_kernels/registry/registry.cpp

@@ -7,79 +7,79 @@
 namespace NYql {
 
 namespace {
-    class TLoader : std::enable_shared_from_this<TLoader> {
-    public:
-        TLoader()
-            : Alloc_(__LOCATION__)
-            , Env_(Alloc_)
-        {
-            Alloc_.Release();
-        }
+class TLoader: std::enable_shared_from_this<TLoader> {
+public:
+    TLoader()
+        : Alloc_(__LOCATION__)
+        , Env_(Alloc_)
+    {
+        Alloc_.Release();
+    }
 
-        void Init(const TString& serialized,
-            const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-            const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
-            TLangVersion langver) {
-            TGuard<NKikimr::NMiniKQL::TScopedAlloc> allocGuard(Alloc_);
-            Pgm_ = NKikimr::NMiniKQL::DeserializeRuntimeNode(serialized, Env_);
-            auto pgmTop = AS_CALLABLE("BlockAsTuple", Pgm_);
-            MKQL_ENSURE(pgmTop->GetInputsCount() == 2, "Expected tuple of 2 items");
-            auto argsNode = pgmTop->GetInput(0);
-            MKQL_ENSURE(!argsNode.IsImmediate() && argsNode.GetNode()->GetType()->IsCallable(), "Expected callable");
-            auto argsCallable = static_cast<NKikimr::NMiniKQL::TCallable*>(argsNode.GetNode());
+    void Init(const TString& serialized,
+              const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+              const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
+              TLangVersion langver) {
+        TGuard<NKikimr::NMiniKQL::TScopedAlloc> allocGuard(Alloc_);
+        Pgm_ = NKikimr::NMiniKQL::DeserializeRuntimeNode(serialized, Env_);
+        auto pgmTop = AS_CALLABLE("BlockAsTuple", Pgm_);
+        MKQL_ENSURE(pgmTop->GetInputsCount() == 2, "Expected tuple of 2 items");
+        auto argsNode = pgmTop->GetInput(0);
+        MKQL_ENSURE(!argsNode.IsImmediate() && argsNode.GetNode()->GetType()->IsCallable(), "Expected callable");
+        auto argsCallable = static_cast<NKikimr::NMiniKQL::TCallable*>(argsNode.GetNode());
 
-            Explorer_.Walk(Pgm_.GetNode(), Env_);
-            NKikimr::NMiniKQL::TComputationPatternOpts opts(Alloc_.Ref(), Env_, nodeFactory,
-                &functionRegistry, NUdf::EValidateMode::None, NUdf::EValidatePolicy::Exception, "OFF",
-                NKikimr::NMiniKQL::EGraphPerProcess::Multi, nullptr, nullptr, nullptr, nullptr, langver);
-            std::vector<NKikimr::NMiniKQL::TNode*> entryPoints;
-            if (argsCallable->GetType()->GetName() == "BlockAsTuple") {
-                for (ui32 i = 0; i < argsCallable->GetInputsCount(); ++i) {
-                    entryPoints.emplace_back(argsCallable->GetInput(i).GetNode());
-                }
+        Explorer_.Walk(Pgm_.GetNode(), Env_);
+        NKikimr::NMiniKQL::TComputationPatternOpts opts(Alloc_.Ref(), Env_, nodeFactory,
+                                                        &functionRegistry, NUdf::EValidateMode::None, NUdf::EValidatePolicy::Exception, "OFF",
+                                                        NKikimr::NMiniKQL::EGraphPerProcess::Multi, nullptr, nullptr, nullptr, nullptr, langver);
+        std::vector<NKikimr::NMiniKQL::TNode*> entryPoints;
+        if (argsCallable->GetType()->GetName() == "BlockAsTuple") {
+            for (ui32 i = 0; i < argsCallable->GetInputsCount(); ++i) {
+                entryPoints.emplace_back(argsCallable->GetInput(i).GetNode());
             }
+        }
 
-            Alloc_.Ref().UseRefLocking = true;
-            Pattern_ = NKikimr::NMiniKQL::MakeComputationPattern(Explorer_, Pgm_, entryPoints, opts);
-            RandomProvider_ = CreateDefaultRandomProvider();
-            TimeProvider_ = CreateDefaultTimeProvider();
+        Alloc_.Ref().UseRefLocking = true;
+        Pattern_ = NKikimr::NMiniKQL::MakeComputationPattern(Explorer_, Pgm_, entryPoints, opts);
+        RandomProvider_ = CreateDefaultRandomProvider();
+        TimeProvider_ = CreateDefaultTimeProvider();
 
-            Graph_ = Pattern_->Clone(opts.ToComputationOptions(*RandomProvider_, *TimeProvider_));
-            NKikimr::NMiniKQL::TBindTerminator terminator(Graph_->GetTerminator());
-            Topology_ = Graph_->GetKernelsTopology();
-            MKQL_ENSURE(Topology_->Items.size() >= 3, "Expected at least 3 kernels");
-        }
+        Graph_ = Pattern_->Clone(opts.ToComputationOptions(*RandomProvider_, *TimeProvider_));
+        NKikimr::NMiniKQL::TBindTerminator terminator(Graph_->GetTerminator());
+        Topology_ = Graph_->GetKernelsTopology();
+        MKQL_ENSURE(Topology_->Items.size() >= 3, "Expected at least 3 kernels");
+    }
 
-        ~TLoader() {
-            Alloc_.Acquire();
-        }
+    ~TLoader() {
+        Alloc_.Acquire();
+    }
 
-        ui32 GetKernelsCount() const {
-            return Topology_->Items.size() - 3;
-        }
+    ui32 GetKernelsCount() const {
+        return Topology_->Items.size() - 3;
+    }
 
-        const arrow::compute::ScalarKernel* GetKernel(ui32 index) const {
-            MKQL_ENSURE(index < Topology_->Items.size() - 3, "Bad kernel index");
-            return &Topology_->Items[index].Node->GetArrowKernel();
-        }
+    const arrow::compute::ScalarKernel* GetKernel(ui32 index) const {
+        MKQL_ENSURE(index < Topology_->Items.size() - 3, "Bad kernel index");
+        return &Topology_->Items[index].Node->GetArrowKernel();
+    }
 
-    private:
-        NKikimr::NMiniKQL::TScopedAlloc Alloc_;
-        NKikimr::NMiniKQL::TTypeEnvironment Env_;
-        NKikimr::NMiniKQL::TRuntimeNode Pgm_;
-        NKikimr::NMiniKQL::TExploringNodeVisitor Explorer_;
-        NKikimr::NMiniKQL::IComputationPattern::TPtr Pattern_;
-        TIntrusivePtr<IRandomProvider> RandomProvider_;
-        TIntrusivePtr<ITimeProvider> TimeProvider_;
-        THolder<NKikimr::NMiniKQL::IComputationGraph> Graph_;
-        const NKikimr::NMiniKQL::TArrowKernelsTopology* Topology_;
-    };
-}
+private:
+    NKikimr::NMiniKQL::TScopedAlloc Alloc_;
+    NKikimr::NMiniKQL::TTypeEnvironment Env_;
+    NKikimr::NMiniKQL::TRuntimeNode Pgm_;
+    NKikimr::NMiniKQL::TExploringNodeVisitor Explorer_;
+    NKikimr::NMiniKQL::IComputationPattern::TPtr Pattern_;
+    TIntrusivePtr<IRandomProvider> RandomProvider_;
+    TIntrusivePtr<ITimeProvider> TimeProvider_;
+    THolder<NKikimr::NMiniKQL::IComputationGraph> Graph_;
+    const NKikimr::NMiniKQL::TArrowKernelsTopology* Topology_;
+};
+} // namespace
 
 std::vector<std::shared_ptr<const arrow::compute::ScalarKernel>> LoadKernels(const TString& serialized,
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-    const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
-    TLangVersion langver) {
+                                                                             const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+                                                                             const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
+                                                                             TLangVersion langver) {
     auto loader = std::make_shared<TLoader>();
     loader->Init(serialized, functionRegistry, nodeFactory, langver);
     std::vector<std::shared_ptr<const arrow::compute::ScalarKernel>> ret(loader->GetKernelsCount());
@@ -91,4 +91,4 @@ std::vector<std::shared_ptr<const arrow::compute::ScalarKernel>> LoadKernels(con
     return ret;
 }
 
-}
+} // namespace NYql

yql/essentials/core/arrow_kernels/registry/registry.h

@@ -9,9 +9,8 @@
 namespace NYql {
 
 std::vector<std::shared_ptr<const arrow::compute::ScalarKernel>> LoadKernels(const TString& serialized,
-    const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
-    const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
-    TLangVersion langver = MinLangVersion);
-
-}
+                                                                             const NKikimr::NMiniKQL::IFunctionRegistry& functionRegistry,
+                                                                             const NKikimr::NMiniKQL::TComputationNodeFactory& nodeFactory,
+                                                                             TLangVersion langver = MinLangVersion);
 
+} // namespace NYql