dblang/src/defaultHandler.ts

import { Attribute, DB, Table } from "./db"
import { Aggregation, Modifier } from "./dbStructure"
import { selectQuery } from "./query"
import { allModifierInput, primaryData, serializeReturn } from "./types"

export class Handler {
    syncDB(db : DB){

    }

    querys = {
        select: (handler:Handler,q: selectQuery): serializeReturn => {
            let args: primaryData[] = [];
            let w = joinArg(", ")(handler,q.attr);
            args.push(...w[1]);
            let sql = `select ${w[0]} from ${q.from == null ? 'DUAL' : q.from.serialize(handler)}`;
            if (q.whereD) {
                let whereS = q.whereD.serialize(handler);
                args.push(...whereS[1]);
                sql += " where " + whereS[0];
            }
            if (q.groupByD.length > 0) {
                let groupByS = joinArg(",")(handler,q.groupByD);
                args.push(...groupByS[1]);
                sql += " group by " + groupByS[0];
                if (q.havingD) {
                    let havingS = q.havingD.serialize(handler);
                    args.push(...havingS[1]);
                    sql += " having " + havingS[0];
                }
            }
            if (q.limitD != null) {
                sql += " limit ?";
                args.push(q.limitD);
            }

            return [sql, args];
        },
        create:(handler:Handler,table: Table): serializeReturn=>{
            let args:primaryData[] = [];
            let sql = `create table if not exists ${table.toString(handler)}(
${Object.entries(table.dbLangTableAttributes).map(([_,a])=>{
                    let atype = a.serializeSettings(handler);
                    args.push(...(atype[1]));
                    return a.serialize(handler)+" "+atype[0];
                }).join(",\n")}
)`;
            return [sql,args];
        }
    }


    builders = {
        attributeSettings: (handler:Handler,a: Attribute): serializeReturn => {
            let dtype = a.type.serialize(handler);
            let sql = ""+dtype[0];
            let args:primaryData[] = [...dtype[1]];
            if (a.ops.autoIncrement) {
                sql += " auto_increment";
            }
            if (a.ops.primaryKey) {
                sql += " primary key";
            }
            if (a.ops.default != null) {
                if (a.ops.autoIncrement || a.ops.primaryKey || a.ops.notNull)
                    throw new Error(`Can not set default when autoIncrement, primaryKey or notNull ist set on Attribute: ${a.toStringFunc(handler)}`);
                sql += " default ?";
                args.push(a.ops.default);
            }

            if (a.ops.unique != null) {
                if (!a.ops.autoIncrement && !a.ops.primaryKey){
                    sql += " unique";
                }
            }
            if (a.ops.notNull != null) {
                if (!a.ops.autoIncrement && !a.ops.primaryKey && a.ops.default == null){
                    sql += " not null";
                }
            }

            if (a.ops.foreginKey != null) {
                sql += ` foreign key references (${a.ops.foreginKey.link.toStringFunc(handler)})`
            }

            return [sql, args];
        },
        escapeID: (key:string) :string =>{
            if(!key || key === "" || key.includes('\u0000')) throw new Error("Can not escape empty key or with null unicode!");
            if (key.match(/^`.+`$/g)) return key;
            return `\`${key.replace(/`/g, '``')}\``;
        }
    }


    aggregations = {
        count: (handler:Handler,a: Attribute): serializeReturn => ["count(" + a.toString(handler) + ")", []],
        sum: (handler:Handler,a: Attribute): serializeReturn => ["sum(" + a.toString(handler) + ")", []],
        avg: (handler:Handler,a: Attribute): serializeReturn => ["avg(" + a.toString(handler) + ")", []],
        min: (handler:Handler,a: Attribute): serializeReturn => ["min(" + a.toString(handler) + ")", []],
        max: (handler:Handler,a: Attribute): serializeReturn => ["max(" + a.toString(handler) + ")", []],
    }

    modifiers = {
        and: joinArg("and"),
        or: joinArg("or"),
        le: joinArg("<"),
        leq: joinArg("<="),
        eq: joinArg("="),
        geq: joinArg(">="),
        ge: joinArg(">"),
        plus: joinArg("+"),
        minus: joinArg("-"),
        not: (handler:Handler,a: allModifierInput[]): serializeReturn => {
            let e = a[0];
            if (e instanceof Attribute) return ["not (" + e.toString(handler) + ")", []];
            if (e instanceof Modifier || e instanceof selectQuery || e instanceof Aggregation) {
                let [sqli, argsi] = e.serialize(handler);
                return ["not (" + sqli + ")", argsi]
            }
            return ["not (?)", [e]];
        }
    }
    datatypes = {
        char: dataTypeSingleNum("char"),
        varchar: dataTypeSingleNum("varchar"),
        binary: dataTypeSingleNum("binary"),
        varbinary: dataTypeSingleNum("varbinary"),

        tinyblob: dataTypeNoArg("tinyblob"),
        blob: dataTypeNoArg("blob"),
        mediumblob: dataTypeNoArg("mediumblob"),
        longblob: dataTypeNoArg("longblob"),
        tinytext: dataTypeNoArg("tinytext"),
        text: dataTypeNoArg("text"),
        mediumtext: dataTypeNoArg("mediumtext"),
        longtext: dataTypeNoArg("longtext"),

        enum: (a: primaryData[]): serializeReturn => {
            console.log(a);
            return ["enum(" + a.map(() => "?").join(", ") + ")", a];
        },
        set: (a: primaryData[]): serializeReturn => {
            return ["set(" + a.map(() => "?").join(", ") + ")", a];
        },
        bool: dataTypeNoArg("bool"),
        bit: dataTypeNoArg("bit"),
        tinyint: dataTypeNoArg("tinyint"),
        smallint: dataTypeNoArg("smallint"),
        mediumint: dataTypeNoArg("mediumint"),
        int: dataTypeNoArg("int"),
        bigint: dataTypeNoArg("bigint"),

        float: dataTypeDblNum("float"),
        double: dataTypeDblNum("double"),
        decimal: dataTypeDblNum("decimal"),

        date: dataTypeNoArg("data"),
        datetime: dataTypeNoArg("datatime"),
        timestamp: dataTypeNoArg("timestamp"),
        time: dataTypeNoArg("time"),
        year: dataTypeNoArg("year"),
    }

};

function dataTypeNoArg(type: string) {
    return (a: primaryData[]): serializeReturn => {
        return [type, []];
    }
}
function dataTypeSingleNum(type: string) {
    return (a: primaryData[]): serializeReturn => {
        return [type + "(?)", [a[0]]];
    }
}
function dataTypeDblNum(type: string) {
    return (a: primaryData[]): serializeReturn => {
        return [type + "(?,?)", [a[0], a[1]]];
    }
}


function joinArg(type: string) {
    return (handler:Handler,a: (allModifierInput)[]): serializeReturn => {
        let args: primaryData[] = [];
        let sql = a.map(d => {
            if (d instanceof Attribute) return d.toString(handler);
            if (d instanceof Modifier || d instanceof selectQuery || d instanceof Aggregation) {
                let [sqli, argsi] = d.serialize(handler);
                args.push(...(argsi.flat(Infinity)));
                return "(" + sqli + ")";
            }
            args.push(d);
            return "?";
        }).join(" " + type + " ");
        return [sql, args]

    }
}