MetadataCache.php

Go to the documentation of this file.

<?php

namespace Elgg\Cache;

use ElggCache;
use Elgg\Database\Clauses\GroupByClause;
use Elgg\Database\Clauses\OrderByClause;
use Elgg\Exceptions\DataFormatException;
use Elgg\Values;
use ElggMetadata;

class MetadataCache {

    protected $cache;

    public function __construct(ElggCache $cache) {
        $this->cache = $cache;
    }

    public function inject($entity_guid, array $values = []) {
        $metadata = [];
        foreach ($values as $key => $value) {
            if ($value instanceof ElggMetadata) {
                $md = $value;
            } else {
                $md = new ElggMetadata();
                $md->name = $key;
                $md->value = $value;
                $md->entity_guid = $entity_guid;
            }

            $metadata[] = $md->toObject();
        }

        $this->cache->save($entity_guid, $metadata);
    }

    public function getAll($entity_guid) {
        $metadata = $this->getEntityMetadata($entity_guid);
        if (empty($metadata)) {
            return [];
        }

        $metadata_values = [];

        foreach ($metadata as $md) {
            $metadata_values[$md->name][] = $md->value;
        }

        return array_map(function($values) {
            return count($values) > 1 ? $values : $values[0];
        }, $metadata_values);
    }

    public function getSingle($entity_guid, $name) {
        $metadata = $this->getEntityMetadata($entity_guid);
        if (empty($metadata)) {
            return null;
        }

        $values = [];

        foreach ($metadata as $md) {
            if ($md->name !== $name) {
                continue;
            }

            $values[] = $md->value;
        }

        if (empty($values)) {
            return null;
        }

        return count($values) > 1 ? $values : $values[0];

    }

    public function getSingleId($entity_guid, $name) {
        $metadata = $this->getEntityMetadata($entity_guid);
        if (empty($metadata)) {
            return null;
        }

        $ids = [];

        foreach ($metadata as $md) {
            if ($md->name !== $name) {
                continue;
            }

            $ids[] = $md->id;
        }

        if (empty($ids)) {
            return null;
        }

        return count($ids) > 1 ? $ids : $ids[0];
    }

    public function clear($entity_guid) {
        $this->invalidateByOptions([
            'guid' => $entity_guid,
        ]);
    }

    public function isLoaded($entity_guid) {
        return $this->cache->load($entity_guid) !== null;
    }

    public function clearAll() {
        $this->invalidateByOptions([]);
    }

    public function getEntityMetadata($entity_guid) {
        $entity_guid = (int) $entity_guid;
        $metadata = $this->cache->load($entity_guid);
        if ($metadata === null) {
            $metadata = elgg_extract($entity_guid, $this->populateFromEntities($entity_guid));
        }
        
        return $metadata;
    }

    public function invalidateByOptions(array $options) {
        if (empty($options['guid'])) {
            _elgg_services()->sessionCache->clear();
            _elgg_services()->dataCache->clear();
        } else {
            _elgg_services()->entityTable->invalidateCache($options['guid']);
        }
    }

    public function populateFromEntities(...$guids) {
        try {
            $guids = Values::normalizeGuids($guids);
        } catch (DataFormatException $e) {
            return null;
        }

        if (empty($guids)) {
            return null;
        }

        $cached_values = [];

        foreach ($guids as $i => $guid) {
            $value = $this->cache->load($guid);
            if ($value !== null) {
                $cached_values[$guid] = $value;
                unset($guids[$i]);
            }
        }

        if (empty($guids)) {
            return $cached_values;
        }

        $data = _elgg_services()->metadataTable->getRowsForGuids($guids);
        
        $values = [];
        foreach ($data as $row) {
            $values[$row->entity_guid][] = $row;
        }

        // store always for every guid, even if there is no metadata
        foreach ($guids as $guid) {
            $metadata = elgg_extract($guid, $values, []);
            
            $this->cache->save($guid, $metadata);
            $cached_values[$guid] = $metadata;
        }
        
        return $cached_values;
    }

    public function filterMetadataHeavyEntities(array $guids, $limit = 1024000) {

        $guids = _elgg_services()->metadataTable->getAll([
            'guids' => $guids,
            'limit' => false,
            'callback' => function($e) {
                return (int) $e->entity_guid;
            },
            'selects' => ['SUM(LENGTH(n_table.value)) AS bytes'],
            'order_by' => [
                new OrderByClause('n_table.entity_guid'),
                new OrderByClause('n_table.time_created'),
            ],
            'group_by' => [
                new GroupByClause('n_table.entity_guid'),
            ],
            'having' => [
                "bytes < $limit",
            ]
        ]);

        return $guids ? : [];
    }
}