chore(query): refine startup message (#18496)

sundy-li · web-flow · commit 5945e57576a7 · 2025-08-07T16:34:11.000+08:00
* chore(query): refine startup message

* chore(query): refine startup message
diff --git a/src/binaries/query/entry.rs b/src/binaries/query/entry.rs
@@ -395,29 +395,24 @@ pub async fn start_services(conf: &InnerConfig) -> Result<(), MainError> {
         "    connect via: mysql -u${{USER}} -p${{PASSWORD}} -h{} -P{}",
         conf.query.mysql_handler_host, conf.query.mysql_handler_port
     );
-    println!("Clickhouse(http)");
+    println!("Databend");
     println!(
         "    listened at {}:{}",
-        conf.query.clickhouse_http_handler_host, conf.query.clickhouse_http_handler_port
+        conf.query.http_handler_host, conf.query.http_handler_port
     );
+
     println!(
-        "    usage: {}",
-        HttpHandlerKind::Clickhouse.usage(
-            format!(
-                "{}:{}",
-                conf.query.clickhouse_http_handler_host, conf.query.clickhouse_http_handler_port
-            )
-            .parse()
-            .with_context(make_error)?
-        )
+        "    usage with args: bendsql -u ${{USER}} -p ${{PASSWORD}} -h {} -P {}",
+        conf.query.http_handler_host, conf.query.http_handler_port
     );
-    println!("Databend HTTP");
+
     println!(
-        "    listened at {}:{}",
+        "    usage with dsn: bendsql --dsn \"databend://${{USER}}:${{PASSWORD}}@{}:{}?sslmode=disable\"",
         conf.query.http_handler_host, conf.query.http_handler_port
     );
+
     println!(
-        "    usage: {}",
+        "    http: {}",
         HttpHandlerKind::Query.usage(
             format!(
                 "{}:{}",
@@ -427,6 +422,7 @@ pub async fn start_services(conf: &InnerConfig) -> Result<(), MainError> {
             .with_context(make_error)?
         )
     );
+
     for (idx, (k, v)) in env::vars()
         .filter(|(k, _)| k.starts_with("_DATABEND"))
         .enumerate()
diff --git a/src/common/exception/src/exception.rs b/src/common/exception/src/exception.rs
@@ -260,6 +260,14 @@ impl<C> ErrorCode<C> {
     }
 }
 
+impl ErrorCode {
+    pub fn aborting() -> Self {
+        ErrorCode::AbortedQuery(
+            "Aborted query, because the server is shutting down or the query was killed.",
+        )
+    }
+}
+
 /// Provides the `map_err_to_code` method for `Result`.
 ///
 /// ```
diff --git a/src/query/pipeline/transforms/src/processors/transforms/transform_compact_block.rs b/src/query/pipeline/transforms/src/processors/transforms/transform_compact_block.rs
@@ -60,9 +60,7 @@ impl BlockMetaTransform<BlockCompactMeta> for TransformCompactBlock {
 
     fn transform(&mut self, meta: BlockCompactMeta) -> Result<Vec<DataBlock>> {
         if unlikely(self.aborting.load(Ordering::Relaxed)) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         match meta {
diff --git a/src/query/pipeline/transforms/src/processors/transforms/transform_sort_merge.rs b/src/query/pipeline/transforms/src/processors/transforms/transform_sort_merge.rs
@@ -82,9 +82,7 @@ impl<R: Rows> MergeSort<R> for TransformSortMerge<R> {
 
     fn add_block(&mut self, block: DataBlock, init_rows: R) -> Result<()> {
         if unlikely(self.aborting.load(Ordering::Relaxed)) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         if unlikely(block.is_empty()) {
@@ -177,9 +175,7 @@ impl<R: Rows> TransformSortMerge<R> {
 
         while let Some(block) = merger.next_block()? {
             if unlikely(self.aborting.load(Ordering::Relaxed)) {
-                return Err(ErrorCode::AbortedQuery(
-                    "Aborted query, because the server is shutting down or the query was killed.",
-                ));
+                return Err(ErrorCode::aborting());
             }
             result.push(block);
         }
diff --git a/src/query/service/src/interpreters/interpreter_kill.rs b/src/query/service/src/interpreters/interpreter_kill.rs
@@ -110,9 +110,7 @@ impl KillInterpreter {
                     }
                 }
 
-                kill_session.force_kill_query(ErrorCode::AbortedQuery(
-                    "Aborted query, because the server is shutting down or the query was killed",
-                ));
+                kill_session.force_kill_query(ErrorCode::aborting());
                 Ok(PipelineBuildResult::create())
             }
         }
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/hash_join_build_state.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/hash_join_build_state.rs
@@ -516,9 +516,7 @@ impl HashJoinBuildState {
         }
 
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let chunk_index = task;
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/hash_join_probe_state.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/hash_join_probe_state.rs
@@ -454,9 +454,7 @@ impl HashJoinProbeState {
         probe_state: &mut ProbeState,
     ) -> Result<Vec<DataBlock>> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         // Probe states.
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/inner_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/inner_join.rs
@@ -178,9 +178,7 @@ impl HashJoinProbeState {
                 let mut filtered_blocks = Vec::with_capacity(result_blocks.len());
                 for result_block in result_blocks {
                     if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-                        return Err(ErrorCode::AbortedQuery(
-                            "Aborted query, because the server is shutting down or the query was killed.",
-                        ));
+                        return Err(ErrorCode::aborting());
                     }
                     let result_block = filter_executor.filter(result_block)?;
                     if !result_block.is_empty() {
@@ -205,9 +203,7 @@ impl HashJoinProbeState {
         right_single_scan_map: &mut [*mut AtomicBool],
     ) -> Result<DataBlock> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_anti_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_anti_join.rs
@@ -74,9 +74,7 @@ impl HashJoinProbeState {
         };
 
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let result_block = DataBlock::take(&process_state.input, &probe_indexes[0..count])?;
@@ -255,9 +253,7 @@ impl HashJoinProbeState {
         filter_executor: &mut FilterExecutor,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_join.rs
@@ -365,9 +365,7 @@ impl HashJoinProbeState {
         build_state: &BuildBlockGenerationState,
     ) -> Result<DataBlock> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
@@ -415,9 +413,7 @@ impl HashJoinProbeState {
         row_state_indexes: Option<&mut Vec<usize>>,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_mark_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_mark_join.rs
@@ -294,9 +294,7 @@ impl HashJoinProbeState {
         mark_scan_map: &mut [Vec<u8>],
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         for probed_row in build_indexes.iter() {
@@ -324,9 +322,7 @@ impl HashJoinProbeState {
         mark_scan_map: &mut [Vec<u8>],
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_semi_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/left_semi_join.rs
@@ -73,9 +73,7 @@ impl HashJoinProbeState {
         }
 
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         if matched_idx > 0 {
@@ -253,9 +251,7 @@ impl HashJoinProbeState {
         filter_executor: &mut FilterExecutor,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_join.rs
@@ -236,9 +236,7 @@ impl HashJoinProbeState {
         filter_executor: Option<&mut FilterExecutor>,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_mark_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_mark_join.rs
@@ -264,9 +264,7 @@ impl HashJoinProbeState {
         other_predicate: &Expr,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_semi_anti_join.rs b/src/query/service/src/pipelines/processors/transforms/hash_join/probe_join/right_semi_anti_join.rs
@@ -246,9 +246,7 @@ impl HashJoinProbeState {
         outer_scan_map: &mut [Vec<bool>],
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         for row_ptr in build_indexes.iter() {
@@ -276,9 +274,7 @@ impl HashJoinProbeState {
         filter_executor: &mut FilterExecutor,
     ) -> Result<()> {
         if self.hash_join_state.interrupt.load(Ordering::Relaxed) {
-            return Err(ErrorCode::AbortedQuery(
-                "Aborted query, because the server is shutting down or the query was killed.",
-            ));
+            return Err(ErrorCode::aborting());
         }
 
         let probe_block = if probe_state.is_probe_projected {
diff --git a/src/query/service/src/pipelines/processors/transforms/sort/sort_spill.rs b/src/query/service/src/pipelines/processors/transforms/sort/sort_spill.rs
@@ -265,9 +265,7 @@ impl<A: SortAlgorithm> StepCollect<A> {
             let mut sorted = VecDeque::new();
             while let Some(data) = merger.next_block()? {
                 if unlikely(aborting.load(atomic::Ordering::Relaxed)) {
-                    return Err(ErrorCode::AbortedQuery(
-                        "Aborted query, because the server is shutting down or the query was killed.",
-                    ));
+                    return Err(ErrorCode::aborting());
                 }
 
                 let mut block = base.new_block(data);
diff --git a/src/query/service/src/sessions/query_ctx_shared.rs b/src/query/service/src/sessions/query_ctx_shared.rs
@@ -413,12 +413,9 @@ impl QueryContextShared {
 
     pub fn check_aborting(&self) -> Result<(), ContextError> {
         if self.aborting.load(Ordering::Acquire) {
-            Err(self.get_error().unwrap_or_else(|| {
-                ErrorCode::AbortedQuery(
-                    "Aborted query, because the server is shutting down or the query was killed.",
-                )
-                .with_context("query aborted")
-            }))
+            Err(self
+                .get_error()
+                .unwrap_or_else(|| ErrorCode::aborting().with_context("query aborted")))
         } else {
             Ok(())
         }
diff --git a/src/query/service/src/sessions/session.rs b/src/query/service/src/sessions/session.rs
@@ -136,9 +136,7 @@ impl Session {
     }
 
     pub fn force_kill_session(&self) {
-        self.force_kill_query(ErrorCode::AbortedQuery(
-            "Aborted query, because the server is shutting down or the query was killed",
-        ));
+        self.force_kill_query(ErrorCode::aborting());
         self.kill(/* shutdown io stream */);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -260,6 +260,14 @@ impl<C> ErrorCode<C> {`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
	`263`	`+impl ErrorCode {`
	`264`	`+ pub fn aborting() -> Self {`
	`265`	`+ ErrorCode::AbortedQuery(`
	`266`	`+ "Aborted query, because the server is shutting down or the query was killed.",`
	`267`	`+ )`
	`268`	`+ }`
	`269`	`+}`
	`270`	`+`
`263`	`271`	/// Provides the `map_err_to_code` method for `Result`.
`264`	`272`	`///`
`265`	`273`	/// ```
Original file line number	Diff line number	Diff line change
`@@ -60,9 +60,7 @@ impl BlockMetaTransform<BlockCompactMeta> for TransformCompactBlock {`
`60`	`60`
`61`	`61`	`fn transform(&mut self, meta: BlockCompactMeta) -> Result<Vec<DataBlock>> {`
`62`	`62`	`if unlikely(self.aborting.load(Ordering::Relaxed)) {`
`63`		`- return Err(ErrorCode::AbortedQuery(`
`64`		`- "Aborted query, because the server is shutting down or the query was killed.",`
`65`		`- ));`
	`63`	`+ return Err(ErrorCode::aborting());`
`66`	`64`	`}`
`67`	`65`
`68`	`66`	`match meta {`
Original file line number	Diff line number	Diff line change
`@@ -82,9 +82,7 @@ impl<R: Rows> MergeSort<R> for TransformSortMerge<R> {`
`82`	`82`
`83`	`83`	`fn add_block(&mut self, block: DataBlock, init_rows: R) -> Result<()> {`
`84`	`84`	`if unlikely(self.aborting.load(Ordering::Relaxed)) {`
`85`		`- return Err(ErrorCode::AbortedQuery(`
`86`		`- "Aborted query, because the server is shutting down or the query was killed.",`
`87`		`- ));`
	`85`	`+ return Err(ErrorCode::aborting());`
`88`	`86`	`}`
`89`	`87`
`90`	`88`	`if unlikely(block.is_empty()) {`
`@@ -177,9 +175,7 @@ impl<R: Rows> TransformSortMerge<R> {`
`177`	`175`
`178`	`176`	`while let Some(block) = merger.next_block()? {`
`179`	`177`	`if unlikely(self.aborting.load(Ordering::Relaxed)) {`
`180`		`- return Err(ErrorCode::AbortedQuery(`
`181`		`- "Aborted query, because the server is shutting down or the query was killed.",`
`182`		`- ));`
	`178`	`+ return Err(ErrorCode::aborting());`
`183`	`179`	`}`
`184`	`180`	`result.push(block);`
`185`	`181`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,9 +110,7 @@ impl KillInterpreter {`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`- kill_session.force_kill_query(ErrorCode::AbortedQuery(`
`114`		`- "Aborted query, because the server is shutting down or the query was killed",`
`115`		`- ));`
	`113`	`+ kill_session.force_kill_query(ErrorCode::aborting());`
`116`	`114`	`Ok(PipelineBuildResult::create())`
`117`	`115`	`}`
`118`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -516,9 +516,7 @@ impl HashJoinBuildState {`
`516`	`516`	`}`
`517`	`517`
`518`	`518`	`if self.hash_join_state.interrupt.load(Ordering::Relaxed) {`
`519`		`- return Err(ErrorCode::AbortedQuery(`
`520`		`- "Aborted query, because the server is shutting down or the query was killed.",`
`521`		`- ));`
	`519`	`+ return Err(ErrorCode::aborting());`
`522`	`520`	`}`
`523`	`521`
`524`	`522`	`let chunk_index = task;`