[improvement](build) Optimize Hive thirdparty startup and refresh workflow

### What problem does this PR solve?

Related Issue: #62101

Related PR: #62102

Problem Summary:

This PR consolidates Hive thirdparty startup improvements to make refresh/rebuild behavior more predictable, reduce startup overhead, and improve operational observability.

Key updates include:

- introduce structured hive startup modes () and module-selective refresh ()

- persist and reuse hive state, with SHA-based incremental refresh for modules and preinstalled HQL files

- reduce refresh/startup log noise (xtrace gating, obsolete compose version cleanup, cleaner refresh stage logs)

- make Hive bootstrap scripts/HQL idempotent with drop-then-create style and repeatable reruns

- optimize healthy refresh path by skipping unnecessary compose-up steps

- switch JuiceFS default metadata backend for Hive to metastore PostgreSQL and remove auto-MySQL dependency

- add Hive README documenting component segmentation, startup modes, module refresh, and troubleshooting

### Release note

None

### Check List (For Author)

- Test: Manual test

    - Ran hive3 refresh and module-scoped refresh via run-thirdparties-docker.sh

- Behavior changed: Yes (Hive startup and refresh behavior is now mode/module driven and defaults to PostgreSQL-backed JuiceFS metadata)

- Does this need documentation: No

Author: suxiaogang223

be/src/exec/operator/hashjoin_build_sink.cpp

@@ -237,18 +237,7 @@ Status HashJoinBuildSinkLocalState::close(RuntimeState* state, Status exec_statu
 
         if (p._use_shared_hash_table) {
             std::unique_lock lock(p._mutex);
-            // Only signal non-builder tasks when the builder actually built the hash table.
-            // When the builder is terminated (woken up early because the probe side finished
-            // first), it never called process_build_block() so the hash table variant is still
-            // monostate. Setting _signaled=true in that case would cause non-builder tasks to
-            // enter std::visit on monostate and crash with "Hash table type mismatch".
-            //
-            // _terminated is reliably true here when the task was woken up early, because
-            // operator terminate() is called from the execute() Defer in PipelineTask
-            // before close() is invoked.
-            if (!_terminated) {
-                p._signaled = true;
-            }
+            p._signaled = true;
             for (auto& dep : _shared_state->sink_deps) {
                 dep->set_ready();
             }
@@ -851,20 +840,12 @@ Status HashJoinBuildSinkOperatorX::sink(RuntimeState* state, Block* in_block, bo
         RETURN_IF_ERROR(local_state.build_asof_index(*local_state._shared_state->build_block));
         local_state.init_short_circuit_for_probe();
     } else if (!local_state._should_build_hash_table) {
-        // The non-builder instance waits for the builder (task 0) to finish building the hash table.
-        // If _signaled is false, either the builder hasn't finished yet, or the builder was
-        // terminated (woken up early) without building the hash table — in both cases, return EOF.
-        //
-        // The close() Defer in the builder conditionally sets _signaled=true ONLY when the builder
-        // was NOT terminated (i.e., the hash table was actually built). When the builder is
-        // terminated, _signaled stays false, so non-builders always hit this guard and return EOF
-        // safely — never reaching the std::visit on an uninitialized (monostate) hash table.
-        //
-        // At this point, termination is reflected solely through the value of _signaled: a
-        // terminated builder never sets _signaled to true. Checking !_signaled is therefore
-        // sufficient and serves as the real guard against racing with an uninitialized hash table.
-        if (!_signaled) {
-            return Status::Error<ErrorCode::END_OF_FILE>("source has closed");
+        // the instance which is not build hash table, it's should wait the signal of hash table build finished.
+        // but if it's running and signaled == false, maybe the source operator have closed caused by some short circuit
+        // return eof will make task marked as wake_up_early
+        // todo: remove signaled after we can guarantee that wake up eraly is always set accurately
+        if (!_signaled || local_state._terminated) {
+            return Status::Error<ErrorCode::END_OF_FILE>("source have closed");
         }
 
         DCHECK_LE(local_state._task_idx,

be/src/exec/pipeline/pipeline_task.cpp

@@ -1063,20 +1063,12 @@ Status PipelineTask::_state_transition(State new_state) {
     }
     _task_profile->add_info_string("TaskState", _to_string(new_state));
     _task_profile->add_info_string("BlockedByDependency", _blocked_dep ? _blocked_dep->name() : "");
-    const auto& table =
-            _wake_up_early ? WAKE_UP_EARLY_LEGAL_STATE_TRANSITION : LEGAL_STATE_TRANSITION;
-    if (!table[(int)new_state].contains(_exec_state)) {
+    if (!LEGAL_STATE_TRANSITION[(int)new_state].contains(_exec_state)) {
         return Status::InternalError(
                 "Task state transition from {} to {} is not allowed! Task info: {}",
                 _to_string(_exec_state), _to_string(new_state), debug_string());
     }
-    // FINISHED/FINALIZED → RUNNABLE is legal under wake_up_early (delayed wake_up() arriving
-    // after the task already terminated), but we must not actually move the state backwards.
-    bool need_move = !((_exec_state == State::FINISHED || _exec_state == State::FINALIZED) &&
-                       new_state == State::RUNNABLE);
-    if (need_move) {
-        _exec_state = new_state;
-    }
+    _exec_state = new_state;
     return Status::OK();
 }
 

be/src/exec/pipeline/pipeline_task.h

@@ -279,19 +279,11 @@ class PipelineTask : public std::enable_shared_from_this<PipelineTask> {
     std::shared_ptr<MemTrackerLimiter> _query_mem_tracker;
 
     /**
-         * Normal state machine:
          *
          * INITED -----> RUNNABLE -------------------------+----> FINISHED ---+---> FINALIZED
          *                   ^                             |                  |
          *                   |                             |                  |
          *                   +----------- BLOCKED <--------+------------------+
-         *
-         * When _wake_up_early is set by make_all_runnable(), additional transitions are allowed:
-         *   BLOCKED    → FINISHED : task skips RUNNABLE, terminates directly
-         *   FINISHED   → RUNNABLE : delayed wake_up() arrives after task already finished,
-         *                           legal but no-op (state stays FINISHED)
-         *   FINALIZED  → RUNNABLE : same as above but task already finalized,
-         *                           legal but no-op (state stays FINALIZED)
          */
     enum class State : int {
         INITED,
@@ -307,15 +299,6 @@ class PipelineTask : public std::enable_shared_from_this<PipelineTask> {
             {State::RUNNABLE},                                // Target state is FINISHED
             {State::INITED, State::FINISHED}};                // Target state is FINALIZED
 
-    // Extended table used when _wake_up_early is true.
-    const std::vector<std::set<State>> WAKE_UP_EARLY_LEGAL_STATE_TRANSITION = {
-            {}, // INITED
-            {State::INITED, State::RUNNABLE, State::BLOCKED, State::FINISHED,
-             State::FINALIZED},                 // RUNNABLE (+ FINISHED, FINALIZED)
-            {State::RUNNABLE, State::FINISHED}, // BLOCKED
-            {State::RUNNABLE, State::BLOCKED},  // FINISHED (+ BLOCKED)
-            {State::INITED, State::FINISHED}};  // FINALIZED
-
     std::string _to_string(State state) const {
         switch (state) {
         case State::INITED: