(count);
for (int i = 0; i < count; i++) {
Element node = (Element)fetchNodes.item(i);
EOFetchSpecification fs =
this.loadFetchSpecificationFromElement(_entityName, node);
if (fs == null) {
log.info("failed to load a fetch node of the model: " + node);
continue;
}
String fsname = node.getAttribute("name");
if (fsname == null || fsname.length() == 0) {
log.info("missing name in a fetch node of the model: " + node);
continue;
}
if (fspecs.containsKey(fsname)) {
log.info("duplicate name in a fetch node of the model: " + node);
continue;
}
fspecs.put(fsname, fs);
}
return fspecs;
}
/**
* "fetch" tag
*
* Attributes:
* name - String - name of fetch specification
* rawrows - boolean - do not map to objects, return raw Map's
* distinct - boolean - make results distinct
* deep - boolean - make a deep query (for hierarchical datasets)
* readonly - boolean - do not store a snapshot to track modifications
* lock - boolean - attempt some SQL lock
* requiresAllBindings - boolean - all bindings must be filled
* attributes - CSV - rawrows|distinct|deep|readonly|lock|allbinds
* limit - int
* offset - int
* prefetch - CSV - list of prefetch pathes
*
* Children:
* 'attribute' tags - CSV (eg name,lastname,firstname)
* 'prefetch' tags - CSV (eg employments.company,projects)
* 'qualifier' tags
* 'ordering' tags
* 'sql' tags (with pattern attribute)
* - EOCustomQueryExpressionHintKeyBindPattern (with pattern)
* - EOCustomQueryExpressionHintKey (w/o pattern)
*
* Example:
* <fetch name="count" rawrows="true">
* <sql>SELECT COUNT(*) FROM table</sql>
* </fetch>
*
* <fetch name="abc" distinct="true" deep="false" lock="false"
* requiresAllBindings="true" limit="100" offset="0"
* entity="Contact"
* attributes="id,lastname,firstname"
* >
* <qualifier>lastname like $name</qualifier>
* <ordering key="balance" order="DESC" />
* <ordering key="lastname" />
* </fetch>
*
*/
protected EOFetchSpecification loadFetchSpecificationFromElement
(String _entityName, Element _node)
{
/*
* TODO: would be cool to allow intermixing of raw SQL and qualifiers, like:
*
* SELECT COUNT(T.*) FROM table T, rel X WHERE
* T.lastname = $lastname
* AND T.id = X.id
* lastname
*
*/
if (_node == null)
return null;
if (!_node.getTagName().equals("fetch")) {
log.info("given node is not a tag");
return null;
}
Map hints = new HashMap(4);
String s;
/* flags */
Boolean fetchesRawRows = this.getBoolAttribute(_node, "rawrows");
Boolean distinct = this.getBoolAttribute(_node, "distinct");
Boolean deep = this.getBoolAttribute(_node, "deep");
Boolean readonly = this.getBoolAttribute(_node, "readonly");
Boolean lock = this.getBoolAttribute(_node, "lock");
Boolean requiresAllBindings =
this.getBoolAttribute(_node, "requiresAllBindings");
String flagSet = _node.getAttribute("flags");
if (flagSet != null && flagSet.length() > 0) {
if (fetchesRawRows == null) fetchesRawRows = flagSet.contains("raw");
if (distinct == null) distinct = flagSet.contains("distinct");
if (readonly == null) readonly = flagSet.contains("readonly");
if (lock == null) lock = flagSet.contains("lock");
if (requiresAllBindings == null)
requiresAllBindings = flagSet.contains("allbinds");
}
if (distinct == null) distinct = Boolean.FALSE;
if (deep == null) deep = Boolean.FALSE;
/* more attributes */
Integer limit = this.getIntAttribute(_node, "limit");
Integer offset = this.getIntAttribute(_node, "offset");
String entityName = _node.getAttribute("entity");
if (entityName != null && entityName.length() == 0)
entityName = null;
if (entityName == null)
entityName = _entityName;
// /* walk elements */
// TBD: walk objects in sequence, possibly creating merged SQL expressions
//
// NodeList children = _node.getChildNodes();
// if (children != null && children.getLength() > 0) {
// List collectAttrs = new ArrayList(8);
//
// for (int i = 0; i < children.getLength(); i++) {
// Node node = children.item(i);
// if (node == null || !(node instanceof Element)) continue;
//
// Element element = (Element)node;
// String tagName = element.getTagName();
//
// if ("attributes".equals(tagName)) {
// }
// }
// }
/* fetch attributes */
String[] fetchAttributes = null;
String[] prefetchPaths = null;
s = _node.getAttribute("attributes");
if (UObject.isNotEmpty(s)) {
fetchAttributes = s.split(",");
}
else {
s = this.joinTrimmedTextsOfElements
(_node.getElementsByTagName("attributes"),",");
if (UObject.isNotEmpty(s))
fetchAttributes = s.split(",");
}
s = _node.getAttribute("prefetch");
if (UObject.isNotEmpty(s)) {
prefetchPaths = s.split(",");
}
else {
s = this.joinTrimmedTextsOfElements
(_node.getElementsByTagName("prefetch"), ",");
if (UObject.isNotEmpty(s))
prefetchPaths = s.split(",");
}
/* qualifiers */
s = this.joinTrimmedTextsOfElements
(_node.getElementsByTagName("qualifier")," AND ");
EOQualifier qualifier = s != null
? EOQualifier.qualifierWithQualifierFormat(s)
: null;
if (s != null && qualifier == null) {
log.error("could not parse qualifier in model:\n'" + s + "'");
return null;
}
/* sort-orderings */
EOSortOrdering[] orderings = null;
NodeList orderingNodes = _node.getElementsByTagName("ordering");
if (orderingNodes != null && orderingNodes.getLength() > 0) {
orderings = new EOSortOrdering[orderingNodes.getLength()];
for (int i = 0; i < orderingNodes.getLength(); i++) {
orderings[i] =
this.loadOrderingFromElement((Element)orderingNodes.item(i));
if (orderings[i] == null) {
log.error("could not parse an ordering in model: " +
orderingNodes.item(i));
return null;
}
}
}
/* custom SQL */
NodeList sqlNodes = _node.getElementsByTagName("sql");
s = this.joinTrimmedTextsOfElements(sqlNodes, "; ");
if (UObject.isNotEmpty(s)) {
Boolean pat = this.getBoolAttribute((Element)sqlNodes.item(0), "pattern");
if (pat != null && pat)
hints.put("EOCustomQueryExpressionHintKeyBindPattern", s);
else
hints.put("EOCustomQueryExpressionHintKey", s);
}
/* construct */
if (hints.size() == 0) hints = null;
EOFetchSpecification fs = new EOFetchSpecification
(entityName, qualifier, orderings, distinct, deep, hints);
if (fetchesRawRows != null) fs.setFetchesRawRows(fetchesRawRows);
if (readonly != null) fs.setFetchesReadOnly(readonly);
if (lock != null) fs.setLocksObjects(lock);
if (limit != null) fs.setFetchLimit(limit);
if (offset != null) fs.setFetchOffset(offset);
if (fetchAttributes != null) fs.setFetchAttributeNames(fetchAttributes);
if (prefetchPaths != null && prefetchPaths.length > 0)
fs.setPrefetchingRelationshipKeyPaths(prefetchPaths);
if (requiresAllBindings != null)
fs.setRequiresAllQualifierBindingVariables(requiresAllBindings);
return fs;
}
protected EOSortOrdering loadOrderingFromElement(Element _e) {
/*
* Eg:
*
*/
if (_e == null)
return null;
if (!_e.getTagName().startsWith("order")) { // allow orderby, etc
log.info("given node is not a tag");
return null;
}
/* determine key */
String key = _e.getAttribute("key");
if (key == null || key.length() == 0)
key = _e.getTextContent();
if (key == null || key.length() == 0) {
log.error("could not parse an ordering in model: " + _e);
return null;
}
/* determine selector */
String ssel = _e.getAttribute("operation");
if (ssel == null || ssel.length() == 0) ssel = _e.getAttribute("op");
if (ssel == null || ssel.length() == 0) ssel = _e.getAttribute("order");
Object sel;
if (ssel == null || ssel.length() == 0)
sel = EOSortOrdering.EOCompareAscending;
else if ("ASC".equalsIgnoreCase(ssel))
sel = EOSortOrdering.EOCompareAscending;
else if ("DESC".equalsIgnoreCase(ssel))
sel = EOSortOrdering.EOCompareDescending;
else if ("CASE ASC".equalsIgnoreCase(ssel))
sel = EOSortOrdering.EOCompareCaseInsensitiveAscending;
else if ("CASE DESC".equalsIgnoreCase(ssel))
sel = EOSortOrdering.EOCompareCaseInsensitiveDescending;
else
sel = ssel;
return new EOSortOrdering(key, sel);
}
/* adaptor operations */
protected Map
loadAdaptorOperationsFromElement(String _entityName, Element _node)
{
NodeList opNodes = _node.getElementsByTagName("operation");
if (opNodes == null || opNodes.getLength() == 0)
return null;
int count = opNodes.getLength();
Map ops =
new HashMap(count);
for (int i = 0; i < count; i++) {
Element node = (Element)opNodes.item(i);
EOAdaptorOperation[] op =
this.loadAdaptorOperationFromElement(_entityName, node);
if (op == null) {
log.info("failed to load an operation node of the model: " + node);
continue;
}
String opname = node.getAttribute("name");
if (opname == null || opname.length() == 0) {
log.info("missing name in an operation of the model: " + node);
continue;
}
if (ops.containsKey(opname)) {
log.info("duplicate name in an operation of the model: " + node);
continue;
}
ops.put(opname, op);
}
return ops;
}
protected EOAdaptorOperation[] loadAdaptorOperationFromElement
(String _entityName, Element _node)
{
log.error("loading of operations not yet implemented ...");
return null;
}
/* support */
protected String joinTrimmedTextsOfElements(NodeList _nodes, String _sep) {
if (_nodes == null || _nodes.getLength() == 0)
return null;
StringBuilder sb = new StringBuilder(256);
boolean isFirst = true;
for (int i = 0; i < _nodes.getLength(); i++) {
Element node = (Element)_nodes.item(i);
node.normalize();
String txt = node.getTextContent();
if (txt == null) continue;
/* we replace newlines, so you can't use them inside elements */
txt = txt.replace("\n", " ").trim();
if (txt.length() == 0) continue;
if (isFirst)
isFirst = false;
else if (_sep != null)
sb.append(_sep);
sb.append(txt);
}
return sb.length() > 0 ? sb.toString() : null;
}
/* attribute helpers */
protected Boolean getBoolAttribute(Element _element, String _attrName) {
if (_element == null || _attrName == null)
return null;
String s = _element.getAttribute(_attrName);
if (UObject.isEmpty(s))
return null;
return UObject.boolValue(s);
}
protected Integer getIntAttribute(Element _element, String _attrName) {
if (_element == null || _attrName == null)
return null;
String s = _element.getAttribute(_attrName);
if (s == null || s.length() == 0)
return null;
return Integer.parseInt(s);
}
/* support */
protected Exception newModelLoadingException(String _reason) {
// TODO: improve error handling
return new Exception(_reason);
}
protected void addError(String _reason) {
log.error(_reason);
this.lastException = this.newModelLoadingException(_reason);
}
protected void addError(String _reason, Exception _e) {
log.error(_reason, _e);
// TODO: wrap exception
this.lastException = _e;
}
public EOModel loadModelFromURL(URL _url) {
boolean isDebugOn = log.isDebugEnabled();
if (isDebugOn) log.debug("loading model from URL: " + _url);
if (_url == null) {
this.addError("missing URL parameter for loading model");
return null;
}
/* instantiate document builder */
DocumentBuilder db;
try {
db = dbf.newDocumentBuilder();
if (isDebugOn) log.debug(" using DOM document builder:" + db);
}
catch (ParserConfigurationException e) {
this.addError("failed to create docbuilder for parsing URL: " + _url, e);
return null;
}
/* load DOM */
Document doc;
try {
doc = db.parse(_url.openStream(), _url.toString());
if (isDebugOn) log.debug(" parsed DOM: " + doc);
}
catch (SAXParseException e) {
this.addError("XML error at line " + e.getLineNumber() +
" when loading model resource: " + _url, e);
return null;
}
catch (SAXException e) {
this.addError("XML error when loading model resource: " + _url, e);
return null;
}
catch (IOException e) {
this.addError("IO error when loading model resource: " + _url, e);
return null;
}
/* transform DOM into model */
EOModel model = this.loadModelFromDocument(doc);
if (isDebugOn && model != null) {
log.debug(" model: " + model);
log.debug("finished model from URL: " + _url);
}
if (model == null)
log.info("failed loading model from URL: " + _url);
return model;
}
}