fix: fix ci tests

Author: wudidapaopao

examples/chdbArrowTest.cpp

@@ -7,6 +7,10 @@
 #include "../programs/local/chdb.h"
 #include "../contrib/arrow/cpp/src/arrow/c/abi.h"
 
+// Global test configuration
+static constexpr size_t TEST_TOTAL_ROWS = 100000;
+static constexpr size_t TEST_BATCH_SIZE = 10000;
+
 // Custom ArrowArrayStream implementation data
 struct CustomStreamData
 {
@@ -16,7 +20,7 @@ struct CustomStreamData
     size_t batch_size;
     std::string last_error;
 
-    CustomStreamData() : schema_sent(false), current_row(0), total_rows(1000000), batch_size(10000) {}
+    CustomStreamData() : schema_sent(false), current_row(0), total_rows(TEST_TOTAL_ROWS), batch_size(TEST_BATCH_SIZE) {}
 
     // Reset the stream to allow reading from the beginning
     void reset()
@@ -344,7 +348,7 @@ static void test_assert_row_count(chdb_result* result, uint64_t expected_rows, c
 void test_arrow_scan(chdb_connection conn)
 {
     std::cout << "\n=== Creating Custom ArrowArrayStream ===\n";
-    std::cout << "Data specification: 1,000,000 rows × 2 columns (id: int64, value: string)\n";
+    std::cout << "Data specification: " << TEST_TOTAL_ROWS << " rows × 2 columns (id: int64, value: string)\n";
 
     struct ArrowArrayStream stream;
     memset(&stream, 0, sizeof(stream));
@@ -375,9 +379,9 @@ void test_arrow_scan(chdb_connection conn)
     result = chdb_arrow_unregister_table(conn, non_exist_table_name);
     test_assert_chdb_state(result, "Unregister non-existent table: " + std::string(non_exist_table_name));
 
-    // Test 3: Count rows - should be exactly 1,000,000
+    // Test 3: Count rows - should be exactly TEST_TOTAL_ROWS
     chdb_result * count_result = chdb_query(conn, "SELECT COUNT(*) as total_rows FROM arrowstream(test_arrow_table)", "CSV");
-    test_assert_row_count(count_result, 1000000, "Count total rows");
+    test_assert_row_count(count_result, TEST_TOTAL_ROWS, "Count total rows");
     chdb_destroy_query_result(count_result);
 
     // Test 4: Sample first 5 rows - should contain id=0,1,2,3,4
@@ -387,31 +391,33 @@ void test_arrow_scan(chdb_connection conn)
     test_assert_query_result_contains(sample_result, "4,\"value_4\"", "First 5 rows contain fifth row");
     chdb_destroy_query_result(sample_result);
 
-    // Test 5: Sample last 5 rows - should contain id=999999,999998,999997,999996,999995
+    // Test 5: Sample last 5 rows - should contain id=(TEST_TOTAL_ROWS-1) to (TEST_TOTAL_ROWS-5)
     reset_arrow_stream(&stream);
     chdb_result * last_result = chdb_query(conn, "SELECT * FROM arrowstream(test_arrow_table) ORDER BY id DESC LIMIT 5", "CSV");
-    test_assert_query_result_contains(last_result, "999999,\"value_999999\"", "Last 5 rows contain last row");
-    test_assert_query_result_contains(last_result, "999995,\"value_999995\"", "Last 5 rows contain fifth row");
+    std::string last_row_expected = std::to_string(TEST_TOTAL_ROWS - 1) + ",\"value_" + std::to_string(TEST_TOTAL_ROWS - 1) + "\"";
+    std::string fifth_last_row_expected = std::to_string(TEST_TOTAL_ROWS - 5) + ",\"value_" + std::to_string(TEST_TOTAL_ROWS - 5) + "\"";
+    test_assert_query_result_contains(last_result, last_row_expected, "Last 5 rows contain last row");
+    test_assert_query_result_contains(last_result, fifth_last_row_expected, "Last 5 rows contain fifth row");
     chdb_destroy_query_result(last_result);
 
     // Test 6: Multiple table registration tests
-    // Create second ArrowArrayStream with different data (500,000 rows)
+    // Create second ArrowArrayStream with different data (50% of TEST_TOTAL_ROWS)
     struct ArrowArrayStream stream2;
     memset(&stream2, 0, sizeof(stream2));
     auto * stream_data2 = new CustomStreamData();
-    stream_data2->total_rows = 500000;  // Different row count
+    stream_data2->total_rows = TEST_TOTAL_ROWS / 2;  // 50% of main table
     stream_data2->current_row = 0;
     stream2.get_schema = custom_get_schema;
     stream2.get_next = custom_get_next;
     stream2.get_last_error = custom_get_last_error;
     stream2.release = custom_release;
     stream2.private_data = stream_data2;
 
-    // Create third ArrowArrayStream with different data (100,000 rows)
+    // Create third ArrowArrayStream with different data (10% of TEST_TOTAL_ROWS)
     struct ArrowArrayStream stream3;
     memset(&stream3, 0, sizeof(stream3));
     auto * stream_data3 = new CustomStreamData();
-    stream_data3->total_rows = 100000;  // Different row count
+    stream_data3->total_rows = TEST_TOTAL_ROWS / 10;  // 10% of main table
     stream_data3->current_row = 0;
     stream3.get_schema = custom_get_schema;
     stream3.get_next = custom_get_next;
@@ -435,17 +441,17 @@ void test_arrow_scan(chdb_connection conn)
     // Test 6a: Verify each table has correct row counts
     reset_arrow_stream(&stream);
     chdb_result * count1_result = chdb_query(conn, "SELECT COUNT(*) FROM arrowstream(test_arrow_table)", "CSV");
-    test_assert_row_count(count1_result, 1000000, "First table row count");
+    test_assert_row_count(count1_result, TEST_TOTAL_ROWS, "First table row count");
     chdb_destroy_query_result(count1_result);
 
     reset_arrow_stream(&stream2);
     chdb_result * count2_result = chdb_query(conn, "SELECT COUNT(*) FROM arrowstream(test_arrow_table_2)", "CSV");
-    test_assert_row_count(count2_result, 500000, "Second table row count");
+    test_assert_row_count(count2_result, TEST_TOTAL_ROWS / 2, "Second table row count");
     chdb_destroy_query_result(count2_result);
 
     reset_arrow_stream(&stream3);
     chdb_result * count3_result = chdb_query(conn, "SELECT COUNT(*) FROM arrowstream(test_arrow_table_3)", "CSV");
-    test_assert_row_count(count3_result, 100000, "Third table row count");
+    test_assert_row_count(count3_result, TEST_TOTAL_ROWS / 10, "Third table row count");
     chdb_destroy_query_result(count3_result);
 
     // Test 6b: Test cross-table JOIN query
@@ -609,16 +615,16 @@ static void create_arrow_array(struct ArrowArray * array, uint64_t row_count)
 void test_arrow_array_scan(chdb_connection conn)
 {
     std::cout << "\n=== Testing ArrowArray Scan Functions ===\n";
-    std::cout << "Data specification: 1,000,000 rows × 2 columns (id: int64, value: string)\n";
+    std::cout << "Data specification: " << TEST_TOTAL_ROWS << " rows × 2 columns (id: int64, value: string)\n";
 
     // Create ArrowSchema (reuse existing function)
     struct ArrowSchema schema;
     create_schema(&schema);
 
-    // Create ArrowArray with 1,000,000 rows
+    // Create ArrowArray with TEST_TOTAL_ROWS rows
     struct ArrowArray array;
     memset(&array, 0, sizeof(array));
-    create_arrow_array(&array, 1000000);
+    create_arrow_array(&array, TEST_TOTAL_ROWS);
 
     std::cout << "✓ ArrowArray initialization completed\n";
     std::cout << "Starting registration with chDB...\n";
@@ -634,7 +640,7 @@ void test_arrow_array_scan(chdb_connection conn)
     test_assert_chdb_state(result, "Register ArrowArray to table: " + std::string(table_name));
 
     chdb_result * count_result = chdb_query(conn, "SELECT COUNT(*) as total_rows FROM arrowstream(test_arrow_array_table)", "CSV");
-    test_assert_row_count(count_result, 1000000, "Count total rows");
+    test_assert_row_count(count_result, TEST_TOTAL_ROWS, "Count total rows");
     chdb_destroy_query_result(count_result);
 
     result = chdb_arrow_unregister_table(conn, table_name);
@@ -661,27 +667,29 @@ void test_arrow_array_scan(chdb_connection conn)
     test_assert_chdb_state(result, "Register ArrowArray for last rows query");
 
     chdb_result * last_result = chdb_query(conn, "SELECT * FROM arrowstream(test_arrow_array_table) ORDER BY id DESC LIMIT 5", "CSV");
-    test_assert_query_result_contains(last_result, "999999,\"value_999999\"", "Last 5 rows contain last row");
-    test_assert_query_result_contains(last_result, "999995,\"value_999995\"", "Last 5 rows contain fifth row");
+    std::string last_row_expected = std::to_string(TEST_TOTAL_ROWS - 1) + ",\"value_" + std::to_string(TEST_TOTAL_ROWS - 1) + "\"";
+    std::string fifth_last_row_expected = std::to_string(TEST_TOTAL_ROWS - 5) + ",\"value_" + std::to_string(TEST_TOTAL_ROWS - 5) + "\"";
+    test_assert_query_result_contains(last_result, last_row_expected, "Last 5 rows contain last row");
+    test_assert_query_result_contains(last_result, fifth_last_row_expected, "Last 5 rows contain fifth row");
     chdb_destroy_query_result(last_result);
 
     result = chdb_arrow_unregister_table(conn, table_name);
     test_assert_chdb_state(result, "Unregister ArrowArray table after last rows query");
 
     // Test 5: Independent multiple table tests
-    // Create second ArrowArray with different data (500,000 rows)
+    // Create second ArrowArray with different data (50% of TEST_TOTAL_ROWS)
     struct ArrowSchema schema2;
     create_schema(&schema2);
     struct ArrowArray array2;
     memset(&array2, 0, sizeof(array2));
-    create_arrow_array(&array2, 500000);
+    create_arrow_array(&array2, TEST_TOTAL_ROWS / 2);
 
-    // Create third ArrowArray with different data (100,000 rows)
+    // Create third ArrowArray with different data (10% of TEST_TOTAL_ROWS)
     struct ArrowSchema schema3;
     create_schema(&schema3);
     struct ArrowArray array3;
     memset(&array3, 0, sizeof(array3));
-    create_arrow_array(&array3, 100000);
+    create_arrow_array(&array3, TEST_TOTAL_ROWS / 10);
 
     const char * table_name2 = "test_arrow_array_table_2";
     const char * table_name3 = "test_arrow_array_table_3";
@@ -691,23 +699,23 @@ void test_arrow_array_scan(chdb_connection conn)
     chdb_arrow_schema arrow_schema3 = reinterpret_cast<chdb_arrow_schema>(&schema3);
     chdb_arrow_array arrow_array3 = reinterpret_cast<chdb_arrow_array>(&array3);
 
-    // Test 5a: Register -> Query -> Unregister for second table (500K rows)
+    // Test 5a: Register -> Query -> Unregister for second table (50% rows)
     result = chdb_arrow_array_scan(conn, table_name2, arrow_schema2, arrow_array2);
     test_assert_chdb_state(result, "Register second ArrowArray to table: " + std::string(table_name2));
 
     chdb_result * count2_result = chdb_query(conn, "SELECT COUNT(*) FROM arrowstream(test_arrow_array_table_2)", "CSV");
-    test_assert_row_count(count2_result, 500000, "Second array table row count");
+    test_assert_row_count(count2_result, TEST_TOTAL_ROWS / 2, "Second array table row count");
     chdb_destroy_query_result(count2_result);
 
     result = chdb_arrow_unregister_table(conn, table_name2);
     test_assert_chdb_state(result, "Unregister second ArrowArray table");
 
-    // Test 5b: Register -> Query -> Unregister for third table (100K rows)
+    // Test 5b: Register -> Query -> Unregister for third table (10% rows)
     result = chdb_arrow_array_scan(conn, table_name3, arrow_schema3, arrow_array3);
     test_assert_chdb_state(result, "Register third ArrowArray to table: " + std::string(table_name3));
 
     chdb_result * count3_result = chdb_query(conn, "SELECT COUNT(*) FROM arrowstream(test_arrow_array_table_3)", "CSV");
-    test_assert_row_count(count3_result, 100000, "Third array table row count");
+    test_assert_row_count(count3_result, TEST_TOTAL_ROWS / 10, "Third array table row count");
     chdb_destroy_query_result(count3_result);
 
     result = chdb_arrow_unregister_table(conn, table_name3);