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);}