--- /dev/null
+/*******************************************************************************\r
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
+ * in Industry THTH ry.\r
+ * All rights reserved. This program and the accompanying materials\r
+ * are made available under the terms of the Eclipse Public License v1.0\r
+ * which accompanies this distribution, and is available at\r
+ * http://www.eclipse.org/legal/epl-v10.html\r
+ *\r
+ * Contributors:\r
+ * VTT Technical Research Centre of Finland - initial API and implementation\r
+ *******************************************************************************/\r
+package org.simantics.db.procore.cluster;\r
+\r
+import java.util.ArrayList;\r
+\r
+import org.simantics.db.Resource;\r
+import org.simantics.db.common.utils.Logger;\r
+import org.simantics.db.exception.DatabaseException;\r
+import org.simantics.db.impl.ClusterBase;\r
+import org.simantics.db.impl.ClusterI;\r
+import org.simantics.db.impl.ClusterI.ObjectProcedure;\r
+import org.simantics.db.impl.ClusterI.PredicateProcedure;\r
+import org.simantics.db.impl.ClusterI.Procedure;\r
+import org.simantics.db.impl.ClusterSupport;\r
+import org.simantics.db.impl.ClusterTraitsBase;\r
+import org.simantics.db.impl.Modifier;\r
+import org.simantics.db.impl.Table;\r
+import org.simantics.db.impl.TableFactory;\r
+import org.simantics.db.impl.TableSizeListener;\r
+import org.simantics.db.impl.graph.ReadGraphImpl;\r
+import org.simantics.db.procedure.AsyncContextMultiProcedure;\r
+import org.simantics.db.procedure.AsyncMultiProcedure;\r
+import org.simantics.db.procore.cluster.PredicateTable.Status;\r
+\r
+\r
+\r
+public final class ResourceTableSmall extends Table<long[]> {\r
+ public ResourceTableSmall(TableSizeListener sizeListener, int[] header, int headerBase) {\r
+ super(TableFactory.getLongFactory(), sizeListener, header, headerBase);\r
+ }\r
+\r
+ public ResourceTableSmall(TableSizeListener sizeListener, int[] header, int headerBase, long[] longs) {\r
+ super(TableFactory.getLongFactory(), sizeListener, header, headerBase, longs);\r
+ }\r
+\r
+ public int getUsedSize() {\r
+ return getTableCount();\r
+ }\r
+\r
+ public short createResource() {\r
+ final int INDEX = getTableCount();\r
+ final int SIZE = ResourceElementSmall.getSizeOf();\r
+ int resourceIndex = createNewElement(SIZE);\r
+ assert (0 != resourceIndex);\r
+ final int REAL_INDEX = checkIndexAndGetRealIndex(resourceIndex, SIZE);\r
+ ResourceElementSmall.construct(getTable(), REAL_INDEX);\r
+ incResourceCount();\r
+ return (short)(INDEX + ZERO_SHIFT);\r
+ }\r
+\r
+ void createResource(int resourceIndex) {\r
+ final int tableCount = getTableCount();\r
+ if (resourceIndex <= tableCount) { // old index\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ if (ResourceElementSmall.isEmpty(getTable(), realIndex))\r
+ return;\r
+ } if (resourceIndex == tableCount+1) {\r
+ createResource();\r
+ return;\r
+ }\r
+ throw new InternalError("Trying to create resource with illegal index=" + resourceIndex);\r
+ }\r
+\r
+ public short getCompleteObjectRef(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.getCompleteObjectRef(getTable(), realIndex);\r
+ }\r
+ \r
+ public ClusterI.CompleteTypeEnum getCompleteType(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.getCompleteType(getTable(), realIndex);\r
+ }\r
+ \r
+ public int getPredicateIndex(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.getPredicateIndex(table, realIndex);\r
+ }\r
+\r
+ public void setPredicateIndex(int resourceIndex, int predicateIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElementSmall.setPredicateIndex(getTable(), realIndex, predicateIndex);\r
+ }\r
+\r
+ public byte[] getValue(ValueTableSmall valueTable, int resourceIndex)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.getValue(valueTable, getTable(), realIndex);\r
+ }\r
+//KRAA:\r
+// char[] getString(ValueTableSmall valueTable, int resourceIndex) {\r
+// int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+// return ResourceElementSmall.getString(valueTable, getTable(), realIndex);\r
+// }\r
+\r
+ public boolean hasValue(int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.hasValue(getTable(), realIndex);\r
+ }\r
+\r
+// boolean hasValue(ValueTable valueTable, int resourceIndex, byte[] value) {\r
+// int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+// return ResourceElementSmall.hasValue(valueTable, getTable(), realIndex, value);\r
+// }\r
+\r
+ public boolean removeValue(ValueTableSmall valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean ret = ResourceElementSmall.removeValue(valueTable, getTable(), realIndex);\r
+// if (ret && !ResourceElementSmall.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return ret;\r
+ }\r
+\r
+ public void setValue(ValueTableSmall valueTable, int resourceIndex, byte[] value, int length)\r
+ throws OutOfSpaceException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElementSmall.setValue(valueTable, getTable(), realIndex, value, length);\r
+ }\r
+\r
+ public boolean isValueEx(ValueTableSmall valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.isValueEx(valueTable, getTable(), realIndex);\r
+ }\r
+\r
+ public void setValueEx(ValueTableSmall valueTable, int resourceIndex) {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElementSmall.setValueEx(valueTable, getTable(), realIndex);\r
+ }\r
+\r
+ static final int RESOURCE_COUNT_INDEX = 0;\r
+ static final int FOREIGN_COUNT_INDEX = 1; // Reserved by server.\r
+ static final int CLUSTER_STATUS_INDEX = 2;\r
+\r
+ int incResourceCount() {\r
+ int count = getExtra(RESOURCE_COUNT_INDEX) + 1;\r
+ setExtra(RESOURCE_COUNT_INDEX, count);\r
+ return count;\r
+ }\r
+\r
+// int decResourceCount() {\r
+// int count = getExtra(RESOURCE_COUNT_INDEX) - 1;\r
+// setExtra(RESOURCE_COUNT_INDEX, count);\r
+// return count;\r
+// }\r
+\r
+ public int getResourceCount() {\r
+ return getExtra(RESOURCE_COUNT_INDEX);\r
+ }\r
+ public int getClusterStatus() {\r
+ return getExtra(CLUSTER_STATUS_INDEX);\r
+ }\r
+ public void setClusterStatus(int value) {\r
+ setExtra(CLUSTER_STATUS_INDEX, value);\r
+ }\r
+\r
+ <Context> boolean foreachResource(ClusterI.ObjectProcedure<Context> procedure, Context context,\r
+ ClusterSupport support, Modifier modifier) throws DatabaseException {\r
+ final int tsize = getTableSize();\r
+// final int rsize = getResourceCount();\r
+ final int esize = ResourceElementSmall.getSizeOf();\r
+ //int count = 0;\r
+ int key = ZERO_SHIFT;\r
+ for (int i = getTableBase(); i < getTableBase() + tsize; i += esize, ++key) {\r
+ if (ResourceElementSmall.isUsed(getTable(), i)) {\r
+ int ref;\r
+ if (null == modifier)\r
+ ref = key;\r
+ else\r
+ ref = modifier.execute(key);\r
+ if (procedure.execute(context, ref))\r
+ return true; // loop was broken by procedure\r
+// if (rsize == ++count)\r
+// return false; // loop finished\r
+ }\r
+ }\r
+ //assert(rsize == count);\r
+ return false; // loop finished\r
+ }\r
+\r
+ public <Context> boolean foreachPredicate(int resourceIndex\r
+ , ClusterI.PredicateProcedure<Context> procedure, Context context\r
+ , ClusterSupport support, Modifier modifier, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.foreachPredicate(getTable(), realIndex\r
+ , procedure, context, support, modifier, ct);\r
+ }\r
+\r
+ public int getSingleObject(int resourceIndex, ClusterSupport support, short pRef, ClusterI.CompleteTypeEnum completeType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.getSingleObject(table, realIndex, support, pRef, completeType, ct, modifier);\r
+ }\r
+\r
+ public void foreachObject(int resourceIndex, ReadGraphImpl graph,\r
+ AsyncMultiProcedure<Resource> procedure, ClusterSupport support, int pRef, ClusterI.CompleteTypeEnum completeType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElementSmall.foreachObject(table, realIndex, graph, procedure, support,\r
+ pRef, completeType, ct, modifier);\r
+ }\r
+\r
+ public <C> void foreachObject(int resourceIndex, ReadGraphImpl graph, C context,\r
+ AsyncContextMultiProcedure<C, Resource> procedure, ClusterSupport support, int pRef, ClusterI.CompleteTypeEnum completeType, CompleteTable ct, Modifier modifier) throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ ResourceElementSmall.foreachObject(table, realIndex, graph, context, procedure, support,\r
+ pRef, completeType, ct, modifier);\r
+ }\r
+\r
+ public <Context> boolean foreachObject(int resourceIndex\r
+ , ClusterI.ObjectProcedure<Context> procedure, Context context\r
+ , ClusterSupport support, Modifier modifier,\r
+ short pRef, ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.foreachObject(table, realIndex\r
+ , procedure, context, support, modifier\r
+ , pRef, completeType, ct);\r
+ }\r
+ public int addStatement(int resourceIndex, short pRef, short oRef, PredicateTable pt, ObjectTable ot\r
+ , ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ return ResourceElementSmall.addStatement(getTable(), realIndex, pRef, oRef, pt, ot, completeType, ct);\r
+ }\r
+\r
+ public boolean removeStatementFromCache(int resourceIndex, short pRef, short oRef,\r
+ ClusterI.CompleteTypeEnum completeType, CompleteTable ct)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean ret = ResourceElementSmall.removeStatement(getTable(), realIndex, pRef, oRef, completeType, ct);\r
+// if (ret && !ResourceElementSmall.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return ret;\r
+ }\r
+ \r
+ public void removeStatement(int resourceIndex, short pRef, short oRef, ClusterI.CompleteTypeEnum pCompleteType, CompleteTable ct,\r
+ PredicateTable pt, ObjectTable ot, ClusterSupport support)\r
+ throws DatabaseException {\r
+ int realIndex = checkIndexAndGetRealIndex(resourceIndex);\r
+ boolean removed = ResourceElementSmall.removeStatement(getTable(), realIndex,\r
+ pRef, oRef, pCompleteType, ct);\r
+ if (!removed)\r
+ return;\r
+ int predicateIndex = ResourceElementSmall.getPredicateIndex(getTable(), realIndex);\r
+ if (0 == predicateIndex) {\r
+// if (!ResourceElementSmall.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ return;\r
+ } else if (ClusterI.CompleteTypeEnum.NotComplete != pCompleteType)\r
+ return; // Complete type statements are not kept in statement cache.\r
+ // We have one more statements in predicate table.\r
+ // Here we check if statement cache needs fixing.\r
+ GetStatementsSmall gs = new GetStatementsSmall(ot);\r
+ pt.foreachPredicate(predicateIndex, gs, null, null, null);\r
+ ArrayList<Statement> stms = gs.getStatements();\r
+\r
+ final int SIZE = stms.size();\r
+ if (SIZE < 3) {\r
+ for (int i = 0; i < SIZE; ++i) {\r
+ Statement stm = stms.get(i);\r
+ PredicateTable.Status ret = pt.removePredicate(predicateIndex,\r
+ stm.pRef, stm.oIndex, ot);\r
+ if (ret == Status.NothingRemoved)\r
+ throw new DatabaseException("Internal error during statement cache fix (2).");\r
+ assert(stm.pRef < (1<<16));\r
+ assert(stm.oIndex < 1<<16);\r
+ int pi = ResourceElementSmall.addStatement(getTable(), realIndex, (short)stm.pRef, (short)stm.oIndex,\r
+ pt, ot, ClusterI.CompleteTypeEnum.NotComplete, ct);\r
+ assert(0 >= pi);\r
+ }\r
+ assert(0 == pt.getPredicateSetSize(predicateIndex));\r
+ ResourceElementSmall.setPredicateIndex(getTable(), realIndex, 0);\r
+ } else {\r
+ for (int i = 0; i < SIZE; ++i) {\r
+ Statement stm = stms.get(i);\r
+ assert(stm.pRef < (1<<16));\r
+ assert(stm.oIndex < 1<<16);\r
+ int pIndex = ResourceElementSmall.addStatement(getTable(), realIndex,\r
+ (short)stm.pRef, (short)stm.oIndex, pt, ot, ClusterI.CompleteTypeEnum.NotComplete, ct);\r
+ if (pIndex > 0)\r
+ return; // cache fixed and full, p and o sets in use\r
+ }\r
+ throw new DatabaseException("Internal error during statement cache fix (3).");\r
+ }\r
+// if (!ResourceElementSmall.isUsed(getTable(), realIndex))\r
+// decResourceCount();\r
+ }\r
+\r
+ private int checkIndexAndGetRealIndex(final int resourceIndex) {\r
+ if (ClusterTraitsBase.isIllegalResourceIndex(resourceIndex))\r
+ throw new RuntimeException("Illegal resource index. index=" + resourceIndex + ".");\r
+ if(resourceIndex > getTableCount())\r
+ throw new RuntimeException("Illegal resource index. index=" + resourceIndex + " table count=" + getTableCount());\r
+ final int SIZE = ResourceElementSmall.getSizeOf();\r
+ final int REAL_INDEX = resourceIndex * SIZE - (SIZE - ZERO_SHIFT) + offset;\r
+ return REAL_INDEX;\r
+ }\r
+ void check(ClusterImpl cluster)\r
+ throws DatabaseException {\r
+// throw new Error("Not implemented.//KRAA:");\r
+ }\r
+\r
+ public void toBig(ClusterBase big, final ClusterSupport support, final ClusterBase small)\r
+ throws DatabaseException {\r
+ int resourceIndex = 1;\r
+ long[] table = getTable();\r
+ int ps = getHeader().getOffset() + ZERO_SHIFT;\r
+ final int TABLE_SIZE = getTableSize();\r
+ int pe = ps + TABLE_SIZE;\r
+ for (int p=ps; p<pe; p+=ResourceElementSmall.getSizeOf(), ++resourceIndex) {\r
+ big.createResource(support);\r
+ int subjectKey = ClusterTraits.createResourceKey(small.clusterKey, resourceIndex); \r
+ if (!ResourceElementSmall.isUsed(table, p))\r
+ continue;\r
+ int cr = ResourceElementSmall.getCompleteObjectRef(table, p);\r
+ if (0 != cr) {\r
+ ClusterI.CompleteTypeEnum ct = ResourceElementSmall.getCompleteType(table, p);\r
+ if (ClusterI.CompleteTypeEnum.NotComplete != ct) {\r
+ int pKey = ClusterTraitsBase.getCompleteTypeResourceKeyFromEnum(ct);\r
+ int oKey = small.getCompleteObjectKey(subjectKey, support);\r
+ big.addRelation(subjectKey, pKey, oKey, support);\r
+ } else {\r
+ final class ForeachObject<Context>\r
+ implements ClusterI.ObjectProcedure<Context> {\r
+ int sKey;\r
+ ClusterBase big;\r
+ public ForeachObject(int sKey, ClusterBase big) {\r
+ this.sKey = sKey;\r
+ this.big = big;\r
+ }\r
+ @Override\r
+ public boolean execute(Context context, int completeRef)\r
+ throws DatabaseException {\r
+ ClusterI.CompleteTypeEnum ct = ClusterTraitsSmall.completeRefAndTypeGetType(completeRef);\r
+ int p = ClusterTraitsBase.getCompleteTypeResourceKeyFromEnum(ct);\r
+ int o = small.execute(completeRef & 0xFFFF);\r
+ big.addRelation(sKey, p, o, support);\r
+ return false; // Continue looping.\r
+ }\r
+ }\r
+ ForeachObject<Object> op = new ForeachObject<Object>(subjectKey, big);\r
+ small.getCompleteTable().foreach(cr & 0xFFFF, op, null, support, null);\r
+ }\r
+ }\r
+ int pi = ResourceElementSmall.getPredicateIndex(table, p);\r
+ if (0 != pi) {\r
+ ToBigStatements tbs = new ToBigStatements(small, big, support, subjectKey);\r
+ small.getPredicateTable().foreach(pi, tbs, null, null, null);\r
+ } else {\r
+ int p1 = ResourceElementSmall.getStm1Predicate(table, p);\r
+ int o1 = ResourceElementSmall.getStm1Object(table, p);\r
+ if (p1 != 0) {\r
+ int pk1 = small.execute(p1);\r
+ int ok1 = small.execute(o1);\r
+ big.addRelation(subjectKey, pk1, ok1, support);\r
+ int p2 = ResourceElementSmall.getStm2Predicate(table, p);\r
+ int o2 = ResourceElementSmall.getStm2Object(table, p);\r
+ if (p2 != 0) {\r
+ int pk2 = small.execute(p2);\r
+ int ok2 = small.execute(o2);\r
+ big.addRelation(subjectKey, pk2, ok2, support);\r
+ }\r
+ }\r
+ }\r
+ int valueIndex = ResourceElementSmall.getValueIndex(table, p);\r
+ if (ClusterTraitsSmall.VALUE_INDEX_EX == valueIndex)\r
+ big.setValueEx(subjectKey);\r
+ else {\r
+ byte[] value = ResourceElementSmall.getValue((ValueTableSmall)small.getValueTable(), table, p);\r
+ if (null != value)\r
+ big.setValue(subjectKey, value, value.length, support);\r
+ }\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public <Context> boolean foreach(int setIndex, Procedure procedure, Context context,\r
+ ClusterSupport support, Modifier modifier) throws DatabaseException {\r
+ throw new UnsupportedOperationException();\r
+ }\r
+}\r
+\r
+class CalculateStatementsSmall\r
+implements ClusterI.PredicateProcedure<CalculateStatements> {\r
+ private ObjectTable ot;\r
+ private final int sRef;\r
+\r
+ CalculateStatementsSmall(int sRef, ObjectTable ot) {\r
+ this.sRef = sRef;\r
+ this.ot = ot;\r
+ }\r
+\r
+ @Override\r
+ public boolean execute(CalculateStatements context\r
+ , final int pKey, int oIndex) {\r
+ if (ClusterTraits.statementIndexIsDirect(oIndex))\r
+ return false; // osize = 1\r
+ try {\r
+ oIndex = ClusterTraits.statementIndexGet(oIndex);\r
+ } catch (DatabaseException e) {\r
+ Logger.getDefault().logError("Missing object set for s="\r
+ + sRef + " p=" + pKey, null);\r
+ return false; // continue looping\r
+ }\r
+ int osize = ot.getObjectSetSize(oIndex);\r
+ if (osize == 3 || osize > 9)\r
+ System.out.println("Resource " + sRef + " predicate " + pKey + " has "\r
+ + osize + " objects.");\r
+ return true; // break loop\r
+ }\r
+}\r
+\r
+class GetStatementsSmall implements ClusterI.PredicateProcedure<Object>, ClusterI.ObjectProcedure<Integer> {\r
+ private ObjectTable ot;\r
+ private final ArrayList<Statement> stms = new ArrayList<Statement>(); \r
+ GetStatementsSmall(ObjectTable ot) {\r
+ this.ot = ot;\r
+ }\r
+ ArrayList<Statement> getStatements() {\r
+ return stms;\r
+ }\r
+ @Override\r
+ public boolean execute(Object context, int pRef, int oIndex) {\r
+ try {\r
+ ot.foreachObject(oIndex, this, pRef, null, null);\r
+ } catch (DatabaseException e) {\r
+ e.printStackTrace();\r
+ return false; // continue looping\r
+ }\r
+ if (stms.size() > 2)\r
+ return true; // break loop\r
+ return false; // continue looping\r
+ }\r
+ \r
+ @Override\r
+ public boolean execute(Integer pRef, int oRef) {\r
+ stms.add(new Statement(pRef, oRef));\r
+ if (stms.size() > 2)\r
+ return true; // break loop\r
+ return false; // continue looping\r
+ }\r
+}\r
+\r
+class ToBigStatements implements PredicateProcedure<Object>, ObjectProcedure<Integer> {\r
+ private ClusterBase small;\r
+ private ClusterBase big;\r
+ private ClusterSupport support;\r
+ private int subjectKey;\r
+ ToBigStatements(ClusterBase small, ClusterBase big, ClusterSupport support, int subjectKey) {\r
+ this.small = small;\r
+ this.big = big;\r
+ this.support = support;\r
+ this.subjectKey = subjectKey;\r
+ }\r
+ @Override\r
+ public boolean execute(Object context, int pRef, int oIndex) {\r
+ try {\r
+ small.getObjectTable().foreach(oIndex, this, pRef, null, null);\r
+ } catch (DatabaseException e) {\r
+ e.printStackTrace();\r
+ return false; // continue looping\r
+ }\r
+ return false; // continue looping\r
+ }\r
+\r
+ @Override\r
+ public boolean execute(Integer pRef, int oRef)\r
+ throws DatabaseException {\r
+ int pKey = small.execute(pRef);\r
+ int oKey = small.execute(oRef);\r
+ big.addRelation(subjectKey, pKey, oKey, support);\r
+ return false; // continue looping\r
+ }\r
+ \r
+}\r
Code Review / simantics / platform.git / blobdiff