Search in sources :

Example 11 with Signature

use of catdata.fql.decl.Signature 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);
}
Also used : FQLException(catdata.fql.FQLException) Instance(catdata.fql.decl.Instance) Signature(catdata.fql.decl.Signature) Mapping(catdata.fql.decl.Mapping)

Example 12 with Signature

use of catdata.fql.decl.Signature in project fql by CategoricalData.

the class Chase method sigma.

public static Instance sigma(Mapping m, Instance i) throws FQLException {
    Triple<Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>, Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>, Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>> kkk = m.toEDs();
    Signature cd = kkk.second.first;
    Map<String, Set<Pair<Object, Object>>> I = new HashMap<>();
    for (Node n : cd.nodes) {
        I.put(n.string, new HashSet<>());
    }
    for (Edge n : cd.edges) {
        I.put(n.name, new HashSet<>());
    }
    for (Attribute<Node> n : cd.attrs) {
        I.put(n.name, new HashSet<>());
    }
    for (String k : i.data.keySet()) {
        I.put("src_" + k, i.data.get(k));
    }
    List<EmbeddedDependency> eds0 = Signature.toED("", kkk.second);
    Pair<List<Triple<List<String>, List<Triple<String, String, String>>, List<Triple<String, String, String>>>>, List<Triple<List<String>, List<Triple<String, String, String>>, List<Pair<String, String>>>>> zzz = split(eds0);
    Set<String> keys = new HashSet<>();
    for (Node n : m.target.nodes) {
        keys.add("dst_" + n.string);
    }
    for (Edge n : m.target.edges) {
        keys.add("dst_" + n.name);
    }
    for (Attribute<Node> n : m.target.attrs) {
        keys.add("dst_" + n.name);
    }
    Map<String, Set<Pair<Object, Object>>> res = chase(keys, zzz, I, KIND.PARALLEL);
    Map<String, Set<Pair<Object, Object>>> res0 = new HashMap<>();
    for (Node n : m.target.nodes) {
        res0.put(n.string, res.get("dst_" + n.string));
    }
    for (Edge n : m.target.edges) {
        res0.put(n.name, res.get("dst_" + n.name));
    }
    for (Attribute<Node> n : m.target.attrs) {
        res0.put(n.name, res.get("dst_" + n.name));
    }
    Instance ret = new Instance(m.target, res0);
    return ret;
}
Also used : HashSet(java.util.HashSet) Set(java.util.Set) Attribute(catdata.fql.decl.Attribute) HashMap(java.util.HashMap) Instance(catdata.fql.decl.Instance) Node(catdata.fql.decl.Node) Signature(catdata.fql.decl.Signature) ArrayList(java.util.ArrayList) LinkedList(java.util.LinkedList) List(java.util.List) Edge(catdata.fql.decl.Edge) EmbeddedDependency(catdata.fql.sql.EmbeddedDependency) Pair(catdata.Pair) HashSet(java.util.HashSet)

Example 13 with Signature

use of catdata.fql.decl.Signature in project fql by CategoricalData.

the class Chase method delta.

public static Instance delta(Mapping m, Instance i) throws FQLException {
    Triple<Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>, Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>, Pair<Signature, List<Pair<Attribute<Node>, Pair<Edge, Attribute<Node>>>>>> kkk = m.toEDs();
    Signature cd = m.toEDs().first.first;
    Map<String, Set<Pair<Object, Object>>> I = new HashMap<>();
    for (Node n : cd.nodes) {
        I.put(n.string, new HashSet<>());
    }
    for (Edge n : cd.edges) {
        I.put(n.name, new HashSet<>());
    }
    for (Attribute<Node> n : cd.attrs) {
        I.put(n.name, new HashSet<>());
    }
    for (String k : i.data.keySet()) {
        I.put("dst_" + k, i.data.get(k));
    }
    List<EmbeddedDependency> eds0 = Signature.toED("", kkk.first);
    Pair<List<Triple<List<String>, List<Triple<String, String, String>>, List<Triple<String, String, String>>>>, List<Triple<List<String>, List<Triple<String, String, String>>, List<Pair<String, String>>>>> zzz = split(eds0);
    Set<String> keys = new HashSet<>();
    for (Node n : m.target.nodes) {
        keys.add("src_" + n.string);
    }
    for (Edge n : m.target.edges) {
        keys.add("src_" + n.name);
    }
    for (Attribute<Node> n : m.target.attrs) {
        keys.add("src_" + n.name);
    }
    // changed
    Map<String, Set<Pair<Object, Object>>> res = chase(keys, zzz, I, KIND.HYBRID);
    Map<String, Set<Pair<Object, Object>>> res0 = new HashMap<>();
    for (Node n : m.source.nodes) {
        res0.put(n.string, res.get("src_" + n.string));
    }
    for (Edge n : m.source.edges) {
        res0.put(n.name, res.get("src_" + n.name));
    }
    for (Attribute<Node> n : m.source.attrs) {
        res0.put(n.name, res.get("src_" + n.name));
    }
    Instance ret = new Instance(m.source, res0);
    return ret;
}
Also used : HashSet(java.util.HashSet) Set(java.util.Set) Attribute(catdata.fql.decl.Attribute) HashMap(java.util.HashMap) Instance(catdata.fql.decl.Instance) Node(catdata.fql.decl.Node) Signature(catdata.fql.decl.Signature) ArrayList(java.util.ArrayList) LinkedList(java.util.LinkedList) List(java.util.List) Edge(catdata.fql.decl.Edge) EmbeddedDependency(catdata.fql.sql.EmbeddedDependency) Pair(catdata.Pair) HashSet(java.util.HashSet)

Example 14 with Signature

use of catdata.fql.decl.Signature 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);
}
Also used : HashMap(java.util.HashMap) LinkedHashMap(java.util.LinkedHashMap) FinCat(catdata.fql.cat.FinCat) Node(catdata.fql.decl.Node) LinkedHashMap(java.util.LinkedHashMap) FQLException(catdata.fql.FQLException) LinkedList(java.util.LinkedList) Triple(catdata.Triple) Arr(catdata.fql.cat.Arr) Attribute(catdata.fql.decl.Attribute) Pair(catdata.Pair) Path(catdata.fql.decl.Path) Fn(catdata.fql.Fn) Signature(catdata.fql.decl.Signature) Edge(catdata.fql.decl.Edge)

Example 15 with Signature

use of catdata.fql.decl.Signature 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());
    }
}
Also used : Arr(catdata.fql.cat.Arr) Set(java.util.Set) HashSet(java.util.HashSet) Attribute(catdata.fql.decl.Attribute) Instance(catdata.fql.decl.Instance) HashMap(java.util.HashMap) LinkedHashMap(java.util.LinkedHashMap) FinCat(catdata.fql.cat.FinCat) Node(catdata.fql.decl.Node) LinkedHashMap(java.util.LinkedHashMap) IntRef(catdata.IntRef) FQLException(catdata.fql.FQLException) List(java.util.List) LinkedList(java.util.LinkedList) Pair(catdata.Pair) HashSet(java.util.HashSet) Path(catdata.fql.decl.Path) Fn(catdata.fql.Fn) Triple(catdata.Triple) Signature(catdata.fql.decl.Signature) Transform(catdata.fql.decl.Transform) Edge(catdata.fql.decl.Edge) HashMap(java.util.HashMap) LinkedHashMap(java.util.LinkedHashMap) Map(java.util.Map)

Aggregations

Signature (catdata.fql.decl.Signature)19 LinkedList (java.util.LinkedList)14 Pair (catdata.Pair)13 Node (catdata.fql.decl.Node)13 FQLException (catdata.fql.FQLException)11 HashMap (java.util.HashMap)11 Attribute (catdata.fql.decl.Attribute)10 Instance (catdata.fql.decl.Instance)10 Edge (catdata.fql.decl.Edge)9 Map (java.util.Map)7 Arr (catdata.fql.cat.Arr)6 Path (catdata.fql.decl.Path)6 Transform (catdata.fql.decl.Transform)6 LinkedHashMap (java.util.LinkedHashMap)6 Triple (catdata.Triple)5 List (java.util.List)5 HashSet (java.util.HashSet)4 Fn (catdata.fql.Fn)3 FinCat (catdata.fql.cat.FinCat)3 InstExp (catdata.fql.decl.InstExp)3