use of fr.lirmm.graphik.graal.store.rdbms.util.DBTable in project graal by graphik-team.
the class AbstractRdbmsConjunctiveQueryTranslator method translate.
@Override
public Iterator<SQLQuery> translate(Rule rangeRestrictedRule) throws AtomSetException {
Collection<SQLQuery> queries = new LinkedList<SQLQuery>();
InMemoryAtomSet body = rangeRestrictedRule.getBody();
CloseableIterator<Atom> it = rangeRestrictedRule.getHead().iterator();
try {
while (it.hasNext()) {
Atom headAtom = it.next();
DBTable table = this.store.createPredicateTableIfNotExist(headAtom.getPredicate());
List<Term> terms = headAtom.getTerms();
ConjunctiveQuery query = DefaultConjunctiveQueryFactory.instance().create(body, terms);
SQLQuery selectQuery = this.translate(query);
if (!selectQuery.hasSchemaError()) {
queries.add(new SQLQuery(store.getDriver().getInsertOrIgnoreQuery(table, selectQuery.toString())));
}
}
} catch (IteratorException e) {
throw new AtomSetException(e);
} catch (SQLException e) {
throw new AtomSetException(e);
}
return queries.iterator();
}
use of fr.lirmm.graphik.graal.store.rdbms.util.DBTable 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);
}
}
use of fr.lirmm.graphik.graal.store.rdbms.util.DBTable 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);
}
}
use of fr.lirmm.graphik.graal.store.rdbms.util.DBTable 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());
}
use of fr.lirmm.graphik.graal.store.rdbms.util.DBTable in project graal by graphik-team.
the class ResultSet2DBTableConverter method convert.
// /////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS
// /////////////////////////////////////////////////////////////////////////
@Override
public DBTable convert(ResultSet result) throws ConversionException {
try {
String tableName = result.getString("TABLE_NAME");
List<DBColumn> cols = this.driver.getColumns(tableName);
if (!this.driver.isCaseSensitive()) {
tableName = tableName.toUpperCase();
}
return new DBTable(tableName, cols);
} catch (SQLException e) {
throw new ConversionException(e);
}
}
Aggregations