EMongoClient.php

<?php

use MongoDB\Client;

/**
 * EMongoClient
 *
 * The MongoDB and MongoClient class combined.
 *
 * Quite deceptively the magic functions of this class actually represent the DATABASE not the connection.
 * This is in contrast to MongoClient whos' own represent the SERVER.
 *
 * Normally this would represent the MongoClient or Mongo and it is even named after them and implements
 * some of their functions but it is not due to the way Yii works.
 */
class EMongoClient extends CApplicationComponent
{

    /**
     * The server string (connection string pre-1.3)
     * @var string
     */
    public $server;

    /**
     * Additional options for the connection constructor
     * @var array
     */
    public $options = [];

    /**
     * The name of the database
     * @var string
     */
    public $db;

    /**
     * Write Concern, will default to acked writes
     * @see http://php.net/manual/en/mongo.writeconcerns.php
     * @var int string
     */
    public $w = 1;

    /**
     * Are we using journaled writes here? Beware this makes all writes wait for the journal, it does not
     * state whether MongoDB is using journaling.
     * Note: this is NOT straight to disk,
     * it infact makes the journal to disk time a third of its normal time (anywhere between 2-30ms).
     * Only works 1.3+ driver
     * @var boolean
     */
    public $j = false;

//    /**
//     * The read preference
//     * The first param is the textual version of the constant name in the MongoClient for the type of read
//     * i.e.
//     * RP_PRIMARY and the second emulates the setReadPreference prototypes second parameter
//     * @see http://php.net/manual/en/mongo.readpreferences.php
//     * @var array()
//     */
//    public $RP = array('RP_PRIMARY', array());

//    /**
//     * The Legacy read preference.
//     * DO NOT USE IF YOU ARE ON VERSION 1.3+
//     * @var boolean
//     */
//    public $setSlaveOkay = false;

    /**
     * Allows one to connect when they want to when turned to false
     * Note that if you try and access MongoDB before it is connected it
     * will attempt to connect
     * @var boolean
     */
    public $autoConnect = true;

    /**
     * Enables logging to the profiler
     * @var boolean
     */
    public $enableProfiling = false;

    /**
     * @var integer number of seconds that query results can remain valid in cache.
     * Use 0 or negative value to indicate not caching query results (the default behavior).
     *
     * In order to enable query caching, this property must be a positive
     * integer and {@link queryCacheID} must point to a valid cache component ID.
     *
     * The method {@link cache()} is provided as a convenient way of setting this property
     * and {@link queryCachingDependency} on the fly.
     *
     * @see cache
     * @see queryCachingDependency
     * @see queryCacheID
     */
    public $queryCachingDuration = 0;

    /**
     * @var CCacheDependency|ICacheDependency the dependency that will be used when saving query results into cache.
     * @see queryCachingDuration
     */
    public $queryCachingDependency;

    /**
     * @var integer the number of SQL statements that need to be cached next.
     * If this is 0, then even if query caching is enabled, no query will be cached.
     * Note that each time after executing a SQL statement (whether executed on DB server or fetched from
     * query cache), this property will be reduced by 1 until 0.
     */
    public $queryCachingCount = 0;

    /**
     * @var string the ID of the cache application component that is used for query caching.
     * Defaults to 'cache' which refers to the primary cache application component.
     * Set this property to false if you want to disable query caching.
     */
    public $queryCacheID = 'cache';

    /**
     * The Mongo Connection instance
     * @var Mongo MongoClient
     */
    private $_mongo;

    /**
     * The database instance
     * @var MongoDB
     */
    private $_db;

    /**
     * Caches reflection properties for our objects so we don't have
     * to keep getting them
     * @var array
     */
    private $_meta = [];

    /**
     * The default action is to find a getX whereby X is the $k param
     * you input.
     * The secondary function, if not getter found, is to get a collection
     */
    public function __get($k)
    {
        $getter = 'get' . $k;
        if (method_exists($this, $getter)) {
            return $this->$getter();
        }
        return $this->selectCollection($k);
    }

    /**
     * Will call a function on the database or error out stating that the function does not exist
     * @param string $name
     * @param array $parameters
     * @return mixed
     */
    public function __call($name, $parameters = [])
    {
        if (!method_exists($this->getDB(), $name)) {
            return parent::__call($name, $parameters);
        }
        return call_user_func_array([$this->getDB(), $name], $parameters);
    }

    public function __construct()
    {
        // We copy this function to add the subdocument validator as a built in validator
        CValidator::$builtInValidators['subdocument'] = 'ESubdocumentValidator';
    }

    /**
     * The init function
     * We also connect here
     * @see yii/framework/base/CApplicationComponent::init()
     */
    public function init()
    {
        parent::init();

        if ($this->db) {
            $this->options['db'] = $this->db;
        }

        if ($this->autoConnect) {
            $this->connect();
        }
    }

    /**
     * Connects to our database
     */
    public function connect()
    {
        if (!extension_loaded('mongodb')) {
            throw new EMongoException(
            yii::t(
            'yii', 'We could not find the MongoDB extension ( https://github.com/mongodb/mongo-php-driver ), please install it'
            )
            );
        }

        // We don't need to throw useless exceptions here, the MongoDB PHP Driver has its own checks and error reporting
        // Yii will easily and effortlessly display the errors from the PHP driver, we should only catch its exceptions if
        // we wanna add our own custom messages on top which we don't, the errors are quite self explanatory
        $this->_mongo = new Client($this->server, $this->options);

//        if ($this->setSlaveOkay) {
//            $this->_mongo->setSlaveOkay($this->setSlaveOkay);
//        }
    }

    /**
     * Gets the connection object
     * Use this to access the Mongo/MongoClient instance within the extension
     * @return Mongo MongoClient
     */
    public function getConnection()
    {
        if (empty($this->_mongo)) {
            $this->connect();
        }
        return $this->_mongo;
    }

    /**
     * Sets the raw database adhoc
     * @param string $name
     */
    public function setDB($name)
    {
        $this->_db = $this->getConnection()->selectDatabase($name);
    }

    /**
     * Selects a different database
     * @param $name
     * @return MongoDB
     */
    public function selectDB($name)
    {
        $this->setDB($name);
        return $this->getDB();
    }

    /**
     * Gets the raw Database
     * @return MongoDB
     */
    public function getDB()
    {
        if (empty($this->_db)) {
            $this->setDB($this->db);
        }
        return $this->_db;
    }

    /**
     * This function is designed to be a helper to make calling the aggregate command
     * more standard across all drivers.
     * 
     * @param string $collection        	
     * @param [] $pipelines
     * @return array
     */
    public function aggregate($collection, $pipelines)
    {
        return iterator_to_array($this->getDB()->$collection->aggregate($pipelines));
    }

    /**
     * Command helper
     * @param array|string $command
     * @return array
     */
    public function command($command = [])
    {
        return $this->getDB()->command($command);
    }

    /**
     * A wrapper for the original processing
     * @param string $name
     * @return MongoDB\Collection
     */
    public function selectCollection($name)
    {
        return $this->getDB()->selectCollection($name);
    }

    /**
     * Sets the document cache for any particular document (EMongoDocument/EMongoModel)
     * sent in as the first parameter of this function.
     * Will not cache actual EMongoDocument/EMongoModel instances
     * only active classes that inherit these
     * @param $o
     */
    public function setDocumentCache($o)
    {
        if (
        $this->getDocumentCache(get_class($o)) === [] && // Run reflection and cache it if not already there
        (get_class($o) != 'EMongoDocument' && get_class($o) != 'EMongoModel') /* We can't cache the model */
        ) {
            $_meta = [];

            $reflect = new ReflectionClass(get_class($o));
            $class_vars = $reflect->getProperties(ReflectionProperty::IS_PUBLIC); // Pre-defined doc attributes

            foreach ($class_vars as $prop) {

                if ($prop->isStatic()) {
                    continue;
                }

                $docBlock = $prop->getDocComment();
                $field_meta = [
                    'name' => $prop->getName(),
                    'virtual' => $prop->isProtected() || preg_match('/@virtual/i', $docBlock) <= 0 ? false : true
                ];

                // Lets fetch the data type for this field
                // Since we always fetch the data type for this field we make a regex that will only pick out the first
                if (preg_match('/@var ([a-zA-Z]+)/', $docBlock, $matches) > 0) {
                    $field_meta['type'] = $matches[1];
                }
                $_meta[$prop->getName()] = $field_meta;
            }
            $this->_meta[get_class($o)] = $_meta;
        }
    }

    /**
     * Get a list of the fields (attributes) for a document from cache
     * @param string $name
     * @param boolean $include_virtual
     * @return array
     */
    public function getFieldCache($name, $include_virtual = false)
    {
        $doc = isset($this->_meta[$name]) ? $this->_meta[$name] : [];
        $fields = [];

        foreach ($doc as $name => $opts) {
            if ($include_virtual || !$opts['virtual']) {
                $fields[] = $name;
            }
        }
        return $fields;
    }

    /**
     * Just gets the document cache for a model
     * @param string $name
     * @return array
     */
    public function getDocumentCache($name)
    {
        return isset($this->_meta[$name]) ? $this->_meta[$name] : [];
    }

    /**
     * Gets the default write concern options for all queries through active record
     * @return array
     */
    public function getDefaultWriteConcern()
    {
        if ($this->w == 1) {
            return ['safe' => true];
        } elseif ($this->w > 0) {
            return ['safe' => $this->w];
        }
        return [];
    }

    /**
     * Set read preference on MongoClient
     * @param string $pref
     * @param array $options
     * @return bool
     */
    public function setReadPreference($pref, $options = [])
    {
        return $this->getConnection()->setReadPreference($pref, $options);
    }

//    /**
//     * setSlaveOkay on Mongo
//     * @param bool $bool
//     * @return bool
//     */
//    public function setSlaveOkay($bool)
//    {
//        return $this->getConnection()->setSlaveOkay($bool);
//    }

    /**
     * Sets the parameters for query caching.
     * This method can be used to enable or disable query caching.
     * By setting the $duration parameter to be 0, the query caching will be disabled.
     * Otherwise, query results of the new SQL statements executed next will be saved in cache
     * and remain valid for the specified duration.
     * If the same query is executed again, the result may be fetched from cache directly
     * without actually executing the SQL statement.
     * 
     * @param integer $duration
     *        	the number of seconds that query results may remain valid in cache.
     *        	If this is 0, the caching will be disabled.
     * @param CCacheDependency|ICacheDependency $dependency
     *        	the dependency that will be used when saving
     *        	the query results into cache.
     * @param integer $queryCount
     *        	number of SQL queries that need to be cached after calling this method. Defaults to 1,
     *        	meaning that the next SQL query will be cached.
     * @return static the connection instance itself.
     * @since 1.1.7
     */
    public function cache($duration, $dependency = null, $queryCount = 1)
    {
        $this->queryCachingDuration = $duration;
        $this->queryCachingDependency = $dependency;
        $this->queryCachingCount = $queryCount;
        return $this;
    }

    public function getSerialisedQuery($criteria = [], $fields = [], $sort = [], $skip = 0, $limit = null)
    {
        $query = [
            '$query' => $criteria,
            '$fields' => $fields,
            '$sort' => $sort,
            '$skip' => $skip,
            '$limit' => $limit
        ];
        return json_encode($query);
    }

    /**
     *
     * @return array the first element indicates the number of query statements executed,
     *         and the second element the total time spent in query execution.
     */
    public function getStats()
    {
        $logger = Yii::getLogger();
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.findOne');
        $count = count($timings);
        $time = array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.insert');
        $count += count($timings);
        $time += array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.find');
        $count += count($timings);
        $time += array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.deleteByPk');
        $count += count($timings);
        $time += array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.updateByPk');
        $count += count($timings);
        $time += array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.updateAll');
        $count += count($timings);
        $time += array_sum($timings);
        $timings = $logger->getProfilingResults(null, 'extensions.MongoYii.EMongoDocument.deleteAll');
        $count += count($timings);
        $time += array_sum($timings);

        return [$count, $time];
    }

}