Search in sources :

Example 1 with En

use of catdata.aql.exp.SchExpRaw.En in project fql by CategoricalData.

the class AqlViewer method viewAlgebra.

private <X, Y> Component viewAlgebra(Algebra<Ty, En, Sym, Fk, Att, Gen, Sk, X, Y> alg) {
    List<JComponent> list = new LinkedList<>();
    Map<En, Pair<List<String>, Object[][]>> entables = makeEnTables(alg);
    Map<Ty, Set<Y>> m = Util.revS(alg.talg().sks.map);
    Map<Ty, Object[][]> tytables = makeTyTables(m, alg);
    for (En en : entables.keySet()) {
        Pair<List<String>, Object[][]> x = entables.get(en);
        String str;
        if (x.second.length == 0) {
            continue;
        } else if (x.second.length < alg.en(en).size()) {
            str = en + " (" + x.second.length + " of " + alg.en(en).size() + ")";
        } else {
            str = en + " (" + x.second.length + ")";
        }
        JPanel p = GuiUtil.makeBoldHeaderTable(Util.toString(alg.schema().attsFrom(en)), BorderFactory.createEmptyBorder(), str, x.second, x.first.toArray(new String[x.first.size()]));
        list.add(p);
    }
    List<String> header = Util.singList("ID");
    for (Ty ty : tytables.keySet()) {
        if (!m.containsKey(ty)) {
            continue;
        }
        Object[][] arr = tytables.get(ty);
        String str;
        if (arr.length < m.get(ty).size()) {
            str = ty + " (" + arr.length + " of " + m.get(ty).size() + ")";
        } else {
            str = ty + " (" + arr.length + ")";
        }
        // TODO: aql boldify attributes
        list.add(GuiUtil.makeTable(BorderFactory.createEmptyBorder(), str, arr, header.toArray()));
    }
    JComponent c = GuiUtil.makeGrid(list);
    c.setPreferredSize(new Dimension(600, 600));
    return c;
}
Also used : JPanel(javax.swing.JPanel) Set(java.util.Set) Ty(catdata.aql.exp.TyExpRaw.Ty) JComponent(javax.swing.JComponent) En(catdata.aql.exp.SchExpRaw.En) Dimension(java.awt.Dimension) LinkedList(java.util.LinkedList) List(java.util.List) LinkedList(java.util.LinkedList) Pair(catdata.Pair)

Example 2 with En

use of catdata.aql.exp.SchExpRaw.En in project fql by CategoricalData.

the class AqlViewer method makeEnTables.

public <X, Y> Map<En, Pair<List<String>, Object[][]>> makeEnTables(Algebra<Ty, En, Sym, Fk, Att, Gen, Sk, X, Y> alg) {
    Map<En, Pair<List<String>, Object[][]>> ret = new LinkedHashMap<>();
    List<En> ens = Util.alphabetical(alg.schema().ens);
    for (En en : ens) {
        List<String> atts0 = Util.alphabetical(alg.schema().attsFrom(en).stream().map((Att x) -> x.str).collect(Collectors.toList()));
        List<String> fks0 = Util.alphabetical(alg.schema().fksFrom(en).stream().map((Fk x) -> x.str).collect(Collectors.toList()));
        List<String> header = Util.<String>append(atts0, fks0);
        header.add(0, "ID");
        int n = Integer.min(maxrows, alg.en(en).size());
        Object[][] data = new Object[n][];
        int i = 0;
        List<X> lll = new LinkedList<>(alg.en(en));
        lll.sort((x, y) -> Util.AlphabeticalComparator.compare(alg.printX(x), alg.printX(y)));
        for (X x : lll) {
            List<Object> row = new LinkedList<>();
            row.add(alg.printX(x));
            for (String att0 : atts0) {
                row.add(alg.att(new Att(en, att0), x).toString(alg::printY, Util.voidFn()));
            }
            for (String fk0 : fks0) {
                row.add(alg.printX(alg.fk(new Fk(en, fk0), x)));
            }
            data[i] = row.toArray();
            i++;
            if (i == n) {
                break;
            }
        }
        ret.put(en, new Pair<>(header, data));
    }
    return ret;
}
Also used : Att(catdata.aql.exp.SchExpRaw.Att) Fk(catdata.aql.exp.SchExpRaw.Fk) En(catdata.aql.exp.SchExpRaw.En) Paint(java.awt.Paint) LinkedList(java.util.LinkedList) LinkedHashMap(java.util.LinkedHashMap) Pair(catdata.Pair)

Example 3 with En

use of catdata.aql.exp.SchExpRaw.En 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;
}
Also used : Att(catdata.aql.exp.SchExpRaw.Att) Var(catdata.aql.Var) Ctx(catdata.Ctx) Schema(catdata.aql.Schema) En(catdata.aql.exp.SchExpRaw.En) LinkedList(java.util.LinkedList) List(java.util.List) HashSet(java.util.HashSet) Pair(catdata.Pair) Ty(catdata.aql.exp.TyExpRaw.Ty) Fk(catdata.aql.exp.SchExpRaw.Fk) Sym(catdata.aql.exp.TyExpRaw.Sym) RawTerm(catdata.aql.RawTerm) Term(catdata.aql.Term) RawTerm(catdata.aql.RawTerm) Triple(catdata.Triple) AqlOptions(catdata.aql.AqlOptions) Collage(catdata.aql.Collage) Chc(catdata.Chc)

Example 4 with En

use of catdata.aql.exp.SchExpRaw.En 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);
}
Also used : Att(catdata.aql.exp.SchExpRaw.Att) HashMap(java.util.HashMap) Var(catdata.aql.Var) Ctx(catdata.Ctx) En(catdata.aql.exp.SchExpRaw.En) Eq(catdata.aql.Eq) Trans(catdata.aql.exp.QueryExpRaw.Trans) Pair(catdata.Pair) Ty(catdata.aql.exp.TyExpRaw.Ty) Fk(catdata.aql.exp.SchExpRaw.Fk) Sym(catdata.aql.exp.TyExpRaw.Sym) RawTerm(catdata.aql.RawTerm) Term(catdata.aql.Term) RawTerm(catdata.aql.RawTerm) Triple(catdata.Triple) Gen(catdata.aql.exp.InstExpRaw.Gen) Sk(catdata.aql.exp.InstExpRaw.Sk) AqlOptions(catdata.aql.AqlOptions) Collage(catdata.aql.Collage) Chc(catdata.Chc)

Example 5 with En

use of catdata.aql.exp.SchExpRaw.En 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;
}
Also used : Att(catdata.aql.exp.SchExpRaw.Att) HashMap(java.util.HashMap) En(catdata.aql.exp.SchExpRaw.En) Ty(catdata.aql.exp.TyExpRaw.Ty) Fk(catdata.aql.exp.SchExpRaw.Fk) Sym(catdata.aql.exp.TyExpRaw.Sym) RawTerm(catdata.aql.RawTerm) Term(catdata.aql.Term) RawTerm(catdata.aql.RawTerm) LiteralTransform(catdata.aql.fdm.LiteralTransform) Gen(catdata.aql.exp.InstExpRaw.Gen) Sk(catdata.aql.exp.InstExpRaw.Sk) AqlOptions(catdata.aql.AqlOptions) Collage(catdata.aql.Collage) Chc(catdata.Chc)

Aggregations

En (catdata.aql.exp.SchExpRaw.En)44 Att (catdata.aql.exp.SchExpRaw.Att)36 Fk (catdata.aql.exp.SchExpRaw.Fk)36 Ty (catdata.aql.exp.TyExpRaw.Ty)35 Sym (catdata.aql.exp.TyExpRaw.Sym)34 Ctx (catdata.Ctx)27 Pair (catdata.Pair)27 Gen (catdata.aql.exp.InstExpRaw.Gen)22 HashSet (java.util.HashSet)20 Chc (catdata.Chc)18 Triple (catdata.Triple)17 AqlOptions (catdata.aql.AqlOptions)17 List (java.util.List)17 Sk (catdata.aql.exp.InstExpRaw.Sk)16 HashMap (java.util.HashMap)15 LinkedList (java.util.LinkedList)14 Collage (catdata.aql.Collage)13 Term (catdata.aql.Term)13 RawTerm (catdata.aql.RawTerm)11 Set (java.util.Set)11