• Quickstart and
  • Architecture and Concepts

  • Architecture and Concepts
  • Architecture and Concepts

    Architecture and Concepts

    The query cache plugin is implemented as a PHP
    extension. It is written in C and operates under the hood of PHP.
    During the startup of the PHP interpreter, it gets registered as a
    mysqlnd plugin to
    replace selected mysqlnd C methods. Hereby, it can change the
    behaviour of any PHP MySQL extension (mysqli, PDO_MYSQL, mysql) compiled to use the mysqlnd library without
    changing the extensions API. This makes the plugin compatible with
    each and every PHP MySQL application. Because existing APIs are not
    changed, it is almost transparent to use. Please, see the mysqlnd plugin API
    for a discussion of the advantages of the plugin
    architecture and a comparison with proxy based solutions.

    Transparent to use

    At PHP run time PECL/mysqlnd_qc can proxy queries
    send from PHP (mysqlnd) to the MySQL server. It then inspects the
    statement string to find whether it shall cache its results. If so,
    result set is cached using a storage handler and further executions
    of the statement are served from the cache for a user-defined
    period. The Time to Live (TTL) of the cache entry can either be set
    globally or on a per statement basis.

    A statement is either cached if the plugin is
    instructed to cache all statements globally using a or, if the
    query string starts with the SQL hint (/*qc=on*/). The
    plugin is capable of caching any query issued by calling
    appropriate API calls of any of the existing PHP MySQL

    Flexible storage: various
    storage handler

    Various storage handler are supported to offer
    different scopes for cache entries. Different scopes allow for
    different degrees in sharing cache entries among clients.

    • default (built-in): process memory, scope:
      process, one or more web requests depending on PHP deployment model

    • APC: shared memory, scope: single server,
      multiple web requests

    • SQLite: memory or file, scope: single
      server, multiple web requests

    • MEMCACHE: main memory, scope: single or
      multiple server, multiple web requests

    • user (built-in): user-defined – any,
      scope: user-defined – any

    Support for the APC, SQLite and
    MEMCACHE storage handler has to be enabled at compile
    time. The default and user handler are built-in.
    It is possible to switch between compiled-in storage handlers on a
    per query basis at run time. However, it is recommended to pick one
    storage handler and use it for all cache entries.

    Built-in slam defense to avoid

    To avoid overload situations the cache plugin has a
    built-in slam defense mechanism. If a popular cache entries expires
    many clients using the cache entries will try to refresh the cache
    entry. For the duration of the refresh many clients may access the
    database server concurrently. In the worst case, the database
    server becomes overloaded and it takes more and more time to
    refresh the cache entry, which in turn lets more and more clients
    try to refresh the cache entry. To prevent this from happening the
    plugin has a slam defense mechanism. If slam defense is enabled and
    the plugin detects an expired cache entry it extends the life time
    of the cache entry before it refreshes the cache entry. This way
    other concurrent accesses to the expired cache entry are still
    served from the cache for a certain time. The other concurrent
    accesses to not trigger a concurrent refresh. Ideally, the cache
    entry gets refreshed by the client which extended the cache entries
    lifespan before other clients try to refresh the cache and
    potentially cause an overload situation.

    Unique approach to

    PECL/mysqlnd_qc has a unique approach to caching
    result sets that is superior to application based cache solutions.
    Application based solutions first fetch a result set into PHP
    variables. Then, the PHP variables are serialized for storage in a
    persistent cache, and then unserialized when fetching. The mysqlnd
    query cache stores the raw wire protocol data sent from MySQL to
    PHP in its cache and replays it, if still valid, on a cache hit.
    This way, it saves an extra serialization step for a cache put that
    all application based solutions have to do. It can store the raw
    wire protocol data in the cache without having to serialize into a
    PHP variable first and deserializing the PHP variable for storing
    in the cache again.