litesql-gen-cpp.cpp

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

                recs.push_back(rec);
                indexes++;
            }
        }
        for (size_t i2 = 0; i2 < obj.indexes.size(); i2++) {
            const xml::Index& idx = obj.indexes[i2];
            Split flds;
            
            for (size_t i3 = 0; i3 < idx.fields.size(); i3++) 
                flds.push_back(obj.name + "::" + idx.fields[i3].name + "_.name()");
            string iname = makeTableName(obj.getTable() + "_" + flds.join("_") + "_idx");
            string unique = "";
            if (idx.isUnique())
                unique = " UNIQUE";
            rec.clear();
            rec.push_back(quote(iname));
            rec.push_back(quote("index"));
            rec.push_back(quote("CREATE"+unique+" INDEX " + iname 
                                + " ON ") + " + " + obj.name + "::table__"
                          + " + \" (\" + " + flds.join(" + \",\" + ")
                          + " + \")\"");
            recs.push_back(rec);                 
            indexes++;
        }
            
        
        if (!obj.parentObject) {
            rec.clear();
            rec.push_back(obj.name + "::sequence__");
            rec.push_back(quote("sequence"));
            rec.push_back(quote("CREATE SEQUENCE \" + " 
                                + obj.name + "::sequence__ + \"" 
                                + " START 1 INCREMENT 1"));
            recs.push_back(rec);
            sequences++;
        }
    }
        
    for (size_t i = 0; i < relations.size(); i++) { 
        const xml::Relation& rel = relations[i];
        Split fields, indexFields;
        for (size_t i2 = 0; i2 < rel.related.size(); i2++) {
            const xml::Relate& relate = rel.related[i2];
            string extra;
            if (relate.isUnique())
                    extra = " + " + quote(" UNIQUE");
            else if (rel.related.size() == 2) { 
                if (i2 == 0 && rel.related[1].hasLimit())
                    extra = " + " + quote(" UNIQUE");
                if (i2 == 1 && rel.related[0].hasLimit())
                    extra = " + " + quote(" UNIQUE");
            }
            
                
            fields.push_back(rel.getName() + "::" 
                             + relate.fieldTypeName + ".name() + \" \" + "
                                   + rel.getName() + "::" + relate.fieldTypeName + ".type()" 
                             + extra);
            indexFields.push_back(rel.getName() + "::" + relate.fieldTypeName + ".name()");

        }
       
        for (size_t i2 = 0; i2 < rel.fields.size(); i2++) {
            const xml::Field& fld = rel.fields[i2];
            string unique;
            if (fld.isUnique())
                unique = " UNIQUE";
            if (!unique.empty())
                unique = " + " + quote(unique);
                
            fields.push_back(rel.getName() + "::" + fld.fieldTypeName 

                             + ".name() + \" \" + " + 
                             rel.getName() + "::" + fld.fieldTypeName + "_.type()"
                             + unique);
        }
        rec.clear();
        rec.push_back(rel.getName() + "::table__");
        rec.push_back(quote("table"));
        rec.push_back(quote("CREATE TABLE ") + " + " + rel.getName() + "::table__"
                      + " + \" (\" + " 
                      + fields.join("+ \",\" + ") + " + \")\"");
        recs.push_back(rec);
        tables++;

        if (rel.related.size() > 1) {
            string iname = makeTableName(rel.getTable() + "_all_idx");
            rec.clear();
            rec.push_back(quote(iname));
            rec.push_back(quote("index"));
            rec.push_back(quote("CREATE INDEX " + iname + " ON ") + " + " + rel.getName() + "::table__"
                            + " + \" (\" + " 
                            + indexFields.join(" + \",\" + ")
                            + " + \")\"");
       
     
            recs.push_back(rec);
            indexes++;
        }
        for (size_t i2 = 0; i2 < rel.related.size(); i2++) {
            const xml::Relate& relate = rel.related[i2];
            rec.clear();
            string iname = makeTableName(rel.getTable() + "_" + relate.fieldTypeName + "_idx");
            rec.push_back(quote(iname));
            rec.push_back(quote("index"));
            rec.push_back(quote("CREATE INDEX " + iname + " ON ") + " + " + rel.getName() + "::table__"
                            + " + \" (\" + " 
                            + rel.getName() + "::" + relate.fieldTypeName + ".name()"
                            + " + \")\"");
            recs.push_back(rec);
            indexes++;
        }
        for (size_t i2 = 0; i2 < rel.fields.size(); i2++) {
            const xml::Field& fld = rel.fields[i2];
       
            if (fld.isIndexed()) {
                rec.clear();
                string iname = makeTableName(rel.getTable() + "_" + fld.name + "_idx");
                rec.push_back(quote(iname));
                rec.push_back(quote("index"));
                rec.push_back(quote("CREATE INDEX " + iname + " ON ") + " + " + rel.getName() + "::table__"
                                + " + \" (\" + " 
                                + rel.getName() + "::" + fld.fieldTypeName + "_.name()"
                                + " + \")\"");
                recs.push_back(rec);
                indexes++;
            }
        }
        for (size_t i2 = 0; i2 < rel.indexes.size(); i2++) {
            const xml::Index& idx = rel.indexes[i2];
            Split flds;
            
            for (size_t i3 = 0; i3 < idx.fields.size(); i3++) 
                flds.push_back(rel.getName() + "::" + idx.fields[i3].name + "_.name()");
            string iname = makeTableName(rel.getTable() + "_" + flds.join("_") + "_idx");
            string unique = "";
            if (idx.isUnique())
                unique = " UNIQUE";
            rec.clear();
            rec.push_back(quote(iname));
            rec.push_back(quote("index"));
            rec.push_back(quote("CREATE"+unique+" INDEX " + iname 
                                + " ON ") + " + " + rel.getName() + "::table__"
                          + " + \" (\" + " + flds.join(" + \",\" + ")
                          + " + \")\"");
            recs.push_back(rec);                 
            indexes++;
        }
    }
    report(toString(tables) + " tables\n");
    report(toString(sequences) + " sequences\n");
    report(toString(indexes) + " indexes\n");
    return recs;
}
void writeDatabaseClass(FILE* hpp, FILE* cpp,
                        xml::Database& dbInfo,
                        vector<xml::Object>& objects,
                        vector<xml::Relation>& relations) {
    gen::Class db(dbInfo.name, "litesql::Database");    
    gen::Method cons(dbInfo.name);
    
    cons.param(Variable("backendType", "std::string"))
        .param(Variable("connInfo", "std::string"))
        .constructor("litesql::Database(backendType, connInfo)");
    cons.body("initialize();");
    db.method(cons);
    gen::Method getSchemaMtd("getSchema", "std::vector<litesql::Database::SchemaItem>");
    getSchemaMtd.virtual_().protected_().const_()
        .body("vector<Database::SchemaItem> res;");
    Records schema = getSchema(objects, relations);
    for (Records::iterator i = schema.begin(); i != schema.end(); i++) {
        if ((*i)[1] == quote("sequence"))
            getSchemaMtd.body("if (backend->supportsSequences())");
        getSchemaMtd.body("res.push_back(Database::SchemaItem(" 
                       + (*i)[0] + "," 
                       + (*i)[1] + ","
                       + (*i)[2] + "));");
    }
    
    getSchemaMtd.body("return res;");

    db.method(getSchemaMtd);
    Method init("initialize", "void");
    init.body("static bool initialized = false;")
        .body("if (initialized)")
        .body("    return;")
        .body("initialized = true;");
    
    for (size_t i = 0; i < objects.size(); i++) {
        xml::Object& o = objects[i];
        for (size_t i2 = 0; i2 < o.fields.size(); i2++)
            if (!o.fields[i2].values.empty()) {
                init.body(o.name + "::initValues();");
                break;
            }
    }
    for (size_t i = 0; i < relations.size(); i++) {
        xml::Relation& r = relations[i];
        for (size_t i2 = 0; i2 < r.fields.size(); i2++)
            if (!r.fields[i2].values.empty()) {
                init.body(r.getName() + "::initValues();");
                break;
            }
    }

    init.protected_().static_();
    db.method(init);
    db.write(hpp, cpp);
}
void writeCPPClasses(xml::Database& db,
                     vector<xml::Object>& objects,
                     vector<xml::Relation>& relations) {
    sanityCheck(db, objects, relations);
    bool hasNamespace = false;
    
    FILE *hpp, *cpp;
    
    string hppName = toLower(db.name) + ".hpp";
    hpp = fopen(hppName.c_str(), "w");
    if (!hpp) {
        string msg = "could not open file : " + hppName;
        perror(msg.c_str());
        return;
    }
    
    string cppName = toLower(db.name) + ".cpp";
    cpp = fopen(cppName.c_str(), "w");
    if (!cpp) {
        string msg = "could not open file : " + cppName;
        perror(msg.c_str());
        return;
    }
    
    fprintf(hpp, "#include \"litesql.hpp\"\n");
    if (!db.include.empty()) 
        fprintf(hpp, "#include \"%s\"\n", db.include.c_str());
    fprintf(cpp, "#include \"%s\"\n", hppName.c_str());
    

    if (!db.nspace.empty()) {
        fprintf(hpp, "namespace %s {\n", db.nspace.c_str());
        fprintf(cpp, "namespace %s {\n", db.nspace.c_str());
        hasNamespace = true;
    } else
        hasNamespace = false;
    fprintf(cpp, "using namespace litesql;\n");

    report("writing prototypes for Persistent classes\n"); 
    for (size_t i = 0; i < objects.size(); i++) 
        fprintf(hpp, "class %s;\n", objects[i].name.c_str());

    report("writing relations\n");
    for (size_t i = 0; i < relations.size(); i++) {
        xml::Relation & o = relations[i];
        Class cl(o.getName());
        writeStaticRelData(cl, o);
        writeRelMethods(db, cl, o);
        
        cl.write(hpp, cpp);
    }
    report("writing persistent objects\n");
    for (size_t i = 0; i < objects.size(); i++) {
        xml::Object & o = objects[i];
        Class cl(o.name, o.inherits);
        writeStaticObjData(cl, o);
        writeObjFields(cl, o);       
        writeObjConstructors(cl, o);
        writeObjRelationHandles(cl, o);
        writeObjBaseMethods(cl, o);
        cl.write(hpp, cpp);

        // Object -> string method (not associated to class)

        gen::Method strMtd("operator<<", "std::ostream &");
        strMtd.param(Variable("os", "std::ostream&"))
            .param(Variable("o", o.name));
        vector<xml::Field> flds;
        o.getAllFields(flds);

        strMtd.body("os << \"-------------------------------------\" << std::endl;");
        for (size_t i2 = 0; i2 < flds.size(); i2++) {
            xml::Field& fld = flds[i2];
            strMtd.body("os << o." + fld.name + ".name() << \" = \" << o." 
                        + fld.name + " << std::endl;");
        }
        strMtd.body("os << \"-------------------------------------\" << std::endl;");
        strMtd.body("return os;");
        
        strMtd.write(hpp, cpp, "", 0);
    }
    report("writing database class\n");
    writeDatabaseClass(hpp, cpp, db, objects, relations);
    
    if (hasNamespace) {
        fprintf(hpp, "}\n");
        fprintf(cpp, "}\n");
    }
    fclose(hpp);
    fclose(cpp);
}