text: "Database cache backend."
  
  from django.core.cache.backends.base import BaseCache
  from django.db import connections, router, transaction, DatabaseError
  import base64, time
  from datetime import datetime
  try:
      import cPickle as pickle
  except ImportError:
      import pickle
  
  class Options(object):
      """A class that will quack like a Django model _meta class.
  
      This allows cache operations to be controlled by the router
      """
      def __init__(self, table):
          self.db_table = table
          self.app_label = 'django_cache'
          self.module_name = 'cacheentry'
          self.verbose_name = 'cache entry'
          self.verbose_name_plural = 'cache entries'
          self.object_name =  'CacheEntry'
          self.abstract = False
          self.managed = True
          self.proxy = False
  
  class BaseDatabaseCache(BaseCache):
      def __init__(self, table, params):
          BaseCache.__init__(self, params)
          self._table = table
  
          class CacheEntry(object):
              _meta = Options(table)
          self.cache_model_class = CacheEntry
  
  class DatabaseCache(BaseDatabaseCache):
      def get(self, key, default=None, version=None):
          key = self.make_key(key, version=version)
          self.validate_key(key)
          db = router.db_for_read(self.cache_model_class)
          table = connections[db].ops.quote_name(self._table)
          cursor = connections[db].cursor()
  
          cursor.execute("SELECT cache_key, value, expires FROM %s WHERE cache_key = %%s" % table, [key])
          row = cursor.fetchone()
          if row is None:
              return default
          now = datetime.now()
          if row[2] < now:
              db = router.db_for_write(self.cache_model_class)
              cursor = connections[db].cursor()
              cursor.execute("DELETE FROM %s WHERE cache_key = %%s" % table, [key])
              transaction.commit_unless_managed(using=db)
              return default
          value = connections[db].ops.process_clob(row[1])
          return pickle.loads(base64.decodestring(value))
  
      def set(self, key, value, timeout=None, version=None):
          key = self.make_key(key, version=version)
          self.validate_key(key)
          self._base_set('set', key, value, timeout)
  
      def add(self, key, value, timeout=None, version=None):
          key = self.make_key(key, version=version)
          self.validate_key(key)
          return self._base_set('add', key, value, timeout)
  
      def _base_set(self, mode, key, value, timeout=None):
          if timeout is None:
              timeout = self.default_timeout
          db = router.db_for_write(self.cache_model_class)
          table = connections[db].ops.quote_name(self._table)
          cursor = connections[db].cursor()
  
          cursor.execute("SELECT COUNT(*) FROM %s" % table)
          num = cursor.fetchone()[0]
          now = datetime.now().replace(microsecond=0)
          exp = datetime.fromtimestamp(time.time() + timeout).replace(microsecond=0)
          if num > self._max_entries:
              self._cull(db, cursor, now)
          encoded = base64.encodestring(pickle.dumps(value, 2)).strip()
          cursor.execute("SELECT cache_key, expires FROM %s WHERE cache_key = %%s" % table, [key])
          try:
              result = cursor.fetchone()
              if result and (mode == 'set' or
                      (mode == 'add' and result[1] < now)):
                  cursor.execute("UPDATE %s SET value = %%s, expires = %%s WHERE cache_key = %%s" % table,
                                 [encoded, connections[db].ops.value_to_db_datetime(exp), key])
              else:
                  cursor.execute("INSERT INTO %s (cache_key, value, expires) VALUES (%%s, %%s, %%s)" % table,
                                 [key, encoded, connections[db].ops.value_to_db_datetime(exp)])
          except DatabaseError:
              # To be threadsafe, updates/inserts are allowed to fail silently
              transaction.rollback_unless_managed(using=db)
              return False
          else:
              transaction.commit_unless_managed(using=db)
              return True
  
      def delete(self, key, version=None):
          key = self.make_key(key, version=version)
          self.validate_key(key)
  
          db = router.db_for_write(self.cache_model_class)
          table = connections[db].ops.quote_name(self._table)
          cursor = connections[db].cursor()
  
          cursor.execute("DELETE FROM %s WHERE cache_key = %%s" % table, [key])
          transaction.commit_unless_managed(using=db)
  
      def has_key(self, key, version=None):
          key = self.make_key(key, version=version)
          self.validate_key(key)
  
          db = router.db_for_read(self.cache_model_class)
          table = connections[db].ops.quote_name(self._table)
          cursor = connections[db].cursor()
  
          now = datetime.now().replace(microsecond=0)
          cursor.execute("SELECT cache_key FROM %s WHERE cache_key = %%s and expires > %%s" % table,
                         [key, connections[db].ops.value_to_db_datetime(now)])
          return cursor.fetchone() is not None
  
      def _cull(self, db, cursor, now):
          if self._cull_frequency == 0:
              self.clear()
          else:
              table = connections[db].ops.quote_name(self._table)
              cursor.execute("DELETE FROM %s WHERE expires < %%s" % table,
                             [connections[db].ops.value_to_db_datetime(now)])
              cursor.execute("SELECT COUNT(*) FROM %s" % table)
              num = cursor.fetchone()[0]
              if num > self._max_entries:
                  cull_num = num / self._cull_frequency
                  if connections[db].vendor == 'oracle':
                      # Special case for Oracle because it doesn't support LIMIT + OFFSET
                      cursor.execute("SELECT cache_key FROM (SELECT ROW_NUMBER() OVER (ORDER BY cache_key) AS counter, cache_key FROM %s) WHERE counter > %%s AND COUNTER <= %%s" % table, [cull_num, cull_num + 1])
  		else:
                      # This isn't standard SQL, it's likely to break with some non officially supported databases             
                      cursor.execute("SELECT cache_key FROM %s ORDER BY cache_key LIMIT 1 OFFSET %%s" % table, [cull_num])
                  cursor.execute("DELETE FROM %s WHERE cache_key < %%s" % table, [cursor.fetchone()[0]])
  
      def clear(self):
          db = router.db_for_write(self.cache_model_class)
          table = connections[db].ops.quote_name(self._table)
          cursor = connections[db].cursor()
          cursor.execute('DELETE FROM %s' % table)
  
  # For backwards compatibility
  class CacheClass(DatabaseCache):
      pass
  