1 /*******************************************************************************
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.acorn.cluster;
14 import java.io.ByteArrayInputStream;
15 import java.io.IOException;
16 import java.io.InputStream;
17 import java.util.Arrays;
19 import org.simantics.acorn.internal.ClusterChange;
20 import org.simantics.acorn.internal.ClusterStream;
21 import org.simantics.acorn.internal.ClusterSupport2;
22 import org.simantics.acorn.internal.DebugPolicy;
23 import org.simantics.db.Resource;
24 import org.simantics.db.exception.DatabaseException;
25 import org.simantics.db.exception.ExternalValueException;
26 import org.simantics.db.exception.ValidationException;
27 import org.simantics.db.impl.ClusterBase;
28 import org.simantics.db.impl.ClusterI;
29 import org.simantics.db.impl.ClusterSupport;
30 import org.simantics.db.impl.ClusterTraitsBase;
31 import org.simantics.db.impl.ForEachObjectContextProcedure;
32 import org.simantics.db.impl.ForEachObjectProcedure;
33 import org.simantics.db.impl.ForPossibleRelatedValueContextProcedure;
34 import org.simantics.db.impl.ForPossibleRelatedValueProcedure;
35 import org.simantics.db.impl.IClusterTable;
36 import org.simantics.db.impl.Table;
37 import org.simantics.db.impl.TableHeader;
38 import org.simantics.db.impl.graph.ReadGraphImpl;
39 import org.simantics.db.procedure.AsyncContextMultiProcedure;
40 import org.simantics.db.procedure.AsyncMultiProcedure;
41 import org.simantics.db.procore.cluster.ClusterMapSmall;
42 import org.simantics.db.procore.cluster.ClusterTraits;
43 import org.simantics.db.procore.cluster.ClusterTraitsSmall;
44 import org.simantics.db.procore.cluster.CompleteTableSmall;
45 import org.simantics.db.procore.cluster.ForeignTableSmall;
46 import org.simantics.db.procore.cluster.ObjectTable;
47 import org.simantics.db.procore.cluster.OutOfSpaceException;
48 import org.simantics.db.procore.cluster.PredicateTable;
49 import org.simantics.db.procore.cluster.ResourceTableSmall;
50 import org.simantics.db.procore.cluster.ValueTableSmall;
51 import org.simantics.db.service.Bytes;
52 import org.simantics.db.service.ClusterUID;
53 import org.simantics.db.service.ResourceUID;
54 import org.simantics.utils.datastructures.Callback;
56 import gnu.trove.map.hash.TIntShortHashMap;
57 import gnu.trove.procedure.TIntProcedure;
58 import gnu.trove.set.hash.TIntHashSet;
60 final public class ClusterSmall extends ClusterImpl {
61 private static final int TABLE_HEADER_SIZE = TableHeader.HEADER_SIZE + TableHeader.EXTRA_SIZE;
62 private static final int RESOURCE_TABLE_OFFSET = 0;
63 private static final int PREDICATE_TABLE_OFFSET = RESOURCE_TABLE_OFFSET + TABLE_HEADER_SIZE;
64 private static final int OBJECT_TABLE_OFFSET = PREDICATE_TABLE_OFFSET + TABLE_HEADER_SIZE;
65 private static final int VALUE_TABLE_OFFSET = OBJECT_TABLE_OFFSET + TABLE_HEADER_SIZE;
66 private static final int FLAT_TABLE_OFFSET = VALUE_TABLE_OFFSET + TABLE_HEADER_SIZE;
67 private static final int COMPLETE_TABLE_OFFSET = FLAT_TABLE_OFFSET + TABLE_HEADER_SIZE;
68 private static final int FOREIGN_TABLE_OFFSET = COMPLETE_TABLE_OFFSET + TABLE_HEADER_SIZE;
69 private static final int INT_HEADER_SIZE = FOREIGN_TABLE_OFFSET + TABLE_HEADER_SIZE;
70 private final int clusterBits;
71 private final ResourceTableSmall resourceTable;
72 private final PredicateTable predicateTable;
73 private final ObjectTable objectTable;
74 private final ValueTableSmall valueTable;
75 private final ForeignTableSmall foreignTable;
76 private final CompleteTableSmall completeTable;
77 private final ClusterMapSmall clusterMap;
78 private final int[] headerTable;
79 public final ClusterSupport2 clusterSupport;
80 private boolean proxy;
81 private boolean deleted = false;
83 protected ClusterSmall() {
85 this.headerTable = null;
86 this.resourceTable = null;
87 this.foreignTable = null;
88 this.predicateTable = null;
89 this.objectTable = null;
90 this.valueTable = null;
91 this.completeTable = null;
92 this.clusterMap = null;
93 this.clusterSupport = null;
98 public ClusterSmall(IClusterTable clusterTable, ClusterUID clusterUID, int clusterKey, ClusterSupport2 support) {
99 super(clusterTable, clusterUID, clusterKey, support);
100 if(DebugPolicy.REPORT_CLUSTER_EVENTS)
101 new Exception(clusterUID.toString()).printStackTrace();
103 this.headerTable = null;
104 this.resourceTable = null;
105 this.foreignTable = null;
106 this.predicateTable = null;
107 this.objectTable = null;
108 this.valueTable = null;
109 this.completeTable = null;
110 this.clusterMap = null;
111 this.clusterSupport = support;
112 this.clusterBits = 0;
114 // new Exception("ClusterSmall " + clusterKey).printStackTrace();
116 ClusterSmall(ClusterUID clusterUID, int clusterKey, ClusterSupport2 support, IClusterTable clusterTable) {
117 super(clusterTable, clusterUID, clusterKey, support);
118 if(DebugPolicy.REPORT_CLUSTER_EVENTS)
119 new Exception(clusterUID.toString()).printStackTrace();
121 this.clusterSupport = support;
122 this.headerTable = new int[INT_HEADER_SIZE];
123 this.resourceTable = new ResourceTableSmall(this, headerTable, RESOURCE_TABLE_OFFSET);
124 this.foreignTable = new ForeignTableSmall(this, headerTable, FOREIGN_TABLE_OFFSET);
125 this.predicateTable = new PredicateTable(this, headerTable, PREDICATE_TABLE_OFFSET);
126 this.objectTable = new ObjectTable(this, headerTable, OBJECT_TABLE_OFFSET);
127 this.valueTable = new ValueTableSmall(this, headerTable, VALUE_TABLE_OFFSET);
128 this.completeTable = new CompleteTableSmall(this, headerTable, COMPLETE_TABLE_OFFSET);
129 this.clusterMap = new ClusterMapSmall(this, foreignTable);
130 this.clusterBits = ClusterTraitsBase.getClusterBits(clusterKey);
131 // if(clusterTable != null)
132 // this.importance = -clusterTable.timeCounter();
135 // new Exception("ClusterSmall " + clusterKey).printStackTrace();
137 protected ClusterSmall(IClusterTable clusterTable, long[] longs, int[] ints, byte[] bytes, ClusterSupport2 support, int clusterKey)
138 throws DatabaseException {
139 super(clusterTable, checkValidity(-1, longs, ints, bytes), clusterKey, support);
141 this.clusterSupport = support;
142 if (ints.length < INT_HEADER_SIZE)
143 throw new IllegalArgumentException("Too small integer table for cluster.");
144 this.headerTable = ints;
145 if(DebugPolicy.REPORT_CLUSTER_EVENTS) new Exception(Long.toString(clusterId)).printStackTrace();
146 this.resourceTable = new ResourceTableSmall(this, ints, RESOURCE_TABLE_OFFSET, longs);
147 this.foreignTable = new ForeignTableSmall(this, headerTable, FOREIGN_TABLE_OFFSET, longs);
148 this.predicateTable = new PredicateTable(this, ints, PREDICATE_TABLE_OFFSET, ints);
149 this.objectTable = new ObjectTable(this, ints, OBJECT_TABLE_OFFSET, ints);
150 this.valueTable = new ValueTableSmall(this, ints, VALUE_TABLE_OFFSET, bytes);
151 this.completeTable = new CompleteTableSmall(this, headerTable, COMPLETE_TABLE_OFFSET, ints);
152 this.clusterMap = new ClusterMapSmall(this, foreignTable);
153 this.clusterBits = ClusterTraitsBase.getClusterBits(clusterKey);
154 // if(clusterTable != null) {
155 // this.importance = clusterTable.timeCounter();
156 // clusterTable.markImmutable(this, getImmutable());
158 // new Exception("ClusterSmall " + clusterKey).printStackTrace();
161 System.out.println("Cluster " + clusterId);
162 System.out.println("-size:" + getUsedSpace());
163 System.out.println(" -rt:" + (resourceTable.getTableCapacity() * 8 + 8));
164 System.out.println(" -ft:" + foreignTable.getTableCapacity() * 8);
165 System.out.println(" -pt:" + predicateTable.getTableCapacity() * 4);
166 System.out.println(" -ot:" + objectTable.getTableCapacity() * 4);
167 System.out.println(" -ct:" + completeTable.getTableCapacity() * 4);
168 System.out.println(" -vt:" + valueTable.getTableCapacity());
170 System.out.println("-resourceTable:");
171 System.out.println(" -resourceCount=" + resourceTable.getResourceCount());
172 System.out.println(" -size=" + resourceTable.getTableSize());
173 System.out.println(" -capacity=" + resourceTable.getTableCapacity());
174 System.out.println(" -count=" + resourceTable.getTableCount());
175 System.out.println(" -size=" + resourceTable.getTableSize());
176 //resourceTable.analyse();
178 public void checkDirectReference(int dr)
179 throws DatabaseException {
180 if (!ClusterTraits.statementIndexIsDirect(dr))
181 throw new ValidationException("Reference is not direct. Reference=" + dr);
182 if (ClusterTraits.isFlat(dr))
183 throw new ValidationException("Reference is flat. Reference=" + dr);
184 if (ClusterTraits.isLocal(dr)) {
185 if (dr < 1 || dr > resourceTable.getUsedSize())
186 throw new ValidationException("Illegal local reference. Reference=" + dr);
188 int fi = ClusterTraits.getForeignIndexFromReference(dr);
189 int ri = ClusterTraits.getResourceIndexFromForeignReference(dr);
190 if (fi < 1 || fi > foreignTable.getUsedSize())
191 throw new ValidationException("Illegal foreign reference. Reference=" + dr + " foreign index=" + fi);
192 if (ri < 1 || ri > ClusterTraits.getMaxNumberOfResources())
193 throw new ValidationException("Illegal foreign reference. Reference=" + dr + " resource index=" + ri);
196 public void checkPredicateIndex(int pi)
197 throws DatabaseException {
198 // predicateTable.checkPredicateSetIndex(this, pi);
200 public void checkObjectSetReference(int or)
201 throws DatabaseException {
202 if (ClusterTraits.statementIndexIsDirect(or))
203 throw new ValidationException("Illegal object set reference. Reference=" + or);
204 int oi = ClusterTraits.statementIndexGet(or);
205 this.objectTable.checkObjectSetIndex(this, oi);
208 public void checkValueInit()
209 throws DatabaseException {
210 valueTable.checkValueInit();
212 public void checkValue(int capacity, int index)
213 throws DatabaseException {
214 valueTable.checkValue(capacity, index);
216 public void checkValueFini()
217 throws DatabaseException {
218 valueTable.checkValueFini();
220 public void checkForeingIndex(int fi)
221 throws DatabaseException {
222 if (fi<1 || fi > foreignTable.getUsedSize())
223 throw new ValidationException("Illegal foreign index=" + fi);
225 public void checkCompleteSetReference(int cr)
226 throws DatabaseException {
227 if (!ClusterTraits.completeReferenceIsMultiple(cr))
228 throw new ValidationException("Illegal complete set reference. Reference=" + cr);
230 this.completeTable.checkCompleteSetIndex(this, ci);
233 throws DatabaseException {
234 // this.completeTable.check(this);
235 // this.objectTable.check(this);
236 // // Must be after object table check.
237 // this.predicateTable.check(this);
238 // this.resourceTable.check(this);
241 public CompleteTypeEnum getCompleteType(int resourceKey, ClusterSupport support)
242 throws DatabaseException {
243 final int resourceRef = getLocalReference(resourceKey);
244 CompleteTypeEnum ct = resourceTable.getCompleteType(resourceRef);
246 System.out.println("ClusterSmall.getCompleteType rk=" + resourceKey + " ct=" + ct);
251 public int getCompleteObjectKey(int resourceKey, ClusterSupport support)
252 throws DatabaseException {
253 final int resourceIndexOld = getLocalReference(resourceKey);
254 short completeRef = resourceTable.getCompleteObjectRef(resourceIndexOld);
257 if (0 == completeRef)
258 throw new DatabaseException("Resource's complete object refernce is null. Resource key=" + resourceKey + ".");
259 ClusterI.CompleteTypeEnum completeType = resourceTable.getCompleteType(resourceIndexOld);
260 if (completeType == ClusterI.CompleteTypeEnum.NotComplete)
261 throw new DatabaseException("Resource has multiple complete objects. Resource key=" + resourceKey + ".");
262 if (ClusterTraitsSmall.resourceRefIsLocal(completeRef)) {
263 clusterIndex = clusterKey;
264 resourceIndex = completeRef;
265 } else { // Resource has one complete statement.
266 ResourceUID resourceUID = clusterMap.getForeignResourceUID(completeRef);
267 ClusterUID uid = resourceUID.asCID();
268 clusterIndex = clusterSupport.getClusterKeyByUID(0, uid.second);
269 //ClusterI c = clusterTable.getClusterByClusterUIDOrMakeProxy(uid);
270 //clusterIndex = c.getClusterKey();
271 //assert(clusterIndex == clusterTable.getClusterByClusterUIDOrMakeProxy(uid).getClusterKey());
272 resourceIndex = resourceUID.getIndex();
274 int key = ClusterTraits.createResourceKey(clusterIndex, resourceIndex);
276 System.out.println("ClusterSmall.complete object rk=" + resourceKey + " ck=" + key);
281 public boolean isComplete(int resourceKey, ClusterSupport support)
282 throws DatabaseException {
283 final int resourceRef = getLocalReference(resourceKey);
284 final ClusterI.CompleteTypeEnum completeType = resourceTable.getCompleteType(resourceRef);
285 boolean complete = completeType != ClusterI.CompleteTypeEnum.NotComplete;
287 System.out.println("ClusterSmall.key=" + resourceKey + " isComplete=" + complete);
290 public int getSingleObject(int resourceKey, int predicateKey, int objectIndex, ClusterSupport support) throws DatabaseException {
292 System.out.println("ClusterSmall.getSingleObject: rk=" + resourceKey + " pk=" + predicateKey);
293 if (0 == objectIndex) {
294 final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKeyNoThrow(resourceKey);
295 final short pRef = getInternalReferenceOrZero2(predicateKey, support);
296 final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
297 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
299 return objectTable.getSingleObject(objectIndex, support, this);
302 public void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, AsyncMultiProcedure<Resource> procedure,
303 ClusterSupport support) throws DatabaseException {
305 System.out.println("ClusterSmall.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
306 if (0 == objectIndex) {
307 final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
308 final int pRef = getInternalReferenceOrZero2(predicateKey, support);
309 final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
310 resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
313 objectTable.foreachObject(graph, objectIndex, procedure, this);
316 public <C> void forObjects(ReadGraphImpl graph, int resourceKey, int predicateKey, int objectIndex, C context, AsyncContextMultiProcedure<C, Resource> procedure,
317 ClusterSupport support) throws DatabaseException {
319 System.out.println("ClusterSmall.forObjects1: rk=" + resourceKey + " pk=" + predicateKey);
320 if (0 == objectIndex) {
321 final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
322 final int pRef = getInternalReferenceOrZero2(predicateKey, support);
323 final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
324 resourceTable.foreachObject(resourceIndex, graph, context, procedure, support, pRef, pCompleteType, completeTable, this);
327 objectTable.foreachObject(graph, objectIndex, context, procedure, this);
331 public <Context> boolean forObjects(int resourceKey, int predicateKey, int objectIndex, ObjectProcedure<Context> procedure,
332 Context context, ClusterSupport support) throws DatabaseException {
334 System.out.println("ClusterSmall.forObjects2: rk=" + resourceKey + " pk=" + predicateKey);
335 if (0 == objectIndex) {
336 final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
337 final short pRef = getInternalReferenceOrZero2(predicateKey, support);
338 final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
339 return resourceTable.foreachObject(resourceIndex, procedure, context, support, this, pRef, pCompleteType, completeTable);
341 return objectTable.foreachObject(objectIndex, procedure, context, support, this);
345 public int getSingleObject(int resourceKey, int predicateKey, ClusterSupport support) throws DatabaseException {
347 System.out.println("ClusterSmall.getSingleObject2: rk=" + resourceKey + " pk=" + predicateKey);
348 final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
349 final short pRef = getInternalReferenceOrZero2(predicateKey, support);
350 final int completeType = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);
351 final ClusterI.CompleteTypeEnum pCompleteType = CompleteTypeEnum.make(completeType);
352 if (completeType > 0)
353 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
354 final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
355 if (0 == predicateIndex) // All relevant data is in resource table.
356 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
357 int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
358 return getSingleObject(resourceKey, predicateKey, objectIndex, support);
362 public <T> int getSingleObject(int resourceKey, ForPossibleRelatedValueProcedure<T> procedure, ClusterSupport support) throws DatabaseException {
363 final short resourceIndex = (short)ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
364 final int predicateKey = procedure.predicateKey;
365 int clusterKey = ClusterTraitsBase.getClusterMaskFromResourceKey(resourceKey);
367 if(procedure.clusterKey[0] == clusterKey) {
368 pRef = (short)procedure.predicateReference[0];
370 pRef = getInternalReferenceOrZero2(predicateKey, support);
371 procedure.clusterKey[0] = clusterKey;
372 procedure.predicateReference[0] = pRef;
375 final ClusterI.CompleteTypeEnum pCompleteType = procedure.completeType;
376 if (CompleteTypeEnum.NotComplete != pCompleteType)
377 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
378 final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
379 if (0 == predicateIndex) // All relevant data is in resource table.
380 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
381 int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
382 return getSingleObject(resourceKey, predicateKey, objectIndex, support);
386 public <C, T> int getSingleObject(int resourceKey, ForPossibleRelatedValueContextProcedure<C, T> procedure, ClusterSupport support) throws DatabaseException {
387 final short resourceIndex = (short)ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
388 final int predicateKey = procedure.predicateKey;
389 int clusterKey = ClusterTraitsBase.getClusterMaskFromResourceKey(resourceKey);
391 if(procedure.clusterKey[0] == clusterKey) {
392 pRef = (short)procedure.predicateReference[0];
394 pRef = getInternalReferenceOrZero2(predicateKey, support);
395 procedure.clusterKey[0] = clusterKey;
396 procedure.predicateReference[0] = pRef;
398 final ClusterI.CompleteTypeEnum pCompleteType = procedure.completeType;
399 if (CompleteTypeEnum.NotComplete != pCompleteType)
400 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
401 final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
402 if (0 == predicateIndex) // All relevant data is in resource table.
403 return resourceTable.getSingleObject(resourceIndex, support, pRef, pCompleteType, completeTable, this);
404 int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
405 return getSingleObject(resourceKey, predicateKey, objectIndex, support);
409 public void forObjects(ReadGraphImpl graph, int resourceKey,
410 int predicateKey, AsyncMultiProcedure<Resource> procedure) throws DatabaseException {
412 throw new UnsupportedOperationException();
414 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
415 // ClusterSupport support = session.clusterTranslator;
417 // System.out.println("ClusterSmall.forObjects3: rk=" + resourceKey + " pk=" + predicateKey);
418 // final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
419 // final int pRef = getInternalReferenceOrZero2(predicateKey, support);
420 // final int completeType = ClusterTraitsBase.getCompleteTypeIntFromResourceKey(predicateKey);
421 // final ClusterI.CompleteTypeEnum pCompleteType = CompleteTypeEnum.make(completeType);
422 // if (completeType > 0) {
423 // resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
426 // final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
427 // if (0 == predicateIndex) {
428 // resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
431 // int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
432 // forObjects(graph, resourceKey, predicateKey, objectIndex, procedure, support);
435 public void forObjects(ReadGraphImpl graph, int resourceKey, ForEachObjectProcedure procedure) throws DatabaseException {
437 throw new UnsupportedOperationException();
439 // final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
440 // final int predicateKey = procedure.predicateKey;
441 // int clusterKey = ClusterTraitsBase.getClusterMaskFromResourceKey(resourceKey);
443 // if(procedure.clusterKey[0] == clusterKey) {
444 // pRef = procedure.predicateReference[0];
446 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
447 // ClusterSupport support = session.clusterTranslator;
448 // pRef = getInternalReferenceOrZero2(predicateKey, support);
449 // procedure.clusterKey[0] = clusterKey;
450 // procedure.predicateReference[0] = pRef;
452 // final ClusterI.CompleteTypeEnum pCompleteType = procedure.completeType;
453 // if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
454 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
455 // ClusterSupport support = session.clusterTranslator;
456 // resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
459 // final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
460 // if (0 == predicateIndex) {
461 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
462 // ClusterSupport support = session.clusterTranslator;
463 // resourceTable.foreachObject(resourceIndex, graph, procedure, support, pRef, pCompleteType, completeTable, this);
466 // int hashBase = predicateIndex + predicateTable.offset;
467 // if (predicateTable.table[hashBase-1] < 0) {
468 // int objectIndex = TableIntArraySet2.get(predicateTable.table, hashBase, pRef & 0xFFFF);
469 // //int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
470 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
471 // ClusterSupport support = session.clusterTranslator;
472 // forObjects(graph, resourceKey, predicateKey, objectIndex, procedure, support);
474 // procedure.finished(graph);
479 public <C> void forObjects(ReadGraphImpl graph, int resourceKey, C context, ForEachObjectContextProcedure<C> procedure) throws DatabaseException {
481 throw new UnsupportedOperationException();
483 // final int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
484 // final int predicateKey = procedure.predicateKey;
485 // int clusterKey = ClusterTraitsBase.getClusterMaskFromResourceKey(resourceKey);
487 // if(procedure.clusterKey[0] == clusterKey) {
488 // pRef = procedure.predicateReference[0];
490 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
491 // ClusterSupport support = session.clusterTranslator;
492 // pRef = getInternalReferenceOrZero2(predicateKey, support);
493 // procedure.clusterKey[0] = clusterKey;
494 // procedure.predicateReference[0] = pRef;
497 // final ClusterI.CompleteTypeEnum pCompleteType = procedure.completeType;
498 // if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
499 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
500 // ClusterSupport support = session.clusterTranslator;
501 // resourceTable.foreachObject(resourceIndex, graph, context, procedure, support, pRef, pCompleteType, completeTable, this);
504 // final int predicateIndex = (int)resourceTable.table[(resourceIndex<<1) - 1 + resourceTable.offset] & 0xFFFFFF;
505 // if (0 == predicateIndex) {
506 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
507 // ClusterSupport support = session.clusterTranslator;
508 // resourceTable.foreachObject(resourceIndex, graph, context, procedure, support, pRef, pCompleteType, completeTable, this);
511 // int hashBase = predicateIndex + predicateTable.offset;
512 // if(predicateTable.table[hashBase-1] < 0) {
513 // int objectIndex = TableIntArraySet2.get(predicateTable.table, hashBase, pRef & 0xFFFF);
514 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
515 // ClusterSupport support = session.clusterTranslator;
516 // forObjects(graph, resourceKey, predicateKey, objectIndex, context, procedure, support);
518 // int objectIndex = TableIntSet2.get(predicateTable.table, hashBase, pRef & 0xFFFF);
519 // SessionImplSocket session = (SessionImplSocket)graph.getSession();
520 // ClusterSupport support = session.clusterTranslator;
521 // forObjects(graph, resourceKey, predicateKey, objectIndex, context, procedure, support);
525 public <Context> boolean forObjects(int resourceKey, int predicateKey,
526 ObjectProcedure<Context> procedure, Context context, ClusterSupport support)
527 throws DatabaseException {
529 System.out.println("ClusterSmall.forObjects4: rk=" + resourceKey + " pk=" + predicateKey);
530 final short resourceIndex = (short)ClusterTraitsBase.getResourceIndexFromResourceKey(resourceKey);
531 final short pRef = getInternalReferenceOrZero2(predicateKey, support);
532 final ClusterI.CompleteTypeEnum pCompleteType = ClusterTraitsBase.getCompleteTypeFromResourceKey(predicateKey);
533 // PredicateType is complete i.e. all relevant data is in resource table.
534 if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType) {
536 System.out.println("ClusterSmall.forObjects: complete type was " + pCompleteType + " cluster=" + getClusterUID());
537 return resourceTable.foreachObject(resourceIndex, procedure, context, support, this, pRef, pCompleteType, completeTable);
539 final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
540 if (0 == predicateIndex) { // All relevant data is in resource table.
542 System.out.println("ClusterSmall.forObjects: no predicate table " + pCompleteType);
543 return resourceTable.foreachObject(resourceIndex, procedure, context, support, this, pRef, pCompleteType, completeTable);
545 int objectIndex = predicateTable.getObjectIndex(predicateIndex, pRef & 0xFFFF);
546 return forObjects(resourceKey, predicateKey, objectIndex, procedure, context, support);
549 public <Context> boolean forPredicates(int resourceKey,
550 PredicateProcedure<Context> procedure, Context context, ClusterSupport support)
551 throws DatabaseException {
553 System.out.println("ClusterSmall.forPredicates: rk=" + resourceKey );
554 final int resourceIndex = getLocalReference(resourceKey);
555 final int predicateIndex = resourceTable.getPredicateIndex(resourceIndex);
556 if (0 == predicateIndex)
557 return resourceTable.foreachPredicate(resourceIndex,
558 procedure, context, support, this, completeTable);
560 boolean broken = resourceTable.foreachPredicate(resourceIndex,
561 procedure, context, support, this, completeTable);
565 return predicateTable.foreachPredicate(predicateIndex,
566 procedure, context, support, this);
570 public ClusterI addRelation(int sResourceKey, ClusterUID puid, int pResourceKey, ClusterUID ouid, int oResourceKey, ClusterSupport support) throws DatabaseException {
573 throw new UnsupportedOperationException();
574 // ClusterImpl cluster = clusterTable.load2(clusterId, clusterKey);
575 // return cluster.addRelation(sResourceKey, pResourceKey, oResourceKey, support);
581 short sri = getLocalReferenceAnd(sResourceKey, support, ClusterChange.ADD_OPERATION);
582 short pri = getReferenceOrCreateIfForeign(pResourceKey, puid, support, ClusterStream.NULL_OPERATION);
583 short ori = getReferenceOrCreateIfForeign(oResourceKey, ouid, support, ClusterStream.NULL_OPERATION);
584 ClusterI.CompleteTypeEnum completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(pResourceKey);
585 ret = addRelationInternal(sri, pri, ori, completeType);
586 calculateModifiedId();
587 } catch (OutOfSpaceException e) {
588 boolean streamOff = support.getStreamOff();
590 support.cancelStatement(this);
591 support.setStreamOff(true);
593 ClusterI cluster = toBig(clusterSupport);
595 support.setStreamOff(false);
596 ClusterI cluster2 = cluster.addRelation(sResourceKey, pResourceKey, oResourceKey, support);
597 if (cluster != cluster2)
598 throw new DatabaseException("Internal error. Contact application support.");
603 support.addStatement(this);
606 support.cancelStatement(this);
613 public ClusterI addRelation(int sResourceKey, int pResourceKey, int oResourceKey, ClusterSupport support) throws DatabaseException {
616 System.out.println("add rk=" + sResourceKey + " pk=" + pResourceKey + " ok=" + oResourceKey);
619 throw new UnsupportedOperationException();
620 // ClusterImpl cluster = clusterTable.load2(clusterId, clusterKey);
621 // return cluster.addRelation(sResourceKey, pResourceKey, oResourceKey, support);
627 short sri = getLocalReferenceAnd(sResourceKey, support, ClusterChange.ADD_OPERATION);
628 short pri = getReferenceOrCreateIfForeign(pResourceKey, support, ClusterStream.NULL_OPERATION);
629 short ori = getReferenceOrCreateIfForeign(oResourceKey, support, ClusterStream.NULL_OPERATION);
630 ClusterI.CompleteTypeEnum completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(pResourceKey);
631 ret = addRelationInternal(sri, pri, ori, completeType);
632 calculateModifiedId();
633 } catch (OutOfSpaceException e) {
634 boolean streamOff = support.getStreamOff();
636 support.cancelStatement(this);
637 support.setStreamOff(true);
639 ClusterI cluster = toBig(clusterSupport);
641 support.setStreamOff(false);
642 ClusterI cluster2 = cluster.addRelation(sResourceKey, pResourceKey, oResourceKey, support);
643 if (cluster != cluster2)
644 throw new DatabaseException("Internal error. Contact application support.");
649 support.addStatement(this);
652 support.cancelStatement(this);
657 public boolean removeRelation(int sResourceKey, int pResourceKey, int oResourceKey, ClusterSupport support)
658 throws DatabaseException {
660 short sri = getLocalReferenceAnd(sResourceKey, support, ClusterChange.REMOVE_OPERATION);
661 short pri = getInternalReferenceOrZeroAnd(pResourceKey, support, ClusterStream.NULL_OPERATION);
662 short ori = getInternalReferenceOrZeroAnd(oResourceKey, support, ClusterStream.NULL_OPERATION);
664 if (0 != pri && 0 != ori) {
665 ClusterI.CompleteTypeEnum completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(pResourceKey);
666 ret = removeRelationInternal(sri, pri, ori, completeType, support);
667 calculateModifiedId();
670 support.removeStatement(this);
672 support.cancelStatement(this);
677 public void denyRelation(int sResourceKey, int pResourceKey, int oResourceKey, ClusterSupport support)
678 throws DatabaseException {
679 short s = checkResourceKeyIsOursAndGetResourceIndexIf(sResourceKey, support);
680 ResourceReferenceAndCluster p = checkResourceKeyAndGetResourceIndexIf(pResourceKey, support);
681 ResourceReferenceAndCluster o = checkResourceKeyAndGetResourceIndexIf(oResourceKey, support);
682 if (0 == s || 0 == p.reference || 0 == o.reference)
685 ClusterI.CompleteTypeEnum completeType = ClusterTraitsBase.getCompleteTypeFromResourceKey(pResourceKey);
686 boolean ret = removeRelationInternal(s, p.reference, o.reference, completeType, support);
688 support.addStatementIndex(this, sResourceKey, getClusterUID(), ClusterChange.REMOVE_OPERATION);
689 support.addStatementIndex(this, pResourceKey, p.clusterUID, ClusterStream.NULL_OPERATION);
690 support.addStatementIndex(this, oResourceKey, o.clusterUID, ClusterStream.NULL_OPERATION);
691 support.removeStatement(this);
693 calculateModifiedId();
698 public InputStream getValueStream(int resourceKey, ClusterSupport support) throws DatabaseException {
700 System.out.println("ClusterSmall.getValue " + resourceKey);
701 int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKeyNoThrow(resourceKey);
703 byte[] buffer = resourceTable.getValue(valueTable, resourceIndex);
704 if(buffer == null) return null;
705 return new ByteArrayInputStream(buffer);
706 } catch (ExternalValueException e) {
707 return support.getValueStreamEx(resourceIndex, clusterUID.second);
711 public byte[] getValue(int resourceKey, ClusterSupport support)
712 throws DatabaseException {
714 System.out.println("ClusterSmall.getValue " + resourceKey);
715 int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKeyNoThrow(resourceKey);
717 return resourceTable.getValue(valueTable, resourceIndex);
718 } catch (ExternalValueException e) {
719 return clusterSupport.impl.getResourceFile(clusterUID.asBytes(), resourceIndex);
720 //return support.getValueEx(resourceIndex, clusterUID.second);
724 public boolean hasValue(int resourceKey, ClusterSupport support)
725 throws DatabaseException {
726 int resourceIndex = getLocalReference(resourceKey);
727 return resourceTable.hasValue(resourceIndex);
730 public boolean removeValue(int resourceKey, ClusterSupport support)
731 throws DatabaseException {
732 int resourceIndex = getLocalReferenceAnd(resourceKey, support, ClusterChange.DELETE_OPERATION);
733 support.removeValue(this);
734 calculateModifiedId();
735 return resourceTable.removeValue(valueTable, resourceIndex);
738 public ClusterI setValue(int rResourceId, byte[] value, int length, ClusterSupport support)
739 throws DatabaseException {
740 int resourceIndex = getLocalReferenceAnd(rResourceId, support, ClusterStream.SET_OPERATION);
741 support.setValue(this, getClusterId(), value, length);
743 resourceTable.setValue(valueTable, resourceIndex, value, length);
744 calculateModifiedId();
746 } catch (OutOfSpaceException e) {
747 boolean streamOff = support.getStreamOff();
749 support.setStreamOff(true);
750 ClusterI cluster = toBig(support);
751 cluster.setValue(rResourceId, value, length, support);
753 support.setStreamOff(false);
758 public ClusterI modiValueEx(int rResourceId, long voffset, int length, byte[] value, int offset, ClusterSupport support)
759 throws DatabaseException {
760 int resourceIndex = getLocalReferenceAnd(rResourceId, support, ClusterStream.MODI_OPERATION);
761 support.modiValue(this, getClusterId(), voffset, length, value, offset);
762 resourceTable.setValueEx(valueTable, resourceIndex);
763 calculateModifiedId();
767 public byte[] readValueEx(int rResourceId, long voffset, int length, ClusterSupport support)
768 throws DatabaseException {
769 int resourceIndex = getLocalReference(rResourceId);
770 boolean isExternal = resourceTable.isValueEx(valueTable, resourceIndex);
772 throw new DatabaseException("ClusterI.readValue supported only for external value. Resource key=" + rResourceId);
773 return support.getValueEx(resourceIndex, getClusterId(), voffset, length);
776 public boolean isValueEx(int resourceKey) throws DatabaseException {
777 int resourceIndex = getLocalReference(resourceKey);
778 return resourceTable.isValueEx(valueTable, resourceIndex);
781 public long getValueSizeEx(int rResourceId, ClusterSupport support)
782 throws DatabaseException, ExternalValueException {
783 int resourceIndex = getLocalReference(rResourceId);
784 boolean isExternal = resourceTable.isValueEx(valueTable, resourceIndex);
786 throw new ExternalValueException("ClusterI.getValueSizeEx supported only for external value. Resource key=" + rResourceId);
787 return support.getValueSizeEx(resourceIndex, getClusterId());
790 public void setValueEx(int rResourceId)
791 throws DatabaseException {
792 int resourceIndex = getLocalReference(rResourceId);
793 resourceTable.setValueEx(valueTable, resourceIndex);
796 public int createResource(ClusterSupport support)
797 throws DatabaseException {
800 throw new UnsupportedOperationException();
801 // ClusterImpl cluster = clusterTable.load2(clusterId, clusterKey);
802 // return cluster.createResource(support);
805 short resourceIndex = resourceTable.createResource();
806 calculateModifiedId();
807 if(DebugPolicy.REPORT_RESOURCE_ID_ALLOCATION)
808 System.out.println("[RID_ALLOCATION]: ClusterSmall[" + clusterId + "] allocates " + resourceIndex);
809 support.createResource(this, resourceIndex, getClusterId());
810 return ClusterTraits.createResourceKey(clusterKey, resourceIndex);
813 public boolean hasResource(int resourceKey, ClusterSupport support) {
814 int clusterKey = ClusterTraitsBase.getClusterKeyFromResourceKeyNoThrow(resourceKey);
815 if (this.clusterKey != clusterKey) // foreign resource
819 resourceIndex = ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
820 } catch (DatabaseException e) {
823 if (resourceIndex > 0 & resourceIndex <= resourceTable.getTableCount())
829 public int getNumberOfResources(ClusterSupport support)
830 throws DatabaseException {
833 throw new UnsupportedOperationException();
834 // ClusterImpl cluster = clusterTable.load2(clusterId, clusterKey);
835 // return cluster.getNumberOfResources(support);
838 return resourceTable.getUsedSize();
841 public int getNumberOfResources() {
843 if(proxy) throw new IllegalStateException();
845 return resourceTable.getUsedSize();
850 public long getUsedSpace() {
851 if(isEmpty()) return 0;
852 long rt = resourceTable.getTableCapacity() * 8 + 8; // (8 = cluster id)
853 long ft = foreignTable.getTableCapacity() * 8;
854 long pt = predicateTable.getTableCapacity() * 4;
855 long ot = objectTable.getTableCapacity() * 4;
856 long ct = completeTable.getTableCapacity() * 4;
857 long vt = valueTable.getTableCapacity() * 1;
858 long cm = clusterMap.getUsedSpace();
859 return rt + ft + pt + ot + ct + vt + cm;
862 public boolean isEmpty() {
863 if(resourceTable == null) return true;
864 return resourceTable.getTableCount() == 0;
867 public void printDebugInfo(String message, ClusterSupport support)
868 throws DatabaseException {
869 throw new DatabaseException("Not implemented!");
871 private short getInternalReferenceOrZero2(int resourceKey, ClusterSupport support) throws DatabaseException {
872 int resourceIndex = ClusterTraitsBase.getResourceIndexFromResourceKeyNoThrow(resourceKey);
873 if (!ClusterTraitsBase.isCluster(clusterBits, resourceKey)) {
874 return clusterMap.getForeignReferenceOrZero(resourceKey);
876 return (short)resourceIndex;
879 private short getInternalReferenceOrZeroAnd(int resourceKey, ClusterSupport support, byte op)
880 throws DatabaseException {
881 int clusterKey = ClusterTraits.getClusterKeyFromResourceKey(resourceKey);
882 int resourceIndex = ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
883 if (this.clusterKey != clusterKey) { // foreign resource
884 ClusterUID clusterUID = clusterSupport.getClusterUIDByResourceKey(resourceKey);
885 short foreignRef = clusterMap.getForeignReferenceOrZero(resourceKey);
886 support.addStatementIndex(this, resourceKey, clusterUID, op);
889 support.addStatementIndex(this, resourceKey, getClusterUID(), op);
890 return (short)resourceIndex;
892 private final short getLocalReference(int resourceKey) throws DatabaseException {
893 return ClusterTraits.getResourceIndexFromResourceKeyNoThrow(resourceKey);
895 private final short getLocalReferenceAnd(int resourceKey, ClusterSupport support, byte op)
896 throws DatabaseException {
897 short resourceIndex = getLocalReference(resourceKey);
898 support.addStatementIndex(this, resourceKey, getClusterUID(), op);
899 return resourceIndex;
901 private short checkResourceKeyIsOursAndGetResourceIndexIf(int resourceKey, ClusterSupport support)
902 throws DatabaseException {
903 int clusterShortId = ClusterTraits.getClusterKeyFromResourceKey(resourceKey);
904 if (this.clusterKey != clusterShortId)
906 int resourceIndex = ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
907 return (short)resourceIndex;
909 private short getReferenceOrCreateIfForeign(int resourceKey, ClusterUID clusterUID, ClusterSupport support, byte op)
910 throws DatabaseException {
911 int clusterKey = ClusterTraits.getClusterKeyFromResourceKey(resourceKey);
912 short resourceIndex = (short)ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
913 if (this.clusterKey != clusterKey) {
914 support.addStatementIndex(this, resourceKey, clusterUID, op);
915 short ref = clusterMap.getForeignReferenceOrCreateByResourceKey(resourceKey, clusterUID);
918 support.addStatementIndex(this, resourceKey, getClusterUID(), op);
919 return resourceIndex;
921 private short getReferenceOrCreateIfForeign(int resourceKey, ClusterSupport support, byte op)
922 throws DatabaseException {
923 int clusterKey = ClusterTraits.getClusterKeyFromResourceKey(resourceKey);
924 short resourceIndex = (short)ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
925 if (this.clusterKey != clusterKey) {
926 ClusterUID clusterUID = clusterSupport.getClusterUIDByResourceKey(resourceKey);
927 support.addStatementIndex(this, resourceKey, clusterUID, op);
928 short ref = clusterMap.getForeignReferenceOrCreateByResourceKey(resourceKey, clusterUID);
931 support.addStatementIndex(this, resourceKey, getClusterUID(), op);
932 return resourceIndex;
934 private class ResourceReferenceAndCluster {
935 ResourceReferenceAndCluster(short reference, ClusterUID clusterUID) {
936 this.reference = reference;
937 this.clusterUID = clusterUID;
939 public final short reference;
940 public final ClusterUID clusterUID;
942 private ResourceReferenceAndCluster checkResourceKeyAndGetResourceIndexIf(int resourceKey, ClusterSupport support)
943 throws DatabaseException {
944 int clusterKey = ClusterTraits.getClusterKeyFromResourceKey(resourceKey);
945 short resourceIndex = (short)ClusterTraits.getResourceIndexFromResourceKey(resourceKey);
946 if (this.clusterKey != clusterKey) { // foreign resource
947 ClusterI foreignCluster = support.getClusterByClusterKey(clusterKey);
948 ClusterUID clusterUID = foreignCluster.getClusterUID();
949 short ref = clusterMap.getForeignReferenceOrZero(resourceKey);
950 return new ResourceReferenceAndCluster(ref, clusterUID);
952 return new ResourceReferenceAndCluster(resourceIndex, getClusterUID());
955 static long fTime = 0;
958 final public int execute(int resourceReference) throws DatabaseException {
959 short resourceRef = (short)resourceReference;
961 if (ClusterTraitsSmall.resourceRefIsLocal(resourceRef)) {
962 key = clusterBits | resourceRef;
964 short foreignIndex = ClusterTraitsSmall.resourceRefGetForeignIndex((short)resourceRef);
965 //long start = System.nanoTime();
966 ResourceUID resourceUID = foreignTable.getResourceUID(foreignIndex);
967 int clusterKey = clusterSupport.getClusterKeyByClusterUIDOrMake(resourceUID.asCID());
968 // ClusterBase cluster = clusterSupport.getClusterByClusterUIDOrMake(resourceUID.asCID());
969 key = ClusterTraitsBase.createResourceKey(clusterKey, resourceUID.getIndex());
970 //fTime += System.nanoTime() - start;
971 //System.err.println("fTime: " + 1e-9*fTime);
974 System.out.println("ClusterSmall.execute key=" + key);
978 private boolean addRelationInternal(short sReference, short pReference, short oReference, ClusterI.CompleteTypeEnum completeType)
979 throws DatabaseException {
980 int predicateIndex = resourceTable.addStatement(sReference, pReference, oReference, predicateTable, objectTable, completeType, completeTable);
981 if (0 == predicateIndex)
982 return true; // added to resourceTable
983 else if (0 > predicateIndex)
984 return false; // old complete statemenent
985 int newPredicateIndex = predicateTable.addPredicate(predicateIndex, 0xFFFF & pReference, 0xFFFF & oReference, objectTable);
986 if (0 == newPredicateIndex)
988 if (predicateIndex != newPredicateIndex)
989 resourceTable.setPredicateIndex(sReference, newPredicateIndex);
992 private boolean removeRelationInternal(int sResourceIndex, short pResourceIndex,
993 short oResourceIndex, ClusterI.CompleteTypeEnum completeType, ClusterSupport support)
994 throws DatabaseException {
995 int predicateIndex = resourceTable.getPredicateIndex(sResourceIndex);
996 if (0 == predicateIndex || ClusterI.CompleteTypeEnum.NotComplete != completeType)
997 return resourceTable.removeStatementFromCache(sResourceIndex,
998 pResourceIndex, oResourceIndex, completeType, completeTable);
999 PredicateTable.Status ret = predicateTable.removePredicate(predicateIndex, 0xFFFF & pResourceIndex, 0xFFFF & oResourceIndex, objectTable);
1001 case NothingRemoved:
1003 case PredicateRemoved: {
1004 if (0 == predicateTable.getPredicateSetSize(predicateIndex))
1005 resourceTable.setPredicateIndex(sResourceIndex, 0);
1006 // intentionally dropping to next case
1010 resourceTable.removeStatement(sResourceIndex,
1011 pResourceIndex, oResourceIndex,
1012 completeType, completeTable,
1013 predicateTable, objectTable, support);
1017 public void load() {
1018 throw new Error("Not supported.");
1022 public void load(Callback<DatabaseException> r) {
1023 throw new Error("Not supported.");
1026 public boolean contains(int resourceKey) {
1027 return ClusterTraitsBase.isCluster(clusterBits, resourceKey);
1030 public void load(final ClusterSupport support, final Runnable callback) {
1032 throw new UnsupportedOperationException();
1035 // clusterTable.load2(clusterId, clusterKey);
1037 // } catch (DatabaseException e) {
1038 // e.printStackTrace();
1043 public ClusterI getClusterByResourceKey(int resourceKey,
1044 ClusterSupport support) {
1048 public void increaseReferenceCount(int amount) {
1052 public void decreaseReferenceCount(int amount) {
1056 public int getReferenceCount() {
1060 public void releaseMemory() {
1063 public void compact() {
1064 clusterMap.compact();
1067 public boolean isLoaded() {
1071 // public ClusterImpl tryLoad(SessionImplSocket sessionImpl) {
1073 // throw new UnsupportedOperationException();
1074 // assert(Constants.ReservedClusterId != clusterId);
1076 // return clusterTable.tryLoad(clusterId, clusterKey);
1082 public ClusterBig toBig(ClusterSupport support)
1083 throws DatabaseException {
1085 System.out.println("DEBUG: toBig cluster=" + clusterId);
1086 new Exception().printStackTrace();
1088 ClusterBig big = new ClusterBig(clusterSupport, getClusterUID(), clusterKey, (ClusterSupport2)support);
1090 // if(big.cc != null)
1091 // big.cc.clusterImpl = this;
1092 resourceTable.toBig(big, support, this);
1093 big.foreignLookup = this.foreignLookup;
1094 big.change = this.change;
1096 this.foreignLookup = null;
1102 public ClusterTypeEnum getType() {
1103 return ClusterTypeEnum.SMALL;
1106 public boolean getImmutable() {
1107 int status = resourceTable.getClusterStatus();
1108 return (status & ClusterStatus.ImmutableMaskSet) == 1;
1111 public void setImmutable(boolean immutable, ClusterSupport support) {
1112 if(resourceTable != null) {
1113 int status = resourceTable.getClusterStatus();
1115 status |= ClusterStatus.ImmutableMaskSet;
1117 status &= ClusterStatus.ImmutableMaskClear;
1118 resourceTable.setClusterStatus(status);
1120 support.setImmutable(this, immutable);
1124 public String toString() {
1126 final TIntHashSet set = new TIntHashSet();
1127 TIntShortHashMap map = foreignTable.getResourceHashMap();
1128 map.forEachKey(new TIntProcedure() {
1130 public boolean execute(int value) {
1131 set.add(value & 0xfffff000);
1135 return "ClusterSmall[" + getClusterUID() + " - " + getClusterId() + " - " + getNumberOfResources() + " - " + foreignTable.getResourceHashMap().size() + " - " + set.size() + "]";
1136 } catch (DatabaseException e) {
1137 return "ClusterSmall[" + getNumberOfResources() + "]";
1142 // bytes (b) | headers(i) | predicateTable (i) | objectTable (i) | completeTable (i) | resourceTable (l) | foreignTable (l)
1145 public byte[] storeBytes() throws IOException {
1147 int byteSize = valueTable.getTableSize();
1148 int longSize = LONG_HEADER_SIZE + resourceTable.getTableSize() + foreignTable.getTableSize();
1149 int intSize = INT_HEADER_SIZE + predicateTable.getTableSize() + objectTable.getTableSize() + completeTable.getTableSize();
1151 byte[] raw = new byte[12 + byteSize + 8*longSize + 4*intSize];
1153 int[] currentHeader = Arrays.copyOf(headerTable, INT_HEADER_SIZE);
1155 Bytes.writeLE(raw, 0, byteSize);
1156 Bytes.writeLE(raw, 4, intSize);
1157 Bytes.writeLE(raw, 8, longSize);
1159 int rawPos = valueTable.storeBytes(raw, 0, 12);
1161 int intBase = rawPos;
1163 rawPos += 4*INT_HEADER_SIZE;
1164 rawPos = predicateTable.storeBytes(raw, (rawPos-intBase)>>2, rawPos);
1165 rawPos = objectTable.storeBytes(raw, (rawPos-intBase)>>2, rawPos);
1166 rawPos = completeTable.storeBytes(raw, (rawPos-intBase)>>2, rawPos);
1168 int longBase = rawPos;
1170 rawPos += 8*LONG_HEADER_SIZE;
1171 rawPos = resourceTable.storeBytes(raw, (rawPos-longBase)>>3, rawPos);
1172 rawPos = foreignTable.storeBytes(raw, (rawPos-longBase)>>3, rawPos);
1174 Bytes.writeLE8(raw, longBase, -1);
1175 Bytes.writeLE8(raw, longBase+8, LONG_HEADER_VERSION);
1176 Bytes.writeLE8(raw, longBase+16, 0);
1177 Bytes.writeLE8(raw, longBase+24, clusterUID.second);
1180 for(int i=0;i<INT_HEADER_SIZE;i++) {
1181 int v = headerTable[i];
1182 Bytes.writeLE(raw, intBase, v);
1186 for(int i=0;i<INT_HEADER_SIZE;i++)
1187 headerTable[i] = currentHeader[i];
1194 public ClusterTables store() throws IOException {
1196 ClusterTables result = new ClusterTables();
1198 int[] currentHeader = Arrays.copyOf(headerTable, INT_HEADER_SIZE);
1200 int byteSize = valueTable.getTableSize();
1201 byte[] byteBytes = new byte[byteSize];
1202 valueTable.store(byteBytes, 0);
1204 result.bytes = byteBytes;
1206 int longSize = LONG_HEADER_SIZE + resourceTable.getTableSize() + foreignTable.getTableSize();
1207 long[] longBytes = new long[longSize];
1210 longBytes[1] = LONG_HEADER_VERSION;
1212 longBytes[3] = clusterUID.second;
1214 int longPos = resourceTable.store(longBytes, LONG_HEADER_SIZE);
1215 foreignTable.store(longBytes, longPos);
1217 result.longs = longBytes;
1219 int intSize = INT_HEADER_SIZE + predicateTable.getTableSize() + objectTable.getTableSize() + completeTable.getTableSize();
1220 int[] intBytes = new int[intSize];
1221 int intPos = INT_HEADER_SIZE;
1222 intPos = predicateTable.store(intBytes, intPos);
1223 intPos = objectTable.store(intBytes, intPos);
1224 intPos = completeTable.store(intBytes, intPos);
1226 for(int i=0;i<INT_HEADER_SIZE;i++) {
1227 int v = headerTable[i];
1229 //Bytes.writeLE(intBytes, i<<2, v);
1232 result.ints = intBytes;
1234 for(int i=0;i<INT_HEADER_SIZE;i++)
1235 headerTable[i] = currentHeader[i];
1242 protected int getResourceTableCount() {
1243 return resourceTable.getTableCount();
1247 public boolean getDeleted() {
1248 if (deleted) return true;
1249 int status = resourceTable.getClusterStatus();
1250 return (status & ClusterStatus.DeletedMaskSet) == ClusterStatus.DeletedMaskSet;
1253 public void setDeleted(boolean set, ClusterSupport support) {
1255 if(resourceTable != null) {
1256 int status = resourceTable.getClusterStatus();
1258 status |= ClusterStatus.DeletedMaskSet;
1260 status &= ClusterStatus.DeletedMaskClear;
1261 resourceTable.setClusterStatus(status);
1263 if (null != support)
1264 support.setDeleted(this, set);
1268 public Table<?> getPredicateTable() {
1269 return predicateTable;
1273 public Table getForeignTable() {
1274 return foreignTable;
1278 public int makeResourceKey(int pRef) throws DatabaseException {
1279 throw new UnsupportedOperationException();
1283 public Table<?> getCompleteTable() {
1284 return completeTable;
1288 public Table<?> getValueTable() {
1293 public Table<?> getObjectTable() {
1299 class ClusterStatus {
1300 public static final int ImmutableMaskClear = 0xFFFFFFFE;
1301 public static final int ImmutableMaskSet = 0x00000001;
1302 public static final int DeletedMaskClear = 0xFFFFFFFD;
1303 public static final int DeletedMaskSet = 0x00000002;