MetadataCache.php

Go to the documentation of this file.

<?php
namespace Elgg\Cache;
 
class MetadataCache {
 
    protected $values = array();
 
    protected $session;
 
    public function __construct(\ElggSession $session) {
        $this->session = $session;
    }
 
    public function inject($entity_guid, array $values) {
        $this->values[$this->getAccessKey()][$entity_guid] = $values;
    }
 
    public function getSingle($entity_guid, $name) {
        $access_key = $this->getAccessKey();
 
        if (isset($this->values[$access_key][$entity_guid])
                && array_key_exists($name, $this->values[$access_key][$entity_guid])) {
            return $this->values[$access_key][$entity_guid][$name];
        } else {
            return null;
        }
    }
 
    public function clear($entity_guid) {
        foreach (array_keys($this->values) as $access_key) {
            unset($this->values[$access_key][$entity_guid]);
        }
    }
 
    public function isLoaded($entity_guid) {
        $access_key = $this->getAccessKey();
 
        if (empty($this->values[$access_key])) {
            return false;
        }
        return array_key_exists($entity_guid, $this->values[$access_key]);
    }
 
    public function clearAll() {
        $this->values = array();
    }
 
    public function invalidateByOptions(array $options) {
        if (empty($options['guid'])) {
            $this->clearAll();
        } else {
            $this->clear($options['guid']);
        }
    }
 
    public function populateFromEntities($guids) {
        if (empty($guids)) {
            return;
        }
 
        $access_key = $this->getAccessKey();
 
        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_services()->db->prefix;
        $options = array(
            'guids' => $guids,
            'limit' => 0,
            'callback' => false,
            'distinct' => 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, n_table.id ASC',
 
            // @todo don't know why this is necessary
            'wheres' => array(_elgg_get_access_where_sql(array(
                'table_alias' => 'n_table',
                'guid_column' => 'entity_guid',
            ))),
        );
        $data = _elgg_services()->metadataTable->getAll($options);
 
        // make sure we show all entities as loaded
        foreach ($guids as $guid) {
            $this->values[$access_key][$guid] = null;
        }
 
        // 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->values[$access_key][$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->values[$access_key][$guid] = $metadata;
            }
            $last_guid = $guid;
        }
    }
 
    public function filterMetadataHeavyEntities(array $guids, $limit = 1024000) {
        $db_prefix = _elgg_services()->config->get('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_services()->metadataTable->getAll($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;
    }
 
    protected function getAccessKey() {
        if ($this->session->getIgnoreAccess()) {
            return "ignored";
        }
        return (string)$this->session->getLoggedInUserGuid();
    }
}