Examples with DBColumn fr.lirmm.graphik.graal.store.rdbms.util.DBColumn used on opensource projects

Example 6 with DBColumn

use of fr.lirmm.graphik.graal.store.rdbms.util.DBColumn in project graal by graphik-team.

the class AbstractRdbmsConjunctiveQueryTranslator method translateRemove.

// /////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public SQLQuery translateRemove(Atom atom) throws AtomSetException {
    DBTable table = this.store.getPredicateTableIfExist(atom.getPredicate());
    if (table == null)
        return SQLQuery.hasSchemaErrorInstance();
    StringBuilder query = new StringBuilder("DELETE FROM ");
    query.append(table);
    query.append(" WHERE ");
    List<DBColumn> columns = table.getColumns();
    int termIndex = 0;
    for (Term t : atom.getTerms()) {
        if (termIndex != 0) {
            query.append(" and ");
        }
        query.append(columns.get(termIndex).getName()).append(" = '").append(t.getLabel()).append("'");
        ++termIndex;
    }
    return new SQLQuery(query.toString());
}

Example 7 with DBColumn

use of fr.lirmm.graphik.graal.store.rdbms.util.DBColumn in project graal by graphik-team.

the class NaturalRDBMSStore method termsByPredicatePosition.

@Override
public CloseableIterator<Term> termsByPredicatePosition(Predicate p, int position) throws AtomSetException {
    if (!this.check(p)) {
        return Iterators.<Term>emptyIterator();
    }
    try {
        SQLQuery query = this.getConjunctiveQueryTranslator().translateTermsByPredicatePositionQuery(p, position);
        if (query.hasSchemaError()) {
            return Iterators.<Term>emptyIterator();
        } else {
            DBTable table = this.getPredicateTable(p);
            if (table == null) {
                throw new AtomSetException("No table for this predicate: " + p);
            }
            DBColumn col = table.getColumns().get(position);
            int sqlType = col.getType();
            return new NaturalResultSetTermIterator(this, query.toString(), sqlType);
        }
    } catch (SQLException e) {
        throw new AtomSetException(e);
    }
}

Example 8 with DBColumn

use of fr.lirmm.graphik.graal.store.rdbms.util.DBColumn in project graal by graphik-team.

the class NaturalConjunctiveQueryTranslator method translate.

// /////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public SQLQuery translate(ConjunctiveQuery cquery) throws AtomSetException {
    if (cquery.getAtomSet().isEmpty()) {
        return SQLQuery.emptyInstance();
    }
    AtomSet atomSet = cquery.getAtomSet();
    StringBuilder fields = new StringBuilder();
    StringBuilder tables = new StringBuilder();
    StringBuilder where = new StringBuilder();
    HashMap<Atom, String> tableAsNames = new HashMap<Atom, String>();
    HashMap<Atom, String> tableNames = new HashMap<Atom, String>();
    HashMap<Atom, List<DBColumn>> tableColumns = new HashMap<Atom, List<DBColumn>>();
    HashMap<String, String> lastOccurrence = new HashMap<String, String>();
    ArrayList<String> constants = new ArrayList<String>();
    ArrayList<String> equivalences = new ArrayList<String>();
    TreeMap<Term, String> columns = new TreeMap<Term, String>();
    int count = -1;
    CloseableIterator<Atom> it = atomSet.iterator();
    try {
        while (it.hasNext()) {
            Atom atom = it.next();
            DBTable table = this.store.getPredicateTableIfExist(atom.getPredicate());
            if (table != null) {
                String tableName = "atom" + ++count;
                tableAsNames.put(atom, tableName);
                tableNames.put(atom, table.getName());
                tableColumns.put(atom, table.getColumns());
            } else {
                return SQLQuery.hasSchemaErrorInstance();
            }
        }
        // Create WHERE clause
        it = atomSet.iterator();
        while (it.hasNext()) {
            Atom atom = it.next();
            String currentAtom = tableAsNames.get(atom) + ".";
            List<DBColumn> columnsInfo = tableColumns.get(atom);
            int position = 0;
            for (Term term : atom.getTerms()) {
                String thisTerm = currentAtom + columnsInfo.get(position).getName();
                if (term.isConstant()) {
                    constants.add(thisTerm + " = '" + term.getIdentifier().toString() + "'");
                } else {
                    if (lastOccurrence.containsKey(term.getIdentifier().toString())) {
                        equivalences.add(lastOccurrence.get(term.getIdentifier().toString()) + " = " + thisTerm);
                    }
                    lastOccurrence.put(term.getIdentifier().toString(), thisTerm);
                    if (cquery.getAnswerVariables().contains(term))
                        columns.put(term, thisTerm + " as " + term.getIdentifier().toString());
                }
                ++position;
            }
        }
        for (String equivalence : equivalences) {
            if (where.length() != 0)
                where.append(" AND ");
            where.append(equivalence);
        }
        for (String constant : constants) {
            if (where.length() != 0)
                where.append(" AND ");
            where.append(constant);
        }
        // Create FROM clause
        for (Map.Entry<Atom, String> entries : tableAsNames.entrySet()) {
            if (tables.length() != 0)
                tables.append(", ");
            tables.append(tableNames.get(entries.getKey()));
            tables.append(" as ");
            tables.append(entries.getValue());
        }
        // Create SELECT clause
        for (Term t : cquery.getAnswerVariables()) {
            if (fields.length() != 0)
                fields.append(", ");
            if (t.isConstant()) {
                fields.append("'");
                fields.append(t.getIdentifier());
                fields.append("'");
            } else {
                fields.append(columns.get(t));
            }
        }
        StringBuilder query = new StringBuilder("SELECT DISTINCT ");
        if (fields.length() > 0)
            query.append(fields);
        else
            query.append("1");
        query.append(" FROM ");
        if (tables.length() > 0)
            query.append(tables);
        if (where.length() > 0)
            query.append(" WHERE ").append(where);
        if (LOGGER.isDebugEnabled())
            LOGGER.debug("Generated SQL query :" + cquery + " --> " + query.toString());
        return new SQLQuery(query.toString());
    } catch (IteratorException e) {
        throw new AtomSetException(e);
    }
}

Example 9 with DBColumn

use of fr.lirmm.graphik.graal.store.rdbms.util.DBColumn in project graal by graphik-team.

the class NaturalConjunctiveQueryTranslator method translateContainsQuery.

@Override
public SQLQuery translateContainsQuery(Atom atom) throws AtomSetException {
    DBTable table = this.store.getPredicateTable(atom.getPredicate());
    if (table == null) {
        return SQLQuery.hasSchemaErrorInstance();
    }
    List<DBColumn> columns = table.getColumns();
    StringBuilder query = new StringBuilder("SELECT 1 FROM ");
    query.append(table.getName());
    query.append(" WHERE ");
    int i = 0;
    for (Term t : atom) {
        if (i != 0) {
            query.append(" AND ");
        }
        DBColumn col = columns.get(i);
        query.append(col.getName());
        query.append(" = ");
        query.append(this.formatFromColumnType(col, t));
        ++i;
    }
    query.append(';');
    return new SQLQuery(query.toString());
}

Example 10 with DBColumn

use of fr.lirmm.graphik.graal.store.rdbms.util.DBColumn in project graal by graphik-team.

the class AbstractMergeRdbmsDriver method getInsertOrIgnoreQuery.

@Override
public String getInsertOrIgnoreQuery(DBTable table, String selectQuery) throws SQLException {
    StringBuilder values = new StringBuilder();
    StringBuilder as = new StringBuilder();
    String using = selectQuery;
    StringBuilder on = new StringBuilder();
    StringBuilder insert = new StringBuilder();
    values.append("VALUES(");
    as.append("data(");
    int i = 0;
    for (DBColumn col : table.getColumns()) {
        if (i > 0) {
            values.append(", ");
            as.append(", ");
            on.append(" AND ");
            insert.append(", ");
        }
        values.append("term").append(i);
        as.append("term").append(i);
        on.append("t.").append(col.getName()).append(" = ").append("term").append(i);
        insert.append("data.term").append(i);
        ++i;
    }
    values.append(") ");
    as.append(") ");
    return String.format(MERGE_FORMAT, table.getName(), using, as, on, insert);
}