olapclient.cpp

// olapclient.cpp
// Implementation of the OLAP client DLL.
//
// Dependencies (Windows only):
//   - msado15.dll  : ADO COM objects (ships with Windows)
//   - MSOLAP       : Microsoft OLE DB Provider for Analysis Services
//                    Installed with SQL Server / SSMS / standalone download.
//
// Supports:
//   - MDX queries against multidimensional SSAS cubes
//   - DAX queries against tabular SSAS models (MSOLAP 11+)

// OLAPCLIENT_EXPORTS is defined by the project preprocessor settings.
// Do NOT redefine it here to avoid C4005 macro-redefinition warnings.
#include "olapclient.h"

#include <windows.h>
#include <comdef.h>
#include <string>
#include <vector>
#include <sstream>
#include <iomanip>

// Import ADO type library by its registered GUID – avoids hard-coded file paths.
// GUID: {00000205-0000-0010-8000-00AA006D2EA4} = Microsoft ADO 6.x
#import "libid:00000205-0000-0010-8000-00AA006D2EA4" \
    rename_namespace("ADODB")                         \
    rename("EOF", "AdoEOF")                           \
    rename("BOF", "AdoBOF")

// ---------------------------------------------------------------------------
// Internal structures
// ---------------------------------------------------------------------------

struct OlapConnection {
    ADODB::_ConnectionPtr spConn;
};

struct OlapResult {
    std::vector<std::string>              colNames;
    std::vector<std::vector<std::string>> rows;
};

// ---------------------------------------------------------------------------
// Thread-local error storage
// ---------------------------------------------------------------------------

static thread_local std::string g_lastError;

static void set_error(const std::string& msg) {
    g_lastError = msg;
}

static void clear_error() {
    g_lastError.clear();
}

// ---------------------------------------------------------------------------
// BSTR / VARIANT conversion helpers
// ---------------------------------------------------------------------------

static std::string bstr_to_utf8(BSTR bstr) {
    if (!bstr) return std::string();
    int len = WideCharToMultiByte(CP_UTF8, 0, bstr, -1, nullptr, 0, nullptr, nullptr);
    if (len <= 0) return std::string();
    std::string result(len - 1, '\0');
    WideCharToMultiByte(CP_UTF8, 0, bstr, -1, &result[0], len, nullptr, nullptr);
    return result;
}

static std::string variant_to_string(const _variant_t& v) {
    if (v.vt == VT_NULL || v.vt == VT_EMPTY) return std::string();

    try {
        switch (v.vt) {
        case VT_BSTR:
            return bstr_to_utf8(v.bstrVal);

        case VT_BOOL:
            return v.boolVal ? "true" : "false";

        case VT_I1:  return std::to_string(static_cast<int>(v.cVal));
        case VT_I2:  return std::to_string(v.iVal);
        case VT_I4:  return std::to_string(v.lVal);
        case VT_I8:  return std::to_string(v.llVal);
        case VT_UI1: return std::to_string(v.bVal);
        case VT_UI2: return std::to_string(v.uiVal);
        case VT_UI4: return std::to_string(v.ulVal);
        case VT_UI8: return std::to_string(v.ullVal);

        case VT_R4: {
            std::ostringstream oss;
            oss << std::setprecision(7) << v.fltVal;
            return oss.str();
        }
        case VT_R8: {
            std::ostringstream oss;
            oss << std::setprecision(15) << v.dblVal;
            return oss.str();
        }

        case VT_DECIMAL: {
            // Convert DECIMAL to double via _variant_t cast
            _variant_t dbl;
            VariantChangeType(&dbl, const_cast<VARIANT*>(static_cast<const VARIANT*>(&v)),
                              0, VT_R8);
            std::ostringstream oss;
            oss << std::setprecision(15) << dbl.dblVal;
            return oss.str();
        }

        case VT_CY: {
            // Currency: CURRENCY = 64-bit int scaled by 10000
            std::ostringstream oss;
            oss << std::setprecision(4) << std::fixed
                << (static_cast<double>(v.cyVal.int64) / 10000.0);
            return oss.str();
        }

        case VT_DATE: {
            // OLE Automation date -> SYSTEMTIME string
            SYSTEMTIME st{};
            if (VariantTimeToSystemTime(v.date, &st)) {
                char buf[32];
                snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d",
                         st.wYear, st.wMonth, st.wDay,
                         st.wHour, st.wMinute, st.wSecond);
                return buf;
            }
            // Fallback: raw double
            std::ostringstream oss;
            oss << v.date;
            return oss.str();
        }

        default: {
            // Try coercing to BSTR as a last resort
            _variant_t tmp;
            if (SUCCEEDED(VariantChangeType(&tmp, const_cast<VARIANT*>(
                    static_cast<const VARIANT*>(&v)), 0, VT_BSTR))) {
                return bstr_to_utf8(tmp.bstrVal);
            }
            return std::string();
        }
        }
    }
    catch (...) {
        return std::string();
    }
}

// ---------------------------------------------------------------------------
// COM initialisation guard (per-thread, reference-counted)
// ---------------------------------------------------------------------------

struct ComInit {
    bool ok;
    ComInit()  : ok(SUCCEEDED(CoInitializeEx(nullptr, COINIT_MULTITHREADED))) {}
    ~ComInit() { if (ok) CoUninitialize(); }
};
static thread_local ComInit g_comInit;

// ---------------------------------------------------------------------------
// API implementation
// ---------------------------------------------------------------------------

OLAP_API OLAP_CONN olap_connect(const char* connection_string) {
    clear_error();
    if (!connection_string || !*connection_string) {
        set_error("Connection string must not be empty.");
        return nullptr;
    }

    // Ensure COM is initialised on this thread
    if (!g_comInit.ok) {
        set_error("CoInitializeEx failed.");
        return nullptr;
    }

    auto* ctx = new (std::nothrow) OlapConnection();
    if (!ctx) {
        set_error("Out of memory.");
        return nullptr;
    }

    try {
        HRESULT hr = ctx->spConn.CreateInstance(__uuidof(ADODB::Connection));
        if (FAILED(hr)) {
            set_error("Failed to create ADO Connection object.");
            delete ctx;
            return nullptr;
        }

        // Convert UTF-8 connection string to wide, then to BSTR
        int wlen = MultiByteToWideChar(CP_UTF8, 0, connection_string, -1, nullptr, 0);
        std::wstring wcs(wlen, L'\0');
        MultiByteToWideChar(CP_UTF8, 0, connection_string, -1, &wcs[0], wlen);

        ctx->spConn->Open(_bstr_t(wcs.c_str()), L"", L"", ADODB::adConnectUnspecified);
    }
    catch (_com_error& ce) {
        std::string msg = "Connection failed: ";
        if (ce.Description().length() > 0)
            msg += bstr_to_utf8(ce.Description());
        else
            msg += bstr_to_utf8(_bstr_t(ce.ErrorMessage()));
        set_error(msg);
        delete ctx;
        return nullptr;
    }
    catch (...) {
        set_error("Unknown exception during connection.");
        delete ctx;
        return nullptr;
    }

    return static_cast<OLAP_CONN>(ctx);
}

OLAP_API void olap_disconnect(OLAP_CONN conn) {
    if (!conn) return;
    auto* ctx = static_cast<OlapConnection*>(conn);
    try {
        if (ctx->spConn && ctx->spConn->State != ADODB::adStateClosed)
            ctx->spConn->Close();
    }
    catch (...) {}
    delete ctx;
}

OLAP_API int olap_is_connected(OLAP_CONN conn) {
    if (!conn) return 0;
    auto* ctx = static_cast<OlapConnection*>(conn);
    try {
        return (ctx->spConn && ctx->spConn->State == ADODB::adStateOpen) ? 1 : 0;
    }
    catch (...) {
        return 0;
    }
}

OLAP_API OLAP_RESULT olap_execute(OLAP_CONN conn, const char* query, int query_type) {
    clear_error();
    if (!conn) {
        set_error("Invalid connection handle.");
        return nullptr;
    }
    if (!query || !*query) {
        set_error("Query must not be empty.");
        return nullptr;
    }

    auto* ctx = static_cast<OlapConnection*>(conn);
    auto* res = new (std::nothrow) OlapResult();
    if (!res) {
        set_error("Out of memory.");
        return nullptr;
    }

    try {
        // For DAX queries on tabular models, MSOLAP 11+ auto-detects the dialect.
        // If needed, we can set the "Dialect" connection property to force DAX:
        //   GUID {C8B522D7-5CF3-11CE-ADE5-00AA0044773D} = MDX
        //   GUID {ED4E3EA1-6F82-4C7C-9DD1-D7E07D21E93F} = DAX
        // For maximum compatibility we pass the query as plain text; modern MSOLAP
        // determines the dialect from the query content.

        ADODB::_RecordsetPtr spRs;
        spRs.CreateInstance(__uuidof(ADODB::Recordset));

        _variant_t vtConn(static_cast<IDispatch*>(ctx->spConn));

        // Convert UTF-8 query to wide BSTR
        int wlen = MultiByteToWideChar(CP_UTF8, 0, query, -1, nullptr, 0);
        std::wstring wq(wlen, L'\0');
        MultiByteToWideChar(CP_UTF8, 0, query, -1, &wq[0], wlen);

        spRs->Open(_bstr_t(wq.c_str()), vtConn,
                   ADODB::adOpenForwardOnly,
                   ADODB::adLockReadOnly,
                   ADODB::adCmdText);

        long fieldCount = spRs->Fields->Count;

        // Collect column names
        res->colNames.reserve(static_cast<size_t>(fieldCount));
        for (long i = 0; i < fieldCount; ++i) {
            ADODB::FieldPtr fld = spRs->Fields->GetItem(static_cast<long>(i));
            res->colNames.push_back(bstr_to_utf8(fld->Name));
        }

        // Collect rows
        while (!spRs->AdoEOF) {
            std::vector<std::string> row;
            row.reserve(static_cast<size_t>(fieldCount));
            for (long i = 0; i < fieldCount; ++i) {
                ADODB::FieldPtr fld = spRs->Fields->GetItem(static_cast<long>(i));
                row.push_back(variant_to_string(_variant_t(fld->Value)));
            }
            res->rows.push_back(std::move(row));
            spRs->MoveNext();
        }

        spRs->Close();
    }
    catch (_com_error& ce) {
        std::string msg = "Query execution failed: ";
        if (ce.Description().length() > 0)
            msg += bstr_to_utf8(ce.Description());
        else
            msg += bstr_to_utf8(_bstr_t(ce.ErrorMessage()));
        set_error(msg);
        delete res;
        return nullptr;
    }
    catch (...) {
        set_error("Unknown exception during query execution.");
        delete res;
        return nullptr;
    }

    return static_cast<OLAP_RESULT>(res);
}

OLAP_API void olap_free_result(OLAP_RESULT result) {
    if (result)
        delete static_cast<OlapResult*>(result);
}

OLAP_API int olap_get_column_count(OLAP_RESULT result) {
    if (!result) return -1;
    return static_cast<int>(static_cast<OlapResult*>(result)->colNames.size());
}

OLAP_API long long olap_get_row_count(OLAP_RESULT result) {
    if (!result) return -1LL;
    return static_cast<long long>(static_cast<OlapResult*>(result)->rows.size());
}

OLAP_API const char* olap_get_column_name(OLAP_RESULT result, int col_index) {
    if (!result) return nullptr;
    auto* res = static_cast<OlapResult*>(result);
    if (col_index < 0 || static_cast<size_t>(col_index) >= res->colNames.size())
        return nullptr;
    return res->colNames[static_cast<size_t>(col_index)].c_str();
}

OLAP_API const char* olap_get_value(OLAP_RESULT result, long long row_index, int col_index) {
    if (!result) return nullptr;
    auto* res = static_cast<OlapResult*>(result);
    if (row_index < 0 || static_cast<size_t>(row_index) >= res->rows.size())
        return nullptr;
    const auto& row = res->rows[static_cast<size_t>(row_index)];
    if (col_index < 0 || static_cast<size_t>(col_index) >= row.size())
        return nullptr;
    return row[static_cast<size_t>(col_index)].c_str();
}

OLAP_API const char* olap_get_last_error(void) {
    return g_lastError.c_str();
}

OLAP_API const char* olap_get_version(void) {
    return "1.0.0";
}

// ---------------------------------------------------------------------------
// DLL entry point
// ---------------------------------------------------------------------------

BOOL APIENTRY DllMain(HMODULE /*hModule*/, DWORD reason, LPVOID /*lpReserved*/) {
    switch (reason) {
    case DLL_PROCESS_ATTACH:
    case DLL_PROCESS_DETACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
        break;
    }
    return TRUE;
}