Class yii\sphinx\Connection

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    parent::__clone();
    $this->_master = false;
    $this->_slave = false;
    $this->_schema = null;
    $this->_transaction = null;
    if (strncmp($this->dsn, 'sqlite::memory:', 15) !== 0) {
        // reset PDO connection, unless its sqlite in-memory, which can only have one connection
        $this->pdo = null;
    }
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __sleep()
{
    $fields = (array) $this;
    unset($fields['pdo']);
    unset($fields["\000" . __CLASS__ . "\000" . '_master']);
    unset($fields["\000" . __CLASS__ . "\000" . '_slave']);
    unset($fields["\000" . __CLASS__ . "\000" . '_transaction']);
    unset($fields["\000" . __CLASS__ . "\000" . '_schema']);
    return array_keys($fields);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function beginTransaction($isolationLevel = null)
{
    $this->open();
    if (($transaction = $this->getTransaction()) === null) {
        $transaction = $this->_transaction = new Transaction(['db' => $this]);
    }
    $transaction->begin($isolationLevel);
    return $transaction;
}

            

                public function behaviors()
{
    return [];
}

            

                public function cache(callable $callable, $duration = null, $dependency = null)
{
    $this->_queryCacheInfo[] = [$duration === null ? $this->queryCacheDuration : $duration, $dependency];
    try {
        $result = call_user_func($callable, $this);
        array_pop($this->_queryCacheInfo);
        return $result;
    } catch (\Exception $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    } catch (\Throwable $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    }
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function close()
{
    if ($this->_master) {
        if ($this->pdo === $this->_master->pdo) {
            $this->pdo = null;
        }
        $this->_master->close();
        $this->_master = false;
    }
    if ($this->pdo !== null) {
        Yii::debug('Closing DB connection: ' . $this->dsn, __METHOD__);
        $this->pdo = null;
    }
    if ($this->_slave) {
        $this->_slave->close();
        $this->_slave = false;
    }
    $this->_schema = null;
    $this->_transaction = null;
    $this->_driverName = null;
    $this->_queryCacheInfo = [];
    $this->_quotedTableNames = null;
    $this->_quotedColumnNames = null;
}

            

                protected function createPdoInstance()
{
    $pdoClass = $this->pdoClass;
    if ($pdoClass === null) {
        $driver = null;
        if ($this->_driverName !== null) {
            $driver = $this->_driverName;
        } elseif (($pos = strpos($this->dsn, ':')) !== false) {
            $driver = strtolower(substr($this->dsn, 0, $pos));
        }
        switch ($driver) {
            case 'mssql':
                $pdoClass = 'yii\db\mssql\PDO';
                break;
            case 'dblib':
                $pdoClass = 'yii\db\mssql\DBLibPDO';
                break;
            case 'sqlsrv':
                $pdoClass = 'yii\db\mssql\SqlsrvPDO';
                break;
            default:
                $pdoClass = 'PDO';
        }
    }
    $dsn = $this->dsn;
    if (strncmp('sqlite:@', $dsn, 8) === 0) {
        $dsn = 'sqlite:' . Yii::getAlias(substr($dsn, 7));
    }
    return new $pdoClass($dsn, $this->username, $this->password, $this->attributes);
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getDriverName()
{
    if ($this->_driverName === null) {
        if (($pos = strpos((string)$this->dsn, ':')) !== false) {
            $this->_driverName = strtolower(substr($this->dsn, 0, $pos));
        } else {
            $this->_driverName = strtolower($this->getSlavePdo(true)->getAttribute(PDO::ATTR_DRIVER_NAME));
        }
    }
    return $this->_driverName;
}

            

                public function getIsActive()
{
    return $this->pdo !== null;
}

            

                public function getMaster()
{
    if ($this->_master === false) {
        $this->_master = $this->shuffleMasters
            ? $this->openFromPool($this->masters, $this->masterConfig)
            : $this->openFromPoolSequentially($this->masters, $this->masterConfig);
    }
    return $this->_master;
}

            

                public function getMasterPdo()
{
    $this->open();
    return $this->pdo;
}

            

                public function getServerVersion()
{
    return $this->getSchema()->getServerVersion();
}

            

                public function getSlave($fallbackToMaster = true)
{
    if (!$this->enableSlaves) {
        return $fallbackToMaster ? $this : null;
    }
    if ($this->_slave === false) {
        $this->_slave = $this->openFromPool($this->slaves, $this->slaveConfig);
    }
    return $this->_slave === null && $fallbackToMaster ? $this : $this->_slave;
}

            

                public function getSlavePdo($fallbackToMaster = true)
{
    $db = $this->getSlave(false);
    if ($db === null) {
        return $fallbackToMaster ? $this->getMasterPdo() : null;
    }
    return $db->pdo;
}

            

                public function getTableSchema($name, $refresh = false)
{
    return $this->getSchema()->getTableSchema($name, $refresh);
}

            

                public function getTransaction()
{
    return $this->_transaction && $this->_transaction->getIsActive() ? $this->_transaction : null;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
}

            

                protected function initConnection()
{
    $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    if ($this->emulatePrepare !== null && constant('PDO::ATTR_EMULATE_PREPARES')) {
        if ($this->driverName !== 'sqlsrv') {
            $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, $this->emulatePrepare);
        }
    }
    if (PHP_VERSION_ID >= 80100 && $this->getDriverName() === 'sqlite') {
        $this->pdo->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
    }
    if (!$this->isSybase && in_array($this->getDriverName(), ['mssql', 'dblib'], true)) {
        $this->pdo->exec('SET ANSI_NULL_DFLT_ON ON');
    }
    if ($this->charset !== null && in_array($this->getDriverName(), ['pgsql', 'mysql', 'mysqli', 'cubrid'], true)) {
        $this->pdo->exec('SET NAMES ' . $this->pdo->quote($this->charset));
    }
    $this->trigger(self::EVENT_AFTER_OPEN);
}

            

                public function noCache(callable $callable)
{
    $this->_queryCacheInfo[] = false;
    try {
        $result = call_user_func($callable, $this);
        array_pop($this->_queryCacheInfo);
        return $result;
    } catch (\Exception $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    } catch (\Throwable $e) {
        array_pop($this->_queryCacheInfo);
        throw $e;
    }
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function open()
{
    if ($this->pdo !== null) {
        return;
    }
    if (!empty($this->masters)) {
        $db = $this->getMaster();
        if ($db !== null) {
            $this->pdo = $db->pdo;
            return;
        }
        throw new InvalidConfigException('None of the master DB servers is available.');
    }
    if (empty($this->dsn)) {
        throw new InvalidConfigException('Connection::dsn cannot be empty.');
    }
    $token = 'Opening DB connection: ' . $this->dsn;
    $enableProfiling = $this->enableProfiling;
    try {
        if ($this->enableLogging) {
            Yii::info($token, __METHOD__);
        }
        if ($enableProfiling) {
            Yii::beginProfile($token, __METHOD__);
        }
        $this->pdo = $this->createPdoInstance();
        $this->initConnection();
        if ($enableProfiling) {
            Yii::endProfile($token, __METHOD__);
        }
    } catch (\PDOException $e) {
        if ($enableProfiling) {
            Yii::endProfile($token, __METHOD__);
        }
        throw new Exception($e->getMessage(), $e->errorInfo, $e->getCode(), $e);
    }
}

            

                protected function openFromPool(array $pool, array $sharedConfig)
{
    shuffle($pool);
    return $this->openFromPoolSequentially($pool, $sharedConfig);
}

            

                protected function openFromPoolSequentially(array $pool, array $sharedConfig)
{
    if (empty($pool)) {
        return null;
    }
    if (!isset($sharedConfig['class'])) {
        $sharedConfig['class'] = get_class($this);
    }
    $cache = is_string($this->serverStatusCache) ? Yii::$app->get($this->serverStatusCache, false) : $this->serverStatusCache;
    foreach ($pool as $i => $config) {
        $pool[$i] = $config = array_merge($sharedConfig, $config);
        if (empty($config['dsn'])) {
            throw new InvalidConfigException('The "dsn" option must be specified.');
        }
        $key = [__METHOD__, $config['dsn']];
        if ($cache instanceof CacheInterface && $cache->get($key)) {
            // should not try this dead server now
            continue;
        }
        /* @var $db Connection */
        $db = Yii::createObject($config);
        try {
            $db->open();
            return $db;
        } catch (\Exception $e) {
            Yii::warning("Connection ({$config['dsn']}) failed: " . $e->getMessage(), __METHOD__);
            if ($cache instanceof CacheInterface) {
                // mark this server as dead and only retry it after the specified interval
                $cache->set($key, 1, $this->serverRetryInterval);
            }
            // exclude server from retry below
            unset($pool[$i]);
        }
    }
    if ($cache instanceof CacheInterface) {
        // if server status cache is enabled and no server is available
        // ignore the cache and try to connect anyway
        // $pool now only contains servers we did not already try in the loop above
        foreach ($pool as $config) {
            /* @var $db Connection */
            $db = Yii::createObject($config);
            try {
                $db->open();
            } catch (\Exception $e) {
                Yii::warning("Connection ({$config['dsn']}) failed: " . $e->getMessage(), __METHOD__);
                continue;
            }
            // mark this server as available again after successful connection
            $cache->delete([__METHOD__, $config['dsn']]);
            return $db;
        }
    }
    return null;
}

            

                public function quoteColumnName($name)
{
    if (isset($this->_quotedColumnNames[$name])) {
        return $this->_quotedColumnNames[$name];
    }
    return $this->_quotedColumnNames[$name] = $this->getSchema()->quoteColumnName($name);
}

            

                public function quoteSql($sql)
{
    return preg_replace_callback(
        '/(\\{\\{(%?[\w\-\. ]+%?)\\}\\}|\\[\\[([\w\-\. ]+)\\]\\])/',
        function ($matches) {
            if (isset($matches[3])) {
                return $this->quoteColumnName($matches[3]);
            }
            return str_replace('%', $this->tablePrefix, $this->quoteTableName($matches[2]));
        },
        $sql
    );
}

            

                public function quoteValue($value)
{
    return $this->getSchema()->quoteValue($value);
}

            

                public function setDriverName($driverName)
{
    $this->_driverName = strtolower($driverName);
}

            

                public function setQueryBuilder($value)
{
    Yii::configure($this->getQueryBuilder(), $value);
    $this->_queryBuilderConfigurations[] = $value;
}

            

                public function transaction(callable $callback, $isolationLevel = null)
{
    $transaction = $this->beginTransaction($isolationLevel);
    $level = $transaction->level;
    try {
        $result = call_user_func($callback, $this);
        if ($transaction->isActive && $transaction->level === $level) {
            $transaction->commit();
        }
    } catch (\Exception $e) {
        $this->rollbackTransactionOnLevel($transaction, $level);
        throw $e;
    } catch (\Throwable $e) {
        $this->rollbackTransactionOnLevel($transaction, $level);
        throw $e;
    }
    return $result;
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            

                public function useMaster(callable $callback)
{
    if ($this->enableSlaves) {
        $this->enableSlaves = false;
        try {
            $result = call_user_func($callback, $this);
        } catch (\Exception $e) {
            $this->enableSlaves = true;
            throw $e;
        } catch (\Throwable $e) {
            $this->enableSlaves = true;
            throw $e;
        }
        // TODO: use "finally" keyword when miminum required PHP version is >= 5.5
        $this->enableSlaves = true;
    } else {
        $result = call_user_func($callback, $this);
    }
    return $result;
}