Symfony Profiler

<?php
namespace SleekDB;
use Exception;
use SleekDB\Classes\IoHelper;
use SleekDB\Classes\NestedHelper;
use SleekDB\Exceptions\InvalidArgumentException;
use SleekDB\Exceptions\IdNotAllowedException;
use SleekDB\Exceptions\InvalidConfigurationException;
use SleekDB\Exceptions\IOException;
use SleekDB\Exceptions\JsonException;
// To provide usage without composer, we need to require all files.
if(false === class_exists("\Composer\Autoload\ClassLoader")) {
foreach (glob(__DIR__ . '/Exceptions/*.php') as $exception) {
require_once $exception;
}
foreach (glob(__DIR__ . '/Classes/*.php') as $traits) {
require_once $traits;
}
foreach (glob(__DIR__ . '/*.php') as $class) {
if (strpos($class, 'SleekDB.php') !== false || strpos($class, 'Store.php') !== false) {
continue;
}
require_once $class;
}
}
class Store
{
protected $root = __DIR__;
protected $storeName = "";
protected $storePath = "";
protected $databasePath = "";
protected $useCache = true;
protected $folderPermissions = 0777;
protected $defaultCacheLifetime;
protected $primaryKey = "_id";
protected $timeout = 120;
protected $searchOptions = [
"minLength" => 2,
"scoreKey" => "searchScore",
"mode" => "or",
"algorithm" => Query::SEARCH_ALGORITHM["hits"]
];
const dataDirectory = "data/";
/**
* Store constructor.
* @param string $storeName
* @param string $databasePath
* @param array $configuration
* @throws InvalidArgumentException
* @throws IOException
* @throws InvalidConfigurationException
*/
public function __construct(string $storeName, string $databasePath, array $configuration = [])
{
$storeName = trim($storeName);
if (empty($storeName)) {
throw new InvalidArgumentException('store name can not be empty');
}
$this->storeName = $storeName;
$databasePath = trim($databasePath);
if (empty($databasePath)) {
throw new InvalidArgumentException('data directory can not be empty');
}
IoHelper::normalizeDirectory($databasePath);
$this->databasePath = $databasePath;
$this->setConfiguration($configuration);
// boot store
$this->createDatabasePath();
$this->createStore();
}
/**
* Change the destination of the store object.
* @param string $storeName
* @param string|null $databasePath If empty, previous database path will be used.
* @param array $configuration
* @return Store
* @throws IOException
* @throws InvalidArgumentException
* @throws InvalidConfigurationException
*/
public function changeStore(string $storeName, string $databasePath = null, array $configuration = []): Store
{
if(empty($databasePath)){
$databasePath = $this->getDatabasePath();
}
$this->__construct($storeName, $databasePath, $configuration);
return $this;
}
/**
* @return string
*/
public function getStoreName(): string
{
return $this->storeName;
}
/**
* @return string
*/
public function getDatabasePath(): string
{
return $this->databasePath;
}
/**
* @return QueryBuilder
*/
public function createQueryBuilder(): QueryBuilder
{
return new QueryBuilder($this);
}
/**
* Insert a new document to the store.
* It is stored as a plaintext JSON document.
* @param array $data
* @return array inserted document
* @throws IOException
* @throws IdNotAllowedException
* @throws InvalidArgumentException
* @throws JsonException
*/
public function insert(array $data): array
{
// Handle invalid data
if (empty($data)) {
throw new InvalidArgumentException('No data found to insert in the store');
}
$data = $this->writeNewDocumentToStore($data);
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return $data;
}
/**
* Insert multiple documents to the store.
* They are stored as plaintext JSON documents.
* @param array $data
* @return array inserted documents
* @throws IOException
* @throws IdNotAllowedException
* @throws InvalidArgumentException
* @throws JsonException
*/
public function insertMany(array $data): array
{
// Handle invalid data
if (empty($data)) {
throw new InvalidArgumentException('No data found to insert in the store');
}
// All results.
$results = [];
foreach ($data as $document) {
$results[] = $this->writeNewDocumentToStore($document);
}
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return $results;
}
/**
* Delete store with all its data and cache.
* @return bool
* @throws IOException
*/
public function deleteStore(): bool
{
$storePath = $this->getStorePath();
return IoHelper::deleteFolder($storePath);
}
/**
* Return the last created store object ID.
* @return int
* @throws IOException
*/
public function getLastInsertedId(): int
{
$counterPath = $this->getStorePath() . '_cnt.sdb';
return (int) IoHelper::getFileContent($counterPath);
}
/**
* @return string
*/
public function getStorePath(): string
{
return $this->storePath;
}
/**
* Retrieve all documents.
* @param array|null $orderBy array($fieldName => $order). $order can be "asc" or "desc"
* @param int|null $limit the amount of data record to limit
* @param int|null $offset the amount of data record to skip
* @return array
* @throws IOException
* @throws InvalidArgumentException
*/
public function findAll(array $orderBy = null, int $limit = null, int $offset = null): array
{
$qb = $this->createQueryBuilder();
if(!is_null($orderBy)){
$qb->orderBy($orderBy);
}
if(!is_null($limit)){
$qb->limit($limit);
}
if(!is_null($offset)){
$qb->skip($offset);
}
return $qb->getQuery()->fetch();
}
/**
* Retrieve one document by its primary key. Very fast because it finds the document by its file path.
* @param int|string $id
* @return array|null
* @throws InvalidArgumentException
*/
public function findById($id){
$id = $this->checkAndStripId($id);
$filePath = $this->getDataPath() . "$id.json";
try{
$content = IoHelper::getFileContent($filePath);
} catch (Exception $exception){
return null;
}
return @json_decode($content, true);
}
/**
* Retrieve one or multiple documents.
* @param array $criteria
* @param array $orderBy
* @param int $limit
* @param int $offset
* @return array
* @throws IOException
* @throws InvalidArgumentException
*/
public function findBy(array $criteria, array $orderBy = null, int $limit = null, int $offset = null): array
{
$qb = $this->createQueryBuilder();
$qb->where($criteria);
if($orderBy !== null) {
$qb->orderBy($orderBy);
}
if($limit !== null) {
$qb->limit($limit);
}
if($offset !== null) {
$qb->skip($offset);
}
return $qb->getQuery()->fetch();
}
/**
* Retrieve one document.
* @param array $criteria
* @return array|null single document or NULL if no document can be found
* @throws IOException
* @throws InvalidArgumentException
*/
public function findOneBy(array $criteria)
{
$qb = $this->createQueryBuilder();
$qb->where($criteria);
$result = $qb->getQuery()->first();
return (!empty($result))? $result : null;
}
/**
* Update or insert one document.
* @param array $data
* @param bool $autoGenerateIdOnInsert
* @return array updated / inserted document
* @throws IOException
* @throws InvalidArgumentException
* @throws JsonException
*/
public function updateOrInsert(array $data, bool $autoGenerateIdOnInsert = true): array
{
$primaryKey = $this->getPrimaryKey();
if(empty($data)) {
throw new InvalidArgumentException("No document to update or insert.");
}
// // we can use this check to determine if multiple documents are given
// // because documents have to have at least the primary key.
// if(array_keys($data) !== range(0, (count($data) - 1))){
// $data = [ $data ];
// }
if(!array_key_exists($primaryKey, $data)) {
// $documentString = var_export($document, true);
// throw new InvalidArgumentException("Documents have to have the primary key \"$primaryKey\". Got data: $documentString");
$data[$primaryKey] = $this->increaseCounterAndGetNextId();
} else {
$data[$primaryKey] = $this->checkAndStripId($data[$primaryKey]);
if($autoGenerateIdOnInsert && $this->findById($data[$primaryKey]) === null){
$data[$primaryKey] = $this->increaseCounterAndGetNextId();
}
}
// One document to update or insert
// save to access file with primary key value because we secured it above
$storePath = $this->getDataPath() . "$data[$primaryKey].json";
IoHelper::writeContentToFile($storePath, json_encode($data));
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return $data;
}
/**
* Update or insert multiple documents.
* @param array $data
* @param bool $autoGenerateIdOnInsert
* @return array updated / inserted documents
* @throws IOException
* @throws InvalidArgumentException
* @throws JsonException
*/
public function updateOrInsertMany(array $data, bool $autoGenerateIdOnInsert = true): array
{
$primaryKey = $this->getPrimaryKey();
if(empty($data)) {
throw new InvalidArgumentException("No documents to update or insert.");
}
// // we can use this check to determine if multiple documents are given
// // because documents have to have at least the primary key.
// if(array_keys($data) !== range(0, (count($data) - 1))){
// $data = [ $data ];
// }
// Check if all documents have the primary key before updating or inserting any
foreach ($data as $key => $document){
if(!is_array($document)) {
throw new InvalidArgumentException('Documents have to be an arrays.');
}
if(!array_key_exists($primaryKey, $document)) {
// $documentString = var_export($document, true);
// throw new InvalidArgumentException("Documents have to have the primary key \"$primaryKey\". Got data: $documentString");
$document[$primaryKey] = $this->increaseCounterAndGetNextId();
} else {
$document[$primaryKey] = $this->checkAndStripId($document[$primaryKey]);
if($autoGenerateIdOnInsert && $this->findById($document[$primaryKey]) === null){
$document[$primaryKey] = $this->increaseCounterAndGetNextId();
}
}
// after the stripping and checking we apply it back
$data[$key] = $document;
}
// One or multiple documents to update or insert
foreach ($data as $document) {
// save to access file with primary key value because we secured it above
$storePath = $this->getDataPath() . "$document[$primaryKey].json";
IoHelper::writeContentToFile($storePath, json_encode($document));
}
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return $data;
}
/**
* Update one or multiple documents.
* @param array $updatable
* @return bool true if all documents could be updated and false if one document did not exist
* @throws IOException
* @throws InvalidArgumentException
*/
public function update(array $updatable): bool
{
$primaryKey = $this->getPrimaryKey();
if(empty($updatable)) {
throw new InvalidArgumentException("No documents to update.");
}
// we can use this check to determine if multiple documents are given
// because documents have to have at least the primary key.
if(array_keys($updatable) !== range(0, (count($updatable) - 1))){
$updatable = [ $updatable ];
}
// Check if all documents exist and have the primary key before updating any
foreach ($updatable as $key => $document){
if(!is_array($document)) {
throw new InvalidArgumentException('Documents have to be an arrays.');
}
if(!array_key_exists($primaryKey, $document)) {
throw new InvalidArgumentException("Documents have to have the primary key \"$primaryKey\".");
}
$document[$primaryKey] = $this->checkAndStripId($document[$primaryKey]);
// after the stripping and checking we apply it back to the updatable array.
$updatable[$key] = $document;
$storePath = $this->getDataPath() . "$document[$primaryKey].json";
if (!file_exists($storePath)) {
return false;
}
}
// One or multiple documents to update
foreach ($updatable as $document) {
// save to access file with primary key value because we secured it above
$storePath = $this->getDataPath() . "$document[$primaryKey].json";
IoHelper::writeContentToFile($storePath, json_encode($document));
}
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return true;
}
/**
* Update properties of one document.
* @param int|string $id
* @param array $updatable
* @return array|false Updated document or false if document does not exist.
* @throws IOException If document could not be read or written.
* @throws InvalidArgumentException If one key to update is primary key or $id is not int or string.
* @throws JsonException If content of document file could not be decoded.
*/
public function updateById($id, array $updatable)
{
$id = $this->checkAndStripId($id);
$filePath = $this->getDataPath() . "$id.json";
$primaryKey = $this->getPrimaryKey();
if(array_key_exists($primaryKey, $updatable)) {
throw new InvalidArgumentException("You can not update the primary key \"$primaryKey\" of documents.");
}
if(!file_exists($filePath)){
return false;
}
$content = IoHelper::updateFileContent($filePath, function($content) use ($filePath, $updatable){
$content = @json_decode($content, true);
if(!is_array($content)){
throw new JsonException("Could not decode content of \"$filePath\" with json_decode.");
}
foreach ($updatable as $key => $value){
NestedHelper::updateNestedValue($key, $content, $value);
}
return json_encode($content);
});
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return json_decode($content, true);
}
/**
* Delete one or multiple documents.
* @param array $criteria
* @param int $returnOption
* @return array|bool|int
* @throws IOException
* @throws InvalidArgumentException
*/
public function deleteBy(array $criteria, int $returnOption = Query::DELETE_RETURN_BOOL){
$query = $this->createQueryBuilder()->where($criteria)->getQuery();
$query->getCache()->deleteAllWithNoLifetime();
return $query->delete($returnOption);
}
/**
* Delete one document by its primary key. Very fast because it deletes the document by its file path.
* @param int|string $id
* @return bool true if document does not exist or deletion was successful, false otherwise
* @throws InvalidArgumentException
*/
public function deleteById($id): bool
{
$id = $this->checkAndStripId($id);
$filePath = $this->getDataPath() . "$id.json";
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return (!file_exists($filePath) || true === @unlink($filePath));
}
/**
* Remove fields from one document by its primary key.
* @param int|string $id
* @param array $fieldsToRemove
* @return false|array
* @throws IOException
* @throws InvalidArgumentException
* @throws JsonException
*/
public function removeFieldsById($id, array $fieldsToRemove)
{
$id = $this->checkAndStripId($id);
$filePath = $this->getDataPath() . "$id.json";
$primaryKey = $this->getPrimaryKey();
if(in_array($primaryKey, $fieldsToRemove, false)) {
throw new InvalidArgumentException("You can not remove the primary key \"$primaryKey\" of documents.");
}
if(!file_exists($filePath)){
return false;
}
$content = IoHelper::updateFileContent($filePath, function($content) use ($filePath, $fieldsToRemove){
$content = @json_decode($content, true);
if(!is_array($content)){
throw new JsonException("Could not decode content of \"$filePath\" with json_decode.");
}
foreach ($fieldsToRemove as $fieldToRemove){
NestedHelper::removeNestedField($content, $fieldToRemove);
}
return $content;
});
$this->createQueryBuilder()->getQuery()->getCache()->deleteAllWithNoLifetime();
return json_decode($content, true);
}
/**
* Do a fulltext like search against one or multiple fields.
* @param array $fields
* @param string $query
* @param array|null $orderBy
* @param int|null $limit
* @param int|null $offset
* @return array
* @throws IOException
* @throws InvalidArgumentException
*/
public function search(array $fields, string $query, array $orderBy = null, int $limit = null, int $offset = null): array
{
$qb = $this->createQueryBuilder();
$qb->search($fields, $query);
if($orderBy !== null) {
$qb->orderBy($orderBy);
}
if($limit !== null) {
$qb->limit($limit);
}
if($offset !== null) {
$qb->skip($offset);
}
return $qb->getQuery()->fetch();
}
/**
* Get the name of the field used as the primary key.
* @return string
*/
public function getPrimaryKey(): string
{
return $this->primaryKey;
}
/**
* Returns the amount of documents in the store.
* @return int
* @throws IOException
*/
public function count(): int
{
if($this->_getUseCache() === true){
$cacheTokenArray = ["count" => true];
$cache = new Cache($this->getStorePath(), $cacheTokenArray, null);
$cacheValue = $cache->get();
if(is_array($cacheValue) && array_key_exists("count", $cacheValue)){
return $cacheValue["count"];
}
}
$value = [
"count" => IoHelper::countFolderContent($this->getDataPath())
];
if(isset($cache)) {
$cache->set($value);
}
return $value["count"];
}
/**
* Returns the search options of the store.
* @return array
*/
public function _getSearchOptions(): array
{
return $this->searchOptions;
}
/**
* Returns if caching is enabled store wide.
* @return bool
*/
public function _getUseCache(): bool
{
return $this->useCache;
}
/**
* Returns the store wide default cache lifetime.
* @return null|int
*/
public function _getDefaultCacheLifetime()
{
return $this->defaultCacheLifetime;
}
/**
* @return string
* @deprecated since version 2.7, use getDatabasePath instead.
*/
public function getDataDirectory(): string
{
// TODO remove with version 3.0
return $this->databasePath;
}
/**
* @throws IOException
*/
private function createDatabasePath()
{
$databasePath = $this->getDatabasePath();
IoHelper::createFolder($databasePath, $this->folderPermissions);
}
/**
* @throws IOException
*/
private function createStore()
{
$storeName = $this->getStoreName();
// Prepare store name.
IoHelper::normalizeDirectory($storeName);
// Store directory path.
$this->storePath = $this->getDatabasePath() . $storeName;
$storePath = $this->getStorePath();
IoHelper::createFolder($storePath, $this->folderPermissions);
// Create the cache directory.
$cacheDirectory = $storePath . 'cache';
IoHelper::createFolder($cacheDirectory, $this->folderPermissions);
// Create the data directory.
IoHelper::createFolder($storePath . self::dataDirectory, $this->folderPermissions);
// Create the store counter file.
$counterFile = $storePath . '_cnt.sdb';
if(!file_exists($counterFile)){
IoHelper::writeContentToFile($counterFile, '0');
}
}
/**
* @param array $configuration
* @throws InvalidConfigurationException
*/
private function setConfiguration(array $configuration)
{
if(array_key_exists("auto_cache", $configuration)){
$autoCache = $configuration["auto_cache"];
if(!is_bool($configuration["auto_cache"])){
throw new InvalidConfigurationException("auto_cache has to be boolean");
}
$this->useCache = $autoCache;
}
if(array_key_exists("cache_lifetime", $configuration)){
$defaultCacheLifetime = $configuration["cache_lifetime"];
if(!is_int($defaultCacheLifetime) && !is_null($defaultCacheLifetime)){
throw new InvalidConfigurationException("cache_lifetime has to be null or int");
}
$this->defaultCacheLifetime = $defaultCacheLifetime;
}
// TODO remove timeout on major update
// Set timeout.
if (array_key_exists("timeout", $configuration)) {
if ((!is_int($configuration['timeout']) || $configuration['timeout'] <= 0) && !($configuration['timeout'] === false)){
throw new InvalidConfigurationException("timeout has to be an int > 0 or false");
}
$this->timeout = $configuration["timeout"];
}
if($this->timeout !== false){
$message = 'The "timeout" configuration is deprecated and will be removed with the next major update.' .
' Set the "timeout" configuration to false and if needed use the set_timeout_limit() function in your own code.';
trigger_error($message, E_USER_DEPRECATED);
set_time_limit($this->timeout);
}
if(array_key_exists("primary_key", $configuration)){
$primaryKey = $configuration["primary_key"];
if(!is_string($primaryKey)){
throw new InvalidConfigurationException("primary key has to be a string");
}
$this->primaryKey = $primaryKey;
}
if(array_key_exists("search", $configuration)){
$searchConfig = $configuration["search"];
if(array_key_exists("min_length", $searchConfig)){
$searchMinLength = $searchConfig["min_length"];
if(!is_int($searchMinLength) || $searchMinLength <= 0){
throw new InvalidConfigurationException("min length for searching has to be an int >= 0");
}
$this->searchOptions["minLength"] = $searchMinLength;
}
if(array_key_exists("mode", $searchConfig)){
$searchMode = $searchConfig["mode"];
if(!is_string($searchMode) || !in_array(strtolower(trim($searchMode)), ["and", "or"])){
throw new InvalidConfigurationException("search mode can just be \"and\" or \"or\"");
}
$this->searchOptions["mode"] = strtolower(trim($searchMode));
}
if(array_key_exists("score_key", $searchConfig)){
$searchScoreKey = $searchConfig["score_key"];
if((!is_string($searchScoreKey) && !is_null($searchScoreKey))){
throw new InvalidConfigurationException("search score key for search has to be a not empty string or null");
}
$this->searchOptions["scoreKey"] = $searchScoreKey;
}
if(array_key_exists("algorithm", $searchConfig)){
$searchAlgorithm = $searchConfig["algorithm"];
if(!in_array($searchAlgorithm, Query::SEARCH_ALGORITHM, true)){
$searchAlgorithm = implode(', ', $searchAlgorithm);
throw new InvalidConfigurationException("The search algorithm has to be one of the following integer values ($searchAlgorithm)");
}
$this->searchOptions["algorithm"] = $searchAlgorithm;
}
}
if ( array_key_exists("folder_permissions", $configuration) ) {
$folderPermissions = $configuration["folder_permissions"];
if ( !is_int($folderPermissions) ) {
throw new InvalidConfigurationException("folder_permissions has to be an integer (e.g. 0777)");
}
$this->folderPermissions = $folderPermissions;
}
}
/**
* Writes an object in a store.
* @param array $storeData
* @return array
* @throws IOException
* @throws IdNotAllowedException
* @throws JsonException
*/
private function writeNewDocumentToStore(array $storeData): array
{
$primaryKey = $this->getPrimaryKey();
// Check if it has the primary key
if (isset($storeData[$primaryKey])) {
throw new IdNotAllowedException(
"The \"$primaryKey\" index is reserved by SleekDB, please delete the $primaryKey key and try again"
);
}
$id = $this->increaseCounterAndGetNextId();
// Add the system ID with the store data array.
$storeData[$primaryKey] = $id;
// Prepare storable data
$storableJSON = @json_encode($storeData);
if ($storableJSON === false) {
throw new JsonException('Unable to encode the data array,
please provide a valid PHP associative array');
}
// Define the store path
$filePath = $this->getDataPath()."$id.json";
IoHelper::writeContentToFile($filePath, $storableJSON);
return $storeData;
}
/**
* Increments the store wide unique store object ID and returns it.
* @return int
* @throws IOException
* @throws JsonException
*/
private function increaseCounterAndGetNextId(): int
{
$counterPath = $this->getStorePath() . '_cnt.sdb';
if (!file_exists($counterPath)) {
throw new IOException("File $counterPath does not exist.");
}
$dataPath = $this->getDataPath();
return (int) IoHelper::updateFileContent($counterPath, function ($counter) use ($dataPath){
$newCounter = ((int) $counter) + 1;
while(file_exists($dataPath."$newCounter.json") === true){
$newCounter++;
}
return (string)$newCounter;
});
}
/**
* @param string|int $id
* @return int
* @throws InvalidArgumentException
*/
private function checkAndStripId($id): int
{
if(!is_string($id) && !is_int($id)){
throw new InvalidArgumentException("The id of the document has to be an integer or string");
}
if(is_string($id)){
$id = IoHelper::secureStringForFileAccess($id);
}
if(!is_numeric($id)){
throw new InvalidArgumentException("The id of the document has to be numeric");
}
return (int) $id;
}
/**
* @return string
*/
private function getDataPath(): string
{
return $this->getStorePath() . self::dataDirectory;
}
}

vendor/rakibtg/sleekdb/src/Store.php line 748