Navigation

← Previous Changeset
Next Changeset →

Changeset 58

Timestamp:

02/26/10 21:57:31 (2 years ago)

Author:

ke

Message:

DB tree bug fix: getChildren(int, int) now returns not only virtual children, but also real children with lower layers.

Files:

kahina/trunk/src/org/kahina/data/tree/KahinaDbTree.java (modified) (26 diffs)
kahina/trunk/src/org/kahina/data/tree/KahinaMemTree.java (modified) (2 diffs)
kahina/trunk/src/org/kahina/data/tree/KahinaTree.java (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

kahina/trunk/src/org/kahina/data/tree/KahinaDbTree.java

r57	r58
13	13	import org.w3c.dom.NodeList;
14	14
15		public class KahinaDbTree extends KahinaTree
16		{
	15	public class KahinaDbTree extends KahinaTree {
17	16	private static final String CLIENT_ID = KahinaDbTree.class.getName();
18	17
…	…
63	62	private int nextID;
64	63
65		public KahinaDbTree(DatabaseHandler db)
66		{
	64	public KahinaDbTree(DatabaseHandler db) {
67	65	this(new DefaultLayerDecider(), db);
68	66	}
69	67
70		public KahinaDbTree(LayerDecider decider, DatabaseHandler db)
71		{
	68	public KahinaDbTree(LayerDecider decider, DatabaseHandler db) {
72	69	super(decider);
73	70	this.db = db;
…	…
77	74	}
78	75
79		private void createTablesIfNecessary()
80		{
81		if (!db.isRegistered(CLIENT_ID))
82		{
	76	private void createTablesIfNecessary() {
	77	if (!db.isRegistered(CLIENT_ID)) {
83	78	db.execute("CREATE TABLE " + NODE_TABLE_NAME + " (id INT, "
84	79	+ "tree INT, " + "nodeCaption LONG VARCHAR, "
…	…
90	85	db.execute("CREATE INDEX realParent ON " + NODE_TABLE_NAME
91	86	+ " (realParent)");
	87	db.execute("CREATE INDEX layer ON " + NODE_TABLE_NAME + " (layer)");
92	88	db.execute("CREATE INDEX virtualParent ON " + NODE_TABLE_NAME
93	89	+ " (virtualParent)");
…	…
96	92	}
97	93
98		private void prepareStatements()
99		{
	94	private void prepareStatements() {
100	95	int treeID = getID();
101	96	addNodeStatement = db.prepareStatement("INSERT INTO " + NODE_TABLE_NAME
…	…
129	124	+ treeID);
130	125	getVirtualChildrenStatement = db.prepareStatement("SELECT id FROM "
131		+ NODE_TABLE_NAME + " WHERE ~~virtualParent = ? AND tree = "~~
132		+ ~~treeID~~);
	126	+ NODE_TABLE_NAME + " WHERE tree = " + treeID
	127	+ " AND (virtualParent = ? OR (realParent = ? AND layer < ?))");
133	128	getEdgeLabelStatement = db.prepareStatement("SELECT edgeLabel FROM "
134	129	+ NODE_TABLE_NAME + " WHERE id = ? AND tree = " + treeID);
…	…
147	142	}
148	143
149		public void addNode(int id, String caption, String label, int nodeStatus)
150		{
151		try
152		{
	144	public void addNode(int id, String caption, String label, int nodeStatus) {
	145	try {
153	146	addNodeStatement.setInt(1, id);
154	147	addNodeStatement.setString(2, caption);
…	…
156	149	addNodeStatement.setInt(4, nodeStatus);
157	150	addNodeStatement.execute();
158		} catch (SQLException e)
159		{
	151	} catch (SQLException e) {
160	152	throw new KahinaException("SQL error.", e);
161	153	}
…	…
164	156
165	157	@Override
166		public int addNode(String caption, String label, int nodeStatus)
167		{
	158	public int addNode(String caption, String label, int nodeStatus) {
168	159	int id = nextID++;
169	160	addNode(id, caption, label, nodeStatus);
…	…
172	163
173	164	@Override
174		public void addChild(int parent, int child)
175		{
176		System.err.println("adding " + child + " to " + parent + " in " + this);
177		try
178		{
	165	public void addChild(int parent, int child) {
	166	try {
179	167	addEdgeStatement.setInt(1, parent);
180	168	addEdgeStatement.setInt(2, child);
181	169	addEdgeStatement.execute();
182		} catch (SQLException e)
183		{
	170	} catch (SQLException e) {
184	171	throw new KahinaException("SQL error.", e);
185	172	}
…	…
187	174	}
188	175
189		private void computeAndStoreLayerInformation(int child)
190		{
	176	private void computeAndStoreLayerInformation(int child) {
191	177	int childLayer = decider.decideOnLayer(child, this);
192	178	int virtualParent = getParent(child);
193	179	int parentLayer = getLayer(virtualParent);
194		while (parentLayer > childLayer)
195		{
	180	while (parentLayer > childLayer) {
196	181	virtualParent = getParent(virtualParent);
197	182	parentLayer = getLayer(virtualParent);
198	183	}
199		if (parentLayer < childLayer)
200		{
	184	if (parentLayer < childLayer) {
201	185	virtualParent = -1;
202	186	}
203		try
204		{
	187	try {
205	188	addLayerInformationStatement.setInt(1, childLayer);
206	189	addLayerInformationStatement.setInt(2, virtualParent);
207	190	addLayerInformationStatement.setInt(3, child);
208	191	addLayerInformationStatement.execute();
209		} catch (SQLException e)
210		{
211		throw new KahinaException("SQL error.", e);
212		}
213		}
214
215		@Override
216		public void setLayerDecider(LayerDecider decider)
217		{
	192	} catch (SQLException e) {
	193	throw new KahinaException("SQL error.", e);
	194	}
	195	}
	196
	197	@Override
	198	public void setLayerDecider(LayerDecider decider) {
218	199	super.setLayerDecider(decider);
219	200	recomputeLayers();
220	201	}
221	202
222		public void recomputeLayers()
223		{
	203	public void recomputeLayers() {
224	204	recomputeLayers(getRootID());
225	205	}
226	206
227		public void recomputeLayers(int nodeID)
228		{
	207	public void recomputeLayers(int nodeID) {
229	208	computeAndStoreLayerInformation(nodeID);
230		for (int childID : getChildren(nodeID))
231		{
	209	for (int childID : getChildren(nodeID)) {
232	210	recomputeLayers(childID);
233	211	}
…	…
235	213
236	214	@Override
237		public int getParent(int nodeID)
238		{
239		try
240		{
	215	public int getParent(int nodeID) {
	216	try {
241	217	getRealParentStatement.setInt(1, nodeID);
242		} catch (SQLException e)
243		{
	218	} catch (SQLException e) {
244	219	throw new KahinaException("SQL error.", e);
245	220	}
…	…
247	222	}
248	223
249		private int getVirtualParent(int nodeID)
250		{
251		try
252		{
	224	private int getVirtualParent(int nodeID) {
	225	try {
253	226	getVirtualParentStatement.setInt(1, nodeID);
254		} catch (SQLException e)
255		{
	227	} catch (SQLException e) {
256	228	throw new KahinaException("SQL error.", e);
257	229	}
…	…
259	231	}
260	232
261		private int getLayer(int nodeID)
262		{
263		try
264		{
	233	private int getLayer(int nodeID) {
	234	try {
265	235	getLayerStatement.setInt(1, nodeID);
266		} catch (SQLException e)
267		{
	236	} catch (SQLException e) {
268	237	throw new KahinaException("SQL error.", e);
269	238	}
…	…
272	241
273	242	@Override
274		public void clear()
275		{
	243	public void clear() {
276	244	db.execute(clearStatement);
277	245	}
278	246
279	247	@Override
280		public void collapse(int nodeID)
281		{
282		try
283		{
	248	public void collapse(int nodeID) {
	249	try {
284	250	collapseStatement.setInt(1, nodeID);
285	251	collapseStatement.execute();
286		} catch (SQLException e)
287		{
288		throw new KahinaException("SQL error.", e);
289		}
290		}
291
292		@Override
293		public void decollapse(int nodeID)
294		{
295		try
296		{
	252	} catch (SQLException e) {
	253	throw new KahinaException("SQL error.", e);
	254	}
	255	}
	256
	257	@Override
	258	public void decollapse(int nodeID) {
	259	try {
297	260	decollapseStatement.setInt(1, nodeID);
298	261	decollapseStatement.execute();
299		} catch (SQLException e)
300		{
301		throw new KahinaException("SQL error.", e);
302		}
303		}
304
305		@Override
306		public void decollapseAll()
307		{
	262	} catch (SQLException e) {
	263	throw new KahinaException("SQL error.", e);
	264	}
	265	}
	266
	267	@Override
	268	public void decollapseAll() {
308	269	db.execute(decollapseAllStatement);
309	270	}
310	271
311	272	@Override
312		public List<Integer> getChildren(int nodeID, int layer)
313		{
314		System.err.print("children for " + nodeID + "(" + getNodeCaption(nodeID) + ") on " + layer + ": ");
	273	public List<Integer> getChildren(int nodeID, int layer) {
315	274	int nodeLayer = getLayer(nodeID);
316		if (layer == nodeLayer)
317		{
	275	if (layer == nodeLayer) {
318	276	// the most common case, for which we have precalculated the virtual
319	277	// children
320		List<Integer> result = getVirtualChildren(nodeID);
321		return ear(result);
322		}
323		if (nodeID == getRootID(layer) \|\| nodeLayer >= layer)
324		{
	278	List<Integer> result = getVirtualChildren(nodeID, nodeLayer);
	279	return result;
	280	}
	281	if (nodeID == getRootID(layer) \|\| nodeLayer >= layer) {
325	282	// usually only the case for the root of a partial tree
326	283	List<Integer> frontLine = getChildren(nodeID);
327		for (int i = 0; i < frontLine.size();)
328		{
	284	for (int i = 0; i < frontLine.size();) {
329	285	int child = frontLine.get(i);
330		if (getLayer(child) > layer)
331		{
	286	if (getLayer(child) > layer) {
332	287	frontLine.remove(i);
333	288	frontLine.addAll(i, getChildren(child));
334		} else
335		{
	289	} else {
336	290	i++;
337	291	}
338	292	}
339		return ~~ear(frontLine)~~;
	293	return frontLine;
340	294	}
341	295	// When we have reached a "cornerstone", pretend it's a leaf:
342		return ear(Collections.emptyList());
343		}
344
345		private List<Integer> getChildren(int nodeID)
346		{
347		try
348		{
	296	return Collections.emptyList();
	297	}
	298
	299	private List<Integer> getChildren(int nodeID) {
	300	try {
349	301	getRealChildrenStatement.setInt(1, nodeID);
350		} catch (SQLException e)
351		{
	302	} catch (SQLException e) {
352	303	throw new KahinaException("SQL error.", e);
353	304	}
…	…
355	306	}
356	307
357		private List<Integer> getVirtualChildren(int nodeID)
358		{
359		try
360		{
	308	private List<Integer> getVirtualChildren(int nodeID, int layer) {
	309	try {
361	310	getVirtualChildrenStatement.setInt(1, nodeID);
362		} catch (SQLException e)
363		{
	311	getVirtualChildrenStatement.setInt(2, nodeID);
	312	getVirtualChildrenStatement.setInt(3, layer);
	313	} catch (SQLException e) {
364	314	throw new KahinaException("SQL error.", e);
365	315	}
…	…
369	319
370	320	@Override
371		public String getEdgeLabel(int nodeID)
372		{
373		try
374		{
	321	public String getEdgeLabel(int nodeID) {
	322	try {
375	323	getEdgeLabelStatement.setInt(1, nodeID);
376		} catch (SQLException e)
377		{
	324	} catch (SQLException e) {
378	325	throw new KahinaException("SQL error.", e);
379	326	}
…	…
382	329
383	330	@Override
384		protected void collectLeaves(int nodeID, List<Integer> leaves)
385		{
	331	protected void collectLeaves(int nodeID, List<Integer> leaves) {
386	332	List<Integer> children = getChildren(nodeID);
387		if (children.isEmpty())
388		{
	333	if (children.isEmpty()) {
389	334	leaves.add(nodeID);
390		} else
391		{
392		for (int child : children)
393		{
	335	} else {
	336	for (int child : children) {
394	337	collectLeaves(child, leaves);
395	338	}
…	…
398	341
399	342	@Override
400		public String getNodeCaption(int nodeID)
401		{
402		try
403		{
	343	public String getNodeCaption(int nodeID) {
	344	try {
404	345	getNodeCaptionStatement.setInt(1, nodeID);
405		} catch (SQLException e)
406		{
	346	} catch (SQLException e) {
407	347	throw new KahinaException("SQL error.", e);
408	348	}
…	…
411	351
412	352	@Override
413		public int getNodeStatus(int nodeID)
414		{
415		try
416		{
	353	public int getNodeStatus(int nodeID) {
	354	try {
417	355	getNodeStatusStatement.setInt(1, nodeID);
418		} catch (SQLException e)
419		{
	356	} catch (SQLException e) {
420	357	throw new KahinaException("SQL error.", e);
421	358	}
…	…
424	361
425	362	@Override
426		public int getParent(int nodeID, int layer)
427		{
428		if (nodeID == getRootID(layer))
429		{
	363	public int getParent(int nodeID, int layer) {
	364	if (nodeID == getRootID(layer)) {
430	365	return -1;
431	366	}
432		if (getLayer(nodeID) == layer)
433		{
	367	if (getLayer(nodeID) == layer) {
434	368	return getVirtualParent(nodeID);
435	369	}
436	370	int result = getParent(nodeID);
437		while (getLayer(result) > layer)
438		{
	371	while (getLayer(result) > layer) {
439	372	result = getParent(result);
440	373	}
…	…
443	376
444	377	@Override
445		public int getRootID()
446		{
	378	public int getRootID() {
447	379	return db.queryInteger(getRootStatement, -1);
448	380	}
449	381
450	382	@Override
451		public int getRootID(int layer)
452		{
453		if (layer == 0)
454		{
	383	public int getRootID(int layer) {
	384	if (layer == 0) {
455	385	return getRootID();
456	386	}
457	387	int result = getReferenceNode();
458		while (getLayer(result) >= layer)
459		{
	388	while (getLayer(result) >= layer) {
460	389	result = getParent(result);
461	390	}
…	…
464	393
465	394	@Override
466		public boolean isCollapsed(int nodeID)
467		{
468		try
469		{
	395	public boolean isCollapsed(int nodeID) {
	396	try {
470	397	isCollapsedStatement.setInt(1, nodeID);
471		} catch (SQLException e)
472		{
	398	} catch (SQLException e) {
473	399	throw new KahinaException("SQL error.", e);
474	400	}
…	…
478	404
479	405	@Override
480		public int getSize()
481		{
	406	public int getSize() {
482	407	return db.queryInteger(getSizeStatement, 0);
483	408	}
484	409
485	410	public static KahinaTree importXML(Document dom, LayerDecider decider,
486		DatabaseHandler db, KahinaTree primaryModel)
487		{
	411	DatabaseHandler db, KahinaTree primaryModel) {
488	412	KahinaDbTree m = new KahinaDbTree(decider, db);
489		if (primaryModel != null)
490		{
	413	if (primaryModel != null) {
491	414	m.setPrimaryModel(primaryModel);
492	415	}
493	416	Element treeElement = dom.getDocumentElement();
494	417	NodeList childNodes = treeElement.getChildNodes();
495		for (int i = 0; i < childNodes.getLength(); i++)
496		{
	418	for (int i = 0; i < childNodes.getLength(); i++) {
497	419	Node n = childNodes.item(i);
498		if (n.getNodeName().equals("node"))
499		{
	420	if (n.getNodeName().equals("node")) {
500	421	importXMLNode(m, (Element) n, -1);
501	422	// TODO: a little risky, root node could be assigned another ID
…	…
507	428	}
508	429
509		private static void importXMLNode(KahinaDbTree m, Element node, int parentID)
510		{
	430	private static void importXMLNode(KahinaDbTree m, Element node, int parentID) {
511	431	String caption = node.getAttribute("caption");
512	432	String label = node.getAttribute("label");
513	433	int status = 0;
514		if (node.getAttribute("status").length() > 0)
515		{
	434	if (node.getAttribute("status").length() > 0) {
516	435	status = Integer.parseInt(node.getAttribute("status"));
517	436	}
518	437	int id;
519		if (node.getAttribute("id").length() > 0)
520		{
	438	if (node.getAttribute("id").length() > 0) {
521	439	id = Integer.parseInt(node.getAttribute("id"));
522	440	m.addNode(id, caption, label, status);
523		} else
524		{
	441	} else {
525	442	id = m.addNode(caption, label, status);
526	443	}
527		if (parentID != -1)
528		{
	444	if (parentID != -1) {
529	445	m.addChild(parentID, id);
530	446	}
531	447	// go through children recursively
532	448	NodeList childNodes = node.getChildNodes();
533		for (int i = 0; i < childNodes.getLength(); i++)
534		{
	449	for (int i = 0; i < childNodes.getLength(); i++) {
535	450	Node n = childNodes.item(i);
536		if (n.getNodeName().equals("node"))
537		{
	451	if (n.getNodeName().equals("node")) {
538	452	importXMLNode(m, (Element) n, id);
539	453	}
…	…
542	456
543	457	@Override
544		public void finalize() throws Throwable
545		{
	458	public void finalize() throws Throwable {
546	459	clear();
547	460	super.finalize();

kahina/trunk/src/org/kahina/data/tree/KahinaMemTree.java

r57	r58
61	61	public List<Integer> getChildren(int nodeID, int layerID)
62	62	{
63		~~System.err.print("children for " + nodeID + "(" + getNodeCaption(nodeID) + ") on " + layerID + ": ");~~
64	63	//System.err.print("KahinaLayeredTree.getChildren(" + nodeID + "," + layerID + ") = ");
65	64	List<Integer> chi = new ArrayList<Integer>();
…	…
88	87	//System.err.println(" node: " + nodeID + " layer: " + layerID + " chi: " + chi);
89	88	//System.err.println(chi);
90		return ~~ear(chi)~~;
	89	return chi;
91	90	}
92	91

kahina/trunk/src/org/kahina/data/tree/KahinaTree.java

r57	r58
23	23	this.decider = decider;
24	24	doClear();
25		}
26
27
28
29		~~public List<Integer> ear(List x)~~
30		{
31		~~System.err.println(x);~~
32		~~return (List<Integer>) x;~~
33	25	}
34	26

Download in other formats: