Examples with FQLException catdata.fql.FQLException used on opensource projects

Example 16 with FQLException

use of catdata.fql.FQLException in project fql by CategoricalData.

the class LeftKanCat method toCategory.

public static Pair<FinCat<Node, Path>, Fn<Path, Arr<Node, Path>>> toCategory(Signature sig) throws FQLException {
    Signature A = sig.onlyObjects();
    Instance X = A.terminal(null);
    Mapping F = subset(A, sig);
    LeftKan lk = new LeftKan(0, F, X);
    if (!lk.compute()) {
        throw new FQLException("Category computation has exceeded allowed iterations.");
    }
    return helper(lk, sig);
}

Example 17 with FQLException

use of catdata.fql.FQLException in project fql by CategoricalData.

the class Driver method makeEnv.

public static Triple<FqlEnvironment, String, List<Throwable>> makeEnv(FQLProgram prog, String... toUpdate) {
    List<Throwable> exns = new LinkedList<>();
    Map<String, Signature> sigs = new HashMap<>();
    Map<String, Mapping> maps = new HashMap<>();
    Map<String, Instance> insts = new HashMap<>();
    Map<String, Query> queries = new HashMap<>();
    Map<String, FullQuery> full_queries = new HashMap<>();
    for (String k : prog.sigs.keySet()) {
        try {
            SigExp v = prog.sigs.get(k);
            v.typeOf(prog);
            sigs.put(k, v.toSig(prog));
            toUpdate[0] = "Last Processed: " + k;
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "schema");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    for (String k : prog.maps.keySet()) {
        try {
            MapExp v = prog.maps.get(k);
            v.type(prog);
            maps.put(k, v.toMap(prog));
            toUpdate[0] = "Last Processed: " + k;
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "mapping");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    for (String k : prog.queries.keySet()) {
        try {
            QueryExp v = prog.queries.get(k);
            v.type(prog);
            queries.put(k, Query.toQuery(prog, v));
            toUpdate[0] = "Last Processed: " + k;
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "query");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    for (String k : prog.full_queries.keySet()) {
        try {
            FullQueryExp v = prog.full_queries.get(k);
            v.type(prog);
            full_queries.put(k, FullQuery.toQuery(prog, v));
            toUpdate[0] = "Last Processed: " + k;
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "QUERY");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    for (String k : prog.insts.keySet()) {
        try {
            InstExp v = prog.insts.get(k);
            v.type(prog);
            toUpdate[0] = "Last Processed: " + v + " (type-check only)";
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "instance");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    for (String k : prog.transforms.keySet()) {
        try {
            TransExp v = prog.transforms.get(k);
            v.type(prog);
            toUpdate[0] = "Last Processed: " + v + " (type-check only)";
        } catch (RuntimeException re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "transform");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    prog = rewriteQueries(prog);
    toUpdate[0] = "SQL generation complete, executing.";
    Triple<Map<String, Set<Map<Object, Object>>>, String, List<Throwable>> res = JDBCBridge.run(prog);
    toUpdate[0] = "SQL Execution Complete";
    exns.addAll(res.third);
    for (String k : prog.insts.keySet()) {
        try {
            Signature s = prog.insts.get(k).type(prog).toSig(prog);
            List<Pair<String, List<Pair<Object, Object>>>> b = PSMGen.gather(k, s, res.first);
            insts.put(k, new Instance(s, b));
            toUpdate[0] = "Last Processed: " + k;
        } catch (Exception re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "instance");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    Map<String, Transform> transforms = new HashMap<>();
    for (String k : prog.transforms.keySet()) {
        try {
            Pair<String, String> val = prog.transforms.get(k).type(prog);
            InstExp i = prog.insts.get(val.first);
            Signature s = i.type(prog).toSig(prog);
            List<Pair<String, List<Pair<Object, Object>>>> b = PSMGen.gather(k, s, res.first);
            transforms.put(k, new Transform(insts.get(val.first), insts.get(val.second), b));
            toUpdate[0] = "Last Processed: " + k;
        } catch (Exception re) {
            re.printStackTrace();
            LineException exn = new LineException(re.getLocalizedMessage(), k, "transform");
            if (DefunctGlobalOptions.debug.fql.continue_on_error) {
                exns.add(exn);
            } else {
                throw exn;
            }
        }
    }
    toUpdate[0] = "Load of SQL data into FQL complete.";
    // check full sigmas with EDs
    if (DefunctGlobalOptions.debug.fql.VALIDATE_WITH_EDS) {
        try {
            validateWithEds(prog, insts);
        } catch (FQLException fe) {
            fe.printStackTrace();
            throw new RuntimeException(fe.getLocalizedMessage());
        }
    }
    String toRetStr = res.second.trim();
    if (containsFullSigma(prog)) {
        toRetStr = "Cannot generate SQL for full sigma";
    }
    return new Triple<>(new FqlEnvironment(sigs, maps, insts, queries, transforms, full_queries), toRetStr, dedup(exns));
}

Example 18 with FQLException

use of catdata.fql.FQLException in project fql by CategoricalData.

the class PSMGen method pi.

public static Pair<List<PSM>, Map<String, Triple<Node, Node, Arr<Node, Path>>[]>> pi(Mapping F0, String src, String dst) throws FQLException {
    tempTables = 0;
    Signature D0 = F0.target;
    Signature C0 = F0.source;
    Pair<FinCat<Node, Path>, Fn<Path, Arr<Node, Path>>> kkk = D0.toCategory2();
    FinCat<Node, Path> D = kkk.first;
    FinCat<Node, Path> C = C0.toCategory2().first;
    FinFunctor<Node, Path, Node, Path> F = F0.toFunctor2().first;
    List<PSM> ret = new LinkedList<>();
    Map<String, Triple<Node, Node, Arr<Node, Path>>[]> colmap = new HashMap<>();
    Map<String, Attribute<Node>[]> amap = new HashMap<>();
    List<Node> doNotDrop = new LinkedList<>();
    for (Node d0 : D.objects) {
        CommaCat<Node, Path, Node, Path, Node, Path> B = doComma(D, C, F, d0, D0);
        Map<Triple<Node, Node, Arr<Node, Path>>, String> xxx1 = new HashMap<>();
        Map<Pair<Arr<Node, Path>, Arr<Node, Path>>, String> xxx2 = new HashMap<>();
        List<PSM> xxx3 = deltaX(src, xxx1, xxx2, B.projB);
        ret.addAll(xxx3);
        Triple<Flower, Triple<Node, Node, Arr<Node, Path>>[], Attribute<Node>[]> xxx = lim(src, C0, D, B, xxx1, xxx2);
        // comma cat is empty, need unit for product
        if (xxx == null) {
            doNotDrop.add(d0);
            Map<String, String> attrs2 = new HashMap<>();
            attrs2.put("guid", PSM.VARCHAR());
            ret.add(new CreateTable(dst + "_" + d0.string + "_limit", attrs2, false));
            ret.add(new InsertEmptyKeygen(dst + "_" + d0.string + "_limit"));
            ret.add(new InsertSQL(dst + "_" + d0.string, new SquishFlower(dst + "_" + d0.string + "_limit"), "c0", "c1"));
            @SuppressWarnings("unchecked") Triple<Node, Node, Arr<Node, Path>>[] cols = new Triple[0];
            colmap.put(d0.string, cols);
            continue;
        }
        Triple<Node, Node, Arr<Node, Path>>[] cols = xxx.second;
        Flower r = xxx.first;
        for (Attribute<Node> a : D0.attrsFor(d0)) {
            List<Attribute<Node>> ls = new LinkedList<>();
            for (Attribute<Node> aa : C0.attrs) {
                if (F.am.get(aa).equals(a)) {
                    ls.add(aa);
                }
            }
            for (int jj = 1; jj < ls.size(); jj++) {
                int xxx02 = cnamelkp(xxx.third, ls.get(0));
                int xxx04 = cnamelkp(xxx.third, ls.get(jj));
                r.where.add(new Pair<>(new Pair<>("t" + (xxx02 + xxx.second.length), "c1"), new Pair<>("t" + (xxx04 + xxx.second.length), "c1")));
            }
        }
        colmap.put(d0.string, cols);
        amap.put(d0.string, xxx.third);
        Map<String, String> attrs1 = new HashMap<>();
        for (int i = 0; i < xxx.second.length; i++) {
            attrs1.put("c" + i, PSM.VARCHAR());
        }
        for (int j = 0; j < xxx.third.length; j++) {
            attrs1.put("c" + (xxx.second.length + j), xxx.third[j].target.psm());
        }
        Map<String, String> attrs2 = new HashMap<>(attrs1);
        attrs2.put("guid", PSM.VARCHAR());
        List<String> attcs = new LinkedList<>(attrs1.keySet());
        ret.add(new CreateTable(dst + "_" + d0.string + "_limnoguid", attrs1, false));
        ret.add(new InsertSQL2(dst + "_" + d0.string + "_limnoguid", r, new LinkedList<>(r.select.keySet())));
        ret.add(new CreateTable(dst + "_" + d0.string + "_limit", attrs2, false));
        ret.add(new InsertKeygen(dst + "_" + d0.string + "_limit", "guid", dst + "_" + d0.string + "_limnoguid", attcs));
        // craeted by createTables
        // ret.add(new CreateTable(dst + "_" + d0.string, twocol_attrs));
        ret.add(new InsertSQL(dst + "_" + d0.string, new SquishFlower(dst + "_" + d0.string + "_limit"), "c0", "c1"));
    }
    for (Edge s : F0.target.edges) {
        Node dA = s.source;
        Node dB = s.target;
        String q2 = dB.string;
        String q1 = dA.string;
        Triple<Node, Node, Arr<Node, Path>>[] q2cols = colmap.get(q2);
        Triple<Node, Node, Arr<Node, Path>>[] q1cols = colmap.get(q1);
        if (q2cols == null) {
            throw new RuntimeException("Cannot find " + q2 + " in " + colmap);
        }
        List<Pair<Pair<String, String>, Pair<String, String>>> where = subset(D, kkk.second.of(new Path(D0, s)), dst, q2cols, q1cols, q2, q1);
        Map<String, String> from = new HashMap<>();
        from.put(dst + "_" + q1 + "_limit_1", dst + "_" + q1 + "_limit");
        from.put(dst + "_" + q2 + "_limit_2", dst + "_" + q2 + "_limit");
        LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
        select.put("c0", new Pair<>(dst + "_" + q1 + "_limit_1", "guid"));
        select.put("c1", new Pair<>(dst + "_" + q2 + "_limit_2", "guid"));
        Flower f = new Flower(select, from, where);
        ret.add(new InsertSQL(dst + "_" + s.name, f, "c0", "c1"));
    }
    for (Attribute<Node> a : F0.target.attrs) {
        int i = colmap.get(a.source.string).length;
        Attribute<Node>[] y = amap.get(a.source.string);
        if (y == null) {
            throw new FQLException("Attribute mapping not surjective " + a.source.string);
        }
        boolean found = false;
        int u = 0;
        // int j = -1;
        List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
        LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
        Map<String, String> from = new HashMap<>();
        List<Integer> xxx = new LinkedList<>();
        for (Attribute<Node> b : y) {
            if (!F0.am.get(b).equals(a)) {
                u++;
                continue;
            }
            found = true;
            xxx.add(u);
            u++;
        }
        if (!found) {
            throw new FQLException("Attribute mapping not found " + a);
        }
        from.put(dst + "_" + a.source + "_limit", dst + "_" + a.source + "_limit");
        select.put("c0", new Pair<>(dst + "_" + a.source + "_limit", "guid"));
        for (int jj = 1; jj < xxx.size(); jj++) {
            where.add(new Pair<>(new Pair<>(dst + "_" + a.source + "_limit", "c" + (xxx.get(0) + i)), new Pair<>(dst + "_" + a.source + "_limit", "c" + (xxx.get(jj) + i))));
        }
        select.put("c1", new Pair<>(dst + "_" + a.source + "_limit", "c" + (xxx.get(0) + i)));
        Flower f = new Flower(select, from, where);
        ret.add(new InsertSQL(dst + "_" + a.name, f, "c0", "c1"));
    // project guid and u+i
    }
    for (Node d0 : D.objects) {
        if (doNotDrop.contains(d0)) {
            continue;
        }
        ret.add(new DropTable(dst + "_" + d0.string + "_limnoguid"));
    }
    for (int ii = 0; ii < tempTables; ii++) {
        ret.add(new DropTable("temp" + ii));
    }
    return new Pair<>(ret, colmap);
}

Example 19 with FQLException

use of catdata.fql.FQLException in project fql by CategoricalData.

the class PropPSM method exec.

@Override
public void exec(PSMInterp interp, Map<String, Set<Map<Object, Object>>> state) {
    try {
        IntRef ref = new IntRef(interp.guid);
        Signature sigX = new Signature(sig.nodes, sig.edges, new LinkedList<>(), sig.eqs);
        Map<Node, List<Pair<Arr<Node, Path>, Attribute<Node>>>> obs = sig.obs();
        Pair<FinCat<Node, Path>, Fn<Path, Arr<Node, Path>>> ooo = sig.toCategory2();
        Fn<Path, Arr<Node, Path>> fn = ooo.second;
        Pair<Pair<Map<Node, Triple<Instance, Map<Object, Path>, Map<Path, Object>>>, Map<Edge, Transform>>, Pair<Instance, Map<Node, Pair<Map<Object, Instance>, Map<Instance, Object>>>>> xxx = sigX.omega(ref);
        interp.prop1.put(pre, xxx.first);
        interp.prop2.put(pre, xxx.second);
        Instance old = xxx.second.first;
        Map<Node, List<LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>> m = sig.obsbar();
        Map<String, Set<Pair<Object, Object>>> data = new HashMap<>();
        Map<Node, Map<Object, Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>>> m1 = new HashMap<>();
        Map<Node, Map<Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>, Object>> m2 = new HashMap<>();
        for (Node n : sig.nodes) {
            Map<Object, Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>> map1 = new HashMap<>();
            Map<Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>, Object> map2 = new HashMap<>();
            Set<Pair<Object, Object>> set = new HashSet<>();
            m1.put(n, map1);
            m2.put(n, map2);
            for (Pair<Object, Object> i1 : old.data.get(n.string)) {
                for (LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object> i2 : m.get(n)) {
                    Object o = Integer.toString(++ref.i);
                    map1.put(o, new Pair<>(i1.first, i2));
                    map2.put(new Pair<>(i1.first, i2), o);
                    set.add(new Pair<>(o, o));
                }
            }
            data.put(n.string, set);
        }
        for (Attribute<Node> a : sig.attrs) {
            Set<Pair<Object, Object>> set = new HashSet<>();
            for (Pair<Object, Object> k : data.get(a.source.string)) {
                Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>> kk = m1.get(a.source).get(k.first);
                // Object old_id = kk.first;
                LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object> new_id = kk.second;
                set.add(new Pair<>(k.first, new_id.get(new Pair<>(new Arr<>(new Path(sig, a.source), a.source, a.source), a))));
            }
            data.put(a.name, set);
        }
        for (Edge a : sig.edges) {
            Set<Pair<Object, Object>> set = new HashSet<>();
            for (Pair<Object, Object> k : data.get(a.source.string)) {
                Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>> kk = m1.get(a.source).get(k.first);
                Object old_id = kk.first;
                Object old_id0 = lookup(old.data.get(a.name), old_id);
                LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object> new_id = kk.second;
                LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object> new_id0 = truncate2(sig, new_id, fn.of(new Path(sig, a)), obs.get(a.target));
                Object o = m2.get(a.target).get(new Pair<>(old_id0, new_id0));
                set.add(new Pair<>(k.first, o));
            }
            data.put(a.name, set);
        }
        interp.prop3.put(pre, m1);
        interp.prop4.put(pre, m2);
        Instance ne = new Instance(sig, data);
        PSMGen.shred(pre, ne, state);
        interp.guid = ref.i;
    } catch (FQLException fe) {
        fe.printStackTrace();
        throw new RuntimeException(fe.getMessage());
    }
}

Example 20 with FQLException

use of catdata.fql.FQLException in project fql by CategoricalData.

the class PSMAnd method exec.

@Override
public void exec(PSMInterp interp, Map<String, Set<Map<Object, Object>>> state) {
    try {
        Signature sig0 = new Signature(sig.nodes, sig.edges, new LinkedList<>(), sig.eqs);
        Pair<Map<Node, Triple<Instance, Map<Object, Path>, Map<Path, Object>>>, Map<Edge, Transform>> H1 = interp.prop1.get(prop);
        Pair<Instance, Map<Node, Pair<Map<Object, Instance>, Map<Instance, Object>>>> H2 = interp.prop2.get(prop);
        // Instance old = H2.first;
        Instance prp = new Instance(sig, PSMGen.gather(prop, sig, state));
        Instance prd = new Instance(sig, PSMGen.gather(prod, sig, state));
        Transform fst = new Transform(prd, prp, PSMGen.gather(prod + "_fst", sig, state));
        Transform snd = new Transform(prd, prp, PSMGen.gather(prod + "_snd", sig, state));
        Map<Node, Map<Object, Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>>> I1 = interp.prop3.get(prop);
        Map<Node, Map<Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>>, Object>> I2 = interp.prop4.get(prop);
        List<Pair<String, List<Pair<Object, Object>>>> data = new LinkedList<>();
        for (Node c : sig.nodes) {
            List<Pair<Object, Object>> data0 = new LinkedList<>();
            Triple<Instance, Map<Object, Path>, Map<Path, Object>> Hc = H1.first.get(c);
            for (Object idp : prd.getNode(c)) {
                Object id0 = lookup(fst.data.get(c.string), idp);
                Object id1 = lookup(snd.data.get(c.string), idp);
                Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>> idl = I1.get(c).get(id0);
                Instance A = H2.second.get(c).first.get(idl.first);
                Pair<Object, LinkedHashMap<Pair<Arr<Node, Path>, Attribute<Node>>, Object>> idr = I1.get(c).get(id1);
                Instance B = H2.second.get(c).first.get(idr.first);
                if (!idl.second.equals(idr.second)) {
                    throw new RuntimeException("bad");
                }
                Instance nA;
                switch(kind) {
                    case "and":
                        nA = isect(A, B);
                        break;
                    case "or":
                        nA = union(A, B);
                        break;
                    case "implies":
                        nA = implies(sig0, H1, Hc, A, B);
                        break;
                    default:
                        throw new RuntimeException();
                }
                Object notId = H2.second.get(c).second.get(nA);
                Object x = I2.get(c).get(new Pair<>(notId, idl.second));
                data0.add(new Pair<>(idp, x));
            }
            data.add(new Pair<>(c.string, data0));
        }
        Transform ret = new Transform(prd, prp, data);
        PSMGen.shred(pre, ret, state);
    } catch (FQLException fe) {
        fe.printStackTrace();
        throw new RuntimeException(fe.getMessage());
    }
}