sqlite.cpp

namespace Sqlite_types {
    enum Type: u8 {
        INVALID, S64, DOUBLE, STR, BLOB
    };
    
    constexpr static s64 sizes[] = {-1, 8, 8, 16, 16};
    constexpr static s64 aligns[] = {-1, 8, 8, 8, 8};
}

struct Sqlite_state {
    sqlite3* db = nullptr;
    Status* status = nullptr;
    Allocator* allocator = nullptr;
};

void sqlite_err(Sqlite_state* state) {
    os_error_print(state->status, 30010000000 + sqlite3_errcode(state->db), "sqlite error\n%s\n", sqlite3_errmsg(state->db));
}

s64 _sqlite_typeinfo_to_offsets(Array<u8> typeinfo, Array_dyn<s64>* out_offsets=nullptr) {
    s64 off = 0;
    s64 max_align = 1;
    for (u8 i: typeinfo) {
        assert(0 < i and i < ARRAY_SIZE(Sqlite_types::sizes));
        assert(0 < i and i < ARRAY_SIZE(Sqlite_types::aligns));
        s64 size = Sqlite_types::sizes[i];
        s64 align = Sqlite_types::aligns[i];
        
        off += off*(align - 1) % align;
        if (out_offsets) array_push(out_offsets, off);
        off += size;
        if (max_align < align) max_align = align;
    }
    off += off*(max_align - 1) % max_align;
    return off;
}

void sqlite_execute_simple(Sqlite_state* state, Array<u8> query) {
    if (state->status->bad()) return;
    sqlite3_stmt* stmt = nullptr;
    defer { sqlite3_finalize(stmt); };
    int code = sqlite3_prepare_v2(state->db, (char*)query.data, query.size, &stmt, nullptr);
    if (code) return sqlite_err(state);
    code = sqlite3_step(stmt);
    if (code != SQLITE_DONE) return sqlite_err(state);
}

void sqlite_begin(Sqlite_state* state) { sqlite_execute_simple(state, "begin"_arr); }
void sqlite_commit(Sqlite_state* state) { sqlite_execute_simple(state, "commit"_arr); }
void sqlite_rollback(Sqlite_state* state) { sqlite_execute_simple(state, "rollback"_arr); }

struct Sqlite_transaction {
    Sqlite_state* state;
    Sqlite_transaction(Sqlite_state* state_): state{state_} {
        sqlite_begin(state);
    }
    ~Sqlite_transaction() {
        if (state->status->good()) {
            sqlite_commit(state);
        } else {
            sqlite_rollback(state);
        }
    }
};
auto sqlite_transaction(Sqlite_state* state) {
    return Sqlite_transaction {state};
}

void sqlite_query_generic(
                          Sqlite_state* state,
                          Array<u8> query,
                          Array<u8> result_typeinfo,
                          Array_dyn<u8>* out_result,
                          Array<u8> param_typeinfo,
                          Array<u8> param_obj
                          ) {
    if (os_status_initp(&state->status)) return;
    
    Array_dyn<s64> param_offsets, result_offsets;
    defer { array_free(&param_offsets); };
    defer { array_free(&result_offsets); };
    s64 param_size_ = _sqlite_typeinfo_to_offsets(param_typeinfo,  &param_offsets );
    s64 result_size = _sqlite_typeinfo_to_offsets(result_typeinfo, &result_offsets);
    s64 param_count = param_size_ == 0 ? 1 : param_obj.size / param_size_;
    assert(param_size_*param_count == param_obj.size);
    
    char const* end;
    sqlite3_stmt* stmt = nullptr;
    defer { sqlite3_finalize(stmt); };
    int code = sqlite3_prepare_v2(state->db, (char*)query.data, query.size, &stmt, &end);
    if (code) return sqlite_err(state);
    if ((u8*)end != query.end()) return os_error_print(state->status, 20240126004, "SQL query contains more than one statement\n");
    
    assert(sqlite3_bind_parameter_count(stmt) == param_typeinfo.size);
    assert(sqlite3_column_count(stmt) == result_typeinfo.size);
    
    Array<u8> row = array_create<u8>(result_size);
    defer { array_free(&row); };
    
    for (s64 iter = 0; iter < param_count; ++iter) {
        if (iter > 0) {
            sqlite3_reset(stmt);
            sqlite3_clear_bindings(stmt);
        }
        
        for (s64 i = 0; i < param_typeinfo.size; ++i) {
            s64 off = iter*param_size_ + param_offsets[i];
            switch (param_typeinfo[i]) {
                case Sqlite_types::S64: {
                    sqlite3_bind_int64(stmt, i+1, *(s64*)&param_obj[off]);
                } break;
                case Sqlite_types::DOUBLE: {
                    sqlite3_bind_double(stmt, i+1, *(double*)&param_obj[off]);
                } break;
                case Sqlite_types::STR: {
                    auto arr = (Array<u8>*)&param_obj[off];
                    sqlite3_bind_text(stmt, i+1, (char*)arr->data, arr->size, SQLITE_TRANSIENT);
                } break;
                case Sqlite_types::BLOB: {
                    auto arr = (Array<u8>*)&param_obj[off];
                    sqlite3_bind_blob(stmt, i+1, (char*)arr->data, arr->size, SQLITE_TRANSIENT);
                } break;
                default: assert(false);
            }
        }
        
        code = sqlite3_step(stmt);
        
        while (code == SQLITE_ROW) {
            array_memset(row);
            
            for (s64 i = 0; i < result_typeinfo.size; ++i) {
                Array<u8> arr;
                s64 x; double y; Array<u8> z;
                
                switch (result_typeinfo[i]) {
                    case Sqlite_types::S64: {
                        x = sqlite3_column_int64(stmt, i);
                        arr = array_bytes(&x);
                    } break;
                    case Sqlite_types::DOUBLE: {
                        y = sqlite3_column_double(stmt, i);
                        arr = array_bytes(&y);
                    } break;
                    case Sqlite_types::STR: {
                        Array<u8> str;
                        str.data = (u8*)sqlite3_column_text(stmt, i);
                        str.size = sqlite3_column_bytes(stmt, i);
                        z = allocator_alloc(state->allocator, str.size);
                        array_memcpy(z, str);
                        arr = array_bytes(&z);
                    } break;
                    case Sqlite_types::BLOB: {
                        Array<u8> str;
                        str.data = (u8*)sqlite3_column_blob(stmt, i);
                        str.size = sqlite3_column_bytes(stmt, i);
                        z = allocator_alloc(state->allocator, str.size);
                        array_memcpy(z, str);
                        arr = array_bytes(&z);
                    } break;
                    default: assert(false);
                }
                
                assert(i+1 == result_offsets.size or result_offsets[i]+arr.size <= result_offsets[i+1]);
                array_memcpy(array_subarray(row, result_offsets[i], result_offsets[i]+arr.size), arr);
            }
            
            array_append(out_result, row);
            
            code = sqlite3_step(stmt);
        }
        
        if (code != SQLITE_DONE) return sqlite_err(state);
    }
}

// Memory returned by this function is inside state->allocator
// (out_result belongs to the caller and is on the heap)
template <typename T, typename S>
void sqlite_query_inplace(
                          Sqlite_state* state, Array<u8> query,
                          Array<u8> result_typeinfo, Array_dyn<T>* out_result,
                          Array<u8> param_typeinfo = {}, S* param = nullptr
                          ) {
    assert(_sqlite_typeinfo_to_offsets(result_typeinfo) == sizeof(T));
    Array_dyn<u8> arr {out_result->data, out_result->size * sizeof(T), out_result->capacity * sizeof(T)};
    sqlite_query_generic(state, query, result_typeinfo, &arr, param_typeinfo, array_bytes(param));
    out_result->data = arr.data;
    assert(arr.size % sizeof(T) == 0);
    out_result->size = arr.size / sizeof(T);
    out_result->capacity = arr.capacity / sizeof(T);
}

// Memory returned by this function is inside state->allocator
template <typename T, typename S = void>
Array<T> sqlite_query(
                      Sqlite_state* state, Array<u8> query,
                      Array<u8> result_typeinfo,
                      Array<u8> param_typeinfo = {}, S* param = nullptr
                      ) {
    assert(_sqlite_typeinfo_to_offsets(result_typeinfo) == sizeof(T));
    Array_dyn<u8> arr;
    defer { array_free(&arr); };
    sqlite_query_generic(state, query, result_typeinfo, &arr, param_typeinfo, array_bytes(param));
    assert(arr.size % sizeof(T) == 0);
    
    Array<T> arr_typed {(T*)arr.data, (s64)(arr.size / sizeof(T))};
    auto result = allocator_alloc<T>(state->allocator, arr_typed.size);
    array_memcpy(result, arr_typed);
    
    return result;
}

// Memory returned by this function is inside state->allocator
template <typename T, typename S = void>
T sqlite_query_one(
                   Sqlite_state* state, Array<u8> query,
                   Array<u8> result_typeinfo,
                   Array<u8> param_typeinfo = {}, S* param = nullptr
                   ) {
    auto arr = sqlite_query<T>(state, query, result_typeinfo, param_typeinfo, param);
    
    if (arr.size != 1) {
        os_error_print(state->status, 20240127001, "SQL query returned %d results, expected 1\n", arr.size);
        return {};
    }
    
    return arr[0];
}

template <typename S = void>
void sqlite_execute(Sqlite_state* state, Array<u8> query, Array<u8> param_typeinfo = {}, S* param = nullptr) {
    sqlite_query_generic(state, query, {}, nullptr, param_typeinfo, array_bytes(param));
}
template <typename S = void>
void sqlite_execute_many(Sqlite_state* state, Array<u8> query, Array<u8> param_typeinfo, Array<S> param) {
    sqlite_query_generic(state, query, {}, nullptr, param_typeinfo, array_bytes_arr(param));
}