sorm/sorm.h

#ifndef SORM_H
#define SORM_H
#include "str.h"
#include <ctype.h>
#include <rlib.h>
#include <sqlite3.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

sqlite3 *db;
sqlite3_stmt *stmt;

char *sorm_last_query = NULL;
char *sorm_last_query_expanded = NULL;

nsecs_t _sorm_query_start = 0;
nsecs_t _sorm_query_end = 0;
nsecs_t _sorm_query_duration = 0;

nsecs_t _sorm_result_format_start = 0;
nsecs_t _sorm_result_format_end = 0;
nsecs_t _sorm_result_format_duration = 0;

int64_t sorm_row_count = 0;

typedef struct sorm_t {
    sqlite3 *conn;
    int current_row;
    int current_column;
    char *csv;
    nsecs_t time_query_start;
    nsecs_t time_query_end;
    nsecs_t time_query_duration;
    nsecs_t time_result_format_start;
    nsecs_t time_result_format_end;
    nsecs_t time_result_format_duration;
} sorm_t;
typedef char *sorm_pk;
typedef char *sorm_int;
typedef char *sorm_ptr;
typedef unsigned char *sorm_str;
typedef double sorm_double;
typedef double sorm_float;
typedef bool sorm_bool;

int sormc(char *path);
void sormd(int db);
char *sormpt(char *sql, int number);
unsigned int sormcq(char *sql, char *out);
unsigned int sormpc(char *sql);
sqlite3_stmt *sormb(sorm_t *db, char *sql, ...);
sorm_ptr sormq(int db, char *sql, ...);
char *sorm_csvc(int db, sqlite3_stmt *stmt);
char *sorm_csvd(int db, sqlite3_stmt *stmt);
char *sorm_csv(int db, sqlite3_stmt *stmt);

typedef enum sorm_query_t {
    SORM_UNKNOWN = 0,
    SORM_SELECT = 1,
    SORM_INSERT = 2,
    SORM_UPDATE = 3,
    SORM_DELETE = 4,
    SORM_CREATE = 5
} sorm_query_t;

const int sorm_null = -1337;

sorm_t **sorm_instances = NULL;
int sorm_instance_count = 0;

int sormc(char *path) {
    // sorm connect
    printf("HIERR\n");
    sorm_instance_count++;
    sorm_instance_count++;
    sorm_instances = realloc(sorm_instances, sorm_instance_count * sizeof(sorm_t *) + sorm_instance_count * sizeof(sorm_t));

    printf("HIERR\n");
    sorm_t *db = &sorm_instances[sorm_instance_count - 1];

    printf("HIERR\n");
    db->conn = NULL;

    printf("HIERR\n");
    db->csv = NULL;
    db->current_column = 0;
    db->current_row = 0;
    db->time_query_duration = 0;
    db->time_query_end = 0;
    db->time_query_start = 0;
    db->time_result_format_duration = 0;
    db->time_result_format_end = 0;
    db->time_result_format_start = 0;

    if (sqlite3_open(path, &db->conn)) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db->conn));
        return 0;
    }
    printf("DONE!\n");
    return sorm_instance_count;
}
sorm_t *sormg(int ptr) { return &sorm_instances[ptr - 1]; }

char *sormgcsv(int ptr) {
    /* sorm get csv*/
    sorm_t *db = sormg(ptr);
    return db->csv;
}

void sormd(int sorm) {
    sorm_t *db = sormg(sorm);
    if (sqlite3_close(db->conn)) {
        fprintf(stderr, "Error closing database: %s\n", sqlite3_errmsg(db->conn));
    }
    if (sorm_last_query) {
        free(sorm_last_query);
        sorm_last_query = NULL;
    }
    if (sorm_last_query_expanded) {
        free(sorm_last_query_expanded);
        sorm_last_query_expanded = NULL;
    }
}

char *sormpt(char *sql, int number) {
    // param type
    char *sqlp = sql;
    char *result = NULL;
    int index = 0;
    while (*sqlp) {
        if (*sqlp == '%' || *sqlp == '?') {
            sqlp++;
            switch (*sqlp) {
            case 'f':
                result = "double";
                break;
            case 's':
                result = "text";
                break;
            case 'd':
                result = "int";
                break;
            case 'b':
                result = "blob";
                break;
            default:
                result = "?";
                break;
            }
            sqlp++;
            index++;
        }
        if (index == number) {
            return result;
        }
        if (*sqlp)
            sqlp++;
    }
    if (number > index) {
        printf("RETURNED\n");
        return NULL;
    }
    return NULL;
}

unsigned int sormcq(char *sql, char *out) {
    // clean query
    // converts %s %i parameters to ?

    unsigned int count = 0;
    while (*sql) {
        if (*sql != '%' && *sql != '?')
            *out = *sql;
        else {
            count++;
            sql++;
            *out = '?';
        }
        out++;
        sql++;
    }
    *out = 0;
    return count;
}

unsigned int sormpc(char *sql) {

    int number = 0;
    while (sormpt(sql, number) != NULL)
        number++;
    printf("FOUND: %d\n", number);
    return number;
}

char *sormcts(int column_type) {
    if (column_type == SQLITE_INTEGER)
        return "integer";
    else if (column_type == SQLITE_TEXT)
        return "text";
    else if (column_type == SQLITE_FLOAT)
        return "float";
    else if (column_type == SQLITE_NULL)
        return "null";
    else if (column_type == SQLITE_BLOB)
        return "blob";
    return "?";
}
/*
Execute 3.35s, Format: 36.77s
Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
*/
char *sorm_csvc(int db, sqlite3_stmt *stmt) {
    sormstr_t *str = sormstrn(512);
    unsigned int column_count = sqlite3_column_count(stmt);
    for (int i = 0; i < column_count; i++) {
        const char *column_name = sqlite3_column_name(stmt, i);
        sormstra(str, column_name);
        sormstra(str, "(");
        char column_type[1000] = "";
        sprintf(column_type, "%s", sormcts(sqlite3_column_type(stmt, i)));
        sormstra(str, column_type);
        sormstra(str, ")");

        // if(i != column_count - 1)
        sormstra(str, ";");
    }
    return sormstrc(str);
}
char *sorm_csvd(int sorm, sqlite3_stmt *stmt) {
    sorm_t *db = sormg(sorm);
    int rc = SQLITE_ROW;
    int column_count = sqlite3_column_count(stmt);
    /*
    sormstrn(1)
    Execute 3.41s, Format: 36.77s
    Memory usage: 5 MB, 96.061 (re)allocated, 96.024 unqiue freed, 2 in use.
    sormstrn(512)
    Execute 3.68s, Format: 36.83s
    Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
    sormstrn(256)
    xecute 3.42s, Format: 37.33s
    Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
    */
    sormstr_t *str = sormstrn(512);
    while (rc == SQLITE_ROW) {
        sorm_row_count++;
        for (int field_index = 0; field_index < column_count; field_index++) {
            if (sqlite3_column_type(stmt, field_index) == SQLITE_INTEGER) {
                char temp[1000] = "";
                sprintf(temp, "%lld", sqlite3_column_int64(stmt, field_index));
                sormstra(str, temp);
            } else if (sqlite3_column_type(stmt, field_index) == SQLITE_FLOAT) {
                char temp[1000] = "";
                sprintf(temp, "%f", sqlite3_column_double(stmt, field_index));
                sormstra(str, temp);
            } else if (sqlite3_column_type(stmt, field_index) == SQLITE3_TEXT) {
                const char *temp = sqlite3_column_text(stmt, field_index);
                sormstra(str, temp);
            } else {
                // exit(1);
            }
            //  if(field_index != column_count - 1)
            sormstra(str, ";");
        }
        sormstra(str, "\n");
        rc = sqlite3_step(stmt);
    }
    char *text = sormstrc(str);
    if (*text)
        if (text[strlen(text) - 1] == '\n')
            text[strlen(text) - 1] = 0;
    return strdup(text);
}

char *sorm_csv(int sorm, sqlite3_stmt *stmt) {
    sorm_t *db = sormg(sorm);
    sorm_row_count = 0;
    char *column_names = sorm_csvc(sorm, stmt);
    char *data = sorm_csvd(sorm, stmt);
    char *result = (char *)malloc(strlen(column_names) + strlen(data) + 2);
    result[0] = 0;
    strcat(result, column_names);
    if (*column_names)
        strcat(result, "\n");
    free(column_names);
    strcat(result, data);
    free(data);
    return result;
}

sqlite3_stmt *sormb(sorm_t *db, char *sql, ...) {
    // Bind parameters to statement and return amount of parameters
    int rc = 0;
    sqlite3_stmt *stmt;
    va_list args;
    va_start(args, sql);
    unsigned int number = 0;
    char *clean_query = (char *)malloc(strlen(sql) + 1);
    unsigned int parameter_count = sormcq(sql, clean_query);
    free(clean_query);

    return stmt;
}

char *sormm(sorm_t *db) {
    /* sormmemory */
    return rmalloc_stats();
}

sorm_ptr sormq(int sorm, char *sql, ...) {
    sorm_t *db = sormg(sorm);
    if (db->csv) {
        // free(db->csv);
        // db->csv = NULL;
    }
    _sorm_query_start = nsecs();
    db->time_query_start = nsecs();
    va_list args;
    va_start(args, sql);
    sqlite3_stmt *stmt;
    sorm_ptr result = NULL;
    char *clean_query = malloc(strlen(sql) + 1);
    unsigned int parameter_count = sormcq(sql, clean_query);
    int rc = sqlite3_prepare_v2(db->conn, clean_query, -1, &stmt, 0);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "%s\n", sqlite3_errmsg(db->conn));
    }
    free(clean_query);
    int number = 0;
    for (int i = 0; i < parameter_count; i++) {
        number++;
        char *column_type = sormpt(sql, number);
        int arg_index = number - 1;
        if (!strcmp(column_type, "int") || !strcmp(column_type, "integer") || !strcmp(column_type, "number")) {
            rc = sqlite3_bind_int(stmt, number, va_arg(args, int));
        } else if (!strcmp(column_type, "int64")) {
            rc = sqlite3_bind_int64(stmt, number, va_arg(args, __uint64_t));
        } else if (!strcmp(column_type, "double") || !strcmp(column_type, "dec") || !strcmp(column_type, "decimal") ||
                   !strcmp(column_type, "float")) {
            rc = sqlite3_bind_double(stmt, number, va_arg(args, double));
        } else if (!strcmp(column_type, "blob")) {
            size_t size = (size_t)va_arg(args, size_t);
            unsigned char *data = va_arg(args, unsigned char *);
            rc = sqlite3_bind_blob(stmt, number, data, size, SQLITE_STATIC);
        } else if (!strcmp(column_type, "text") || !strcmp(column_type, "str") || !strcmp(column_type, "string")) {
            unsigned char *data = va_arg(args, unsigned char *);
            rc = sqlite3_bind_text(stmt, number, data, -1, SQLITE_STATIC);
        }
        if (rc != SQLITE_OK) {
            fprintf(stderr, "Failed to bind parameters: %s\n", sqlite3_errmsg(db->conn));
            result = NULL;
        }
    }
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
        fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
    } else if (rc == SQLITE_DONE) {
        if (!sqlite3_strnicmp(sql, "SELECT", 6)) {
            result = 0;
        } else {
            result = (sorm_ptr)sqlite3_last_insert_rowid(db->conn);
        }
    } else if (rc == SQLITE_ROW) {
        result = sorm_csv(sorm, stmt);
    }

    else {
        fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
    }
    if (sorm_last_query) {
        free(sorm_last_query);
    }
    if (sorm_last_query) {
        free(sorm_last_query_expanded);
    }
    sorm_last_query = strdup(sqlite3_sql(stmt));
    sorm_last_query_expanded = strdup(sqlite3_expanded_sql(stmt));
    sqlite3_finalize(stmt);
    _sorm_query_end = nsecs();
    _sorm_query_duration = _sorm_query_end - _sorm_query_start;
    db->time_query_end = nsecs();
    db->time_query_duration = db->time_query_end - db->time_query_start;
    db->csv = result;
    return result;
}

char sormlc(char *sql) {
    // returns last char
    char last_char = 0;
    while (*sql) {
        if (*sql == ' ' || *sql == '\t' || *sql == '\n')
            continue;

        // printf("%c\n",*sql);
        last_char = *sql;
        sql++;
    }
    return last_char;
}

int sormlv(char *csv) {
    size_t longest = 0;
    while (*csv) {
        char *found = strstr(csv, ";");
        if (found) {
            if (found - csv > longest)
                longest = found - csv;
            csv = csv + (found - csv) + 1;
        } else {
            break;
        }
    }
    return longest;
}

sorm_query_t sormqt(char *sql) {
    while (*sql && isspace(*sql))
        sql++;
    if (!sqlite3_strnicmp(sql, "select", 6))
        return SORM_SELECT;
    else if (!sqlite3_strnicmp(sql, "update", 6))
        return SORM_UPDATE;
    else if (!sqlite3_strnicmp(sql, "delete", 6))
        return SORM_DELETE;
    else if (!sqlite3_strnicmp(sql, "create", 6)) {
        return SORM_CREATE;
    } else {
        return SORM_UNKNOWN;
    }
}

char *sormrq(FILE *f) {

    static char buffer[4097];
    buffer[0] = 0;
    char *bufferp = buffer;
    char c;
    bool in_string = false;
    while ((c = fgetc(f)) != EOF && strlen(buffer) != sizeof(buffer) - 2) {
        *bufferp = c;
        if (c == '"') {
            in_string = !in_string;
        }
        if (!in_string && c == ';') {
            break;
        }
        bufferp++;
        *bufferp = 0;
    }
    return strdup(buffer);
}

char *sormcsvn(char *csv) {
    if (!csv || !*csv)
        return NULL;
    char *pos = strstr(csv, ";");
    char *pos2 = strstr(csv, "\n");
    if (pos2) {
        if (pos > pos2) {
            pos = pos2;
        }
        // pos = pos > pos2 ? pos2 : pos;
    }
    if (!pos || !*pos)
        return strdup(csv);

    int length = pos - csv;

    char *result = malloc(length + 2);
    strncpy(result, csv, length);
    result[length] = 0;
    // csv += strlen(result);
    return result;
}

char *sormfmt(char *csv) {
    _sorm_result_format_start = nsecs();
    size_t longest = sormlv(csv);
    char *field;
    /*
    sormstrn(1)
    Execute 3.77s, Format: 36.40s
    Memory usage: 6 MB, 96.055 (re)allocated, 96.024 unqiue freed, 2 in use.
    sormstrn(longest);
    Execute 3.27s, Format: 36.61s
    Memory usage: 6 MB, 96.053 (re)allocated, 96.024 unqiue freed, 2 in use.
    sormstrn(longest * 2);
    xecute 3.42s, Format: 37.33s
    Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
    sormstrn(512);
    Execute 3.11s, Format: 36.45s
    Memory usage: 6 MB, 96.048 (re)allocated, 96.024 unqiue freed, 2 in use.
    */
    sormstr_t *str = sormstrn(longest + 2);
    while (*csv && (field = sormcsvn(csv))) {
        sormstra(str, field);
        for (int i = 0; i < longest - strlen(field); i++)
            sormstra(str, " ");

        csv += strlen(field);
        while (*csv == ';' || *csv == '\n') {
            if (*csv == '\n')
                sormstra(str, "\n");
            csv++;
        }
        free(field);
    }
    _sorm_result_format_end = nsecs();
    _sorm_result_format_duration = _sorm_result_format_end - _sorm_result_format_start;
    return sormstrc(str);
}

void apply_colors(char *csv) {
    char *end;

    bool even = false;
    while (*csv) {
        printf("%s\n", csv);
        end = strstr(csv, "\n");
        char *line;
        if (end) {
            line = (char *)malloc(end - csv + 1024);
            strncpy(line, csv, end - csv);
        } else {
            line = (char *)malloc(strlen(csv) + 1024);
            strcpy(line, csv);
        }
        if (even) {
            printf("%s", "\033[37m");
        }
        printf("%s\n", line);
        free(line);
        if (even) {
            printf("%s", "\033[0m");
        }
        even = !even;
        csv += end - csv;

        if (*csv && *(csv + 1))
            csv++;
    }
}

void sormfmtd(char *csv) {
    char *formatted = sormfmt(csv);
    printf("%s\n", formatted);
    free(formatted);
}

#endif