ElggVolatileMetadataCache.php

Go to the documentation of this file.

<?php
class ElggVolatileMetadataCache {

    protected $values = array();

    protected $isSynchronized = array();

    protected $ignoreAccess = null;

    public function saveAll($entity_guid, array $values) {
        if (!$this->getIgnoreAccess()) {
            $this->values[$entity_guid] = $values;
            $this->isSynchronized[$entity_guid] = true;
        }
    }

    public function loadAll($entity_guid) {
        if (isset($this->values[$entity_guid])) {
            return $this->values[$entity_guid];
        } else {
            return array();
        }
    }

    public function markOutOfSync($entity_guid) {
        unset($this->isSynchronized[$entity_guid]);
    }

    public function isSynchronized($entity_guid) {
        return isset($this->isSynchronized[$entity_guid]);
    }

    public function save($entity_guid, $name, $value, $allow_multiple = false) {
        if ($this->getIgnoreAccess()) {
            // we don't know if what gets saves here will be available to user once
            // access control returns, hence it's best to forget :/
            $this->markUnknown($entity_guid, $name);
        } else {
            if ($allow_multiple) {
                if ($this->isKnown($entity_guid, $name)) {
                    $existing = $this->load($entity_guid, $name);
                    if ($existing !== null) {
                        $existing = (array) $existing;
                        $existing[] = $value;
                        $value = $existing;
                    }
                } else {
                    // we don't know whether there are unknown values, so it's
                    // safest to leave that assumption
                    $this->markUnknown($entity_guid, $name);
                    return;
                }
            }
            $this->values[$entity_guid][$name] = $value;
        }
    }

    public function load($entity_guid, $name) {
        if (isset($this->values[$entity_guid]) && array_key_exists($name, $this->values[$entity_guid])) {
            return $this->values[$entity_guid][$name];
        } else {
            return null;
        }
    }

    public function markUnknown($entity_guid, $name) {
        unset($this->values[$entity_guid][$name]);
        $this->markOutOfSync($entity_guid);
    }

    public function isKnown($entity_guid, $name) {
        if (isset($this->isSynchronized[$entity_guid])) {
            return true;
        } else {
            return (isset($this->values[$entity_guid]) && array_key_exists($name, $this->values[$entity_guid]));
        }

    }

    public function markEmpty($entity_guid, $name) {
        $this->values[$entity_guid][$name] = null;
    }

    public function clear($entity_guid) {
        unset($this->values[$entity_guid]);
        $this->markOutOfSync($entity_guid);
    }

    public function flush() {
        $this->values = array();
        $this->isSynchronized = array();
    }

    public function setIgnoreAccess($ignore) {
        $this->ignoreAccess = (bool) $ignore;
    }

    public function unsetIgnoreAccess() {
        $this->ignoreAccess = null;
    }

    protected function getIgnoreAccess() {
        if (null === $this->ignoreAccess) {
            return elgg_get_ignore_access();
        } else {
            return $this->ignoreAccess;
        }
    }

    public function invalidateByOptions($action, array $options) {
        // remove as little as possible, optimizing for common cases
        if (empty($options['guid'])) {
            // safest to clear everything unless we want to make this even more complex :(
            $this->flush();
        } else {
            if (empty($options['metadata_name'])) {
                // safest to clear the whole entity
                $this->clear($options['guid']);
            } else {
                switch ($action) {
                    case 'delete':
                        $this->markEmpty($options['guid'], $options['metadata_name']);
                        break;
                    default:
                        $this->markUnknown($options['guid'], $options['metadata_name']);
                }
            }
        }
    }

    public function populateFromEntities($guids) {
        if (empty($guids)) {
            return;
        }
        if (!is_array($guids)) {
            $guids = array($guids);
        }
        $guids = array_unique($guids);

        // could be useful at some point in future
        //$guids = $this->filterMetadataHeavyEntities($guids);

        $db_prefix = elgg_get_config('dbprefix');
        $options = array(
            'guids' => $guids,
            'limit' => 0,
            'callback' => false,
            'joins' => array(
                "JOIN {$db_prefix}metastrings v ON n_table.value_id = v.id",
                "JOIN {$db_prefix}metastrings n ON n_table.name_id = n.id",
            ),
            'selects' => array('n.string AS name', 'v.string AS value'),
            'order_by' => 'n_table.entity_guid, n_table.time_created ASC',

            // @todo don't know why this is necessary
            'wheres' => array(_elgg_get_access_where_sql(array('table_alias' => 'n_table'))),
        );
        $data = elgg_get_metadata($options);

        // build up metadata for each entity, save when GUID changes (or data ends)
        $last_guid = null;
        $metadata = array();
        $last_row_idx = count($data) - 1;
        foreach ($data as $i => $row) {
            $name = $row->name;
            $value = ($row->value_type === 'text') ? $row->value : (int) $row->value;
            $guid = $row->entity_guid;
            if ($guid !== $last_guid) {
                if ($last_guid) {
                    $this->saveAll($last_guid, $metadata);
                }
                $metadata = array();
            }
            if (isset($metadata[$name])) {
                $metadata[$name] = (array) $metadata[$name];
                $metadata[$name][] = $value;
            } else {
                $metadata[$name] = $value;
            }
            if (($i == $last_row_idx)) {
                $this->saveAll($guid, $metadata);
            }
            $last_guid = $guid;
        }
    }

    public function filterMetadataHeavyEntities(array $guids, $limit = 1024000) {
        $db_prefix = elgg_get_config('dbprefix');

        $options = array(
            'guids' => $guids,
            'limit' => 0,
            'callback' => false,
            'joins' => "JOIN {$db_prefix}metastrings v ON n_table.value_id = v.id",
            'selects' => array('SUM(LENGTH(v.string)) AS bytes'),
            'order_by' => 'n_table.entity_guid, n_table.time_created ASC',
            'group_by' => 'n_table.entity_guid',
        );
        $data = elgg_get_metadata($options);
        // don't cache if metadata for entity is over 10MB (or rolled INT)
        foreach ($data as $row) {
            if ($row->bytes > $limit || $row->bytes < 0) {
                array_splice($guids, array_search($row->entity_guid, $guids), 1);
            }
        }
        return $guids;
    }
}