Changeset 8130

Timestamp:

Mar 21, 2023, 11:10:53 AM (7 months ago)

Author:

Nicklas Nordborg

Message:

References #2296: Improve performance when loading many any-to-any links

Added AnyToAny.getFastLoader() which returns a FastLinkLoader instance for loading any-to-any links with fixed link name between source and target item types.

The fast loaded need to be pre-loaded with items before it can be used. The simplest way is to use FastLinkLoader.preloadAll() but there is also an alternative that allows a subset of the links to be pre-loaded.

Location:

branches/3.19-stable/src/core/net/sf/basedb/core

Files:

• AnyToAny.java (modified) (4 diffs)
• query/IdListRestriction.java (modified) (3 diffs)

branches/3.19-stable/src/core/net/sf/basedb/core/AnyToAny.java

@@ -25 +25 @@
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 import org.hibernate.mapping.PersistentClass;
@@ -31 +34 @@
 
 import net.sf.basedb.core.data.AnyToAnyData;
+import net.sf.basedb.core.data.BasicData;
 import net.sf.basedb.core.hibernate.TypeWrapper;
 import net.sf.basedb.core.query.Expressions;
 import net.sf.basedb.core.query.Hql;
+import net.sf.basedb.core.query.IdListRestriction;
+import net.sf.basedb.core.query.Restriction;
 import net.sf.basedb.core.query.Restrictions;
 import net.sf.basedb.core.signal.ThreadSignalHandler;
@@ -253 +259 @@
     );
     return query;
+  }
+  
+  /**
+    Create an optimized implementation for loading the target item of a given named link from 
+    multiple source items. When the source item type, target item type and link name is known
+    this implementation can be used to load the target items much more quickly than when loaded
+    one by one. The {@link FastLinkLoader#get(BasicItem)} is equivalent to 
+    {@link AnyToAny#getByName(DbControl, BasicItem, String)#getTo()}.
+    
+    @since 3.19.8
+  */
+  public static <S extends BasicItem, T extends BasicItem> FastLinkLoader<S, T> getFastLoader(DbControl dc, Item fromType, String linkName, Item toType)
+  {
+    return new FastLinkLoader<>(dc, fromType, linkName, toType);
   }
   
@@ -742 +762 @@
   }
 
-  
+  /**
+    Helper class for faster loading of any-to-any links between items.
+    A single instance have a fixed source item type, link name and target
+    item type. Before the loader can be used at least one of the <code>preload()</code>
+    methods should be used.
+    
+    @since 3.19.8
+  */
+  public static class FastLinkLoader<S extends BasicItem, T extends BasicItem>
+  {
+    
+    private final DbControl dc;
+    private final Item fromType;
+    private final Item toType;
+    private final String linkName;
+    
+    private final Map<Integer, AnyToAnyData> links;
+    private final Map<Integer, BasicData> targets;
+    
+    FastLinkLoader(DbControl dc, Item fromType, String linkName, Item toType)
+    {
+      this.dc = dc;
+      this.fromType = fromType;
+      this.toType = toType;
+      this.linkName = linkName;
+      this.links = new HashMap<>();
+      this.targets = new HashMap<>();
+    }
+    
+    /**
+      Pre-load all links between source and target item type with the
+      given link name.
+      @return This instance
+    */
+    public FastLinkLoader<S, T> preloadAll()
+    {
+      preload(null, null);
+      return this;
+    }
+    
+    
+    /**
+      Pre-load links between source and target item type with the
+      given link name and optionally extra restrictions for the any-to-any
+      link and/or the target item type.
+      @return This instance
+    */
+    public FastLinkLoader<S, T> preload(Restriction linkRestriction, Restriction targetRestriction)
+    {
+      // Load all AnyToAny links with the specified linkName between source and target item types
+      // We store the mapping between source item id and target item id
+      Map<Integer, Integer> idMap = new HashMap<>();
+      DataQuery<AnyToAnyData> linkQuery = new DataQuery<>(AnyToAnyData.class, null);
+      linkQuery.restrict(Restrictions.eq(Hql.property("fromType"), Expressions.integer(fromType.getValue())));
+      linkQuery.restrict(Restrictions.eq(Hql.property("toType"), Expressions.integer(toType.getValue())));
+      linkQuery.restrict(Restrictions.eq(Hql.property("name"), Expressions.string(linkName)));
+      if (linkRestriction != null) linkQuery.restrict(linkRestriction);
+      Iterator<AnyToAnyData> linkIterator = linkQuery.iterate(dc);
+      while (linkIterator.hasNext())
+      {
+        AnyToAnyData a = linkIterator.next();
+        idMap.put(a.getFromId(), a.getToId());
+        links.put(a.getFromId(), a);
+      }
+      
+      // Load the *Data objects of all target items that was found in the previous step
+      // Store the mapping between target item id and *Data object
+      Map<Integer, BasicData> targetMap = new HashMap<>(idMap.size());
+      DataQuery<? extends BasicData> targetQuery = new DataQuery<>(toType.getDataClass(), null);
+      targetQuery.restrict(new IdListRestriction("id", idMap.values()));
+      if (targetRestriction != null) targetQuery.restrict(targetRestriction);
+      Iterator<? extends BasicData> targetIterator = targetQuery.iterate(dc);
+      while (targetIterator.hasNext())
+      {
+        BasicData target = targetIterator.next();
+        targetMap.put(target.getId(), target);
+      }
+      
+      // Populate the linked items which is a map from source item id to target *Data object
+      for (Map.Entry<Integer, Integer> e : idMap.entrySet())
+      {
+        BasicData target = targetMap.get(e.getValue());
+        if (target != null) targets.put(e.getKey(), target);
+      }
+      
+      return this;
+    }
+    
+    /**
+      The source item type.
+    */
+    public Item getFromType()
+    {
+      return fromType;
+    }
+    
+    /**
+      The target item type.
+    */
+    public Item getToType()
+    {
+      return toType;
+    }
+    
+    /**
+      The link name.
+    */
+    public String getLinkName()
+    {
+      return linkName;
+    }
+    
+    /**
+      Number of items that matches.
+    */
+    public int size()
+    {
+      return targets.size();
+    }
+    
+    /**
+      Get the any-to-any link.
+    */
+    public AnyToAny getLink(S item)
+    {
+      AnyToAnyData link = links.get(item.getId());
+      return link == null ? null : dc.getItem(AnyToAny.class, link);
+    }
+    
+    /**
+      Get the target item that is linked from the source item by the named link.
+    */
+    @SuppressWarnings("unchecked")
+    public T getTo(S item)
+    {
+      BasicData target = targets.get(item.getId());
+      return target == null ? null : (T)dc.getItem(toType.getItemClass(), target);
+    }
+    
+  }
 }

branches/3.19-stable/src/core/net/sf/basedb/core/query/IdListRestriction.java

@@ -50 +50 @@
   public IdListRestriction()
   {
-    this(false, new HashSet<>());
+    this("id", false, new HashSet<>());
   }
   
@@ -58 +58 @@
   public IdListRestriction(boolean notIn)
   {
-    this(notIn, new HashSet<>());
+    this("id", notIn, new HashSet<>());
   }
   
   public IdListRestriction(Set<Integer> idList)
   {
-    this(false, idList);
+    this("id", false, idList);
   }
   
+  /**
+    @since 3.19.8
+  */
+  public IdListRestriction(String idProperty, Collection<Integer> idList)
+  {
+    this(idProperty, false, idList);
+  }
+
   /**
     @since 3.18
@@ -71 +79 @@
   public IdListRestriction(boolean notIn, Set<Integer> idList)
   {
+    this("id", notIn, idList);
+  }
+
+  /**
+    @since 3.19.8
+  */
+  public IdListRestriction(String idProperty, boolean notIn, Collection<Integer> idList)
+  {
     this.notIn = notIn;
     this.idList = new HashSet<>(idList);
-    this.idExpression = Hql.property("id");
+    this.idExpression = Hql.property(idProperty);
   }
+
   
   @Override