use of catdata.Pair in project fql by CategoricalData.
the class InstExpCsvQuotient method eval.
@Override
public Instance<Ty, En, Sym, Fk, Att, Gen, Sk, ID, Chc<Sk, Pair<ID, Att>>> eval(AqlEnv env) {
Instance<Ty, En, Sym, Fk, Att, Gen, Sk, X, Y> J = I.eval(env);
Collage<Ty, En, Sym, Fk, Att, Gen, Sk> col = new Collage<>(J.collage());
AqlOptions strat = new AqlOptions(options, col, env.defaults);
Set<Pair<Term<Ty, En, Sym, Fk, Att, Gen, Sk>, Term<Ty, En, Sym, Fk, Att, Gen, Sk>>> eqs0 = new HashSet<>(J.eqs());
Map<String, String> map = new HashMap<>();
for (String q : queries) {
map.put(q, q);
}
try {
Map<En, List<String[]>> ret = InstExpCsv.start2(map, strat, J.schema(), true);
for (En q : ret.keySet()) {
for (String[] row : ret.get(q)) {
if (row.length != 2) {
throw new RuntimeException("On " + q + ", encountered a row of length != 2: " + Arrays.toString(row));
}
Gen gen1 = (Gen) row[0];
Gen gen2 = (Gen) row[1];
if (gen1 == null) {
throw new RuntimeException("Encountered a NULL generator in column 1 of " + q);
}
if (gen2 == null) {
throw new RuntimeException("Encountered a NULL generator in column 2 of " + q);
}
if (!J.gens().containsKey(gen1)) {
throw new RuntimeException("Cannot import record linkage: " + gen1 + " is not a generator in the input instance");
} else if (!J.gens().containsKey(gen2)) {
throw new RuntimeException("Cannot import record linkage: " + gen2 + " is not a generator in the input instance");
}
Term<Ty, En, Sym, Fk, Att, Gen, Sk> l = Term.Gen(gen1);
Term<Ty, En, Sym, Fk, Att, Gen, Sk> r = Term.Gen(gen2);
eqs0.add(new Pair<>(l, r));
col.eqs.add(new Eq<>(new Ctx<>(), l, r));
}
}
InitialAlgebra<Ty, En, Sym, Fk, Att, Gen, Sk, ID> initial0 = new InitialAlgebra<>(strat, J.schema(), col, new It(), Object::toString, Object::toString);
return new LiteralInstance<>(J.schema(), col.gens.map, col.sks.map, eqs0, initial0.dp(), initial0, (Boolean) strat.getOrDefault(AqlOption.require_consistency), (Boolean) strat.getOrDefault(AqlOption.allow_java_eqs_unsafe));
} catch (Exception ex) {
throw new RuntimeException(ex.getMessage());
}
}
use of catdata.Pair in project fql by CategoricalData.
the class InstExpCsv method joinedEn.
@Override
protected void joinedEn(Map<En, List<String[]>> rows, En en0, Pair<List<Pair<String, String>>, List<Pair<String, String>>> s, Schema<Ty, En, Sym, Fk, Att> sch) throws Exception {
String en = en0.str;
Map<String, String> inner;
if (s == null) {
inner = new HashMap<>();
} else {
inner = Util.toMapSafely(s.second);
}
boolean autoGenIds = (Boolean) op.getOrDefault(inner, AqlOption.csv_generate_ids);
for (En en2 : rows.keySet()) {
if (rows.get(en2).size() == 0) {
throw new RuntimeException("No header in CSV file for " + en2);
}
}
// index of each column name
Ctx<String, Integer> m = new Ctx<>();
for (int i = 0; i < rows.get(en0).get(0).length; i++) {
m.put(rows.get(en0).get(0)[i], i);
}
boolean prepend = (boolean) op.getOrDefault(inner, AqlOption.csv_prepend_entity);
String sep = (String) op.getOrDefault(inner, AqlOption.import_col_seperator);
String pre = (String) op.getOrDefault(inner, AqlOption.csv_import_prefix);
// System.out.println("prefix is " + pre);
Map<String, String> map;
if (s != null) {
map = new Ctx<>(Util.toMapSafely(s.first)).map;
} else {
map = new HashMap<>();
}
Function<String, String> mediate = x -> {
if (map.containsKey(x)) {
return map.get(x);
}
String z = map.containsKey(x) ? map.get(x) : x;
if (prepend) {
int i = x.indexOf(en + sep);
if (i != 0) {
return pre + z;
}
String temp = x.substring((en + sep).length());
return pre + temp;
}
return pre + z;
};
int startId = 0;
for (String[] row : rows.get(en0).subList(1, rows.get(en0).size())) {
Gen l0;
String idCol = map.containsKey(en) ? map.get(en) : (String) op.getOrDefault(inner, AqlOption.id_column_name);
if (autoGenIds && !m.containsKey(idCol)) {
l0 = toGen(en0, "" + startId++);
} else if (!autoGenIds && !m.containsKey(idCol)) {
throw new RuntimeException("On " + en + ", ID column " + idCol + " not found in headers " + m.keySet() + ". \n\nPossible solution: provide a mapping.\n\nPossible solution: set csv_generate_ids=true to auto-generate IDs.\n\nPossible solution: rename the headers in the CSV file.\n\nPossible solution: add an ID column to the CSV file.");
} else {
l0 = toGen(en0, row[m.get(idCol)]);
}
ens0.get(en0).add(l0);
for (Fk fk : sch.fksFrom(en0)) {
if (!fks0.containsKey(l0)) {
fks0.put(l0, new Ctx<>());
}
Gen g = toGen(sch.fks.get(fk).second, row[m.get(mediate.apply(fk.str))]);
fks0.get(l0).put(fk, g);
}
for (Att att : sch.attsFrom(en0)) {
if (!atts0.containsKey(l0)) {
atts0.put(l0, new Ctx<>());
}
String zz = mediate.apply(att.str);
if (!m.containsKey(zz)) {
throw new RuntimeException("No column " + att + " in file for " + en + " nor explicit mapping for " + att + " given. Tried " + zz + " and options are " + m.keySet());
}
int z = m.get(zz);
if (z >= row.length) {
throw new RuntimeException("Cannot get index " + z + " from " + Arrays.toString(row));
}
String o = row[z];
Term<Ty, Void, Sym, Void, Void, Void, Null<?>> r = objectToSk(sch, o, l0, att, tys0, extraRepr, true, nullOnErr);
atts0.get(l0).put(att, r);
}
}
}
use of catdata.Pair in project fql by CategoricalData.
the class InstExpImport method forTheory.
public static <Ty, En, Sym, Fk, Att, Gen> Instance<Ty, En, Sym, Fk, Att, Gen, Null<?>, Gen, Null<?>> forTheory(Schema<Ty, En, Sym, Fk, Att> sch, Ctx<En, Collection<Gen>> ens0, Ctx<Ty, Collection<Null<?>>> tys0, Ctx<Gen, Ctx<Fk, Gen>> fks0, Ctx<Gen, Ctx<Att, Term<Ty, Void, Sym, Void, Void, Void, Null<?>>>> atts0, AqlOptions op) {
Set<Pair<Term<Ty, En, Sym, Fk, Att, Gen, Null<?>>, Term<Ty, En, Sym, Fk, Att, Gen, Null<?>>>> eqs0 = new HashSet<>();
Collage<Ty, En, Sym, Fk, Att, Gen, Null<?>> col = new Collage<>(sch.collage());
for (Gen gen : fks0.keySet()) {
for (Fk fk : fks0.get(gen).keySet()) {
eqs0.add(new Pair<>(Term.Fk(fk, Term.Gen(gen)), Term.Gen(fks0.get(gen).get(fk))));
col.eqs.add(new Eq<>(new Ctx<>(), Term.Fk(fk, Term.Gen(gen)), Term.Gen(fks0.get(gen).get(fk))));
}
}
for (Gen gen : atts0.keySet()) {
for (Att att : atts0.get(gen).keySet()) {
eqs0.add(new Pair<>(Term.Att(att, Term.Gen(gen)), atts0.get(gen).get(att).convert()));
col.eqs.add(new Eq<>(new Ctx<>(), Term.Att(att, Term.Gen(gen)), atts0.get(gen).get(att).convert()));
}
}
for (En en : ens0.keySet()) {
for (Gen gen : ens0.get(en)) {
col.gens.put(gen, en);
}
}
for (Ty ty : tys0.keySet()) {
for (Null<?> sk : tys0.get(ty)) {
col.sks.put(sk, ty);
}
}
InitialAlgebra<Ty, En, Sym, Fk, Att, Gen, Null<?>, ID> initial = new InitialAlgebra<>(op, sch, col, new It(), (Gen x) -> x.toString(), (Null<?> x) -> x.toString());
Instance<Ty, En, Sym, Fk, Att, Gen, Null<?>, ID, Chc<Null<?>, Pair<ID, Att>>> I = new LiteralInstance<>(sch, col.gens.map, col.sks.map, eqs0, initial.dp(), initial, (Boolean) op.getOrDefault(AqlOption.require_consistency), (Boolean) op.getOrDefault(AqlOption.allow_java_eqs_unsafe));
@SuppressWarnings("unchecked") Instance<Ty, En, Sym, Fk, Att, Gen, Null<?>, Gen, Null<?>> J = (Instance<Ty, En, Sym, Fk, Att, Gen, Null<?>, Gen, Null<?>>) ((Object) I);
return J;
}
use of catdata.Pair in project fql by CategoricalData.
the class InstExpJdbcAll method makeSchema.
public Schema<Ty, En, Sym, Fk, Att> makeSchema(AqlEnv env, SqlSchema info, AqlOptions ops) {
boolean checkJava = !(Boolean) ops.getOrDefault(AqlOption.allow_java_eqs_unsafe);
TypeSide<Ty, Sym> typeSide = new SqlTypeSide(ops);
// typeSide.validate(true);
Collage<Ty, En, Sym, Fk, Att, Void, Void> col0 = new Collage<>(typeSide.collage());
Set<Triple<Pair<Var, En>, Term<Ty, En, Sym, Fk, Att, Void, Void>, Term<Ty, En, Sym, Fk, Att, Void, Void>>> eqs = new HashSet<>();
for (SqlTable table : info.tables) {
col0.ens.add(new En(table.name));
for (SqlColumn c : table.columns) {
if (col0.atts.containsKey(new Att(new En(table.name), c.name))) {
throw new RuntimeException("Name collision: table " + c.table.name + " col " + c.name + " against table " + col0.atts.get(new Att(new En(table.name), c.name)).first + "\n\n.Possible solution: set option jdbc_import_col_seperator so as to avoid name collisions.");
}
col0.atts.put(new Att(new En(table.name), c.name), new Pair<>(new En(table.name), new Ty(sqlTypeToAqlType(c.type.name))));
}
}
for (SqlForeignKey fk : info.fks) {
col0.fks.put(new Fk(new En(fk.source.name), fk.toString()), new Pair<>(new En(fk.source.name), new En(fk.target.name)));
Var v = new Var("x");
for (SqlColumn tcol : fk.map.keySet()) {
SqlColumn scol = fk.map.get(tcol);
Att l = new Att(new En(scol.table.name), scol.name);
Att r = new Att(new En(tcol.table.name), tcol.name);
Term<Ty, En, Sym, Fk, Att, Void, Void> lhs = Term.Att(l, Term.Var(v));
Term<Ty, En, Sym, Fk, Att, Void, Void> rhs = Term.Att(r, Term.Fk(new Fk(new En(fk.source.name), fk.toString()), Term.Var(v)));
eqs.add(new Triple<>(new Pair<>(v, new En(fk.source.name)), lhs, rhs));
col0.eqs.add(new Eq<>(new Ctx<>(new Pair<>(v, Chc.inRight(new En(fk.source.name)))), lhs, rhs));
}
}
DP<Ty, En, Sym, Fk, Att, Void, Void> dp = AqlProver.create(new AqlOptions(options, col0, env.defaults), col0, typeSide.js);
Schema<Ty, En, Sym, Fk, Att> sch = new Schema<>(typeSide, col0.ens, col0.atts.map, col0.fks.map, eqs, dp, checkJava);
return sch;
}
use of catdata.Pair in project fql by CategoricalData.
the class ColimitSchema method renameEntity.
public ColimitSchema<N> renameEntity(En src, En dst, boolean checkJava) {
if (!schemaStr.ens.contains(src)) {
throw new RuntimeException(src + " is not an entity in \n" + schemaStr);
}
if (schemaStr.ens.contains(dst)) {
throw new RuntimeException(dst + " is already an entity in \n" + schemaStr);
}
Mapping<Ty, En, Sym, Fk, Att, En, Fk, Att> isoToUser = Mapping.id(schemaStr);
Mapping<Ty, En, Sym, Fk, Att, En, Fk, Att> isoFromUser = Mapping.id(schemaStr);
Function<Fk, Fk> updateFk = x -> {
if (x.en.equals(src)) {
return new Fk(dst, x.str);
}
return x;
};
Function<Fk, Fk> deUpdateFk = x -> {
if (x.en.equals(dst)) {
return new Fk(src, x.str);
}
return x;
};
Function<Att, Att> updateAtt = x -> {
if (x.en.equals(src)) {
return new Att(dst, x.str);
}
return x;
};
Function<Att, Att> deUpdateAtt = x -> {
if (x.en.equals(dst)) {
return new Att(src, x.str);
}
return x;
};
Set<En> ens = new HashSet<>(schemaStr.ens);
ens.remove(src);
ens.add(dst);
Map<Att, Pair<En, Ty>> atts = new HashMap<>();
for (Att k : schemaStr.atts.keySet()) {
Pair<En, Ty> v = schemaStr.atts.get(k);
En s = v.first.equals(src) ? dst : v.first;
atts.put(updateAtt.apply(k), new Pair<>(s, v.second));
}
Map<Fk, Pair<En, En>> fks = new HashMap<>();
for (Fk k : schemaStr.fks.keySet()) {
Pair<En, En> v = schemaStr.fks.get(k);
En s = v.first.equals(src) ? dst : v.first;
En t = v.second.equals(src) ? dst : v.second;
fks.put(updateFk.apply(k), new Pair<>(s, t));
}
Set<Triple<Pair<Var, En>, Term<Ty, En, Sym, Fk, Att, Void, Void>, Term<Ty, En, Sym, Fk, Att, Void, Void>>> eqs = new HashSet<>();
for (Triple<Pair<Var, En>, Term<Ty, En, Sym, Fk, Att, Void, Void>, Term<Ty, En, Sym, Fk, Att, Void, Void>> eq : schemaStr.eqs) {
Pair<Var, En> v = eq.first;
En t = v.second.equals(src) ? dst : v.second;
eqs.add(new Triple<>(new Pair<>(v.first, t), eq.second.mapFk(updateFk).mapAtt(updateAtt), eq.third.mapFk(updateFk).mapAtt(updateAtt)));
}
DP<Ty, En, Sym, Fk, Att, Void, Void> dp = new DP<Ty, En, Sym, Fk, Att, Void, Void>() {
@Override
public String toStringProver() {
return "rename entity of " + schemaStr.dp.toStringProver();
}
@Override
public // TODO aql check this
boolean eq(Ctx<Var, Chc<Ty, En>> ctx, Term<Ty, En, Sym, Fk, Att, Void, Void> lhs, Term<Ty, En, Sym, Fk, Att, Void, Void> rhs) {
return schemaStr.dp.eq(ctx.map(v -> v.left ? v : (v.r.equals(dst) ? Chc.inRight(src) : v)), lhs.mapFk(deUpdateFk).mapAtt(deUpdateAtt), rhs.mapFk(deUpdateFk).mapAtt(deUpdateAtt));
}
};
Schema<Ty, En, Sym, Fk, Att> schemaStr2 = // TODO aql java
new Schema<>(ty, ens, atts, fks, eqs, dp, checkJava);
Map<En, En> ensM = new HashMap<>();
for (En k : schemaStr.ens) {
ensM.put(k, k.equals(src) ? dst : k);
}
Map<Att, Triple<Var, En, Term<Ty, En, Sym, Fk, Att, Void, Void>>> attsM = new HashMap<>();
for (Att k : schemaStr.atts.keySet()) {
attsM.put(k, new Triple<Var, En, Term<Ty, En, Sym, Fk, Att, Void, Void>>(isoToUser.atts.get(k).first, isoToUser.atts.get(k).second.equals(src) ? dst : isoToUser.atts.get(k).second, isoToUser.atts.get(k).third.mapAtt(updateAtt).mapFk(updateFk)));
}
Map<Fk, Pair<En, List<Fk>>> fksM = new HashMap<>();
for (Fk k : schemaStr.fks.keySet()) {
fksM.put(k, new Pair<>(isoToUser.fks.get(k).first.equals(src) ? dst : isoToUser.fks.get(k).first, isoToUser.fks.get(k).second.stream().map(updateFk).collect(Collectors.toList())));
}
isoToUser = new Mapping<>(ensM, attsM, fksM, schemaStr, schemaStr2, checkJava);
Map<En, En> ensM2 = new HashMap<>();
for (En k : schemaStr2.ens) {
ensM2.put(k, k.equals(dst) ? src : k);
}
Map<Att, Triple<Var, En, Term<Ty, En, Sym, Fk, Att, Void, Void>>> attsM2 = new HashMap<>();
for (Att k : schemaStr2.atts.keySet()) {
attsM2.put(updateAtt.apply(k), new Triple<>(isoFromUser.atts.get(deUpdateAtt.apply(k)).first, isoFromUser.atts.get(deUpdateAtt.apply(k)).second.equals(dst) ? src : isoFromUser.atts.get(deUpdateAtt.apply(k)).second, isoFromUser.atts.get(deUpdateAtt.apply(k)).third));
}
Map<Fk, Pair<En, List<Fk>>> fksM2 = new HashMap<>();
for (Fk k : schemaStr2.fks.keySet()) {
fksM2.put(updateFk.apply(k), new Pair<>(isoFromUser.fks.get(deUpdateFk.apply(k)).first.equals(dst) ? src : isoFromUser.fks.get(deUpdateFk.apply(k)).first, isoFromUser.fks.get(deUpdateFk.apply(k)).second.stream().map(deUpdateFk).collect(Collectors.toList())));
}
isoFromUser = new Mapping<>(ensM2, attsM2, fksM2, schemaStr2, schemaStr, checkJava);
return wrap(isoToUser, isoFromUser);
}
Aggregations