litesql-gen-cpp.cpp

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provide

                .param(Variable("vals", "const litesql::FieldType::Values&", "Values()"))
                .constructor("litesql::FieldType(n,t,tbl,vals)");
            
            ftypeCl.method(cons);
            for (size_t v = 0; v < fld.values.size(); v++) {
                const xml::Value& value = fld.values[v];
                string v;
                if (fld.getCPPType() == "std::string")
                    v = quote(value.value);
                else
                    v = value.value;
                Variable val(value.name, "const " + fld.getCPPType(), v);
                
                val.static_();
                ftypeCl.variable(val);
            }
            cl.class_(ftypeCl);
        }
        Variable ftype(fld.fieldTypeName, ftypeClass, data);

        ftype.static_();
        cl.variable(ftype);
    }
    if (hasValues)
        cl.method(initValues);
    Class rowcl("Row");
    Method rowcons("Row");
    rowcons.param(Variable("db", "const litesql::Database&"))
        .param(Variable("rec", "const litesql::Record&", "litesql::Record()"));
//        .constructor("litesql::Record(db, rec)");
    Split consParams;
    int fieldNum = r.related.size() + r.fields.size();
    rowcons.body("switch(rec.size()) {");
    for (int i = r.fields.size()-1; i >= 0; i--) {
        xml::Field& fld = r.fields[i];
        Variable fldvar(fld.name, "litesql::Field<" + fld.getCPPType() + ">");
        rowcl.variable(fldvar);        

        rowcons.body("case " + toString(fieldNum) + ":")
            .body("    " + fld.name + " = rec[" + toString(fieldNum-1) + "];");
        consParams.push_back(fld.name +
                             "(" + r.getName() + "::" + fld.fieldTypeName + ")");
        fieldNum--;
        
    }
    for (int i = r.related.size()-1; i >= 0; i--) {
        xml::Relate& rel = r.related[i];
        string fname = xml::decapitalize(rel.fieldTypeName);
        Variable fld(fname, "litesql::Field<int>");
        rowcl.variable(fld);
        rowcons.body("case " + toString(fieldNum) + ":")
            .body("    " + fname + " = rec[" 
                  + toString(fieldNum-1) + "];"); 

        consParams.push_back(fname 
                             + "(" + r.getName() 
                             + "::" + rel.fieldTypeName +")");
        fieldNum--;
    }
    rowcons.body("}");
    rowcons.constructor(consParams.join(", "));
    rowcl.method(rowcons);    
    cl.class_(rowcl);

}
void writeRelMethods(xml::Database& database,
		     Class& cl, xml::Relation& r) {
    Variable dbparam("db", "const litesql::Database&");
    Variable destExpr("expr", "const litesql::Expr&", 
                       "litesql::Expr()");
    Variable srcExpr("srcExpr", "const litesql::Expr&", 
                       "litesql::Expr()");
    Method link("link", "void");
    Method unlink("unlink", "void");
    Method del("del", "void");
    Method getRows("getRows", 
                   "litesql::DataSource<"+r.getName()+"::Row>");
    
    link.static_().param(dbparam);
    link.body("Record values;")
        .body("Split fields;");
    for (size_t i = 0; i < r.related.size(); i++) {
        xml::Relate& rel = r.related[i];
        link.body("fields.push_back(" + rel.fieldTypeName + ".name());");
        link.body("values.push_back(o" + toString(i) + ".id);");
        rel.paramPos = i;
    }
    for (size_t i = 0; i < r.fields.size(); i++) {
        xml::Field& fld = r.fields[i];
        
        link.body("fields.push_back(" + fld.fieldTypeName + ".name());");
        if (fld.getCPPType() != "std::string")
            link.body("values.push_back(toString(" + fld.name + "));");
        else
            link.body("values.push_back(" + fld.name + ");");
    }
    link.body("db.insert(table__, values, fields);");
    if (r.isUnidir()==false && r.related.size() == 2 && r.sameTypes() == 2) {
        link.body("fields.clear();")
            .body("values.clear();");
        for (size_t i = 0; i < r.related.size(); i++) {
            xml::Relate& rel = r.related[i];
            link.body("fields.push_back(" + rel.fieldTypeName + ".name());");
            link.body("values.push_back(o" + toString(1-i) + ".id);");
        }
        for (size_t i = 0; i < r.fields.size(); i++) {
            xml::Field& fld = r.fields[i];
        
            link.body("fields.push_back(" + fld.fieldTypeName + ".name());");
            if (fld.getCPPType() != "std::string")
                link.body("values.push_back(toString(" + fld.name + "));");
            else
                link.body("values.push_back(" + fld.name + ");");
        }
        link.body("db.insert(table__, values, fields);");
    }

    unlink.static_().param(dbparam);
    Split unlinks;
    for (size_t i = 0; i < r.related.size(); i++) {
        xml::Relate& rel = r.related[i];
        unlinks.push_back(rel.fieldTypeName + " == o" 
                          + toString(i) + ".id");
    }
    for (size_t i = 0; i < r.fields.size(); i++) {
        xml::Field& fld = r.fields[i];
        unlinks.push_back("(" + fld.fieldTypeName + " == " + fld.name + ")");
    }
    
    unlink.body("db.delete_(table__, (" + unlinks.join(" && ") + "));");
    if (r.isUnidir()==false && r.related.size() == 2 && r.sameTypes() == 2) {
        unlinks.clear();
        for (size_t i = 0; i < r.related.size(); i++) {
            xml::Relate& rel = r.related[i];
            unlinks.push_back(rel.fieldTypeName + " == o" 
                              + toString(1-i) + ".id");
        }
        for (size_t i = 0; i < r.fields.size(); i++) {
            xml::Field& fld = r.fields[i];
            unlinks.push_back("(" + fld.fieldTypeName + " == " + fld.name + ")");
        }
        unlink.body("db.delete_(table__, (" + unlinks.join(" && ") + "));");
    }

    del.static_().param(dbparam).param(destExpr); 
    del.body("db.delete_(table__, expr);");
    getRows.static_().param(dbparam).param(destExpr)
        .body("SelectQuery sel;");

    for (size_t i = 0; i < r.related.size(); i++) {
        xml::Relate& rel = r.related[i];        
        getRows.body("sel.result(" + rel.fieldTypeName + ".fullName());");
    }
    for (size_t i = 0; i < r.fields.size(); i++) {
        xml::Field& fld = r.fields[i];
        getRows.body("sel.result(" + fld.fieldTypeName + ".fullName());");
    }
    getRows.body("sel.source(table__);")
        .body("sel.where(expr);")
        .body("return DataSource<" + r.getName() + "::Row>(db, sel);");

    for (size_t i2 = 0; i2 < r.related.size(); i2++) {
        xml::Relate& rel = r.related[i2];
        Variable obj("o" + toString(i2), "const " +  database.nspace + "::" +rel.objectName + "&");
        link.param(obj);
        unlink.param(obj);
    }
    for (size_t i2 = 0; i2 < r.fields.size(); i2++) {
        xml::Field& fld = r.fields[i2];
        link.param(Variable(fld.name, fld.getCPPType(), 
                            fld.getQuotedDefaultValue()));
        unlink.param(Variable(fld.name,  fld.getCPPType()));
    }
    cl.method(link).method(unlink).method(del).method(getRows);
    if (r.sameTypes() == 1) {
        Method getTpl("get", "litesql::DataSource<T>");
        getTpl.static_().template_("class T").defineOnly()
            .param(dbparam).param(destExpr).param(srcExpr);
        cl.method(getTpl);
        for (size_t i2 = 0; i2 < r.related.size(); i2++) {
            xml::Relate& rel = r.related[i2];
            Method get("get", "litesql::DataSource<" 
                       + database.nspace + "::" + rel.objectName + ">");
            rel.getMethodName = "get<" + rel.objectName + ">";
            get.static_().templateSpec("")
                .param(dbparam).param(destExpr).param(srcExpr)
                .body("SelectQuery sel;")
                .body("sel.source(table__);")
                .body("sel.result(" + rel.fieldTypeName + ".fullName());")
                .body("sel.where(srcExpr);")
                .body("return DataSource<" + database.nspace + "::" + rel.objectName 
                      + ">(db, "+database.nspace + "::" + rel.objectName+"::Id.in(sel) && expr);");
            cl.method(get);
        }
    } else {
        map<string, int> counter;
        for (size_t i2 = 0; i2 < r.related.size(); i2++) {
            string num;
            xml::Relate& rel = r.related[i2];
            if (r.countTypes(rel.objectName) > 1) {
                if (counter.find(rel.objectName) == counter.end())
                    counter[rel.objectName] = 0;
                counter[rel.objectName]++;
                num = toString(counter[rel.objectName]);        
            }
            rel.getMethodName = "get" + rel.objectName + num;
            Method get(rel.getMethodName, 
                       "litesql::DataSource<" + database.nspace + "::" 
                        + rel.objectName + ">");

            get.static_()
                .param(dbparam).param(destExpr).param(srcExpr)
                .body("SelectQuery sel;")
                .body("sel.source(table__);")
                .body("sel.result(" + rel.fieldTypeName + ".fullName());")
                .body("sel.where(srcExpr);")
                .body("return DataSource<" + database.nspace + "::" 
                     + rel.objectName 
                      + ">(db, "+database.nspace + "::" + rel.objectName+"::Id.in(sel) && expr);");
            cl.method(get);
        }
    }


}




void makeRelationHandles(map<string, xml::Object*>& objMap,
                         vector<xml::Object>& objects,
                         vector<xml::Relation>& relations) {
    for (size_t i = 0; i < relations.size(); i++) {
        xml::Relation& rel = relations[i];
        for (size_t i2 = 0; i2 < rel.related.size(); i2++) {
            xml::Relate& relate = rel.related[i2];
            if (objMap.find(relate.objectName) 
                == objMap.end()) 
                throw Except("undefined object : "                                      + relate.objectName);
        }
        for (size_t i2 = 0; i2 < rel.related.size(); i2++) {
            xml::Relate& relate = rel.related[i2];
            xml::Object* obj = objMap[relate.objectName];
            if (obj->relations.find(&rel) == obj->relations.end())
                obj->relations[&rel] = vector<xml::Relate*>();
            obj->relations[&rel].push_back(&relate);
            if (!relate.handle.empty()) {
                xml::RelationHandle handle(relate.handle, &rel,
                                           &relate, obj);
                for (size_t i3 = 0; i3 < rel.related.size(); i3++) {
                    if (i2 != i3) {
                        xml::Object* o = objMap[rel.related[i3].objectName];
                        handle.destObjects.push_back(make_pair(o,&rel.related[i3]));
                    }
                }
                obj->handles.push_back(handle);
            }
        }
    }
}
Records getSchema(const vector<xml::Object>& objects,
                  const vector<xml::Relation>& relations) {
    int tables = 0, sequences = 0, indexes = 0;
    Records recs;
    Record rec;
    rec.push_back(quote("schema"));
    rec.push_back(quote("table"));
    rec.push_back(quote("CREATE TABLE schema (name TEXT, type TEXT, sql TEXT);"));
    recs.push_back(rec);
    for (size_t i = 0; i < objects.size(); i++) {
        const xml::Object& obj = objects[i];
        Split fields;

        fields.push_back(obj.name + "::Id.name() + \" \" + backend->getRowIDType()");
        for (size_t i2 = obj.parentObject ? 0 : 1; 
             i2 < obj.fields.size(); i2++) {
            string unique;
            if (obj.fields[i2].isUnique())
                unique = " UNIQUE";
            if (!unique.empty())
                unique = " + " + quote(unique);
            fields.push_back(obj.name + "::" + obj.fields[i2].fieldTypeName + ".name()" 
                             + " + \" \" + " + obj.name + "::" + obj.fields[i2].fieldTypeName + ".type()" + unique);
        }
        rec.clear();
        rec.push_back(obj.name + "::table__");
        rec.push_back(quote("table"));
        rec.push_back(quote("CREATE TABLE ") + " + " + obj.name + "::table__"
                      + " + \" (\" + " + fields.join(" + \",\" + ") + " + \")\"");
        recs.push_back(rec);
        tables++;

        for (size_t i2 = obj.parentObject ? 1 : 2; 
             i2 < obj.fields.size(); i2++) {
            const xml::Field& fld = obj.fields[i2];
            if (fld.isIndexed()) {
                rec.clear();
                string iname = makeTableName(obj.getTable() + "_" + fld.name + "_idx");
                rec.push_back(quote(iname));
                rec.push_back(quote("index"));
                rec.push_back(quote("CREATE INDEX " + iname + " ON ") + " + " + obj.name + "::table__"
                                + " + \" (\" + " 
                                + obj.name + "::" + fld.fieldTypeName + ".name()"
                                + " + \")\"");