6812-fast-find-cache.diff

     import java.lang.ref.*;
     import java.util.*;
     import java.util.BitSet;
     import java.util.concurrent.*;
     /**
      * Implementation of FastFind caching algorithm. The internal structures use a triple-cache to store the
-...
        public static final RecordIdentifier<String> NO_RECORD = new RecordIdentifier<>("", -1L);
        /** The singleton instance for permanent database(s). */
        private static final FastFindCache permanentInstance = new FastFindCache();
        private static final Map<String, FastFindCache> permanentInstances = new ConcurrentHashMap<>();
        /** The context-local instance for the current session for temp-tables. */
        private static final ContextLocal<FastFindCache> tempTableInstances = new ContextLocal<FastFindCache>()
-...
           @Override
           protected FastFindCache initialValue()
+          {
              return new FastFindCache();
              return new FastFindCache(false);
+          }
        };
-...
        /** Reverse cache of record identifiers to invalidation info, for queries with non-indexed properties */
        private final ReverseLookup reverseLookup = new ReverseLookup();
        private final boolean isPermanent;
        private FastFindCache(boolean isPermanent)
+       {
           this.isPermanent = isPermanent;
+       }
        /**
         * Obtain the singleton instance, if FastFind mode enabled.
         * Return {@code null} to disable FastFind mode.
-...
+        *
         * @return  the static instance of {@code FastFindCache}, or {@code null} if FastFind mode is disabled.
         */
        public static FastFindCache getInstance(boolean temporary)
        public static FastFindCache getInstance(boolean temporary, String databaseName)
+       {
           return temporary ? tempTableInstances.get() : permanentInstance;
           return temporary ? tempTableInstances.get() : permanentInstances.computeIfAbsent(databaseName, dbName -> new FastFindCache(true));
+       }
        /**
-...
         */
        private void synchronize(Runnable code)
+       {
           if (this != permanentInstance)
           if (!isPermanent)
+          {
              // no synchronization needed here
              code.run();
              return;
+          }
           synchronized (permanentInstance)
           synchronized (this)
+          {
              code.run();
+          }

         * Special care is taken to not close a database session while other
         * entities are dependent upon it for services.
         */
        class Context
        public class Context
+       {
           /** Cache of FQL strings, with or without max results and start offsets, to queries. */
           private final ExpiryCache<QueryKey, Query> staticQueryCache = new LRUCache<>(1000);
-...
           private final BufferManager bufferManager = BufferManager.get();
           /** Object which manages newly created records */
           private final RecordNursery nursery = new RecordNursery(FastFindCache.getInstance(isTemporary()));
           private final RecordNursery nursery = new RecordNursery(FastFindCache.getInstance(isTemporary(), database.getName()));
           /** Context-local record lock context */
           private final RecordLockContext lockContext = RecordLockContext.get(Persistence.this, bufferManager);
-...
+           *
            * @return  Persistence object.
            */
           Persistence getPersistence()
           public Persistence getPersistence()
+          {
              return Persistence.this;
+          }

new/src/com/goldencode/p2j/persist/RandomAccessQuery.java 2023-02-23 21:24:53 +0000
1364	1364
1365	1365	if (!dmoMeta.isMeta() && index != 0)
1366	1366	{
1367		this.ffCache = FastFindCache.getInstance(buffer.isTemporary());
	1367	this.ffCache = FastFindCache.getInstance(buffer.isTemporary(), buffer.persistenceContext.getPersistence().getDatabase().getName());
1368	1368	}
1369	1369
1370	1370	// override lock type if this is a temporary buffer; this allows some downstream optimizations

        protected boolean ignoreBeforeTracking = false;
        /** Current persistence context */
        protected Persistence.Context persistenceContext = null;
        public Persistence.Context persistenceContext = null;
        /** Cached hash code */
        private final int hashCode;
-...
           metadata = dmoInfo.getRecordMeta();
           ffCache = FastFindCache.getInstance(isTemporary());
           ffCache = FastFindCache.getInstance(isTemporary(), database.getName());
           // Notify the connection manager that this buffer is using the backing, physical database.
           onOpenOutermostScope();

new/src/com/goldencode/p2j/persist/orm/SavepointManager.java 2023-02-23 21:24:53 +0000
908	908	changedIsIterated = false;
909	909	}
910	910
911		FastFindCache.getInstance(isTemp).invalidate(dmoSet);
	911	FastFindCache.getInstance(isTemp, "TODO").invalidate(dmoSet);
912	912	}
913	913
914	914	/**

           // to lose the optimization than to get incorrect results in a parallel thread if it was accessing
           // the cache between save and invalidate operations
           RecordMeta recMeta = dmo._recordMeta();
           FastFindCache ffc = FastFindCache.getInstance(recMeta.isTemporary());
           FastFindCache ffc = FastFindCache.getInstance(recMeta.isTemporary(), buffer.persistenceContext.getPersistence().getDatabase().getName());
           boolean wasNew = dmo.checkState(NEW);
           if (wasNew)
+          {

Project

General

Profile

FWD » Core Development » Database