use of catdata.aql.Collage in project fql by CategoricalData.
the class SchExpRaw method eval.
// TODO: aql printing of contexts broken when conitain choices
@SuppressWarnings("unused")
@Override
public synchronized Schema<Ty, En, Sym, Fk, Att> eval(AqlEnv env) {
TypeSide<Ty, Sym> ts = typeSide.eval(env);
Collage<Ty, En, Sym, Fk, Att, Void, Void> col = new Collage<>(ts.collage());
Set<Triple<Pair<Var, En>, Term<Ty, En, Sym, Fk, Att, Void, Void>, Term<Ty, En, Sym, Fk, Att, Void, Void>>> eqs0 = new HashSet<>();
for (String k : imports) {
@SuppressWarnings("unchecked") Schema<Ty, En, Sym, Fk, Att> v = env.defs.schs.get(k);
col.addAll(v.collage());
eqs0.addAll(v.eqs);
}
col.ens.addAll(ens.stream().map(x -> new En(x)).collect(Collectors.toList()));
col.fks.putAll(conv1(fks));
col.atts.putAll(conv2(atts));
for (Quad<String, String, RawTerm, RawTerm> eq : t_eqs) {
try {
Map<String, Chc<Ty, En>> ctx = Util.singMap(eq.first, eq.second == null ? null : Chc.inRight(new En(eq.second)));
Triple<Ctx<Var, Chc<Ty, En>>, Term<Ty, En, Sym, Fk, Att, Gen, Sk>, Term<Ty, En, Sym, Fk, Att, Gen, Sk>> eq0 = RawTerm.infer1x(ctx, eq.third, eq.fourth, null, col.convert(), "", ts.js).first3();
Chc<Ty, En> v = eq0.first.get(new Var(eq.first));
if (v.left) {
throw new RuntimeException(eq.first + " has type " + v.l + " which is not an entity");
}
En t = v.r;
eqs0.add(new Triple<>(new Pair<>(new Var(eq.first), t), eq0.second.convert(), eq0.third.convert()));
} catch (RuntimeException ex) {
ex.printStackTrace();
throw new LocException(find("obs equations", eq), "In equation " + eq.third + " = " + eq.fourth + ", " + ex.getMessage());
}
}
for (Pair<List<String>, List<String>> eq : p_eqs) {
try {
String vv = "v";
Var var = new Var(vv);
Map<String, Chc<Ty, En>> ctx = Util.singMap(vv, null);
RawTerm lhs = RawTerm.fold(col.fks.keySet(), col.ens, eq.first, vv);
RawTerm rhs = RawTerm.fold(col.fks.keySet(), col.ens, eq.second, vv);
Triple<Ctx<Var, Chc<Ty, En>>, Term<Ty, En, Sym, Fk, Att, Gen, Sk>, Term<Ty, En, Sym, Fk, Att, Gen, Sk>> eq0 = RawTerm.infer1x(ctx, lhs, rhs, null, col.convert(), "", ts.js).first3();
Chc<Ty, En> v = eq0.first.get(var);
if (v.left) {
throw new RuntimeException("the equation's source " + eq.first + " is type " + v.l + " which is not an entity");
}
En t = v.r;
if (eq0.first.size() != 1) {
throw new RuntimeException("java constants cannot be used ");
}
eqs0.add(new Triple<>(new Pair<>(var, t), eq0.second.convert(), eq0.third.convert()));
} catch (RuntimeException ex) {
ex.printStackTrace();
throw new LocException(find("path equations", eq), "In equation " + Util.sep(eq.first, ".") + " = " + Util.sep(eq.second, ".") + ", " + ex.getMessage());
}
}
for (Triple<Pair<Var, En>, Term<Ty, En, Sym, Fk, Att, Void, Void>, Term<Ty, En, Sym, Fk, Att, Void, Void>> eq : eqs0) {
col.eqs.add(new Eq<>(new Ctx<>(eq.first).inRight(), eq.second, eq.third));
}
AqlOptions strat = new AqlOptions(options, col, env.defaults);
AqlOptions s = new AqlOptions(Util.singMap(AqlOption.prover.toString(), ProverName.fail.toString()), col, env.defaults);
// forces type checking before prover construction
new Schema<>(ts, col.ens, col.atts.map, col.fks.map, eqs0, AqlProver.create(s, col, ts.js), false);
Schema<Ty, En, Sym, Fk, Att> ret = new Schema<>(ts, col.ens, col.atts.map, col.fks.map, eqs0, AqlProver.create(strat, col, ts.js), !((Boolean) strat.getOrDefault(AqlOption.allow_java_eqs_unsafe)));
return ret;
}
use of catdata.aql.Collage in project fql by CategoricalData.
the class QueryExpRaw method eval.
@Override
public Query<Ty, En, Sym, Fk, Att, En, Fk, Att> eval(AqlEnv env) {
Schema<Ty, En, Sym, Fk, Att> src0 = src.eval(env);
Schema<Ty, En, Sym, Fk, Att> dst0 = dst.eval(env);
Ctx<En, Triple<Ctx<Var, En>, Collection<Eq<Ty, En, Sym, Fk, Att, Var, Var>>, AqlOptions>> ens0 = new Ctx<>();
Ctx<Att, Term<Ty, En, Sym, Fk, Att, Var, Var>> atts0 = new Ctx<>();
Ctx<Fk, Pair<Ctx<Var, Term<Void, En, Void, Fk, Void, Var, Void>>, Boolean>> fks0 = new Ctx<>();
Ctx<Var, Ty> xxx = new Ctx<>();
Ctx<Var, Term<Ty, Void, Sym, Void, Void, Void, Void>> yyy = new Ctx<>();
for (String k : imports) {
@SuppressWarnings("unchecked") Query<Ty, En, Sym, Fk, Att, En, Fk, Att> v = env.defs.qs.get(k);
for (Var var : v.params.keySet()) {
// allow benign collisions
xxx.map.put(var, v.params.get(var));
}
for (Var var : v.consts.keySet()) {
yyy.map.put(var, v.consts.get(var));
}
for (En En : v.ens.keySet()) {
ens0.put(En, new Triple<>(v.ens.get(En).gens, v.ens.get(En).eqs, v.ens.get(En).options));
}
for (Att Att : v.atts.keySet()) {
atts0.put(Att, v.atts.get(Att));
}
for (Fk Fk : v.fks.keySet()) {
fks0.put(Fk, new Pair<>(v.fks.get(Fk).gens(), v.doNotValidate.get(Fk)));
}
}
Ctx<En, Collage<Ty, En, Sym, Fk, Att, Var, Var>> cols = new Ctx<>();
for (Block p : blocks) {
try {
if (!dst0.ens.contains(p.en)) {
throw new RuntimeException("the proposed target entity " + p.en + " does not actually appear in the target schema");
}
processBlock(options, env, src0, ens0, cols, p, params);
} catch (RuntimeException ex) {
ex.printStackTrace();
throw new LocException(b1.get(p.en), "In block for target entity " + p.en + ", " + ex.getMessage());
}
for (Pair<catdata.aql.exp.SchExpRaw.Att, RawTerm> pp : p.atts) {
try {
processAtt(src0, dst0, ens0, atts0, cols, pp, params);
} catch (Exception ex) {
ex.printStackTrace();
throw new LocException(b3.get(pp.first), "In return clause for " + pp.first + ", " + ex.getMessage());
}
}
}
// two loops bc need stuff in en to do this part
for (Block p : blocks) {
for (Pair<catdata.aql.exp.SchExpRaw.Fk, Trans> pp : p.fks) {
try {
Ctx<Var, Term<Void, En, Void, Fk, Void, Var, Void>> trans = new Ctx<>();
for (Pair<Var, RawTerm> v : pp.second.gens) {
Ctx<String, Chc<Ty, En>> ctx = unVar(ens0.get(dst0.fks.get(pp.first).first).first.inRight());
Collage<Ty, En, Sym, Fk, Att, Var, Var> col = cols.get(dst0.fks.get(pp.first).first);
Chc<Ty, En> required = Chc.inRight(ens0.get(dst0.fks.get(pp.first).second).first.get(v.first));
Term<catdata.aql.exp.TyExpRaw.Ty, catdata.aql.exp.SchExpRaw.En, catdata.aql.exp.TyExpRaw.Sym, catdata.aql.exp.SchExpRaw.Fk, catdata.aql.exp.SchExpRaw.Att, Gen, Sk> term = RawTerm.infer1x(ctx.map, v.second, null, required, col.convert(), "in foreign key " + pp.first.str + ", ", src0.typeSide.js).second;
trans.put(v.first, freeze(term.convert(), params).convert());
}
boolean doNotCheckEqs = (Boolean) new AqlOptions(pp.second.options, null, env.defaults).getOrDefault(AqlOption.dont_validate_unsafe);
fks0.put(pp.first, new Pair<>(trans, doNotCheckEqs));
} catch (RuntimeException ex) {
ex.printStackTrace();
throw new LocException(b2.get(pp.first), ex.getMessage());
}
}
}
boolean doNotCheckEqs = (Boolean) new AqlOptions(options, null, env.defaults).getOrDefault(AqlOption.dont_validate_unsafe);
boolean elimRed = (Boolean) new AqlOptions(options, null, env.defaults).getOrDefault(AqlOption.query_remove_redundancy);
for (String s : params.keySet()) {
xxx.put(new Var(s), new Ty(params.get(s)));
}
for (String s : consts.keySet()) {
Chc<Ty, En> required = Chc.inLeft(xxx.get(new Var(s)));
Term<catdata.aql.exp.TyExpRaw.Ty, catdata.aql.exp.SchExpRaw.En, catdata.aql.exp.TyExpRaw.Sym, catdata.aql.exp.SchExpRaw.Fk, catdata.aql.exp.SchExpRaw.Att, Gen, Sk> term = RawTerm.infer1x(new HashMap<>(), consts.get(s), null, required, src0.collage().convert(), "", src0.typeSide.js).second;
yyy.put(new Var(s), term.convert());
}
return Query.makeQuery2(xxx, yyy, ens0, atts0, fks0, src0, dst0, doNotCheckEqs, elimRed);
}
use of catdata.aql.Collage in project fql by CategoricalData.
the class TransExpRaw method eval.
@Override
public synchronized Transform<Ty, En, Sym, Fk, Att, Gen, Sk, Gen, Sk, String, String, String, String> eval(AqlEnv env) {
Instance<Ty, En, Sym, Fk, Att, Gen, Sk, String, String> src0 = src.eval(env);
Instance<Ty, En, Sym, Fk, Att, Gen, Sk, String, String> dst0 = dst.eval(env);
// Collage<String, String, String, String, String, Void, Void> scol = new Collage<>(src0);
Collage<Ty, En, Sym, Fk, Att, Gen, Sk> dcol = new Collage<>(dst0.collage());
Map<Gen, Term<Void, En, Void, Fk, Void, Gen, Void>> gens0 = new HashMap<>();
Map<Sk, Term<Ty, En, Sym, Fk, Att, Gen, Sk>> sks0 = new HashMap<>();
for (String k : imports) {
@SuppressWarnings("unchecked") Transform<Ty, En, Sym, Fk, Att, Gen, Sk, Gen, Sk, String, String, String, String> v = env.defs.trans.get(k);
Util.putAllSafely(gens0, v.gens().map);
Util.putAllSafely(sks0, v.sks().map);
}
for (Pair<String, RawTerm> gen : gens) {
try {
RawTerm term = gen.second;
Map<String, Chc<Ty, En>> ctx = new HashMap<>();
Chc<Ty, En> required;
if (src0.gens().containsKey(new Gen(gen.first)) && src0.sks().containsKey(new Sk(gen.first))) {
throw new RuntimeException(gen.first + " is ambiguous");
} else if (src0.gens().containsKey(new Gen(gen.first))) {
required = Chc.inRight(src0.gens().get(new Gen(gen.first)));
} else if (src0.sks().containsKey(new Sk(gen.first))) {
required = Chc.inLeft(src0.sks().get(new Sk(gen.first)));
} else {
throw new RuntimeException(gen.first + " is not a source generator/labelled null");
}
Term<Ty, En, Sym, Fk, Att, Gen, Sk> term0 = RawTerm.infer1x(ctx, term, null, required, dcol, "", src0.schema().typeSide.js).second;
if (required.left) {
Util.putSafely(sks0, new Sk(gen.first), term0.convert());
} else {
Util.putSafely(gens0, new Gen(gen.first), term0.convert());
}
} catch (RuntimeException ex) {
ex.printStackTrace();
throw new LocException(find("generators", gen), "In transform for " + gen.first + ", " + ex.getMessage());
}
}
AqlOptions ops = new AqlOptions(options, null, env.defaults);
LiteralTransform<Ty, En, Sym, Fk, Att, Gen, Sk, Gen, Sk, String, String, String, String> ret = new LiteralTransform<Ty, En, Sym, Fk, Att, Gen, Sk, Gen, Sk, String, String, String, String>(gens0, sks0, src0, dst0, (Boolean) ops.getOrDefault(AqlOption.dont_validate_unsafe));
return ret;
}
use of catdata.aql.Collage 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.aql.Collage 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;
}
Aggregations