dive4elements/river: artifacts/src/main/java/org/dive4elements/river/artifacts/datacage/templating/Builder.java comparison

comparison artifacts/src/main/java/org/dive4elements/river/artifacts/datacage/templating/Builder.java @ 5890:6ea004d51203

Datacage: Introduced <dc:group epxr="xpath" type="type"> ... </dc:group> and XPath function dc:group-key(). This splits the current result set into groups formed by expr. The type defaults to string. Afterwards all these groups are iterated by there natural order. The dc:group-key() gives access to the result of the grouping expression that forms a group. Say, you have a result set like this: name | description -----+------------ a | foo a | bar b | baz b | bla c | blub you can use: <dc:group expr="$name"> <group name="{dc:group-key()}"> <dc:for-each> <description value="{$description}"/> </dc:for-each> </group> </dc:group> to create: <group name="a"> <description name="foo"/> <description name="bar"/> </group> <group name="b"> <description name="baz"/> <description name="bla"/> </group> <group name="c"> <description name="blub"/> </group>

author	Sascha L. Teichmann <teichmann@intevation.de>
date	Thu, 02 May 2013 20:52:18 +0200
parents	88fca576e9e6
children	9a3ca7532f2a

comparison

equal deleted inserted replaced

-:a763fb7aa2e5
+:6ea004d51203
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Deque;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import javax.xml.namespace.QName;
 protected StackFrames                              frames;
 protected List<NamedConnection>                    connections;
 protected Map<String, CompiledStatement.Instance>  statements;
 protected Deque<Pair<NamedConnection, ResultData>> connectionsStack;
 protected Deque<NodeList>                          macroBodies;
+protected Deque<Object>                            groupExprStack;
 protected FunctionResolver                         functionResolver;
 protected Map<String, XPathExpression>             expressions;
 public BuildHelper(
 new ArrayDeque<Pair<NamedConnection, ResultData>>();
 this.output      = output;
 frames           = new StackFrames(parameters);
 owner            = getOwnerDocument(output);
 macroBodies      = new ArrayDeque<NodeList>();
+groupExprStack   = new ArrayDeque<Object>();
 functionResolver = new FunctionResolver(this);
 expressions      = new HashMap<String, XPathExpression>();
 statements       =
 new HashMap<String, CompiledStatement.Instance>();
 }
 pair.setB(orig);
 }
 }
 }
+protected Map<Object, ResultData> createGroupedResultData(
+ResultData rd,
+String     expr,
+String     type
+) {
+List<Object []> rows = rd.getRows();
+String [] columns = rd.getColumnLabels();
+XPathExpression x;
+try {
+x = getXPathExpression(expr);
+}
+catch (XPathExpressionException xee) {
+log.warn("Invalid expression '" + expr + "'.");
+return Collections.<Object, ResultData>emptyMap();
+}
+QName returnType = typeToQName(type);
+Map<Object, ResultData> groups = new TreeMap<Object, ResultData>();
+for (Object [] row: rows) {
+frames.enter();
+try {
+frames.put(columns, row);
+Object key = x.evaluate(EVAL_DOCUMENT, returnType);
+ResultData group = groups.get(key);
+if (group == null) {
+group = new ResultData(rd.getColumnLabels());
+groups.put(key, group);
+}
+group.add(row);
+}
+catch (XPathExpressionException xxe) {
+log.warn("unable to apply expression '" +
+expr + "' to dataset.");
+}
+finally {
+frames.leave();
+}
+}
+return groups;
+}
+protected void group(Node parent, Element current)
+throws SQLException
+{
+log.debug("dc:group");
+if (connectionsStack.isEmpty()) {
+log.debug("dc:group without having results");
+return;
+}
+NodeList subs = current.getChildNodes();
+int S = subs.getLength();
+if (S == 0) {
+log.debug("dc:group has no children");
+return;
+}
+String expr = current.getAttribute("expr").trim();
+String type = current.getAttribute("type").trim();
+Pair<Builder.NamedConnection, ResultData> pair =
+connectionsStack.peek();
+ResultData orig = connectionsStack.peek().getB();
+Map<Object, ResultData> groups =
+createGroupedResultData(orig, expr, type);
+String [] columns = orig.getColumnLabels();
+try {
+for (Map.Entry<Object, ResultData> entry: groups.entrySet()) {
+ResultData rd = entry.getValue();
+pair.setB(rd);
+groupExprStack.push(entry.getKey());
+try {
+for (Object [] row: rd.getRows()) {
+frames.enter();
+try {
+frames.put(columns, row);
+for (int i = 0; i < S; ++i) {
+build(parent, subs.item(i));
+}
+}
+finally {
+frames.leave();
+}
+}
+}
+finally {
+groupExprStack.pop();
+}
+}
+}
+finally {
+pair.setB(orig);
+}
+}
+public Object getGroupKey() {
+return groupExprStack.isEmpty()
+? null
+: groupExprStack.peek();
+}
 /**
 * Kind of foreach over results of a statement within a context.
 */
 protected void foreach(Node parent, Element current)
 throws SQLException
 else if ("for-each".equals(localName)) {
 foreach(parent, curr);
 }
 else if ("filter".equals(localName)) {
 filter(parent, curr);
+}
+else if ("group".equals(localName)) {
+group(parent, curr);
 }
 else if ("text".equals(localName)) {
 text(parent, curr);
 }
 else if ("variable".equals(localName)) {

Mercurial > dive4elements > river

comparison artifacts/src/main/java/org/dive4elements/river/artifacts/datacage/templating/Builder.java @ 5890:6ea004d51203