ci: ttc test with arrow body format. (#18985)

* ci: ttc test with arrow body format.

* fix dynamic_schema

Author: youngsofun

src/query/service/src/interpreters/util.rs

@@ -137,7 +137,10 @@ impl Client for ScriptClient {
         let interpreter = InterpreterFactory::get(ctx.clone(), &plan).await?;
         let stream = interpreter.execute(ctx.clone()).await?;
         let blocks = stream.try_collect::<Vec<_>>().await?;
-        let schema = plan.schema();
+        let mut schema = plan.schema();
+        if let Some(real_schema) = interpreter.get_dynamic_schema().await {
+            schema = real_schema;
+        }
 
         let block = match blocks.len() {
             0 => DataBlock::empty_with_schema(schema.clone()),

tests/sqllogictests/src/client/mod.rs

@@ -31,12 +31,22 @@ pub use ttc_client::TTCClient;
 use crate::error::Result;
 use crate::util::ColumnType;
 
+#[derive(Debug, Clone, Copy)]
+pub enum BodyFormat {
+    Json,
+    Arrow,
+}
+
 #[derive(Debug, Clone)]
 pub enum ClientType {
     MySQL,
     Http,
     // Tcp Testing Container
-    Ttc(String, u16),
+    Ttc {
+        image: String,
+        port: u16,
+        body_format: BodyFormat,
+    },
     Hybird,
 }
 

tests/sqllogictests/src/main.rs

@@ -36,6 +36,7 @@ use testcontainers::GenericImage;
 use testcontainers::Image;
 
 use crate::arg::SqlLogicTestArgs;
+use crate::client::BodyFormat;
 use crate::client::Client;
 use crate::client::ClientType;
 use crate::client::HttpClient;
@@ -65,17 +66,27 @@ static HYBRID_CONFIGS: LazyLock<Vec<(Box<ClientType>, usize)>> = LazyLock::new(|
     vec![
         (Box::new(ClientType::MySQL), 3),
         (
-            Box::new(ClientType::Ttc(
-                "ghcr.io/databendlabs/ttc-rust:latest".to_string(),
-                TTC_PORT_START,
-            )),
+            Box::new(ClientType::Ttc {
+                image: "ghcr.io/databendlabs/ttc-rust:latest".to_string(),
+                port: TTC_PORT_START,
+                body_format: BodyFormat::Arrow,
+            }),
             5,
         ),
         (
-            Box::new(ClientType::Ttc(
-                "ghcr.io/databendlabs/ttc-go:latest".to_string(),
-                TTC_PORT_START + 1,
-            )),
+            Box::new(ClientType::Ttc {
+                image: "ghcr.io/databendlabs/ttc-rust:latest".to_string(),
+                port: TTC_PORT_START + 1,
+                body_format: BodyFormat::Json,
+            }),
+            5,
+        ),
+        (
+            Box::new(ClientType::Ttc {
+                image: "ghcr.io/databendlabs/ttc-go:latest".to_string(),
+                port: TTC_PORT_START + 2,
+                body_format: BodyFormat::Json,
+            }),
             5,
         ),
     ]
@@ -138,12 +149,20 @@ pub async fn main() -> Result<()> {
             handler if handler.starts_with("ttc") => {
                 if handler != "ttc_dev" {
                     let image = format!("ghcr.io/databendlabs/{handler}:latest");
-                    run_ttc_container(&image, TTC_PORT_START, args.port, &mut containers).await?;
+                    run_ttc_container(
+                        &image,
+                        TTC_PORT_START,
+                        args.port,
+                        &mut containers,
+                        BodyFormat::Json,
+                    )
+                    .await?;
                 }
-                run_ttc_client(
-                    args.clone(),
-                    ClientType::Ttc(handler.to_string(), TTC_PORT_START),
-                )
+                run_ttc_client(args.clone(), ClientType::Ttc {
+                    image: handler.to_string(),
+                    port: TTC_PORT_START,
+                    body_format: BodyFormat::Json,
+                })
                 .await?;
             }
             _ => {
@@ -181,8 +200,12 @@ async fn run_hybrid_client(
     for (c, _) in HYBRID_CONFIGS.iter() {
         match c.as_ref() {
             ClientType::MySQL | ClientType::Http => {}
-            ClientType::Ttc(image, port) => {
-                run_ttc_container(image, *port, args.port, cs).await?;
+            ClientType::Ttc {
+                image,
+                port,
+                body_format,
+            } => {
+                run_ttc_container(image, *port, args.port, cs, *body_format).await?;
             }
             ClientType::Hybird => panic!("Can't run hybrid client in hybrid client"),
         }
@@ -221,7 +244,11 @@ async fn create_databend(client_type: &ClientType, filename: &str) -> Result<Dat
             client = Client::Http(HttpClient::create(args.port).await?);
         }
 
-        ClientType::Ttc(image, port) => {
+        ClientType::Ttc {
+            image,
+            port,
+            body_format: _,
+        } => {
             let conn = format!("127.0.0.1:{port}");
             client = Client::Ttc(TTCClient::create(image, &conn).await?);
         }

tests/sqllogictests/src/util.rs

@@ -42,6 +42,7 @@ use walkdir::DirEntry;
 use walkdir::WalkDir;
 
 use crate::arg::SqlLogicTestArgs;
+use crate::client::BodyFormat;
 use crate::error::DSqlLogicTestError;
 use crate::error::Result;
 
@@ -254,6 +255,7 @@ pub async fn run_ttc_container(
     port: u16,
     http_server_port: u16,
     cs: &mut Vec<ContainerAsync<GenericImage>>,
+    body_format: BodyFormat,
 ) -> Result<()> {
     let docker = &docker_client_instance().await?;
     let mut images = image.split(":");
@@ -271,10 +273,13 @@ pub async fn run_ttc_container(
     let container_name = format!("databend-ttc-{}-{}", port, x);
     let start = Instant::now();
     println!("Starting container {container_name}");
-    let dsn = format!(
+    let mut dsn = format!(
         "databend://root:@127.0.0.1:{}?sslmode=disable",
         http_server_port
     );
+    if matches!(body_format, BodyFormat::Arrow) {
+        dsn = format!("{dsn}&body_format=arrow");
+    }
 
     let mut i = 1;
     loop {