.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()"                                + " + \")\"");