chore: make databend_common_expression compilation cacheable (#17806)

expression

Author: forsaken628

Cargo.lock

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//! The compilation artefact of this crate cannot be cached, so to avoid long ci compilation times,
+//! you should avoid introducing this crate in the underlying crate.
+
 use std::sync::LazyLock;
 
 use semver::Version;
@@ -52,6 +55,9 @@ pub static DATABEND_SEMVER: LazyLock<Version> = LazyLock::new(|| {
     Version::parse(semver).unwrap_or_else(|e| panic!("Invalid semver: {:?}: {}", semver, e))
 });
 
+pub static UDF_CLIENT_USER_AGENT: LazyLock<String> =
+    LazyLock::new(|| format!("databend-query/{}", *DATABEND_SEMVER));
+
 pub static DATABEND_COMMIT_VERSION: LazyLock<String> = LazyLock::new(|| {
     let semver = DATABEND_GIT_SEMVER;
     let git_sha = VERGEN_GIT_SHA;

src/common/version/src/lib.rs

@@ -28,7 +28,6 @@ databend-common-exception = { workspace = true }
 databend-common-grpc = { workspace = true }
 databend-common-hashtable = { workspace = true }
 databend-common-io = { workspace = true }
-databend-common-version = { workspace = true }
 educe = { workspace = true }
 either = { workspace = true }
 enum-as-inner = { workspace = true }

src/query/expression/Cargo.toml

@@ -29,7 +29,6 @@ use databend_common_base::headers::HEADER_TENANT;
 use databend_common_exception::ErrorCode;
 use databend_common_exception::Result;
 use databend_common_grpc::DNSService;
-use databend_common_version::DATABEND_SEMVER;
 use futures::stream;
 use futures::StreamExt;
 use futures::TryStreamExt;
@@ -65,13 +64,14 @@ impl UDFFlightClient {
         addr: &str,
         conn_timeout: u64,
         request_timeout: u64,
+        user_agent: &str,
     ) -> Result<Arc<Endpoint>> {
         let tls_config = ClientTlsConfig::new().with_native_roots();
         let endpoint = Endpoint::from_shared(addr.to_string())
             .map_err(|err| {
                 ErrorCode::UDFServerConnectError(format!("Invalid UDF Server address: {err}"))
             })?
-            .user_agent(format!("databend-query/{}", *DATABEND_SEMVER))
+            .user_agent(user_agent)
             .map_err(|err| {
                 ErrorCode::UDFServerConnectError(format!("Invalid UDF Client User Agent: {err}"))
             })?

src/query/expression/src/utils/udf_client.rs

@@ -41,6 +41,7 @@ use databend_common_metrics::external_server::record_running_requests_external_f
 use databend_common_metrics::external_server::record_running_requests_external_start;
 use databend_common_pipeline_transforms::processors::AsyncTransform;
 use databend_common_sql::executor::physical_plans::UdfFunctionDesc;
+use databend_common_version::UDF_CLIENT_USER_AGENT;
 use tokio::sync::Semaphore;
 use tonic::transport::Endpoint;
 
@@ -81,8 +82,12 @@ impl TransformUdfServer {
             if endpoints.contains_key(server_addr) {
                 continue;
             }
-            let endpoint =
-                UDFFlightClient::build_endpoint(server_addr, connect_timeout, request_timeout)?;
+            let endpoint = UDFFlightClient::build_endpoint(
+                server_addr,
+                connect_timeout,
+                request_timeout,
+                UDF_CLIENT_USER_AGENT.as_str(),
+            )?;
             endpoints.insert(server_addr.clone(), endpoint);
         }
         Ok(endpoints)

src/query/service/src/pipelines/processors/transforms/transform_udf_server.rs

@@ -52,6 +52,7 @@ use databend_common_meta_app::schema::TableMeta;
 use databend_common_pipeline_core::Pipeline;
 use databend_common_pipeline_sources::OneBlockSource;
 use databend_common_storages_factory::Table;
+use databend_common_version::UDF_CLIENT_USER_AGENT;
 use url::Url;
 
 pub struct UdfEchoTable {
@@ -142,8 +143,12 @@ impl Table for UdfEchoTable {
         let connect_timeout = settings.get_external_server_connect_timeout_secs()?;
         let request_timeout = settings.get_external_server_request_timeout_secs()?;
 
-        let endpoint =
-            UDFFlightClient::build_endpoint(&self.address, connect_timeout, request_timeout)?;
+        let endpoint = UDFFlightClient::build_endpoint(
+            &self.address,
+            connect_timeout,
+            request_timeout,
+            UDF_CLIENT_USER_AGENT.as_str(),
+        )?;
         let mut client = UDFFlightClient::connect(endpoint, connect_timeout, 65536)
             .await?
             .with_tenant(ctx.get_tenant().tenant_name())?

src/query/service/src/table_functions/others/udf.rs

@@ -30,6 +30,7 @@ databend-common-storage = { workspace = true }
 databend-common-storages-result-cache = { workspace = true }
 databend-common-storages-view = { workspace = true }
 databend-common-users = { workspace = true }
+databend-common-version = { workspace = true }
 databend-enterprise-data-mask-feature = { workspace = true }
 databend-storages-common-cache = { workspace = true }
 databend-storages-common-io = { workspace = true }

src/query/sql/Cargo.toml

@@ -32,6 +32,7 @@ use databend_common_meta_app::principal::UDFDefinition as PlanUDFDefinition;
 use databend_common_meta_app::principal::UDFScript;
 use databend_common_meta_app::principal::UDFServer;
 use databend_common_meta_app::principal::UserDefinedFunction;
+use databend_common_version::UDF_CLIENT_USER_AGENT;
 
 use crate::normalize_identifier;
 use crate::optimizer::ir::SExpr;
@@ -105,8 +106,12 @@ impl Binder {
                         .get_settings()
                         .get_external_server_request_batch_rows()? as usize;
 
-                let endpoint =
-                    UDFFlightClient::build_endpoint(address, connect_timeout, request_timeout)?;
+                let endpoint = UDFFlightClient::build_endpoint(
+                    address,
+                    connect_timeout,
+                    request_timeout,
+                    UDF_CLIENT_USER_AGENT.as_str(),
+                )?;
 
                 let mut client = UDFFlightClient::connect(endpoint, connect_timeout, batch_rows)
                     .await?