morningman
diff --git a/‎be/src/service/internal_service.cpp‎
Lines changed: 90 additions & 34 deletions b/‎be/src/service/internal_service.cpp‎
Lines changed: 90 additions & 34 deletions
diff --git a/‎be/src/util/jdbc_utils.cpp‎
Lines changed: 57 additions & 0 deletions b/‎be/src/util/jdbc_utils.cpp‎
Lines changed: 57 additions & 0 deletions
diff --git a/‎be/src/util/jdbc_utils.h‎
Lines changed: 48 additions & 0 deletions b/‎be/src/util/jdbc_utils.h‎
Lines changed: 48 additions & 0 deletions
diff --git a/‎be/src/vec/aggregate_functions/aggregate_function_java_udaf.h‎
Lines changed: 5 additions & 5 deletions b/‎be/src/vec/aggregate_functions/aggregate_function_java_udaf.h‎
Lines changed: 5 additions & 5 deletions
@@ -41,7 +41,7 @@
 #include <stdint.h>
 #include <sys/stat.h>
 #include <vec/data_types/data_type.h>
-#include <vec/exec/vjdbc_connector.h>
+#include <vec/exec/format/jni_reader.h>
 #include <vec/sink/varrow_flight_result_writer.h>
 
 #include <algorithm>
@@ -107,6 +107,7 @@
 #include "util/brpc_client_cache.h"
 #include "util/brpc_closure.h"
 #include "util/doris_metrics.h"
+#include "util/jdbc_utils.h"
 #include "util/md5.h"
 #include "util/metrics.h"
 #include "util/network_util.h"
@@ -119,7 +120,6 @@
 #include "util/uid_util.h"
 #include "vec/common/variant_util.h"
 #include "vec/core/block.h"
-#include "vec/exec/format/avro//avro_jni_reader.h"
 #include "vec/exec/format/csv/csv_reader.h"
 #include "vec/exec/format/generic_reader.h"
 #include "vec/exec/format/json/new_json_reader.h"
@@ -867,11 +867,7 @@ void PInternalService::fetch_table_schema(google::protobuf::RpcController* contr
                                                               file_slots, io_ctx.get(), io_ctx);
             break;
         }
-        case TFileFormatType::FORMAT_AVRO: {
-            reader = vectorized::AvroJNIReader::create_unique(profile.get(), params, range,
-                                                              file_slots);
-            break;
-        }
+
         default:
             st = Status::InternalError("Not supported file format in fetch table schema: {}",
                                        params.format_type);
@@ -991,7 +987,6 @@ void PInternalService::test_jdbc_connection(google::protobuf::RpcController* con
                 fmt::format("InternalService::test_jdbc_connection"));
         SCOPED_ATTACH_TASK(mem_tracker);
         TTableDescriptor table_desc;
-        vectorized::JdbcConnectorParam jdbc_param;
         Status st = Status::OK();
         {
             const uint8_t* buf = (const uint8_t*)request->jdbc_table().data();
@@ -1004,35 +999,96 @@ void PInternalService::test_jdbc_connection(google::protobuf::RpcController* con
             }
         }
         TJdbcTable jdbc_table = (table_desc.jdbcTable);
-        jdbc_param.catalog_id = jdbc_table.catalog_id;
-        jdbc_param.driver_class = jdbc_table.jdbc_driver_class;
-        jdbc_param.driver_path = jdbc_table.jdbc_driver_url;
-        jdbc_param.driver_checksum = jdbc_table.jdbc_driver_checksum;
-        jdbc_param.jdbc_url = jdbc_table.jdbc_url;
-        jdbc_param.user = jdbc_table.jdbc_user;
-        jdbc_param.passwd = jdbc_table.jdbc_password;
-        jdbc_param.query_string = request->query_str();
-        jdbc_param.table_type = static_cast<TOdbcTableType::type>(request->jdbc_table_type());
-        jdbc_param.use_transaction = false;
-        jdbc_param.connection_pool_min_size = jdbc_table.connection_pool_min_size;
-        jdbc_param.connection_pool_max_size = jdbc_table.connection_pool_max_size;
-        jdbc_param.connection_pool_max_life_time = jdbc_table.connection_pool_max_life_time;
-        jdbc_param.connection_pool_max_wait_time = jdbc_table.connection_pool_max_wait_time;
-        jdbc_param.connection_pool_keep_alive = jdbc_table.connection_pool_keep_alive;
-
-        std::unique_ptr<vectorized::JdbcConnector> jdbc_connector;
-        jdbc_connector.reset(new (std::nothrow) vectorized::JdbcConnector(jdbc_param));
-
-        st = jdbc_connector->test_connection();
-        st.to_protobuf(result->mutable_status());
 
-        Status clean_st = jdbc_connector->clean_datasource();
-        if (!clean_st.ok()) {
-            LOG(WARNING) << "Failed to clean JDBC datasource: " << clean_st.msg();
+        // Resolve driver URL to absolute file:// path
+        std::string driver_url;
+        st = JdbcUtils::resolve_driver_url(jdbc_table.jdbc_driver_url, &driver_url);
+        if (!st.ok()) {
+            st.to_protobuf(result->mutable_status());
+            return;
+        }
+
+        // Build params for JdbcConnectionTester
+        std::map<std::string, std::string> params;
+        params["jdbc_url"] = jdbc_table.jdbc_url;
+        params["jdbc_user"] = jdbc_table.jdbc_user;
+        params["jdbc_password"] = jdbc_table.jdbc_password;
+        params["jdbc_driver_class"] = jdbc_table.jdbc_driver_class;
+        params["jdbc_driver_url"] = driver_url;
+        params["query_sql"] = request->query_str();
+        params["catalog_id"] = std::to_string(jdbc_table.catalog_id);
+        params["connection_pool_min_size"] = std::to_string(jdbc_table.connection_pool_min_size);
+        params["connection_pool_max_size"] = std::to_string(jdbc_table.connection_pool_max_size);
+        params["connection_pool_max_wait_time"] =
+                std::to_string(jdbc_table.connection_pool_max_wait_time);
+        params["connection_pool_max_life_time"] =
+                std::to_string(jdbc_table.connection_pool_max_life_time);
+        params["connection_pool_keep_alive"] =
+                jdbc_table.connection_pool_keep_alive ? "true" : "false";
+        params["clean_datasource"] = "true";
+        // Map jdbc_table_type (TOdbcTableType enum value) to string name
+        // for JdbcTypeHandlerFactory to select the correct type handler.
+        // This ensures the right validation query is used (e.g. Oracle: "SELECT 1 FROM dual").
+        if (request->has_jdbc_table_type()) {
+            std::string type_name;
+            switch (request->jdbc_table_type()) {
+            case 0:
+                type_name = "MYSQL";
+                break;
+            case 1:
+                type_name = "ORACLE";
+                break;
+            case 2:
+                type_name = "POSTGRESQL";
+                break;
+            case 3:
+                type_name = "SQLSERVER";
+                break;
+            case 6:
+                type_name = "CLICKHOUSE";
+                break;
+            case 7:
+                type_name = "SAP_HANA";
+                break;
+            case 8:
+                type_name = "TRINO";
+                break;
+            case 9:
+                type_name = "PRESTO";
+                break;
+            case 10:
+                type_name = "OCEANBASE";
+                break;
+            case 11:
+                type_name = "OCEANBASE_ORACLE";
+                break;
+            case 13:
+                type_name = "DB2";
+                break;
+            case 14:
+                type_name = "GBASE";
+                break;
+            default:
+                break;
+            }
+            if (!type_name.empty()) {
+                params["table_type"] = type_name;
+            }
         }
-        Status close_st = jdbc_connector->close();
+        // required_fields and columns_types are required by JniReader
+        params["required_fields"] = "result";
+        params["columns_types"] = "int";
+
+        // Use JniReader to create JdbcConnectionTester, which tests
+        // the connection in its open() method.
+        auto jni_reader = std::make_unique<vectorized::JniReader>(
+                "org/apache/doris/jdbc/JdbcConnectionTester", params);
+        st = jni_reader->open(nullptr, nullptr);
+        st.to_protobuf(result->mutable_status());
+
+        Status close_st = jni_reader->close();
         if (!close_st.ok()) {
-            LOG(WARNING) << "Failed to close JDBC connector: " << close_st.msg();
+            LOG(WARNING) << "Failed to close JDBC connection tester: " << close_st.msg();
         }
     });
 
 
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "util/jdbc_utils.h"
+
+#include <filesystem>
+
+#include "common/config.h"
+
+namespace doris {
+
+Status JdbcUtils::resolve_driver_url(const std::string& url, std::string* result_url) {
+    // Already a full URL (e.g. "file:///path/to/driver.jar" or "hdfs://...")
+    if (url.find(":/") != std::string::npos) {
+        *result_url = url;
+        return Status::OK();
+    }
+
+    const char* doris_home = std::getenv("DORIS_HOME");
+    if (doris_home == nullptr) {
+        return Status::InternalError("DORIS_HOME environment variable is not set");
+    }
+
+    std::string default_url = std::string(doris_home) + "/plugins/jdbc_drivers";
+    std::string default_old_url = std::string(doris_home) + "/jdbc_drivers";
+
+    if (config::jdbc_drivers_dir == default_url) {
+        std::string target_path = default_url + "/" + url;
+        std::string old_target_path = default_old_url + "/" + url;
+        if (std::filesystem::exists(target_path)) {
+            *result_url = "file://" + target_path;
+        } else if (std::filesystem::exists(old_target_path)) {
+            *result_url = "file://" + old_target_path;
+        } else {
+            return Status::InternalError("JDBC driver file does not exist: " + url);
+        }
+    } else {
+        *result_url = "file://" + config::jdbc_drivers_dir + "/" + url;
+    }
+    return Status::OK();
+}
+
+} // namespace doris
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <string>
+
+#include "common/status.h"
+
+namespace doris {
+
+/**
+ * Utility functions for JDBC driver management.
+ */
+class JdbcUtils {
+public:
+    /**
+     * Resolve a JDBC driver URL to an absolute file:// URL.
+     *
+     * FE sends just the JAR filename (e.g. "mysql-connector-java-8.0.25.jar").
+     * This method resolves it to a full file:// URL by searching in the
+     * configured jdbc_drivers_dir (or the default DORIS_HOME/plugins/jdbc_drivers).
+     *
+     * If the URL already contains ":/", it is assumed to be a full URL and
+     * returned as-is.
+     *
+     * @param url         The driver URL from FE (may be just a filename)
+     * @param result_url  Output: the resolved file:// URL
+     * @return Status::OK on success, or InternalError if the file is not found
+     */
+    static Status resolve_driver_url(const std::string& url, std::string* result_url);
+};
+
+} // namespace doris
@@ -38,7 +38,7 @@
 #include "vec/common/string_ref.h"
 #include "vec/core/field.h"
 #include "vec/core/types.h"
-#include "vec/exec/jni_connector.h"
+#include "vec/exec/jni_data_bridge.h"
 #include "vec/io/io_helper.h"
 
 namespace doris::vectorized {
@@ -110,8 +110,8 @@ struct AggregateJavaUdafData {
                                                      std::to_string(i)));
         }
         std::unique_ptr<long[]> input_table;
-        RETURN_IF_ERROR(JniConnector::to_java_table(&input_block, input_table));
-        auto input_table_schema = JniConnector::parse_table_schema(&input_block);
+        RETURN_IF_ERROR(JniDataBridge::to_java_table(&input_block, input_table));
+        auto input_table_schema = JniDataBridge::parse_table_schema(&input_block);
         std::map<String, String> input_params = {
                 {"meta_address", std::to_string((long)input_table.get())},
                 {"required_fields", input_table_schema.first},
@@ -190,7 +190,7 @@ struct AggregateJavaUdafData {
 
         Block output_block;
         output_block.insert(ColumnWithTypeAndName(to.get_ptr(), result_type, "_result_"));
-        auto output_table_schema = JniConnector::parse_table_schema(&output_block);
+        auto output_table_schema = JniDataBridge::parse_table_schema(&output_block);
         std::string output_nullable = result_type->is_nullable() ? "true" : "false";
         std::map<String, String> output_params = {{"is_nullable", output_nullable},
                                                   {"required_fields", output_table_schema.first},
@@ -205,7 +205,7 @@ struct AggregateJavaUdafData {
                                 .with_arg(output_map)
                                 .call(&output_address));
 
-        return JniConnector::fill_block(&output_block, {0}, output_address);
+        return JniDataBridge::fill_block(&output_block, {0}, output_address);
     }
 
 private: