Result lifecycle handled by golang gc

Author: auxten

chdbstable/chdb.go

@@ -0,0 +1,89 @@
+package chdbstable
+
+/*
+#cgo LDFLAGS: -L. -lchdb
+#include <stdlib.h> // Include the C standard library for C.free
+#include "chdb.h"
+*/
+import "C"
+import (
+    "runtime"
+    "unsafe"
+)
+
+// LocalResult mirrors the C struct local_result in Go.
+type LocalResult struct {
+    cResult *C.struct_local_result
+}
+
+// newLocalResult creates a new LocalResult and sets a finalizer to free C memory.
+func newLocalResult(cResult *C.struct_local_result) *LocalResult {
+    result := &LocalResult{cResult: cResult}
+    runtime.SetFinalizer(result, freeLocalResult)
+    return result
+}
+
+// freeLocalResult is called by the garbage collector.
+func freeLocalResult(result *LocalResult) {
+    C.free_result(result.cResult)
+}
+
+// QueryStable calls the C function query_stable.
+func QueryStable(argc int, argv []string) *LocalResult {
+    cArgv := make([]*C.char, len(argv))
+    for i, s := range argv {
+        cArgv[i] = C.CString(s)
+        defer C.free(unsafe.Pointer(cArgv[i]))
+    }
+
+    cResult := C.query_stable(C.int(argc), &cArgv[0])
+    return newLocalResult(cResult)
+}
+
+// Accessor methods to access fields of the local_result struct.
+func (r *LocalResult) Buf() []byte {
+    if r.cResult == nil {
+        return nil
+    }
+    if r.cResult.buf == nil {
+        return nil
+    }
+    return C.GoBytes(unsafe.Pointer(r.cResult.buf), C.int(r.cResult.len))
+}
+
+// Stringer interface for LocalResult
+func (r LocalResult) String() string {
+    ret := r.Buf()
+    if ret == nil {
+        return ""
+    }
+    return string(ret)
+}
+
+func (r *LocalResult) Len() int {
+    if r.cResult == nil {
+        return 0
+    }
+    return int(r.cResult.len)
+}
+
+func (r *LocalResult) Elapsed() float64 {
+    if r.cResult == nil {
+        return 0
+    }
+    return float64(r.cResult.elapsed)
+}
+
+func (r *LocalResult) RowsRead() uint64 {
+    if r.cResult == nil {
+        return 0
+    }
+    return uint64(r.cResult.rows_read)
+}
+
+func (r *LocalResult) BytesRead() uint64 {
+    if r.cResult == nil {
+        return 0
+    }
+    return uint64(r.cResult.bytes_read)
+}

chdbstable/chdb.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifdef __cplusplus
+#    include <cstddef>
+#    include <cstdint>
+extern "C" {
+#else
+#    include <stddef.h>
+#    include <stdint.h>
+#endif
+
+#define CHDB_EXPORT __attribute__((visibility("default")))
+struct CHDB_EXPORT local_result
+{
+    char * buf;
+    size_t len;
+    void * _vec; // std::vector<char> *, for freeing
+    double elapsed;
+    uint64_t rows_read;
+    uint64_t bytes_read;
+};
+
+CHDB_EXPORT struct local_result * query_stable(int argc, char ** argv);
+CHDB_EXPORT void free_result(struct local_result * result);
+
+#ifdef __cplusplus
+}
+#endif

chdbstable/chdb_test.go

@@ -0,0 +1,47 @@
+package chdbstable
+
+import (
+    "testing"
+)
+
+// TestCase defines the structure of a test case
+type TestCase struct {
+    name         string   // Name of the test case
+    argv         []string // Arguments to pass to QueryStable
+    expectError  bool     // Whether an error is expected
+    expectOutput string   // Expected output
+}
+
+func TestQueryStableMultipleCases(t *testing.T) {
+    // Define a series of test cases
+    testCases := []TestCase{
+        {
+            name:        "Single Query",
+            argv:        []string{"clickhouse", "--multiquery", "--output-format=CSV", "--query=SELECT 123;"},
+            expectError: false,
+            expectOutput: "123\n",
+        },
+        {
+            name:        "Multiple Queries",
+            argv:        []string{"clickhouse", "--multiquery", "--output-format=CSV", "--query=SELECT 'abc';"},
+            expectError: false,
+            expectOutput: "abc",
+        },
+    }
+
+    // Iterate over the test cases
+    for _, tc := range testCases {
+        t.Run(tc.name, func(t *testing.T) {
+            result := QueryStable(len(tc.argv), tc.argv)
+
+            // Assert based on the expected outcome of the test case
+            if (result == nil) != tc.expectError {
+                t.Errorf("QueryStable() with args %v, expect error: %v, got result: %v", tc.argv, tc.expectError, result)
+            }
+
+            if (result != nil) && (string(result) != tc.expectOutput) {
+                t.Errorf("QueryStable() with args %v, expect output: %v, got output: %v", tc.argv, tc.expectOutput, string(result.Buf()))
+            }
+        })
+    }
+}