Class yii\elasticsearch\ActiveRecord

                public function arrayAttributes()
{
    return [];
}

            

                public function attributes()
{
    throw new InvalidConfigException('The attributes() method of Elasticsearch ActiveRecord has to be implemented by child classes.');
}

            

                public function delete($options = [])
{
    if (!$this->beforeDelete()) {
        return false;
    }
    if (isset($options['optimistic_locking']) && $options['optimistic_locking']) {
        if ($this->_version === null) {
            throw new InvalidArgumentException('Unable to use optimistic locking on a record that has no version set. Refer to the docs of ActiveRecord::delete() for details.');
        }
        $options['version'] = $this->_version;
        unset($options['optimistic_locking']);
    }
    try {
        $result = static::getDb()->createCommand()->delete(
            static::index(),
            static::type(),
            $this->getOldPrimaryKey(false),
            $options
        );
    } catch (Exception $e) {
        // HTTP 409 is the response in case of failed optimistic locking
        // https://www.elastic.co/guide/en/elasticsearch/guide/current/optimistic-concurrency-control.html
        if (isset($e->errorInfo['responseCode']) && $e->errorInfo['responseCode'] == 409) {
            throw new StaleObjectException('The object being deleted is outdated.', $e->errorInfo, $e->getCode(), $e);
        }
        throw $e;
    }
    $this->setOldAttributes(null);
    $this->afterDelete();
    if ($result === false) {
        return 0;
    } else {
        return 1;
    }
}

            

                public static function deleteAll($condition = [])
{
    $primaryKeys = static::primaryKeysByCondition($condition);
    if (empty($primaryKeys)) {
        return 0;
    }
    $bulkCommand = static::getDb()->createBulkCommand([
        "index" => static::index(),
        "type" => static::type(),
    ]);
    foreach ($primaryKeys as $pk) {
        $bulkCommand->addDeleteAction($pk);
    }
    $response = $bulkCommand->execute();
    $n = 0;
    $errors = [];
    foreach ($response['items'] as $item) {
        if (isset($item['delete']['status']) && $item['delete']['status'] == 200) {
            if (isset($item['delete']['found']) && $item['delete']['found']) {
                # ES5 uses "found"
                $n++;
            } elseif (isset($item['delete']['result']) && $item['delete']['result'] == "deleted") {
                # ES6 uses "result"
                $n++;
            }
        } else {
            $errors[] = $item['delete'];
        }
    }
    if (!empty($errors) || isset($response['errors']) && $response['errors']) {
        throw new Exception(__METHOD__ . ' failed deleting records.', $errors);
    }
    return $n;
}

            

                public static function find()
{
    return Yii::createObject(ActiveQuery::className(), [get_called_class()]);
}

            

                public static function findAll($condition)
{
    if (!ArrayHelper::isAssociative($condition)) {
        return static::mget(is_array($condition) ? array_values($condition) : [$condition]);
    }
    $condition = static::filterCondition($condition);
    return static::find()->andWhere($condition)->all();
}

            

                public static function findOne($condition)
{
    if (!is_array($condition)) {
        return static::get($condition);
    }
    if (!ArrayHelper::isAssociative($condition)) {
        $records = static::mget(array_values($condition));
        return empty($records) ? null : reset($records);
    }
    $condition = static::filterCondition($condition);
    return static::find()->andWhere($condition)->one();
}

            

                public static function get($primaryKey, $options = [])
{
    if ($primaryKey === null) {
        return null;
    }
    $command = static::getDb()->createCommand();
    $result = $command->get(static::index(), static::type(), $primaryKey, $options);
    if ($result && $result['found']) {
        $model = static::instantiate($result);
        static::populateRecord($model, $result);
        $model->afterFind();
        return $model;
    }
    return null;
}

            

                public static function getDb()
{
    return \Yii::$app->get('elasticsearch');
}

            

                public function getExplanation()
{
    return $this->_explanation;
}

            

                public function getHighlight()
{
    return $this->_highlight;
}

            

                public function getOldPrimaryKey($asArray = false)
{
    $pk = static::primaryKey()[0];
    if ($this->getIsNewRecord()) {
        $id = null;
    } else {
        $id = $this->_id;
    }
    if ($asArray) {
        return [$pk => $id];
    } else {
        return $id;
    }
}

            

                public function getPrimaryKey($asArray = false)
{
    $pk = static::primaryKey()[0];
    if ($asArray) {
        return [$pk => $this->$pk];
    } else {
        return $this->$pk;
    }
}

            

                public function getScore()
{
    return $this->_score;
}

            

                public function get_id()
{
    $pk = static::primaryKey()[0];
    return $this->$pk;
}

            

                public static function index()
{
    return Inflector::pluralize(Inflector::camel2id(StringHelper::basename(get_called_class()), '-'));
}

            

                public function insert($runValidation = true, $attributes = null, $options = [ ])
{
    if ($runValidation && !$this->validate($attributes)) {
        return false;
    }
    if (!$this->beforeSave(true)) {
        return false;
    }
    $values = $this->getDirtyAttributes($attributes);
    if ($this->getPrimaryKey() !== null) {
        $options['op_type'] = isset($options['op_type']) ? $options['op_type'] : 'create';
    }
    $response = static::getDb()->createCommand()->insert(
        static::index(),
        static::type(),
        $values,
        $this->getPrimaryKey(),
        $options
    );
    if ($response === false) {
        return false;
    }
    $pk = static::primaryKey()[0];
    $this->$pk = $response['_id'];
    if ($pk != '_id') {
        $values[$pk] = $response['_id'];
    }
    $this->_version = $response['_version'];
    $this->_score = null;
    $changedAttributes = array_fill_keys(array_keys($values), null);
    $this->setOldAttributes($values);
    $this->afterSave(true, $changedAttributes);
    return true;
}

            

                public static function instantiate($row)
{
    return new static;
}

            

                public function link($name, $model, $extraColumns = [])
{
    $relation = $this->getRelation($name);
    if ($relation->via === null) {
        $this->validateViaRelationLink($model, $relation);
    }
    parent::link($name, $model, $extraColumns);
}

            

                public static function mget(array $primaryKeys, $options = [])
{
    if (empty($primaryKeys)) {
        return [];
    }
    if (count($primaryKeys) === 1) {
        $model = static::get(reset($primaryKeys));
        return $model === null ? [] : [$model];
    }
    $command = static::getDb()->createCommand();
    $result = $command->mget(static::index(), static::type(), $primaryKeys, $options);
    $models = [];
    foreach ($result['docs'] as $doc) {
        if ($doc['found']) {
            $model = static::instantiate($doc);
            static::populateRecord($model, $doc);
            $model->afterFind();
            $models[] = $model;
        }
    }
    return $models;
}

            

                public function optimisticLock()
{
    return null;
}

            

                public static function populateRecord($record, $row)
{
    $attributes = [];
    if (isset($row['_source'])) {
        $attributes = $row['_source'];
    }
    if (isset($row['fields'])) {
        // reset fields in case it is scalar value
        $arrayAttributes = $record->arrayAttributes();
        foreach ($row['fields'] as $key => $value) {
            if (!isset($arrayAttributes[$key]) && count($value) === 1) {
                $row['fields'][$key] = reset($value);
            }
        }
        $attributes = array_merge($attributes, $row['fields']);
    }
    parent::populateRecord($record, $attributes);
    $pk = static::primaryKey()[0];
    $record->_id = $row[$pk];
    $record->_highlight = isset($row['highlight']) ? $row['highlight'] : null;
    $record->_score = isset($row['_score']) ? $row['_score'] : null;
    $record->_version = isset($row['_version']) ? $row['_version'] : null; // TODO version should always be available...
    $record->_explanation = isset($row['_explanation']) ? $row['_explanation'] : null;
}

            

                final public static function primaryKey()
{
    return ['_id'];
}

            

                protected static function primaryKeysByCondition($condition)
{
    $pkName = static::primaryKey()[0];
    if (count($condition) == 1 && isset($condition[$pkName])) {
        $primaryKeys = (array)$condition[$pkName];
    } else {
        //fetch only document metadata (no fields), 1000 documents per shard
        $query = static::find()->where($condition)->asArray()->source(false)->limit(1000);
        $primaryKeys = [];
        foreach ($query->each('1m') as $document) {
            $primaryKeys[] = $document['_id'];
        }
    }
    return $primaryKeys;
}

            

                public function setPrimaryKey($value)
{
    $pk = static::primaryKey()[0];
    $this->$pk = $value;
}

            

                public function set_id($value)
{
    $pk = static::primaryKey()[0];
    if ($this->getIsNewRecord()) {
        $this->$pk = $value;
    } else {
        throw new InvalidCallException('Changing the primaryKey of an already saved record is not allowed.');
    }
}

            

                public static function type()
{
    return Inflector::camel2id(StringHelper::basename(get_called_class()), '-');
}

            

                public function unlinkAll($name, $delete = false)
{
    throw new NotSupportedException('unlinkAll() is not supported by Elasticsearch, use unlink() instead.');
}

            

                public function update($runValidation = true, $attributeNames = null, $options = [])
{
    if ($runValidation && !$this->validate($attributeNames)) {
        return false;
    }
    return $this->updateInternal($attributeNames, $options);
}

            

                public static function updateAll($attributes, $condition = [])
{
    $primaryKeys = static::primaryKeysByCondition($condition);
    if (empty($primaryKeys)) {
        return 0;
    }
    $bulkCommand = static::getDb()->createBulkCommand([
        "index" => static::index(),
        "type" => static::type(),
    ]);
    foreach ($primaryKeys as $pk) {
        $bulkCommand->addAction(["update" => ["_id" => $pk]], ["doc" => $attributes]);
    }
    $response = $bulkCommand->execute();
    $n = 0;
    $errors = [];
    foreach ($response['items'] as $item) {
        if (isset($item['update']['status']) && $item['update']['status'] == 200) {
            $n++;
        } else {
            $errors[] = $item['update'];
        }
    }
    if (!empty($errors) || isset($response['errors']) && $response['errors']) {
        throw new Exception(__METHOD__ . ' failed updating records.', $errors);
    }
    return $n;
}

            

                public static function updateAllCounters($counters, $condition = [])
{
    $primaryKeys = static::primaryKeysByCondition($condition);
    if (empty($primaryKeys) || empty($counters)) {
        return 0;
    }
    $bulkCommand = static::getDb()->createBulkCommand([
        "index" => static::index(),
        "type" => static::type(),
    ]);
    foreach ($primaryKeys as $pk) {
        $script = '';
        foreach ($counters as $counter => $value) {
            $script .= "ctx._source.{$counter} += params.{$counter};\n";
        }
        $bulkCommand->addAction(["update" => ["_id" => $pk]], [
            'script' => [
                'inline' => $script,
                'params' => $counters,
                'lang' => 'painless',
            ],
        ]);
    }
    $response = $bulkCommand->execute();
    $n = 0;
    $errors = [];
    foreach ($response['items'] as $item) {
        if (isset($item['update']['status']) && $item['update']['status'] == 200) {
            $n++;
        } else {
            $errors[] = $item['update'];
        }
    }
    if (!empty($errors) || isset($response['errors']) && $response['errors']) {
        throw new Exception(__METHOD__ . ' failed updating records counters.', $errors);
    }
    return $n;
}

            

                protected function updateInternal($attributes = null, $options = [])
{
    if (!$this->beforeSave(false)) {
        return false;
    }
    $values = $this->getDirtyAttributes($attributes);
    if (empty($values)) {
        $this->afterSave(false, $values);
        return 0;
    }
    if (isset($options['optimistic_locking']) && $options['optimistic_locking']) {
        if ($this->_version === null) {
            throw new InvalidArgumentException('Unable to use optimistic locking on a record that has no version set. Refer to the docs of ActiveRecord::update() for details.');
        }
        $options['version'] = $this->_version;
        unset($options['optimistic_locking']);
    }
    try {
        $result = static::getDb()->createCommand()->update(
            static::index(),
            static::type(),
            $this->getOldPrimaryKey(false),
            $values,
            $options
        );
    } catch (Exception $e) {
        // HTTP 409 is the response in case of failed optimistic locking
        // https://www.elastic.co/guide/en/elasticsearch/guide/current/optimistic-concurrency-control.html
        if (isset($e->errorInfo['responseCode']) && $e->errorInfo['responseCode'] == 409) {
            throw new StaleObjectException('The object being updated is outdated.', $e->errorInfo, $e->getCode(), $e);
        }
        throw $e;
    }
    if (is_array($result) && isset($result['_version'])) {
        $this->_version = $result['_version'];
    }
    $changedAttributes = [];
    foreach ($values as $name => $value) {
        $changedAttributes[$name] = $this->getOldAttribute($name);
        $this->setOldAttribute($name, $value);
    }
    $this->afterSave(false, $changedAttributes);
    if ($result === false) {
        return 0;
    } else {
        return 1;
    }
}

            

                protected function validateViaRelationLink($model, $relation)
{
    $p1 = $model->isPrimaryKey(array_keys($relation->link));
    $p2 = static::isPrimaryKey(array_values($relation->link));
    $atLeastOneExists = !$this->getIsNewRecord() || !$model->getIsNewRecord();
    $foreign = null;
    $link = null;
    if ($p1 && $p2 && $atLeastOneExists) {
        if ($this->getIsNewRecord()) {
            $foreign = $this;
            $link = array_flip($relation->link);
        } else {
            $foreign = $model;
            $link = $relation->link;
        }
    } elseif ($p1) {
        $foreign = $this;
        $link = array_flip($relation->link);
    } elseif ($p2) {
        $foreign = $model;
        $link = $relation->link;
    }
    if ($foreign && $link) {
        foreach ($link as $fk => $pk) {
            if (is_array($foreign->{$fk})) {
                throw new InvalidCallException('Unable to link models: foreign model cannot be linked if its property is an array.');
            }
        }
    }
}