Abstract Class yii\sphinx\ActiveRecord

Returns the list of all attribute names of the model.

The default implementation will return all column names of the table associated with this AR class.

Returns tokenized and normalized forms of the keywords, and, optionally, keyword statistics.

Builds a snippet from provided data and query, using specified index settings.

Deletes the index entry corresponding to this active record.

This method performs the following steps in order:

1. call beforeDelete(). If the method returns false, it will skip the rest of the steps;
2. delete the record from the index;
3. call afterDelete().

In the above step 1 and 3, events named EVENT_BEFORE_DELETE and EVENT_AFTER_DELETE will be raised by the corresponding methods.

Deletes rows in the index using the provided conditions.

For example, to delete all articles whose status is 3:

Article::deleteAll('status = 3');

Returns a value indicating whether the given active record is the same as the current one.

The comparison is made by comparing the index names and the primary key values of the two active records. If one of the records is new they are also considered not equal.

Builds up the snippet value from the given query.

Creates an yii\db\ActiveQueryInterface instance for query purpose.

The returned yii\db\ActiveQueryInterface instance can be further customized by calling methods defined in yii\db\ActiveQueryInterface before one() or all() is called to return populated ActiveRecord instances. For example,

// find the customer whose ID is 1
$customer = Customer::find()->where(['id' => 1])->one();

// find all active customers and order them by their age:
$customers = Customer::find()
    ->where(['status' => 1])
    ->orderBy('age')
    ->all();

This method is also called by yii\db\BaseActiveRecord::hasOne() and yii\db\BaseActiveRecord::hasMany() to create a relational query.

You may override this method to return a customized query. For example,

class Customer extends ActiveRecord
{
    public static function find()
    {
        // use CustomerQuery instead of the default ActiveQuery
        return new CustomerQuery(get_called_class());
    }
}

The following code shows how to apply a default condition for all queries:

class Customer extends ActiveRecord
{
    public static function find()
    {
        return parent::find()->where(['deleted' => false]);
    }
}

// Use andWhere()/orWhere() to apply the default condition
// SELECT FROM customer WHERE `deleted`=:deleted AND age>30
$customers = Customer::find()->andWhere('age>30')->all();

// Use where() to ignore the default condition
// SELECT FROM customer WHERE age>30
$customers = Customer::find()->where('age>30')->all();

Creates an yii\sphinx\ActiveQuery instance with a given SQL statement.

Note that because the SQL statement is already specified, calling additional query modification methods (such as where(), order()) on the created yii\sphinx\ActiveQuery instance will have no effect. However, calling with(), asArray() or indexBy() is still fine.

Below is an example:

$customers = Article::findBySql("SELECT * FROM `idx_article` WHERE MATCH('development')")->all();

Returns the Sphinx connection used by this AR class.

By default, the "sphinx" application component is used as the Sphinx connection. You may override this method if you want to use a different Sphinx connection.

Returns the schema information of the Sphinx index associated with this AR class.

Returns current snippet value or generates new one from given match.

Returns the string, which should be used as a source to create snippet for this Active Record instance.

Child classes must implement this method to return the actual snippet source text. For example:

public function getSnippetSource()
{
    return $this->snippetSourceRelation->content;
}

Declares the name of the Sphinx index associated with this AR class.

By default this method returns the class name as the index name by calling yii\helpers\Inflector::camel2id(). For example, 'Article' becomes 'article', and 'StockItem' becomes 'stock_item'. You may override this method if the index is not named after this convention.

Inserts a row into the associated Sphinx index using the attribute values of this record.

This method performs the following steps in order:

1. call beforeValidate() when $runValidation is true. If validation fails, it will skip the rest of the steps;
2. call afterValidate() when $runValidation is true.
3. call beforeSave(). If the method returns false, it will skip the rest of the steps;
4. insert the record into index. If this fails, it will skip the rest of the steps;
5. call afterSave();

In the above step 1, 2, 3 and 5, events EVENT_BEFORE_VALIDATE, EVENT_BEFORE_INSERT, EVENT_AFTER_INSERT and EVENT_AFTER_VALIDATE will be raised by the corresponding methods.

Only the changedAttributes will be inserted.

For example, to insert an article record:

$article = new Article();
$article->id = $id;
$article->genre_id = $genreId;
$article->content = $content;
$article->insert();

Returns a value indicating whether the specified operation is transactional in the current $scenario.

Populates an active record object using a row of data from the database/storage.

This is an internal method meant to be called to create active record objects after fetching data from the database. It is mainly used by yii\sphinx\ActiveQuery to populate the query results into active records.

When calling this method manually you should call afterFind() on the created record to trigger the afterFind Event.

Returns the primary key name for this AR class.

The default implementation will return the primary key as declared in the Sphinx index, which is associated with this AR class.

Note that an array should be returned even for a table with single primary key.

Declares which operations should be performed within a transaction in different scenarios.

The supported DB operations are: OP_INSERT, OP_UPDATE and OP_DELETE, which correspond to the insert(), update() and delete() methods, respectively. By default, these methods are NOT enclosed in a transaction.

In some scenarios, to ensure data consistency, you may want to enclose some or all of them in transactions. You can do so by overriding this method and returning the operations that need to be transactional. For example,

return [
    'admin' => self::OP_INSERT,
    'api' => self::OP_INSERT | self::OP_UPDATE | self::OP_DELETE,
    // the above is equivalent to the following:
    // 'api' => self::OP_ALL,

];

The above declaration specifies that in the "admin" scenario, the insert operation (insert()) should be done in a transaction; and in the "api" scenario, all the operations should be done in a transaction.

Saves the changes to this active record into the associated Sphinx index.

This method performs the following steps in order:

1. call beforeValidate() when $runValidation is true. If validation fails, it will skip the rest of the steps;
2. call afterValidate() when $runValidation is true.
3. call beforeSave(). If the method returns false, it will skip the rest of the steps;
4. save the record into index. If this fails, it will skip the rest of the steps;
5. call afterSave();

In the above step 1, 2, 3 and 5, events EVENT_BEFORE_VALIDATE, EVENT_BEFORE_UPDATE, EVENT_AFTER_UPDATE and EVENT_AFTER_VALIDATE will be raised by the corresponding methods.

Only the changedAttributes will be saved into database.

For example, to update an article record:

$article = Article::findOne($id);
$article->genre_id = $genreId;
$article->group_id = $groupId;
$article->update();

Note that it is possible the update does not affect any row in the table. In this case, this method will return 0. For this reason, you should use the following code to check if update() is successful or not:

if ($this->update() !== false) {
    // update successful
} else {
    // update failed
}

Updates the whole table using the provided attribute values and conditions.

For example, to change the status to be 1 for all articles which status is 2:

Article::updateAll(['status' => 1], 'status = 2');

See also CActiveRecord::update().