@Override
public org.mmbase.bridge.Node getNode(final Cloud userCloud, final Document doc) {
String docId = doc.get("number");
if (docId == null) {
throw new IllegalArgumentException("No number found in " + doc);
}
LazyMap m = nodeCache.get(docId); //
if (m == null) {
Map<String, String> keys = new HashMap<String, String>();
for (String keyWord : keyWords) {
keys.put(keyWord, doc.get(keyWord));
}
m = new LazyMap(docId, keys);
nodeCache.put(docId, m);
}
org.mmbase.bridge.Node node =
new MapNode<String>(
m,
new MapNodeManager(userCloud, m) {
@Override
public boolean hasField(String name) {
if (JdbcIndexDefinition.this.key.equals(name)) return true;
return super.hasField(name);
}
@Override
public org.mmbase.bridge.Field getField(String name) {
if (map == null && JdbcIndexDefinition.this.key.equals(name)) {
org.mmbase.core.CoreField fd =
org.mmbase.core.util.Fields.createField(
name,
org.mmbase.core.util.Fields.classToType(Object.class),
org.mmbase.bridge.Field.TYPE_UNKNOWN,
org.mmbase.bridge.Field.STATE_VIRTUAL,
null);
return new org.mmbase.bridge.implementation.BasicField(fd, this);
} else {
return super.getField(name);
}
}
});
if (log.isDebugEnabled()) {
log.debug("Returning node for " + node);
}
return node;
}
@Override
public CloseableIterator<JdbcEntry> getSubCursor(String identifier) {
if (isSub) {
log.debug("Using getSubCursor for " + identifier);
return getSqlCursor(getSql(identifier));
} else {
return getSqlCursor(getFindSql(identifier));
}
}
@Override
public boolean inIndex(String identifier) {
CloseableIterator<JdbcEntry> i = getSqlCursor(getFindSql(identifier));
boolean result = i.hasNext();
try {
i.close();
} catch (IOException ex) {
log.warn(ex);
}
return result;
}
/**
* Jdbc connection pooling of MMBase would kill the statement if too duratious. This produces a
* 'direct connection' in that case, to circumvent that problem (Indexing queries _may_ take a
* while).
*/
protected Connection getDirectConnection() throws SQLException {
directConnections++;
try {
if (dataSource instanceof GenericDataSource) {
return ((GenericDataSource) dataSource).getDirectConnection();
} else {
return dataSource.getConnection();
}
} catch (SQLException sqe) {
log.error("With direct connection #" + directConnections + ": " + sqe.getMessage());
throw sqe;
} catch (Throwable t) {
throw new RuntimeException("direct connection #" + directConnections, t);
}
}
CloseableIterator<JdbcEntry> getSqlCursor(final String sql) {
try {
long start = System.currentTimeMillis();
final Connection con = getDirectConnection();
log.debug("About to execute " + sql + " (" + directConnections + ")");
final Statement statement = con.createStatement();
final ResultSet results = statement.executeQuery(sql);
if (log.isDebugEnabled()) {
log.debug("Executed " + sql + " in " + (System.currentTimeMillis() - start) + " ms");
}
final ResultSetMetaData meta = results.getMetaData();
return new CloseableIterator<JdbcEntry>() {
boolean hasNext = results.isBeforeFirst();
int i = 0;
@Override
public boolean hasNext() {
return hasNext;
}
@Override
public JdbcEntry next() {
if (!hasNext) {
throw new NoSuchElementException();
}
try {
results.next();
hasNext = !results.isLast();
} catch (java.sql.SQLException sqe) {
log.error(sqe);
hasNext = false;
}
JdbcEntry entry = new JdbcEntry(meta, results, sql);
i++;
if (log.isServiceEnabled()) {
if (i % 100 == 0) {
log.service("jdbc cursor " + i + " (now at id=" + entry.getIdentifier() + ")");
} else if (log.isDebugEnabled()) {
log.trace("jdbc cursor " + i + " (now at id=" + entry.getIdentifier() + ")");
}
}
return entry;
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
@Override
public void close() {
log.debug("Closing " + con);
try {
if (results != null) results.close();
if (statement != null) statement.close();
if (con != null) con.close();
} catch (Exception e) {
log.error(e);
}
}
};
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}