Examples with Times catdata.fql.decl.InstExp.Times used on opensource projects

Example 11 with Times

use of catdata.fql.decl.InstExp.Times in project fql by CategoricalData.

the class InstOps method visit.

@Override
public List<PSM> visit(String env, Implies e) {
    List<PSM> ret = new LinkedList<>();
    Times pr = (Times) prog.insts.get(e.prop);
    Signature sig = pr.type(prog).toSig(prog);
    ret.add(new PSMAnd(sig, env, e.prop, pr.a, "implies"));
    return ret;
}

Example 12 with Times

use of catdata.fql.decl.InstExp.Times in project fql by CategoricalData.

the class InstOps method visit.

@Override
public List<PSM> visit(String env, And e) {
    List<PSM> ret = new LinkedList<>();
    Times pr = (Times) prog.insts.get(e.prop);
    Signature sig = pr.type(prog).toSig(prog);
    ret.add(new PSMAnd(sig, env, e.prop, pr.a, "and"));
    return ret;
}

Example 13 with Times

use of catdata.fql.decl.InstExp.Times in project fql by CategoricalData.

the class InstOps method visit.

@Override
public Pair<List<PSM>, Object> visit(String dst, Times e) {
    try {
        SigExp k = e.type(prog);
        Signature s = k.toSig(prog);
        List<PSM> ret = new LinkedList<>();
        ret.addAll(PSMGen.makeTables(dst + "_fst", s, false));
        ret.addAll(PSMGen.makeTables(dst + "_snd", s, false));
        Pair<Map<Node, List<Pair<Path, Attribute<Node>>>>, List<PSM>> l_obs = Relationalizer.observations(s, dst + "_l_obs", e.a, false);
        Pair<Map<Node, List<Pair<Path, Attribute<Node>>>>, List<PSM>> r_obs = Relationalizer.observations(s, dst + "_r_obs", e.b, false);
        if (!(l_obs.first.equals(r_obs.first))) {
            throw new RuntimeException("Internal error, please report.");
        }
        ret.addAll(PSMGen.makeTables(dst + "_l_obs", s, false));
        ret.addAll(l_obs.second);
        ret.addAll(PSMGen.dropTables(dst + "_l_obs", s));
        ret.addAll(PSMGen.makeTables(dst + "_r_obs", s, false));
        ret.addAll(r_obs.second);
        ret.addAll(PSMGen.dropTables(dst + "_r_obs", s));
        for (Node n : s.nodes) {
            List<Pair<Path, Attribute<Node>>> lats = l_obs.first.get(n);
            // List<Pair<Path, Attribute<Node>>> rats = r_obs.first.get(n);
            LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
            Map<String, String> from = new HashMap<>();
            List<String> attrs = new LinkedList<>();
            Map<String, String> attrsM = new HashMap<>();
            List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
            from.put("lft", dst + "_l_obs_" + n.string + "_observables");
            from.put("rght", dst + "_r_obs_" + n.string + "_observables");
            attrs.add("lft");
            attrs.add("rght");
            attrsM.put("lft", PSM.VARCHAR());
            attrsM.put("rght", PSM.VARCHAR());
            select.put("lft", new Pair<>("lft", "id"));
            select.put("rght", new Pair<>("rght", "id"));
            int idx = 0;
            for (Pair<Path, Attribute<Node>> aa : lats) {
                Attribute<Node> a = aa.second;
                where.add(new Pair<>(new Pair<>("lft", "c" + idx), new Pair<>("rght", "c" + idx)));
                select.put("c" + idx, new Pair<>("lft", "c" + idx));
                attrs.add("c" + idx);
                attrsM.put("c" + idx, a.target.psm());
                idx++;
            }
            Flower f = new Flower(select, from, where);
            ret.add(new CreateTable(dst + "_prod_temp_" + n.string, attrsM, false));
            ret.add(new InsertSQL2(dst + "_prod_temp_" + n.string, f, attrs));
            Map<String, String> attrsM0 = new HashMap<>(attrsM);
            attrsM0.put("gguid", PSM.VARCHAR());
            ret.add(new CreateTable(dst + "_prod_guid_" + n.string, attrsM0, false));
            ret.add(new InsertKeygen(dst + "_prod_guid_" + n.string, "gguid", dst + "_prod_temp_" + n.string, attrs));
            List<Pair<Pair<String, String>, Pair<String, String>>> where0 = new LinkedList<>();
            from = new HashMap<>();
            from.put("t", dst + "_prod_guid_" + n.string);
            select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("t", "gguid"));
            select.put("c1", new Pair<>("t", "lft"));
            f = new Flower(select, from, where0);
            ret.add(new InsertSQL(dst + "_fst_" + n, f, "c0", "c1"));
            from = new HashMap<>();
            from.put("t", dst + "_prod_guid_" + n.string);
            select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("t", "gguid"));
            select.put("c1", new Pair<>("t", "rght"));
            f = new Flower(select, from, where0);
            ret.add(new InsertSQL(dst + "_snd_" + n, f, "c0", "c1"));
            LinkedHashMap<String, Pair<String, String>> select0 = new LinkedHashMap<>();
            select0.put("c0", new Pair<>("t", "gguid"));
            select0.put("c1", new Pair<>("t", "gguid"));
            Map<String, String> from0 = new HashMap<>();
            from0.put("t", dst + "_prod_guid_" + n.string);
            Flower sql = new Flower(select0, from0, where0);
            ret.add(new InsertSQL(dst + "_" + n.string, sql, "c0", "c1"));
            for (Attribute<Node> a : s.attrsFor(n)) {
                select0 = new LinkedHashMap<>();
                select0.put("c0", new Pair<>("t", "gguid"));
                Arr<Node, Path> ppp = s.toCategory2().first.id(n);
                int ppp0 = lats.indexOf(new Pair<>(ppp.arr, a));
                select0.put("c1", new Pair<>("t", "c" + ppp0));
                from0 = new HashMap<>();
                from0.put("t", dst + "_prod_guid_" + n.string);
                sql = new Flower(select0, from0, where0);
                ret.add(new InsertSQL(dst + "_" + a.name, sql, "c0", "c1"));
            }
        // ret.add(new DropTable(dst + "_prod_temp_" + n));
        }
        for (Edge edge : s.edges) {
            Map<String, String> from = new HashMap<>();
            from.put("leftEdge", e.a + "_" + edge.name);
            from.put("rightEdge", e.b + "_" + edge.name);
            from.put("srcGuid", dst + "_prod_guid_" + edge.source);
            from.put("dstGuid", dst + "_prod_guid_" + edge.target);
            List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
            where.add(new Pair<>(new Pair<>("leftEdge", "c0"), new Pair<>("srcGuid", "lft")));
            where.add(new Pair<>(new Pair<>("rightEdge", "c0"), new Pair<>("srcGuid", "rght")));
            where.add(new Pair<>(new Pair<>("leftEdge", "c1"), new Pair<>("dstGuid", "lft")));
            where.add(new Pair<>(new Pair<>("rightEdge", "c1"), new Pair<>("dstGuid", "rght")));
            LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
            select.put("c0", new Pair<>("srcGuid", "gguid"));
            select.put("c1", new Pair<>("dstGuid", "gguid"));
            Flower f = new Flower(select, from, where);
            ret.add(new InsertSQL(dst + "_" + edge.name, f, "c0", "c1"));
        }
        Fn<Quad<String, String, String, String>, List<PSM>> fn = x -> {
            // x.third -> e.a
            String f = x.first;
            // x.third -> e.b
            String g = x.second;
            // String C = x.third;
            String dst0 = x.fourth;
            // must be a map x.third -> dst
            List<PSM> ret1 = new LinkedList<>();
            for (Node n : s.nodes) {
                List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
                Map<String, String> from = new HashMap<>();
                from.put("f", f + "_" + n.string);
                from.put("g", g + "_" + n.string);
                from.put("lim", dst + "_prod_guid_" + n.string);
                where.add(new Pair<>(new Pair<>("f", "c0"), new Pair<>("g", "c0")));
                where.add(new Pair<>(new Pair<>("lim", "lft"), new Pair<>("f", "c1")));
                where.add(new Pair<>(new Pair<>("lim", "rght"), new Pair<>("g", "c1")));
                LinkedHashMap<String, Pair<String, String>> select = new LinkedHashMap<>();
                select.put("c0", new Pair<>("f", "c0"));
                select.put("c1", new Pair<>("lim", "gguid"));
                Flower flower = new Flower(select, from, where);
                ret1.add(new InsertSQL(dst0 + "_" + n.string, flower, "c0", "c1"));
            }
            return ret1;
        };
        return new Pair<>(ret, fn);
    } catch (FQLException fe) {
        throw new RuntimeException(fe.getLocalizedMessage());
    }
}

Example 14 with Times

use of catdata.fql.decl.InstExp.Times in project fql by CategoricalData.

the class InstOps method visit.

@Override
public List<PSM> visit(String env, TransCurry e) {
    List<PSM> ret = new LinkedList<>();
    Signature sig = prog.insts.get(e.inst).type(prog).toSig(prog);
    Pair<String, String> k = prog.transforms.get(e.trans).type(prog);
    Times t = (Times) prog.insts.get(k.first);
    ret.add(new PSMCurry(env, t.a, e.inst, e.trans, k.first, k.second, t.b, sig));
    return ret;
}

Example 15 with Times

use of catdata.fql.decl.InstExp.Times in project fql by CategoricalData.

the class FQLProgram method build.

private Graph<String, Object> build() {
    // Graph<V, E> where V is the type of the vertices
    Graph<String, Object> g2 = new DirectedSparseMultigraph<>();
    Ref<Integer> guid = new Ref<>(0);
    for (String k : insts.keySet()) {
        InstExp i = insts.get(k);
        i.type(this).toConst(this);
        g2.addVertex(k);
        i.accept(new Unit(), new InstExpVisitor<Unit, Unit>() {

            @Override
            public Unit visit(Unit env, Zero e) {
                return null;
            }

            @Override
            public Unit visit(Unit env, One e) {
                return null;
            }

            @Override
            public Unit visit(Unit env, Two e) {
                return null;
            }

            @Override
            public Unit visit(Unit env, Plus e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.a, k);
                g2.addEdge(new Pair<>(pp(guid), e), e.b, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Times e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.a, k);
                g2.addEdge(new Pair<>(pp(guid), e), e.b, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Exp e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.a, k);
                g2.addEdge(new Pair<>(pp(guid), e), e.b, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Const e) {
                return null;
            }

            @Override
            public Unit visit(Unit env, Delta e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.I, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Sigma e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.I, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Pi e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.I, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, FullSigma e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.I, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Relationalize e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.I, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, External e) {
                return null;
            }

            @Override
            public Unit visit(Unit env, Eval e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.e, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, FullEval e) {
                g2.addEdge(new Pair<>(pp(guid), e), e.e, k);
                return null;
            }

            @Override
            public Unit visit(Unit env, Kernel e) {
                TransExp t = transforms.get(e.trans);
                Pair<String, String> p = t.type(FQLProgram.this);
                g2.addEdge(new Pair<>(pp(guid), e), p.first, k);
                g2.addEdge(new Pair<>(pp(guid), e), p.second, k);
                return null;
            }

            private Integer pp(Ref<Integer> ref) {
                int ret = ref.x;
                ref.x = ret + 1;
                return ref.x;
            }

            @Override
            public Unit visit(Unit env, Step e) {
                // (Step) this should add an edge
                return null;
            }
        });
    }
    return g2;
}