cachedresult.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 *   FILE
 *      pqxx/cachedresult.h
 *
 *   DESCRIPTION
 *      definitions for the pqxx::cachedresult class and support classes.
 *   pqxx::cachedresult is a lazy-fetching, transparently-cached result set
 *
 * Copyright (c) 2001-2004, Jeroen T. Vermeulen <jtv@xs4all.nl>
 *
 * See COPYING for copyright license.  If you did not receive a file called
 * COPYING with this source code, please notify the distributor of this mistake,
 * or contact the author.
 *
 *-------------------------------------------------------------------------
 */
#ifndef PQXX_CACHEDRESULT_H
#define PQXX_CACHEDRESULT_H

#include <map>

#include "pqxx/cursor.h"
#include "pqxx/result.h"

namespace pqxx
{

class PQXX_LIBEXPORT cachedresult
{
public:
  typedef result::size_type size_type;
  typedef size_type blocknum;

  typedef result::tuple tuple;

  typedef tuple Tuple;

  template<typename TRANSACTION> explicit
    cachedresult(TRANSACTION &T,
                 const char Query[],
                 const PGSTD::string &BaseName="query",
                 size_type Granularity=100) :                           //[t40]
      m_Granularity(Granularity),
      m_Cache(),
      m_Cursor(T, Query, BaseName, Granularity),
      m_EmptyResult(),
      m_HaveEmpty(false)
  {
    // Trigger build error if T has insufficient isolation level
    error_permitted_isolation_level(PQXX_TYPENAME TRANSACTION::isolation_tag());
    init();
  }



  const tuple operator[](size_type i) const                             //[t41]
        { return GetBlock(BlockFor(i))[Offset(i)]; }


   const tuple at(size_type i) const                                    //[t40]
        { return GetBlock(BlockFor(i)).at(Offset(i)); }

  size_type size() const;                                               //[t40]
  
  bool empty() const;                                                   //[t47]

private:
  typedef Cursor::pos pos;

#ifndef PQXX_WORKAROUND_VC7


  template<typename ISOLATIONTAG>
    static inline void error_permitted_isolation_level(ISOLATIONTAG) throw ();

#if defined(__SUNPRO_CC)
  // Incorrect, but needed to compile with Sun CC
  template<> static void 
    error_permitted_level(isolation_traits<serializable>) throw() {}
#endif  // __SUNPRO_CC
#else
  // Incorrect, but needed to compile with Visual C++ 7
  template<> static inline void
    error_permitted_isolation_level(isolation_traits<serializable>) throw ();
#endif

  void init();

  blocknum BlockFor(size_type Row) const throw () 
        { return Row / m_Granularity; }
  size_type Offset(size_type Row) const throw ()
        { return Row % m_Granularity; }
  Cursor::size_type FirstRowOf(blocknum Block) const throw ()
        { return Block*m_Granularity; }

  void MoveTo(blocknum) const;

  const result &Fetch() const;

  const result &GetBlock(blocknum b) const
  {
    CacheMap::const_iterator i = m_Cache.find(b);
    if (i != m_Cache.end()) return i->second;

    MoveTo(b);
    return Fetch();
  }

  size_type m_Granularity;

  typedef PGSTD::map<blocknum, result> CacheMap;
  mutable CacheMap m_Cache;

  mutable Cursor m_Cursor;
  mutable result m_EmptyResult;
  mutable bool   m_HaveEmpty;

  // Not allowed:
  cachedresult();
  cachedresult(const cachedresult &);
  cachedresult &operator=(const cachedresult &);
};

typedef cachedresult CachedResult;

template<> inline void
cachedresult::error_permitted_isolation_level(isolation_traits<serializable>)
  throw () {}

} // namespace pqxx

#endif

---