Examples with EQUALS org.molgenis.emx2.Operator.EQUALS used on opensource projects

Example 6 with EQUALS

use of org.molgenis.emx2.Operator.EQUALS in project molgenis-emx2 by molgenis.

the class GraphqlApi method getVariablesFromRequest.

private static Map<String, Object> getVariablesFromRequest(Request request) {
    if ("POST".equals(request.requestMethod())) {
        try {
            if (request.headers("Content-Type").startsWith("multipart/form-data")) {
                Map<String, Object> variables = new ObjectMapper().readValue(request.queryParams(VARIABLES), Map.class);
                // now replace each part id with the part
                putPartsIntoMap(variables, request.raw().getParts().stream().filter(p -> !p.getName().equals(VARIABLES) && !p.getName().equals(QUERY)).collect(Collectors.toList()));
                // 
                return variables;
            } else {
                Map<String, Object> node = new ObjectMapper().readValue(request.body(), Map.class);
                return (Map<String, Object>) node.get(VARIABLES);
            }
        } catch (Exception e) {
            throw new MolgenisException("Parsing of graphql variables failed. Should be an object with each graphql variable a key. " + e.getMessage(), e);
        }
    }
    return null;
}

Example 7 with EQUALS

use of org.molgenis.emx2.Operator.EQUALS in project molgenis-emx2 by molgenis.

the class Column method getReferences.

/**
 * will return self in case of single, and multiple in case of composite key wrapper
 */
public List<Reference> getReferences() {
    // no ref
    if (getRefTable() == null) {
        return new ArrayList<>();
    }
    List<Column> pkeys = getRefTable().getPrimaryKeyColumns();
    List<Reference> refColumns = new ArrayList<>();
    // check if primary key exists
    if (pkeys.size() == 0) {
        throw new MolgenisException("Error in column '" + getName() + "': Reference to " + getRefTableName() + " fails because that table has no primary key");
    }
    // create the refs
    Column refLink = getRefLinkColumn();
    for (Column keyPart : pkeys) {
        if (keyPart.isReference()) {
            for (Reference ref : keyPart.getReferences()) {
                ColumnType type = ref.getPrimitiveType();
                if (!isRef()) {
                    type = getArrayType(type);
                }
                List<String> path = ref.getPath();
                path.add(0, keyPart.getName());
                String name = null;
                if (refLink != null) {
                    for (Reference overlap : refLink.getReferences()) {
                        if (overlap.getTargetTable().equals(ref.getTargetTable()) && overlap.getTargetColumn().equals(ref.getTargetColumn())) {
                            name = overlap.getName();
                        }
                    }
                }
                if (name == null) {
                    name = getName();
                    if (pkeys.size() > 1) {
                        name += COMPOSITE_REF_SEPARATOR + ref.getName();
                    }
                }
                refColumns.add(new Reference(this, name, ref.getName(), getColumnType(), type, keyPart.getColumnType().isArray(), ref.getTargetTable(), ref.getTargetColumn(), ref.isRequired() || this.isRequired(), path));
            }
        } else {
            ColumnType type = keyPart.getColumnType();
            // all but ref is array
            if (!isRef()) {
                type = getArrayType(type);
            }
            // create the ref
            String name = getName();
            if (pkeys.size() > 1) {
                name += COMPOSITE_REF_SEPARATOR + keyPart.getName();
            }
            refColumns.add(new Reference(this, name, keyPart.getName(), getColumnType(), type, getColumnType().isArray(), getRefTableName(), keyPart.getName(), keyPart.isRequired() || this.isRequired(), new ArrayList<>(List.of(keyPart.getName()))));
        }
    }
    // clean up in case only one
    if (refColumns.stream().filter(r -> r.getName().startsWith(getName())).count() == 1) {
        refColumns = refColumns.stream().map(r -> {
            if (r.getName().startsWith(getName()))
                r.setName(getName());
            return r;
        }).collect(Collectors.toList());
    }
    // remove duplicates
    HashSet<Object> seen = new HashSet<>();
    refColumns.removeIf(e -> !seen.add(e.getName()));
    return refColumns;
}

Example 8 with EQUALS

use of org.molgenis.emx2.Operator.EQUALS in project molgenis-emx2 by molgenis.

the class TestCompositeForeignKeys method testCompositeRef.

@Test
public void testCompositeRef() {
    Schema schema = database.dropCreateSchema(TestCompositeForeignKeys.class.getSimpleName() + "Ref");
    schema.create(table("Person", column("firstName").setPkey(), column("lastName").setPkey(), column("uncle", REF).setRefTable("Person")));
    Table p = schema.getTable("Person");
    p.insert(new Row().setString("firstName", "Donald").setString("lastName", "Duck"));
    try {
        p.insert(new Row().setString("firstName", "Kwik").setString("lastName", "Duck").setString("uncle.firstName", "Donald").setString("uncle.lastName", "MISSING"));
        fail("should have failed on missing foreign key");
    } catch (Exception e) {
        System.out.println("errored correctly: " + e);
    }
    p.insert(new Row().setString("firstName", "Kwik").setString("lastName", "Duck").setString("uncle.firstName", "Donald").setString("uncle.lastName", "Duck"));
    p.insert(new Row().setString("firstName", "Kwek").setString("lastName", "Duck").setString("uncle.firstName", "Donald").setString("uncle.lastName", "Duck"));
    p.insert(new Row().setString("firstName", "Kwak").setString("lastName", "Duck").setString("uncle.firstName", "Donald").setString("uncle.lastName", "Duck"));
    try {
        p.delete(new Row().setString("firstName", "Donald").setString("lastName", "Duck"));
        fail("should have failed on foreign key (Donald is used in foreign key)");
    } catch (Exception e) {
        System.out.println("errored correctly: " + e);
    }
    schema.create(table("Student").setInherit("Person"));
    Table s = schema.getTable("Student");
    s.insert(new Row().setString("firstName", "Mickey").setString("lastName", "Mouse").setString("uncle.firstName", "Kwik").setString("uncle.lastName", "Duck"));
    String result = schema.query("Student", s("firstName"), s("lastName"), s("uncle", s("firstName"), s("lastName")), s("uncle", s("firstName"), s("lastName"))).retrieveJSON();
    System.out.println(result);
    result = schema.query("Student").select(s("firstName"), s("lastName")).where(or(and(f("firstName", EQUALS, "Donald"), f("lastName", EQUALS, "Duck")), and(f("firstName", EQUALS, "Mickey"), f("lastName", EQUALS, "Mouse")))).retrieveJSON();
    System.out.println(result);
    assertTrue(result.contains("Mouse"));
    assertFalse(result.contains("Duck"));
    result = schema.query("Person").select(s("firstName"), s("lastName")).where(or(and(f("firstName", EQUALS, "Donald"), f("lastName", EQUALS, "Duck")), and(f("firstName", EQUALS, "Mickey"), f("lastName", EQUALS, "Mouse")))).retrieveJSON();
    System.out.println(result);
    assertTrue(result.contains("Mouse"));
    assertTrue(result.contains("Duck"));
    // composite key filter
    result = schema.query("Person").select(s("firstName"), s("lastName")).where(f("uncle", or(and(f("firstName", EQUALS, "Donald"), f("lastName", EQUALS, "Duck")), and(f("firstName", EQUALS, "Mickey"), f("lastName", EQUALS, "Mouse"))))).retrieveJSON();
    System.out.println(result);
    assertTrue(result.contains("Kwik"));
    assertFalse(result.contains("Mouse"));
    // refback
    schema.getTable("Person").getMetadata().add(column("nephew").setType(REFBACK).setRefTable("Person").setRefBack("uncle"));
    s.insert(new Row().setString("firstName", "Katrien").setString("lastName", "Duck").setString("nephew.firstName", "Kwik").setString("nephew.lastName", // I know, not true
    "Duck"));
    assertTrue(List.of(s.query().select(s("firstName"), s("lastName"), s("nephew", s("firstName"), s("lastName")), s("uncle", s("firstName"), s("lastName"))).where(f("firstName", EQUALS, "Katrien")).retrieveRows().get(0).getStringArray("nephew-firstName")).contains("Kwik"));
    assertTrue(List.of(p.query().select(s("firstName"), s("lastName"), s("nephew", s("firstName"), s("lastName")), s("uncle", s("firstName"), s("lastName"))).where(f("firstName", EQUALS, "Kwik")).retrieveRows().get(0).getStringArray("uncle-firstName")).contains("Katrien"));
    // test order by for refback
    p.query().select(s("firstName"), s("lastName"), s("nephew", s("firstName"), s("lastName")), s("uncle", s("firstName"), s("lastName"))).orderBy("nephew").retrieveJSON();
}

Example 9 with EQUALS

use of org.molgenis.emx2.Operator.EQUALS in project molgenis-emx2 by molgenis.

the class TestQueryJsonGraph method testSearch.

@Test
public void testSearch() {
    Query s = this.schema.getTable("Person").query();
    s.select(s("name"));
    s.search("opa");
    String result = s.retrieveJSON();
    System.out.println("search for 'opa':\n " + result);
    assertTrue(result.contains("opa"));
    s = schema.getTable("Person").query();
    s.select(s("name"), s("children", s("name"), s("children", s("name"))), s("father", s("name")));
    s.search("opa");
    result = s.retrieveJSON();
    System.out.println("search for 'opa' also in grandparents:\n " + result);
    assertTrue(result.contains("opa"));
    StopWatch.print("complete");
    s.where(f("name", EQUALS, "opa1"), f("children", f("name", EQUALS, "ma"), f("children", f("name", EQUALS, "kind"))));
    result = s.retrieveJSON();
    System.out.println(result);
    assertTrue(result.contains("opa1"));
    s.where(f("children", f("children", f("name", EQUALS, "kind"))));
    result = s.retrieveJSON();
    System.out.println(result);
    assertTrue(result.contains("kind"));
    // 
    // s.search("opa");
    // {father : {name: { eq:[opa2]}, mother: {name: {eq: oma1}, father: {name: {eq: opa2}}
    // 
    // s.where(
    // "name",
    // eq("pa"),
    // "father",
    // Map.of("name", eq("opa2"), "mother", Map.of("name", eq("oma2"))));
    // s.where("father", "name")
    // .eq("opa1")
    // .and("father", "mother", "name")
    // .eq("opa2")
    // .and("father", "father", "name")
    // .eq("opa2");
    StopWatch.print("complete");
    s = schema.query("Person");
    s.select(s("name"));
    s.where(f("name", TRIGRAM_SEARCH, "opa"));
    result = s.retrieveJSON();
    System.out.println();
    assertTrue(result.contains("opa"));
}

Example 10 with EQUALS

use of org.molgenis.emx2.Operator.EQUALS in project molgenis-emx2 by molgenis.

the class TableSort method sortTableByDependency.

public static void sortTableByDependency(List<TableMetadata> tableList) {
    ArrayList<TableMetadata> result = new ArrayList<>();
    ArrayList<TableMetadata> todo = new ArrayList<>(tableList);
    // ensure deterministic order
    todo.sort(new Comparator<TableMetadata>() {

        @Override
        public int compare(TableMetadata o1, TableMetadata o2) {
            return o1.getTableName().compareTo(o2.getTableName());
        }
    });
    while (!todo.isEmpty()) {
        int size = todo.size();
        for (int i = 0; i < todo.size(); i++) {
            TableMetadata current = todo.get(i);
            boolean depends = false;
            for (int j = 0; j < todo.size(); j++) {
                if (current.getInherit() != null && current.getImportSchema() == null && todo.get(j).equals(current.getInheritedTable())) {
                    depends = true;
                    break;
                }
            }
            if (!depends)
                for (Column c : current.getColumns()) {
                    if (c.getRefTableName() != null && !c.isRefback()) {
                        for (int j = 0; j < todo.size(); j++) {
                            if (i != j && (todo.get(j).getTableName().equals(c.getRefTableName()))) {
                                depends = true;
                                break;
                            }
                        }
                    }
                }
            if (!depends) {
                result.add(todo.get(i));
                todo.remove(i);
            }
        }
        // check for circular relationship
        if (size == todo.size()) {
            throw new MolgenisException("circular dependency error: following tables have circular dependency: " + todo.stream().map(TableMetadata::getTableName).collect(Collectors.joining(",")));
        }
    }
    tableList.clear();
    tableList.addAll(result);
}