diff --git a/yum/rpmsack.py b/yum/rpmsack.py
index adf70af..f6619e8 100644
--- a/yum/rpmsack.py
+++ b/yum/rpmsack.py
@@ -176,6 +176,7 @@ class RPMDBPackageSack(PackageSackBase):
         '''Getter for the pkglist property. 
         Returns a list of package tuples.
         '''
+        print "JDBG: GPL"
         if not self._simple_pkgtup_list:
             for (hdr, mi) in self._all_packages():
                 self._simple_pkgtup_list.append(self._hdr2pkgTuple(hdr))
@@ -331,6 +332,7 @@ class RPMDBPackageSack(PackageSackBase):
         return self.searchPrco(name, 'conflicts')
 
     def simplePkgList(self):
+        print "JDBG: SPL"
         return self.pkglist
 
     installed = PackageSackBase.contains
@@ -417,6 +419,8 @@ class RPMDBPackageSack(PackageSackBase):
         """Returns a list of packages. Note that the packages are
            always filtered to those matching the patterns/case. repoid is
            ignored, and is just here for compatibility with non-rpmdb sacks. """
+        print "JDBG: RP:", patterns, ignore_case
+
         if not self._completely_loaded:
             rpats = self._compile_patterns(patterns, ignore_case)
             for hdr, idx in self._all_packages():
@@ -528,6 +532,10 @@ class RPMDBPackageSack(PackageSackBase):
             data = self._trans_cache_store['file-requires']
             self._write_file_requires(rpmdbv, data)
 
+        if 'yumdb-package-checksums' in self._trans_cache_store:
+            data = self._trans_cache_store['yumdb-package-checksums']
+            self._write_package_checksums(rpmdbv, data)
+
         self._trans_cache_store = {}
 
     def transactionReset(self):
@@ -699,6 +707,75 @@ class RPMDBPackageSack(PackageSackBase):
         os.rename(self._cachedir + '/file-requires.tmp',
                   self._cachedir + '/file-requires')
 
+    def preloadPackageChecksums(self):
+        """ As simpleVersion() et. al. requires it, we "cache" this yumdb data
+            as part of our rpmdb cache. """
+        if not self.__cache_rpmdb__:
+            return
+
+        if not os.path.exists(self._cachedir + '/yumdb-package-checksums'):
+            return
+
+        def _read_str(fo):
+            return fo.readline()[:-1]
+
+        rpmdbv = self.simpleVersion(main_only=True)[0]
+        fo = open(self._cachedir + '/yumdb-package-checksums')
+        frpmdbv = fo.readline()
+        if not frpmdbv or rpmdbv != frpmdbv[:-1]:
+            return
+
+        checksum_data = {}
+        try:
+            # Read the checksums...
+            pkgtups_num = int(_read_str(fo))
+            while pkgtups_num > 0:
+                pkgtups_num -= 1
+
+                # n, a, e, v, r
+                pkgtup = (_read_str(fo), _read_str(fo),
+                          _read_str(fo), _read_str(fo), _read_str(fo))
+                int(pkgtup[2]) # Check epoch is valid
+
+                T = _read_str(fo)
+                D = _read_str(fo)
+                checksum_data[pkgtup] = (T, D)
+
+            if fo.readline() != '': # Should be EOF
+                return
+        except ValueError:
+            return
+
+        for pkgtup in checksum_data:
+            (n, a, e, v, r) = pkgtup
+            pkg = self.searchNevra(n, e, v, r, a)[0]
+            (T, D) = checksum_data[pkgtup]
+            pkg.yumdb_info._read_cached_data['checksum_type'] = T
+            pkg.yumdb_info._read_cached_data['checksum_data'] = D
+
+    def transactionCachePackageChecksums(self, pkg_checksum_tups):
+        if not self.__cache_rpmdb__:
+            return
+
+        self._trans_cache_store['yumdb-package-checksums'] = pkg_checksum_tups
+
+    def _write_package_checksums(self, rpmdbversion, data):
+        if not os.access(self._cachedir, os.W_OK):
+            return
+
+        pkg_checksum_tups = data
+        fo = open(self._cachedir + '/yumdb-package-checksums.tmp', 'w')
+        fo.write("%s\n" % rpmdbversion)
+        fo.write("%u\n" % len(pkg_checksum_tups))
+        for pkgtup, TD in sorted(pkg_checksum_tups):
+            for var in pkgtup:
+                fo.write("%s\n" % var)
+            for var in TD:
+                fo.write("%s\n" % var)
+        fo.close()
+        os.rename(self._cachedir + '/yumdb-package-checksums.tmp',
+                  self._cachedir + '/yumdb-package-checksums')
+
     def _get_cached_simpleVersion_main(self):
         """ Return the cached string of the main rpmdbv. """
         if self._have_cached_rpmdbv_data is not None:
diff --git a/yum/transactioninfo.py b/yum/transactioninfo.py
index 30a2625..e7b60de 100644
--- a/yum/transactioninfo.py
+++ b/yum/transactioninfo.py
@@ -577,12 +577,15 @@ class TransactionData:
                 _reinstalled_pkgtups[txmbr.po.pkgtup] = txmbr.po
             pkgs.append(txmbr.po)
 
+        self.rpmdb.preloadPackageChecksums()
         main = PackageSackVersion()
+        pkg_checksum_tups = []
         for pkg in sorted(pkgs):
             if pkg.repoid != 'installed':
                 # Paste from PackageSackBase.simpleVersion()
                 csum = pkg.returnIdSum()
                 main.update(pkg, csum)
+                pkg_checksum_tups.append((pkg.pkgtup, csum))
                 continue
 
             # Installed pkg, see if it's about to die
@@ -597,7 +600,11 @@ class TransactionData:
             csum = None
             if 'checksum_type' in ydbi and 'checksum_data' in ydbi:
                 csum = (ydbi.checksum_type, ydbi.checksum_data)
+                pkg_checksum_tups.append((pkg.pkgtup, csum))
             main.update(pkg, csum)
+
+        self.rpmdb.transactionCachePackageChecksums(pkg_checksum_tups)
+
         return main
 
 class ConditionalTransactionData(TransactionData):