Merge pull request #1295 from yiisoft/elasticsearch

.gitignore

@@ -13,13 +13,15 @@ nbproject
 Thumbs.db
 
 # composer vendor dir
-/yii/vendor
+/vendor
 
 # composer itself is not needed
 composer.phar
+# composer.lock should not be committed as we always want the latest versions
+/composer.lock
 
 # Mac DS_Store Files
 .DS_Store
 
 # local phpunit config
-/phpunit.xml
\ No newline at end of file
+/phpunit.xml

.travis.yml

@@ -7,12 +7,14 @@ php:
 services:
   - redis-server
   - memcached
+  - elasticsearch
 
 before_script:
   - composer self-update && composer --version
   - composer require satooshi/php-coveralls 0.6.* --dev --prefer-dist
   - mysql -e 'CREATE DATABASE yiitest;';
   - psql -U postgres -c 'CREATE DATABASE yiitest;';
+  - echo 'elasticsearch version ' && curl http://localhost:9200/
   - tests/unit/data/travis/apc-setup.sh
   - tests/unit/data/travis/memcache-setup.sh
   - tests/unit/data/travis/cubrid-setup.sh

extensions/elasticsearch/ActiveQuery.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yii\elasticsearch;
+
+use yii\db\ActiveQueryInterface;
+use yii\db\ActiveQueryTrait;
+
+/**
+ * ActiveQuery represents a [[Query]] associated with an [[ActiveRecord]] class.
+ *
+ * ActiveQuery instances are usually created by [[ActiveRecord::find()]].
+ *
+ * ActiveQuery mainly provides the following methods to retrieve the query results:
+ *
+ * - [[one()]]: returns a single record populated with the first row of data.
+ * - [[all()]]: returns all records based on the query results.
+ * - [[count()]]: returns the number of records.
+ * - [[scalar()]]: returns the value of the first column in the first row of the query result.
+ * - [[column()]]: returns the value of the first column in the query result.
+ * - [[exists()]]: returns a value indicating whether the query result has data or not.
+ *
+ * Because ActiveQuery extends from [[Query]], one can use query methods, such as [[where()]],
+ * [[orderBy()]] to customize the query options.
+ *
+ * ActiveQuery also provides the following additional query options:
+ *
+ * - [[with()]]: list of relations that this query should be performed with.
+ * - [[indexBy()]]: the name of the column by which the query result should be indexed.
+ * - [[asArray()]]: whether to return each record as an array.
+ *
+ * These options can be configured using methods of the same name. For example:
+ *
+ * ~~~
+ * $customers = Customer::find()->with('orders')->asArray()->all();
+ * ~~~
+ *
+ * @author Carsten Brandt <mail@cebe.cc>
+ * @since 2.0
+ */
+class ActiveQuery extends Query implements ActiveQueryInterface
+{
+	use ActiveQueryTrait;
+
+	/**
+	 * Creates a DB command that can be used to execute this query.
+	 * @param Connection $db the DB connection used to create the DB command.
+	 * If null, the DB connection returned by [[modelClass]] will be used.
+	 * @return Command the created DB command instance.
+	 */
+	public function createCommand($db = null)
+	{
+		/** @var ActiveRecord $modelClass */
+		$modelClass = $this->modelClass;
+		if ($db === null) {
+			$db = $modelClass::getDb();
+		}
+
+		if ($this->type === null) {
+			$this->type = $modelClass::type();
+		}
+		if ($this->index === null) {
+			$this->index = $modelClass::index();
+			$this->type = $modelClass::type();
+		}
+		$commandConfig = $db->getQueryBuilder()->build($this);
+		return $db->createCommand($commandConfig);
+	}
+
+	/**
+	 * Executes query and returns all results as an array.
+	 * @param Connection $db the DB connection used to create the DB command.
+	 * If null, the DB connection returned by [[modelClass]] will be used.
+	 * @return array the query results. If the query results in nothing, an empty array will be returned.
+	 */
+	public function all($db = null)
+	{
+		$result = $this->createCommand($db)->search();
+		if (empty($result['hits']['hits'])) {
+			return [];
+		}
+		if ($this->fields !== null) {
+			foreach ($result['hits']['hits'] as &$row) {
+				$row['_source'] = isset($row['fields']) ? $row['fields'] : [];
+				unset($row['fields']);
+			}
+			unset($row);
+		}
+		if ($this->asArray && $this->indexBy) {
+			foreach ($result['hits']['hits'] as &$row) {
+				$row['_source'][ActiveRecord::PRIMARY_KEY_NAME] = $row['_id'];
+				$row = $row['_source'];
+			}
+		}
+		$models = $this->createModels($result['hits']['hits']);
+		if ($this->asArray && !$this->indexBy) {
+			foreach($models as $key => $model) {
+				$model['_source'][ActiveRecord::PRIMARY_KEY_NAME] = $model['_id'];
+				$models[$key] = $model['_source'];
+			}
+		}
+		if (!empty($this->with)) {
+			$this->findWith($this->with, $models);
+		}
+		return $models;
+	}
+
+	/**
+	 * Executes query and returns a single row of result.
+	 * @param Connection $db the DB connection used to create the DB command.
+	 * If null, the DB connection returned by [[modelClass]] will be used.
+	 * @return ActiveRecord|array|null a single row of query result. Depending on the setting of [[asArray]],
+	 * the query result may be either an array or an ActiveRecord object. Null will be returned
+	 * if the query results in nothing.
+	 */
+	public function one($db = null)
+	{
+		if (($result = parent::one($db)) === false) {
+			return null;
+		}
+		if ($this->asArray) {
+			$model = $result['_source'];
+			$model[ActiveRecord::PRIMARY_KEY_NAME] = $result['_id'];
+		} else {
+			/** @var ActiveRecord $class */
+			$class = $this->modelClass;
+			$model = $class::create($result);
+		}
+		if (!empty($this->with)) {
+			$models = [$model];
+			$this->findWith($this->with, $models);
+			$model = $models[0];
+		}
+		return $model;
+	}
+
+	/**
+	 * @inheritDocs
+	 */
+	public function search($db = null, $options = [])
+	{
+		$result = $this->createCommand($db)->search($options);
+		if (!empty($result['hits']['hits'])) {
+			$models = $this->createModels($result['hits']['hits']);
+			if ($this->asArray) {
+				foreach($models as $key => $model) {
+					$model['_source'][ActiveRecord::PRIMARY_KEY_NAME] = $model['_id'];
+					$models[$key] = $model['_source'];
+				}
+			}
+			if (!empty($this->with)) {
+				$this->findWith($this->with, $models);
+			}
+			$result['hits']['hits'] = $models;
+		}
+		return $result;
+	}
+
+	/**
+	 * @inheritDocs
+	 */
+	public function scalar($field, $db = null)
+	{
+		$record = parent::one($db);
+		if ($record !== false) {
+			if ($field == ActiveRecord::PRIMARY_KEY_NAME) {
+				return $record['_id'];
+			} elseif (isset($record['_source'][$field])) {
+				return $record['_source'][$field];
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * @inheritDocs
+	 */
+	public function column($field, $db = null)
+	{
+		if ($field == ActiveRecord::PRIMARY_KEY_NAME) {
+			$command = $this->createCommand($db);
+			$command->queryParts['fields'] = [];
+			$result = $command->search();
+			if (empty($result['hits']['hits'])) {
+				return [];
+			}
+			$column = [];
+			foreach ($result['hits']['hits'] as $row) {
+				$column[] = $row['_id'];
+			}
+			return $column;
+		}
+		return parent::column($field, $db);
+	}
+}

extensions/elasticsearch/ActiveRelation.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yii\elasticsearch;
+
+use yii\db\ActiveRelationInterface;
+use yii\db\ActiveRelationTrait;
+
+/**
+ * ActiveRelation represents a relation between two Active Record classes.
+ *
+ * ActiveRelation instances are usually created by calling [[ActiveRecord::hasOne()]] and
+ * [[ActiveRecord::hasMany()]]. An Active Record class declares a relation by defining
+ * a getter method which calls one of the above methods and returns the created ActiveRelation object.
+ *
+ * A relation is specified by [[link]] which represents the association between columns
+ * of different tables; and the multiplicity of the relation is indicated by [[multiple]].
+ *
+ * If a relation involves a pivot table, it may be specified by [[via()]] method.
+ *
+ * @author Carsten Brandt <mail@cebe.cc>
+ * @since 2.0
+ */
+class ActiveRelation extends ActiveQuery implements ActiveRelationInterface
+{
+	use ActiveRelationTrait;
+
+	/**
+	 * Creates a DB command that can be used to execute this query.
+	 * @param Connection $db the DB connection used to create the DB command.
+	 * If null, the DB connection returned by [[modelClass]] will be used.
+	 * @return Command the created DB command instance.
+	 */
+	public function createCommand($db = null)
+	{
+		if ($this->primaryModel !== null) {
+			// lazy loading
+			if (is_array($this->via)) {
+				// via relation
+				/** @var ActiveRelation $viaQuery */
+				list($viaName, $viaQuery) = $this->via;
+				if ($viaQuery->multiple) {
+					$viaModels = $viaQuery->all();
+					$this->primaryModel->populateRelation($viaName, $viaModels);
+				} else {
+					$model = $viaQuery->one();
+					$this->primaryModel->populateRelation($viaName, $model);
+					$viaModels = $model === null ? [] : [$model];
+				}
+				$this->filterByModels($viaModels);
+			} else {
+				$this->filterByModels([$this->primaryModel]);
+			}
+		}
+		return parent::createCommand($db);
+	}
+}

extensions/elasticsearch/Connection.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yii\elasticsearch;
+
+use Yii;
+use yii\base\Component;
+use yii\base\InvalidConfigException;
+use yii\helpers\Json;
+
+/**
+ * elasticsearch Connection is used to connect to an elasticsearch cluster version 0.20 or higher
+ *
+ * @author Carsten Brandt <mail@cebe.cc>
+ * @since 2.0
+ */
+class Connection extends Component
+{
+	/**
+	 * @event Event an event that is triggered after a DB connection is established
+	 */
+	const EVENT_AFTER_OPEN = 'afterOpen';
+
+	/**
+	 * @var bool whether to autodetect available cluster nodes on [[open()]]
+	 */
+	public $autodetectCluster = true;
+	/**
+	 * @var array cluster nodes
+	 * This is populated with the result of a cluster nodes request when [[autodetectCluster]] is true.
+	 * @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/cluster-nodes-info.html#cluster-nodes-info
+	 */
+	public $nodes = [
+		['http_address' => 'inet[/127.0.0.1:9200]'],
+	];
+	/**
+	 * @var array the active node. key of [[nodes]]. Will be randomly selected on [[open()]].
+	 */
+	public $activeNode;
+
+	// TODO http://www.elasticsearch.org/guide/en/elasticsearch/client/php-api/current/_configuration.html#_example_configuring_http_basic_auth
+	public $auth = [];
+	/**
+	 * @var float timeout to use for connecting to an elasticsearch node.
+	 * This value will be used to configure the curl `CURLOPT_CONNECTTIMEOUT` option.
+	 * If not set, no explicit timeout will be set for curl.
+	 */
+	public $connectionTimeout = null;
+	/**
+	 * @var float timeout to use when reading the response from an elasticsearch node.
+	 * This value will be used to configure the curl `CURLOPT_TIMEOUT` option.
+	 * If not set, no explicit timeout will be set for curl.
+	 */
+	public $dataTimeout = null;
+
+
+	public function init()
+	{
+		foreach($this->nodes as $node) {
+			if (!isset($node['http_address'])) {
+				throw new InvalidConfigException('Elasticsearch node needs at least a http_address configured.');
+			}
+		}
+	}
+
+	/**
+	 * Closes the connection when this component is being serialized.
+	 * @return array
+	 */
+	public function __sleep()
+	{
+		$this->close();
+		return array_keys(get_object_vars($this));
+	}
+
+	/**
+	 * Returns a value indicating whether the DB connection is established.
+	 * @return boolean whether the DB connection is established
+	 */
+	public function getIsActive()
+	{
+		return $this->activeNode !== null;
+	}
+
+	/**
+	 * Establishes a DB connection.
+	 * It does nothing if a DB connection has already been established.
+	 * @throws Exception if connection fails
+	 */
+	public function open()
+	{
+		if ($this->activeNode !== null) {
+			return;
+		}
+		if (empty($this->nodes)) {
+			throw new InvalidConfigException('elasticsearch needs at least one node to operate.');
+		}
+		if ($this->autodetectCluster) {
+			$node = reset($this->nodes);
+			$host = $node['http_address'];
+			if (strncmp($host, 'inet[/', 6) == 0) {
+				$host = substr($host, 6, -1);
+			}
+			$response = $this->httpRequest('GET', 'http://' . $host . '/_cluster/nodes');
+			$this->nodes = $response['nodes'];
+			if (empty($this->nodes)) {
+				throw new Exception('cluster autodetection did not find any active node.');
+			}
+		}
+		$this->selectActiveNode();
+		Yii::trace('Opening connection to elasticsearch. Nodes in cluster: ' . count($this->nodes)
+			. ', active node: ' . $this->nodes[$this->activeNode]['http_address'], __CLASS__);
+		$this->initConnection();
+	}
+
+	/**
+	 * select active node randomly
+	 */
+	protected function selectActiveNode()
+	{
+		$keys = array_keys($this->nodes);
+		$this->activeNode = $keys[rand(0, count($keys) - 1)];
+	}
+
+	/**
+	 * Closes the currently active DB connection.
+	 * It does nothing if the connection is already closed.
+	 */
+	public function close()
+	{
+		Yii::trace('Closing connection to elasticsearch. Active node was: '
+			. $this->nodes[$this->activeNode]['http_address'], __CLASS__);
+		$this->activeNode = null;
+	}
+
+	/**
+	 * Initializes the DB connection.
+	 * This method is invoked right after the DB connection is established.
+	 * The default implementation triggers an [[EVENT_AFTER_OPEN]] event.
+	 */
+	protected function initConnection()
+	{
+		$this->trigger(self::EVENT_AFTER_OPEN);
+	}
+
+	/**
+	 * Returns the name of the DB driver for the current [[dsn]].
+	 * @return string name of the DB driver
+	 */
+	public function getDriverName()
+	{
+		return 'elasticsearch';
+	}
+
+	/**
+	 * Creates a command for execution.
+	 * @param array $config the configuration for the Command class
+	 * @return Command the DB command
+	 */
+	public function createCommand($config = [])
+	{
+		$this->open();
+		$config['db'] = $this;
+		$command = new Command($config);
+		return $command;
+	}
+
+	public function getQueryBuilder()
+	{
+		return new QueryBuilder($this);
+	}
+
+	public function get($url, $options = [], $body = null)
+	{
+		$this->open();
+		return $this->httpRequest('GET', $this->createUrl($url, $options), $body);
+	}
+
+	public function head($url, $options = [], $body = null)
+	{
+		$this->open();
+		return $this->httpRequest('HEAD', $this->createUrl($url, $options), $body);
+	}
+
+	public function post($url, $options = [], $body = null)
+	{
+		$this->open();
+		return $this->httpRequest('POST', $this->createUrl($url, $options), $body);
+	}
+
+	public function put($url, $options = [], $body = null)
+	{
+		$this->open();
+		return $this->httpRequest('PUT', $this->createUrl($url, $options), $body);
+	}
+
+	public function delete($url, $options = [], $body = null)
+	{
+		$this->open();
+		return $this->httpRequest('DELETE', $this->createUrl($url, $options), $body);
+	}
+
+	private function createUrl($path, $options = [])
+	{
+		$url = implode('/', array_map(function($a) {
+			return urlencode(is_array($a) ? implode(',', $a) : $a);
+		}, $path));
+
+		if (!empty($options)) {
+			$url .= '?' . http_build_query($options);
+		}
+		return [$this->nodes[$this->activeNode]['http_address'], $url];
+	}
+
+	protected function httpRequest($method, $url, $requestBody = null)
+	{
+		$method = strtoupper($method);
+
+		// response body and headers
+		$headers = [];
+		$body = '';
+
+		$options = [
+			CURLOPT_USERAGENT      => 'Yii2 Framework ' . __CLASS__,
+			CURLOPT_RETURNTRANSFER => false,
+			CURLOPT_HEADER         => false,
+			// http://www.php.net/manual/en/function.curl-setopt.php#82418
+			CURLOPT_HTTPHEADER     => ['Expect:'],
+
+			CURLOPT_WRITEFUNCTION  => function($curl, $data) use (&$body) {
+				$body .= $data;
+				return mb_strlen($data, '8bit');
+			},
+			CURLOPT_HEADERFUNCTION => function($curl, $data) use (&$headers) {
+				foreach(explode("\r\n", $data) as $row) {
+					if (($pos = strpos($row, ':')) !== false) {
+						$headers[strtolower(substr($row, 0, $pos))] = trim(substr($row, $pos + 1));
+					}
+				}
+				return mb_strlen($data, '8bit');
+			},
+			CURLOPT_CUSTOMREQUEST  => $method,
+		];
+		if ($this->connectionTimeout !== null) {
+			$options[CURLOPT_CONNECTTIMEOUT] = $this->connectionTimeout;
+		}
+		if ($this->dataTimeout !== null) {
+			$options[CURLOPT_TIMEOUT] = $this->dataTimeout;
+		}
+		if ($requestBody !== null) {
+			$options[CURLOPT_POSTFIELDS] = $requestBody;
+		}
+		if ($method == 'HEAD') {
+			$options[CURLOPT_NOBODY] = true;
+			unset($options[CURLOPT_WRITEFUNCTION]);
+		}
+
+		if (is_array($url)) {
+			list($host, $q) = $url;
+			if (strncmp($host, 'inet[/', 6) == 0) {
+				$host = substr($host, 6, -1);
+			}
+			$profile = $q . $requestBody;
+			$url = 'http://' . $host . '/' . $q;
+		} else {
+			$profile = false;
+		}
+
+		Yii::trace("Sending request to elasticsearch node: $url\n$requestBody", __METHOD__);
+		if ($profile !== false) {
+			Yii::beginProfile($profile, __METHOD__);
+		}
+
+		$curl = curl_init($url);
+		curl_setopt_array($curl, $options);
+		if (curl_exec($curl) === false) {
+			throw new Exception('Elasticsearch request failed: ' . curl_errno($curl) . ' - ' . curl_error($curl), [
+				'requestMethod' => $method,
+				'requestUrl' => $url,
+				'requestBody' => $requestBody,
+				'responseHeaders' => $headers,
+				'responseBody' => $body,
+			]);
+		}
+
+		$responseCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+		curl_close($curl);
+
+		if ($profile !== false) {
+			Yii::endProfile($profile, __METHOD__);
+		}
+
+		if ($responseCode >= 200 && $responseCode < 300) {
+			if ($method == 'HEAD') {
+				return true;
+			} else {
+				if (isset($headers['content-length']) && ($len = mb_strlen($body, '8bit')) < $headers['content-length']) {
+					throw new Exception("Incomplete data received from elasticsearch: $len < {$headers['content-length']}", [
+						'requestMethod' => $method,
+						'requestUrl' => $url,
+						'requestBody' => $requestBody,
+						'responseCode' => $responseCode,
+						'responseHeaders' => $headers,
+						'responseBody' => $body,
+					]);
+				}
+				if (isset($headers['content-type']) && !strncmp($headers['content-type'], 'application/json', 16)) {
+					return Json::decode($body);
+				}
+				throw new Exception('Unsupported data received from elasticsearch: ' . $headers['content-type'], [
+					'requestMethod' => $method,
+					'requestUrl' => $url,
+					'requestBody' => $requestBody,
+					'responseCode' => $responseCode,
+					'responseHeaders' => $headers,
+					'responseBody' => $body,
+				]);
+			}
+		} elseif ($responseCode == 404) {
+			return false;
+		} else {
+			throw new Exception("Elasticsearch request failed with code $responseCode.", [
+				'requestMethod' => $method,
+				'requestUrl' => $url,
+				'requestBody' => $requestBody,
+				'responseCode' => $responseCode,
+				'responseHeaders' => $headers,
+				'responseBody' => $body,
+			]);
+		}
+	}
+
+	public function getNodeInfo()
+	{
+		return $this->get([]);
+	}
+
+	public function getClusterState()
+	{
+		return $this->get(['_cluster', 'state']);
+	}
+}
\ No newline at end of file

extensions/elasticsearch/Exception.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yii\elasticsearch;
+
+/**
+ * Exception represents an exception that is caused by elasticsearch-related operations.
+ *
+ * @author Carsten Brandt <mail@cebe.cc>
+ * @since 2.0
+ */
+class Exception extends \yii\db\Exception
+{
+	/**
+	 * @var array additional information about the http request that caused the error.
+	 */
+	public $errorInfo = [];
+
+	/**
+	 * Constructor.
+	 * @param string $message error message
+	 * @param array $errorInfo error info
+	 * @param integer $code error code
+	 * @param \Exception $previous The previous exception used for the exception chaining.
+	 */
+	public function __construct($message, $errorInfo = [], $code = 0, \Exception $previous = null)
+	{
+		$this->errorInfo = $errorInfo;
+		parent::__construct($message, $code, $previous);
+	}
+
+	/**
+	 * @return string the user-friendly name of this exception
+	 */
+	public function getName()
+	{
+		return \Yii::t('yii', 'Elasticsearch Database Exception');
+	}
+}
\ No newline at end of file

extensions/elasticsearch/LICENSE.md

+The Yii framework is free software. It is released under the terms of
+the following BSD License.
+
+Copyright © 2008 by Yii Software LLC (http://www.yiisoft.com)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+ * Neither the name of Yii Software LLC nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

extensions/elasticsearch/QueryBuilder.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yii\elasticsearch;
+
+use yii\base\InvalidParamException;
+use yii\base\NotSupportedException;
+use yii\helpers\Json;
+
+/**
+ * QueryBuilder builds an elasticsearch query based on the specification given as a [[Query]] object.
+ *
+ *
+ * @author Carsten Brandt <mail@cebe.cc>
+ * @since 2.0
+ */
+class QueryBuilder extends \yii\base\Object
+{
+	/**
+	 * @var Connection the database connection.
+	 */
+	public $db;
+
+	/**
+	 * Constructor.
+	 * @param Connection $connection the database connection.
+	 * @param array $config name-value pairs that will be used to initialize the object properties
+	 */
+	public function __construct($connection, $config = [])
+	{
+		$this->db = $connection;
+		parent::__construct($config);
+	}
+
+	/**
+	 * Generates query from a [[Query]] object.
+	 * @param Query $query the [[Query]] object from which the query will be generated
+	 * @return array the generated SQL statement (the first array element) and the corresponding
+	 * parameters to be bound to the SQL statement (the second array element).
+	 */
+	public function build($query)
+	{
+		$parts = [];
+
+		if ($query->fields !== null) {
+			$parts['fields'] = (array) $query->fields;
+		}
+		if ($query->limit !== null && $query->limit >= 0) {
+			$parts['size'] = $query->limit;
+		}
+		if ($query->offset > 0) {
+			$parts['from'] = (int) $query->offset;
+		}
+
+		if (empty($parts['query'])) {
+			$parts['query'] = ["match_all" => (object)[]];
+		}
+
+		$whereFilter = $this->buildCondition($query->where);
+		if (is_string($query->filter)) {
+			if (empty($whereFilter)) {
+				$parts['filter'] = $query->filter;
+			} else {
+				$parts['filter'] = '{"and": [' . $query->filter . ', ' . Json::encode($whereFilter) . ']}';
+			}
+		} elseif ($query->filter !== null) {
+			if (empty($whereFilter)) {
+				$parts['filter'] = $query->filter;
+			} else {
+				$parts['filter'] = ['and' => [$query->filter, $whereFilter]];
+			}
+		} elseif (!empty($whereFilter)) {
+			$parts['filter'] = $whereFilter;
+		}
+
+		$sort = $this->buildOrderBy($query->orderBy);
+		if (!empty($sort)) {
+			$parts['sort'] = $sort;
+		}
+
+		if (!empty($query->facets)) {
+			$parts['facets'] = $query->facets;
+		}
+
+		$options = [];
+		if ($query->timeout !== null) {
+			$options['timeout'] = $query->timeout;
+		}
+
+		return [
+			'queryParts' => $parts,
+			'index' => $query->index,
+			'type' => $query->type,
+			'options' => $options,
+		];
+	}
+
+	/**
+	 * adds order by condition to the query
+	 */
+	public function buildOrderBy($columns)
+	{
+		if (empty($columns)) {
+			return [];
+		}
+		$orders = [];
+		foreach ($columns as $name => $direction) {
+			if (is_string($direction)) {
+				$column = $direction;
+				$direction = SORT_ASC;
+			} else {
+				$column = $name;
+			}
+			if ($column == ActiveRecord::PRIMARY_KEY_NAME) {
+				$column = '_id';
+			}
+
+			// allow elasticsearch extended syntax as described in http://www.elasticsearch.org/guide/reference/api/search/sort/
+			if (is_array($direction)) {
+				$orders[] = [$column => $direction];
+			} else {
+				$orders[] = [$column => ($direction === SORT_DESC ? 'desc' : 'asc')];
+			}
+		}
+		return $orders;
+	}
+
+	/**
+	 * Parses the condition specification and generates the corresponding SQL expression.
+	 * @param string|array $condition the condition specification. Please refer to [[Query::where()]]
+	 * on how to specify a condition.
+	 * @param array $params the binding parameters to be populated
+	 * @return string the generated SQL expression
+	 * @throws \yii\db\Exception if the condition is in bad format
+	 */
+	public function buildCondition($condition)
+	{
+		static $builders = array(
+			'and' => 'buildAndCondition',
+			'or' => 'buildAndCondition',
+			'between' => 'buildBetweenCondition',
+			'not between' => 'buildBetweenCondition',
+			'in' => 'buildInCondition',
+			'not in' => 'buildInCondition',
+			'like' => 'buildLikeCondition',
+			'not like' => 'buildLikeCondition',
+			'or like' => 'buildLikeCondition',
+			'or not like' => 'buildLikeCondition',
+		);
+
+		if (empty($condition)) {
+			return [];
+		}
+		if (!is_array($condition)) {
+			throw new NotSupportedException('String conditions in where() are not supported by elasticsearch.');
+		}
+		if (isset($condition[0])) { // operator format: operator, operand 1, operand 2, ...
+			$operator = strtolower($condition[0]);
+			if (isset($builders[$operator])) {
+				$method = $builders[$operator];
+				array_shift($condition);
+				return $this->$method($operator, $condition);
+			} else {
+				throw new InvalidParamException('Found unknown operator in query: ' . $operator);
+			}
+		} else { // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
+			return $this->buildHashCondition($condition);
+		}
+	}
+
+	private function buildHashCondition($condition)
+	{
+		$parts = [];
+		foreach($condition as $attribute => $value) {
+			if ($attribute == ActiveRecord::PRIMARY_KEY_NAME) {
+				if ($value == null) { // there is no null pk
+					$parts[] = ['script' => ['script' => '0==1']];
+				} else {
+					$parts[] = ['ids' => ['values' => is_array($value) ? $value : [$value]]];
+				}
+			} else {
+				if (is_array($value)) { // IN condition
+					$parts[] = ['in' => [$attribute => $value]];
+				} else {
+					if ($value === null) {
+						$parts[] = ['missing' => ['field' => $attribute, 'existence' => true, 'null_value' => true]];
+					} else {
+						$parts[] = ['term' => [$attribute => $value]];
+					}
+				}
+			}
+		}
+		return count($parts) === 1 ? $parts[0] : ['and' => $parts];
+	}
+
+	private function buildAndCondition($operator, $operands)
+	{
+		$parts = [];
+		foreach ($operands as $operand) {
+			if (is_array($operand)) {
+				$operand = $this->buildCondition($operand);
+			}
+			if (!empty($operand)) {
+				$parts[] = $operand;
+			}
+		}
+		if (!empty($parts)) {
+			return [$operator => $parts];
+		} else {
+			return [];
+		}
+	}
+
+	private function buildBetweenCondition($operator, $operands)
+	{
+		if (!isset($operands[0], $operands[1], $operands[2])) {
+			throw new InvalidParamException("Operator '$operator' requires three operands.");
+		}
+
+		list($column, $value1, $value2) = $operands;
+		if ($column == ActiveRecord::PRIMARY_KEY_NAME) {
+			throw new NotSupportedException('Between condition is not supported for primaryKey.');
+		}
+		$filter = ['range' => [$column => ['gte' => $value1, 'lte' => $value2]]];
+		if ($operator == 'not between') {
+			$filter = ['not' => $filter];
+		}
+		return $filter;
+	}
+
+	private function buildInCondition($operator, $operands)
+	{
+		if (!isset($operands[0], $operands[1])) {
+			throw new InvalidParamException("Operator '$operator' requires two operands.");
+		}
+
+		list($column, $values) = $operands;
+
+		$values = (array)$values;
+
+		if (empty($values) || $column === []) {
+			return $operator === 'in' ? ['script' => ['script' => '0==1']] : [];
+		}
+
+		if (count($column) > 1) {
+			return $this->buildCompositeInCondition($operator, $column, $values, $params);
+		} elseif (is_array($column)) {
+			$column = reset($column);
+		}
+		$canBeNull = false;
+		foreach ($values as $i => $value) {
+			if (is_array($value)) {
+				$values[$i] = $value = isset($value[$column]) ? $value[$column] : null;
+			}
+			if ($value === null) {
+				$canBeNull = true;
+				unset($values[$i]);
+			}
+		}
+		if ($column == ActiveRecord::PRIMARY_KEY_NAME) {
+			if (empty($values) && $canBeNull) { // there is no null pk
+				$filter = ['script' => ['script' => '0==1']];
+			} else {
+				$filter = ['ids' => ['values' => array_values($values)]];
+				if ($canBeNull) {
+					$filter = ['or' => [$filter, ['missing' => ['field' => $column, 'existence' => true, 'null_value' => true]]]];
+				}
+			}
+		} else {
+			if (empty($values) && $canBeNull) {
+				$filter = ['missing' => ['field' => $column, 'existence' => true, 'null_value' => true]];
+			} else {
+				$filter = ['in' => [$column => array_values($values)]];
+				if ($canBeNull) {
+					$filter = ['or' => [$filter, ['missing' => ['field' => $column, 'existence' => true, 'null_value' => true]]]];
+				}
+			}
+		}
+		if ($operator == 'not in') {
+			$filter = ['not' => $filter];
+		}
+		return $filter;
+	}
+
+	protected function buildCompositeInCondition($operator, $columns, $values)
+	{
+		throw new NotSupportedException('composite in is not supported by elasticsearch.');
+		$vss = array();
+		foreach ($values as $value) {
+			$vs = array();
+			foreach ($columns as $column) {
+				if (isset($value[$column])) {
+					$phName = self::PARAM_PREFIX . count($params);
+					$params[$phName] = $value[$column];
+					$vs[] = $phName;
+				} else {
+					$vs[] = 'NULL';
+				}
+			}
+			$vss[] = '(' . implode(', ', $vs) . ')';
+		}
+		foreach ($columns as $i => $column) {
+			if (strpos($column, '(') === false) {
+				$columns[$i] = $this->db->quoteColumnName($column);
+			}
+		}
+		return '(' . implode(', ', $columns) . ") $operator (" . implode(', ', $vss) . ')';
+	}
+
+	private function buildLikeCondition($operator, $operands)
+	{
+		throw new NotSupportedException('like conditions is not supported by elasticsearch.');
+		if (!isset($operands[0], $operands[1])) {
+			throw new Exception("Operator '$operator' requires two operands.");
+		}
+
+		list($column, $values) = $operands;
+
+		$values = (array)$values;
+
+		if (empty($values)) {
+			return $operator === 'LIKE' || $operator === 'OR LIKE' ? '0==1' : '';
+		}
+
+		if ($operator === 'LIKE' || $operator === 'NOT LIKE') {
+			$andor = ' AND ';
+		} else {
+			$andor = ' OR ';
+			$operator = $operator === 'OR LIKE' ? 'LIKE' : 'NOT LIKE';
+		}
+
+		if (strpos($column, '(') === false) {
+			$column = $this->db->quoteColumnName($column);
+		}
+
+		$parts = array();
+		foreach ($values as $value) {
+			$phName = self::PARAM_PREFIX . count($params);
+			$params[$phName] = $value;
+			$parts[] = "$column $operator $phName";
+		}
+
+		return implode($andor, $parts);
+	}
+}

extensions/elasticsearch/README.md

+Elasticsearch Query and ActiveRecord for Yii 2
+==============================================
+
+This extension provides the [elasticsearch](http://www.elasticsearch.org/) integration for the Yii2 framework.
+It includes basic querying/search support and also implements the `ActiveRecord` pattern that allows you to store active
+records in elasticsearch.
+
+To use this extension, you have to configure the Connection class in your application configuration:
+
+```php
+return [
+	//....
+	'components' => [
+        'elasticsearch' => [
+            'class' => 'yii\elasticsearch\Connection',
+            'hosts' => [
+                ['http_address' => '127.0.0.1:9200'],
+                // configure more hosts if you have a cluster
+            ],
+        ],
+	]
+];
+```
+
+
+Installation
+------------
+
+The preferred way to install this extension is through [composer](http://getcomposer.org/download/).
+
+Either run
+
+```
+php composer.phar require yiisoft/yii2-elasticsearch "*"
+```
+
+or add
+
+```json
+"yiisoft/yii2-elasticsearch": "*"
+```
+
+to the require section of your composer.json.
+
+
+Using the Query
+---------------
+
+TBD
+
+Using the ActiveRecord
+----------------------
+
+For general information on how to use yii's ActiveRecord please refer to the [guide](https://github.com/yiisoft/yii2/blob/master/docs/guide/active-record.md).
+
+For defining an elasticsearch ActiveRecord class your record class needs to extend from `yii\elasticsearch\ActiveRecord` and
+implement at least the `attributes()` method to define the attributes of the record.
+The primary key (the `_id` field in elasticsearch terms) is represented by `getId()` and `setId()` and can not be changed.
+The primary key is not part of the attributes.
+
+ primary key can be defined via [[primaryKey()]] which defaults to `id` if not specified.
+The primaryKey needs to be part of the attributes so make sure you have an `id` attribute defined if you do
+not specify your own primary key.
+
+The following is an example model called `Customer`:
+
+```php
+class Customer extends \yii\elasticsearch\ActiveRecord
+{
+    /**
+     * @return array the list of attributes for this record
+     */
+    public function attributes()
+    {
+        return ['id', 'name', 'address', 'registration_date'];
+    }
+
+    /**
+     * @return ActiveRelation defines a relation to the Order record (can be in other database, e.g. redis or sql)
+     */
+    public function getOrders()
+    {
+        return $this->hasMany(Order::className(), ['customer_id' => 'id'])->orderBy('id');
+    }
+
+    /**
+     * Defines a scope that modifies the `$query` to return only active(status = 1) customers
+     */
+    public static function active($query)
+    {
+        $query->andWhere(array('status' => 1));
+    }
+}
+```
+
+You may override [[index()]] and [[type()]] to define the index and type this record represents.
+
+The general usage of elasticsearch ActiveRecord is very similar to the database ActiveRecord as described in the
+[guide](https://github.com/yiisoft/yii2/blob/master/docs/guide/active-record.md).
+It supports the same interface and features except the following limitations and additions(*!*):
+
+- As elasticsearch does not support SQL, the query API does not support `join()`, `groupBy()`, `having()` and `union()`.
+  Sorting, limit, offset and conditional where are all supported.
+- `from()` does not select the tables, but the [index](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/glossary.html#glossary-index)
+  and [type](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/glossary.html#glossary-type) to query against.
+- `select()` has been replaced with `fields()` which basically does the same but `fields` is more elasticsearch terminology.
+  It defines the fields to retrieve from a document.
+- `via`-relations can not be defined via a table as there are not tables in elasticsearch. You can only define relations via other records.
+- As elasticsearch is a data storage and search engine there is of course support added for search your records.
+  TBD ...
+- It is also possible to define relations from elasticsearch ActiveRecords to normal ActiveRecord classes and vice versa.
+
+Elasticsearch separates primary key from attributes. You need to set the `id` property of the record to set its primary key.
+
+Usage example:
+
+```php
+$customer = new Customer();
+$customer->id = 1;
+$customer->attributes = ['name' => 'test'];
+$customer->save();
+
+$customer = Customer::get(1); // get a record by pk
+$customers = Customer::get([1,2,3]); // get a records multiple by pk
+$customer = Customer::find()->where(['name' => 'test'])->one(); // find by query
+$customer = Customer::find()->active()->all(); // find all by query (using the `active` scope)
+```
\ No newline at end of file

extensions/elasticsearch/composer.json

+{
+	"name": "yiisoft/yii2-elasticsearch",
+	"description": "Elasticsearch integration and ActiveRecord for the Yii framework",
+	"keywords": ["yii", "elasticsearch", "active-record", "search", "fulltext"],
+	"type": "yii2-extension",
+	"license": "BSD-3-Clause",
+	"support": {
+		"issues": "https://github.com/yiisoft/yii2/issues?labels=ext%3Aelasticsearch",
+		"forum": "http://www.yiiframework.com/forum/",
+		"wiki": "http://www.yiiframework.com/wiki/",
+		"irc": "irc://irc.freenode.net/yii",
+		"source": "https://github.com/yiisoft/yii2"
+	},
+	"authors": [
+		{
+			"name": "Carsten Brandt",
+			"email": "mail@cebe.cc"
+		}
+	],
+	"require": {
+		"yiisoft/yii2": "*",
+		"ext-curl": "*"
+	},
+	"autoload": {
+		"psr-0": { "yii\\elasticsearch\\": "" }
+	},
+	"target-dir": "yii/elasticsearch"
+}

extensions/redis/ActiveQuery.php

@@ -226,7 +226,7 @@ class ActiveQuery extends \yii\base\Component implements ActiveQueryInterface
 	{
 		$record = $this->one($db);
 		if ($record !== null) {
-			return $record->$attribute;
+			return $record->hasAttribute($attribute) ? $record->$attribute : null;
 		} else {
 			return null;
 		}

extensions/redis/ActiveRecord.php

@@ -298,7 +298,7 @@ class ActiveRecord extends \yii\db\ActiveRecord
 	 */
 	public static function getTableSchema()
 	{
-		throw new NotSupportedException('getTableSchema() is not supported by redis ActiveRecord');
+		throw new NotSupportedException('getTableSchema() is not supported by redis ActiveRecord.');
 	}
 
 	/**
@@ -306,7 +306,7 @@ class ActiveRecord extends \yii\db\ActiveRecord
 	 */
 	public static function findBySql($sql, $params = [])
 	{
-		throw new NotSupportedException('findBySql() is not supported by redis ActiveRecord');
+		throw new NotSupportedException('findBySql() is not supported by redis ActiveRecord.');
 	}
 
 	/**

extensions/redis/README.md

@@ -181,4 +181,4 @@ echo $customer->id; // id will automatically be incremented if not set explicitl
 
 $customer = Customer::find()->where(['name' => 'test'])->one(); // find by query
 $customer = Customer::find()->active()->all(); // find all by query (using the `active` scope)
-```
\ No newline at end of file
+```

framework/yii/db/ActiveQuery.php

@@ -23,6 +23,7 @@ namespace yii\db;
  * - [[min()]]: returns the min over the specified column.
  * - [[max()]]: returns the max over the specified column.
  * - [[scalar()]]: returns the value of the first column in the first row of the query result.
+ * - [[column()]]: returns the value of the first column in the query result.
  * - [[exists()]]: returns a value indicating whether the query result has data or not.
  *
  * Because ActiveQuery extends from [[Query]], one can use query methods, such as [[where()]],

framework/yii/db/ActiveRecord.php

@@ -754,7 +754,7 @@ class ActiveRecord extends Model
 	 * [[EVENT_BEFORE_INSERT]], [[EVENT_AFTER_INSERT]] and [[EVENT_AFTER_VALIDATE]]
 	 * will be raised by the corresponding methods.
 	 *
-	 * Only the [[changedAttributes|changed attribute values]] will be inserted into database.
+	 * Only the [[dirtyAttributes|changed attribute values]] will be inserted into database.
 	 *
 	 * If the table's primary key is auto-incremental and is null during insertion,
 	 * it will be populated with the actual value after insertion.
@@ -1169,7 +1169,7 @@ class ActiveRecord extends Model
 			return false;
 		}
 		foreach ($this->attributes() as $name) {
-			$this->_attributes[$name] = $record->_attributes[$name];
+			$this->_attributes[$name] = isset($record->_attributes[$name]) ? $record->_attributes[$name] : null;
 		}
 		$this->_oldAttributes = $this->_attributes;
 		$this->_related = [];
@@ -1179,11 +1179,15 @@ class ActiveRecord extends Model
 	/**
 	 * Returns a value indicating whether the given active record is the same as the current one.
 	 * The comparison is made by comparing the table names and the primary key values of the two active records.
+	 * If one of the records [[isNewRecord|is new]] they are also considered not equal.
 	 * @param ActiveRecord $record record to compare to
 	 * @return boolean whether the two active records refer to the same row in the same database table.
 	 */
 	public function equals($record)
 	{
+		if ($this->isNewRecord || $record->isNewRecord) {
+			return false;
+		}
 		return $this->tableName() === $record->tableName() && $this->getPrimaryKey() === $record->getPrimaryKey();
 	}
 

framework/yii/db/Query.php

@@ -42,7 +42,7 @@ class Query extends Component implements QueryInterface
 
 	/**
 	 * @var array the columns being selected. For example, `['id', 'name']`.
-	 * This is used to construct the SELECT clause in a SQL statement. If not set, if means selecting all columns.
+	 * This is used to construct the SELECT clause in a SQL statement. If not set, it means selecting all columns.
 	 * @see select()
 	 */
 	public $select;

framework/yii/db/QueryBuilder.php

@@ -7,6 +7,7 @@
 
 namespace yii\db;
 
+use yii\base\InvalidParamException;
 use yii\base\NotSupportedException;
 
 /**
@@ -782,7 +783,7 @@ class QueryBuilder extends \yii\base\Object
 	 * on how to specify a condition.
 	 * @param array $params the binding parameters to be populated
 	 * @return string the generated SQL expression
-	 * @throws \yii\db\Exception if the condition is in bad format
+	 * @throws InvalidParamException if the condition is in bad format
 	 */
 	public function buildCondition($condition, &$params)
 	{
@@ -811,7 +812,7 @@ class QueryBuilder extends \yii\base\Object
 				array_shift($condition);
 				return $this->$method($operator, $condition, $params);
 			} else {
-				throw new Exception('Found unknown operator in query: ' . $operator);
+				throw new InvalidParamException('Found unknown operator in query: ' . $operator);
 			}
 		} else { // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
 			return $this->buildHashCondition($condition, $params);
@@ -883,12 +884,12 @@ class QueryBuilder extends \yii\base\Object
 	 * describe the interval that column value should be in.
 	 * @param array $params the binding parameters to be populated
 	 * @return string the generated SQL expression
-	 * @throws Exception if wrong number of operands have been given.
+	 * @throws InvalidParamException if wrong number of operands have been given.
 	 */
 	public function buildBetweenCondition($operator, $operands, &$params)
 	{
 		if (!isset($operands[0], $operands[1], $operands[2])) {
-			throw new Exception("Operator '$operator' requires three operands.");
+			throw new InvalidParamException("Operator '$operator' requires three operands.");
 		}
 
 		list($column, $value1, $value2) = $operands;
@@ -1003,7 +1004,7 @@ class QueryBuilder extends \yii\base\Object
 	public function buildLikeCondition($operator, $operands, &$params)
 	{
 		if (!isset($operands[0], $operands[1])) {
-			throw new Exception("Operator '$operator' requires two operands.");
+			throw new InvalidParamException("Operator '$operator' requires two operands.");
 		}
 
 		list($column, $values) = $operands;

tests/unit/bootstrap.php

@@ -8,6 +8,11 @@ define('YII_DEBUG', true);
 $_SERVER['SCRIPT_NAME'] = '/' . __DIR__;
 $_SERVER['SCRIPT_FILENAME'] = __FILE__;
 
+// require composer autoloader if available
+$composerAutoload = __DIR__ . '/../../vendor/autoload.php';
+if (is_file($composerAutoload)) {
+	require_once($composerAutoload);
+}
 require_once(__DIR__ . '/../../framework/yii/Yii.php');
 
 Yii::setAlias('@yiiunit', __DIR__);

tests/unit/data/ar/Customer.php

 <?php
 namespace yiiunit\data\ar;
 
+use yiiunit\framework\db\ActiveRecordTest;
+
 /**
  * Class Customer
  *
@@ -17,9 +19,6 @@ class Customer extends ActiveRecord
 
 	public $status2;
 
-	public static $afterSaveInsert = null;
-	public static $afterSaveNewRecord = null;
-
 	public static function tableName()
 	{
 		return 'tbl_customer';
@@ -37,8 +36,8 @@ class Customer extends ActiveRecord
 
 	public function afterSave($insert)
 	{
-		static::$afterSaveInsert = $insert;
-		static::$afterSaveNewRecord = $this->isNewRecord;
+		ActiveRecordTest::$afterSaveInsert = $insert;
+		ActiveRecordTest::$afterSaveNewRecord = $this->isNewRecord;
 		parent::afterSave($insert);
 	}
 }

tests/unit/data/ar/Order.php

@@ -35,6 +35,22 @@ class Order extends ActiveRecord
 			})->orderBy('id');
 	}
 
+	public function getItemsInOrder1()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_ASC]);
+			})->orderBy('name');
+	}
+
+	public function getItemsInOrder2()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_DESC]);
+			})->orderBy('name');
+	}
+
 	public function getBooks()
 	{
 		return $this->hasMany(Item::className(), ['id' => 'item_id'])

tests/unit/data/ar/elasticsearch/ActiveRecord.php

+<?php
+/**
+ * @link http://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license http://www.yiiframework.com/license/
+ */
+
+namespace yiiunit\data\ar\elasticsearch;
+
+/**
+ * ActiveRecord is ...
+ *
+ * @author Qiang Xue <qiang.xue@gmail.com>
+ * @since 2.0
+ */
+class ActiveRecord extends \yii\elasticsearch\ActiveRecord
+{
+	public static $db;
+
+	/**
+	 * @return \yii\elasticsearch\Connection
+	 */
+	public static function getDb()
+	{
+		return self::$db;
+	}
+
+	public static function index()
+	{
+		return 'yiitest';
+	}
+}

tests/unit/data/ar/elasticsearch/Customer.php

+<?php
+namespace yiiunit\data\ar\elasticsearch;
+
+use yiiunit\extensions\elasticsearch\ActiveRecordTest;
+
+/**
+ * Class Customer
+ *
+ * @property integer $id
+ * @property string $name
+ * @property string $email
+ * @property string $address
+ * @property integer $status
+ */
+class Customer extends ActiveRecord
+{
+	const STATUS_ACTIVE = 1;
+	const STATUS_INACTIVE = 2;
+
+	public $status2;
+
+	public static function attributes()
+	{
+		return ['name', 'email', 'address', 'status'];
+	}
+
+	public function getOrders()
+	{
+		return $this->hasMany(Order::className(), array('customer_id' => ActiveRecord::PRIMARY_KEY_NAME))->orderBy('create_time');
+	}
+
+	public static function active($query)
+	{
+		$query->andWhere(array('status' => 1));
+	}
+
+	public function afterSave($insert)
+	{
+		ActiveRecordTest::$afterSaveInsert = $insert;
+		ActiveRecordTest::$afterSaveNewRecord = $this->isNewRecord;
+		parent::afterSave($insert);
+	}
+}

tests/unit/data/ar/elasticsearch/Item.php

+<?php
+
+namespace yiiunit\data\ar\elasticsearch;
+
+/**
+ * Class Item
+ *
+ * @property integer $id
+ * @property string $name
+ * @property integer $category_id
+ */
+class Item extends ActiveRecord
+{
+	public static function attributes()
+	{
+		return ['name', 'category_id'];
+	}
+}

tests/unit/data/ar/elasticsearch/Order.php

+<?php
+
+namespace yiiunit\data\ar\elasticsearch;
+
+/**
+ * Class Order
+ *
+ * @property integer $id
+ * @property integer $customer_id
+ * @property integer $create_time
+ * @property string $total
+ */
+class Order extends ActiveRecord
+{
+	public static function attributes()
+	{
+		return ['customer_id', 'create_time', 'total'];
+	}
+
+	public function getCustomer()
+	{
+		return $this->hasOne(Customer::className(), [ActiveRecord::PRIMARY_KEY_NAME => 'customer_id']);
+	}
+
+	public function getOrderItems()
+	{
+		return $this->hasMany(OrderItem::className(), ['order_id' => ActiveRecord::PRIMARY_KEY_NAME]);
+	}
+
+	public function getItems()
+	{
+		return $this->hasMany(Item::className(), [ActiveRecord::PRIMARY_KEY_NAME => 'item_id'])
+			->via('orderItems')->orderBy('id');
+	}
+
+	public function getItemsInOrder1()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_ASC]);
+			})->orderBy('name');
+	}
+
+	public function getItemsInOrder2()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_DESC]);
+			})->orderBy('name');
+	}
+
+//	public function getBooks()
+//	{
+//		return $this->hasMany('Item', [ActiveRecord::PRIMARY_KEY_NAME => 'item_id'])
+//			->viaTable('tbl_order_item', ['order_id' => ActiveRecord::PRIMARY_KEY_NAME])
+//			->where(['category_id' => 1]);
+//	}
+
+	public function beforeSave($insert)
+	{
+		if (parent::beforeSave($insert)) {
+//			$this->create_time = time();
+			return true;
+		} else {
+			return false;
+		}
+	}
+}

tests/unit/data/ar/elasticsearch/OrderItem.php

+<?php
+
+namespace yiiunit\data\ar\elasticsearch;
+
+/**
+ * Class OrderItem
+ *
+ * @property integer $order_id
+ * @property integer $item_id
+ * @property integer $quantity
+ * @property string $subtotal
+ */
+class OrderItem extends ActiveRecord
+{
+	public static function attributes()
+	{
+		return ['order_id', 'item_id', 'quantity', 'subtotal'];
+	}
+
+	public function getOrder()
+	{
+		return $this->hasOne(Order::className(), [ActiveRecord::PRIMARY_KEY_NAME => 'order_id']);
+	}
+
+	public function getItem()
+	{
+		return $this->hasOne(Item::className(), [ActiveRecord::PRIMARY_KEY_NAME => 'item_id']);
+	}
+}

tests/unit/data/ar/redis/Customer.php

@@ -2,6 +2,8 @@
 
 namespace yiiunit\data\ar\redis;
 
+use yiiunit\extensions\redis\ActiveRecordTest;
+
 class Customer extends ActiveRecord
 {
 	const STATUS_ACTIVE = 1;
@@ -26,4 +28,11 @@ class Customer extends ActiveRecord
 	{
 		$query->andWhere(['status' => 1]);
 	}
+
+	public function afterSave($insert)
+	{
+		ActiveRecordTest::$afterSaveInsert = $insert;
+		ActiveRecordTest::$afterSaveNewRecord = $this->isNewRecord;
+		parent::afterSave($insert);
+	}
 }
\ No newline at end of file

tests/unit/data/ar/redis/Order.php

@@ -27,6 +27,22 @@ class Order extends ActiveRecord
 			});
 	}
 
+	public function getItemsInOrder1()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_ASC]);
+			})->orderBy('name');
+	}
+
+	public function getItemsInOrder2()
+	{
+		return $this->hasMany(Item::className(), ['id' => 'item_id'])
+			->via('orderItems', function ($q) {
+				$q->orderBy(['subtotal' => SORT_DESC]);
+			})->orderBy('name');
+	}
+
 	public function getBooks()
 	{
 		return $this->hasMany(Item::className(), ['id' => 'item_id'])

tests/unit/data/config.php

@@ -29,6 +29,9 @@ return [
 			'password' => 'postgres',
 			'fixture' => __DIR__ . '/postgres.sql',
 		],
+		'elasticsearch' => [
+			'dsn' => 'elasticsearch://localhost:9200'
+		],
 		'redis' => [
 			'hostname' => 'localhost',
 			'port' => 6379,

tests/unit/data/cubrid.sql

@@ -23,7 +23,7 @@ CREATE TABLE `tbl_constraints`
 CREATE TABLE `tbl_customer` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `email` varchar(128) NOT NULL,
-  `name` varchar(128) NOT NULL,
+  `name` varchar(128),
   `address` string,
   `status` int (11) DEFAULT 0,
   PRIMARY KEY (`id`)

tests/unit/data/mssql.sql

@@ -9,7 +9,7 @@ IF OBJECT_ID('[dbo].[tbl_null_values]', 'U') IS NOT NULL DROP TABLE [dbo].[tbl_n
 CREATE TABLE [dbo].[tbl_customer] (
 	[id] [int] IDENTITY(1,1) NOT NULL,
 	[email] [varchar](128) NOT NULL,
-	[name] [varchar](128) NOT NULL,
+	[name] [varchar](128),
 	[address] [text],
 	[status] [int] DEFAULT 0,
 	CONSTRAINT [PK_customer] PRIMARY KEY CLUSTERED (

tests/unit/data/mysql.sql

@@ -23,7 +23,7 @@ CREATE TABLE `tbl_constraints`
 CREATE TABLE `tbl_customer` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `email` varchar(128) NOT NULL,
-  `name` varchar(128) NOT NULL,
+  `name` varchar(128),
   `address` text,
   `status` int (11) DEFAULT 0,
   PRIMARY KEY (`id`)

tests/unit/data/postgres.sql

@@ -22,7 +22,7 @@ CREATE TABLE tbl_constraints
 CREATE TABLE tbl_customer (
   id serial not null primary key,
   email varchar(128) NOT NULL,
-  name varchar(128) NOT NULL,
+  name varchar(128),
   address text,
   status integer DEFAULT 0
 );

tests/unit/data/sqlite.sql

@@ -15,7 +15,7 @@ DROP TABLE IF EXISTS tbl_null_values;
 CREATE TABLE tbl_customer (
   id INTEGER NOT NULL,
   email varchar(128) NOT NULL,
-  name varchar(128) NOT NULL,
+  name varchar(128),
   address text,
   status INTEGER DEFAULT 0,
   PRIMARY KEY (id)

tests/unit/extensions/elasticsearch/ElasticSearchConnectionTest.php

+<?php
+
+namespace yiiunit\extensions\elasticsearch;
+
+use yii\elasticsearch\Connection;
+
+/**
+ * @group elasticsearch
+ */
+class ElasticSearchConnectionTest extends ElasticSearchTestCase
+{
+	public function testOpen()
+	{
+		$connection = new Connection();
+		$connection->autodetectCluster;
+		$connection->nodes = [
+			['http_address' => 'inet[/127.0.0.1:9200]'],
+		];
+		$this->assertNull($connection->activeNode);
+		$connection->open();
+		$this->assertNotNull($connection->activeNode);
+		$this->assertArrayHasKey('name', reset($connection->nodes));
+		$this->assertArrayHasKey('hostname', reset($connection->nodes));
+		$this->assertArrayHasKey('version', reset($connection->nodes));
+		$this->assertArrayHasKey('http_address', reset($connection->nodes));
+	}
+
+}
\ No newline at end of file

tests/unit/extensions/elasticsearch/ElasticSearchTestCase.php

+<?php
+
+namespace yiiunit\extensions\elasticsearch;
+
+use Yii;
+use yii\elasticsearch\Connection;
+use yiiunit\TestCase;
+
+Yii::setAlias('@yii/elasticsearch', __DIR__ . '/../../../../extensions/elasticsearch');
+
+/**
+ * ElasticSearchTestCase is the base class for all elasticsearch related test cases
+ */
+class ElasticSearchTestCase extends TestCase
+{
+	protected function setUp()
+	{
+		$this->mockApplication();
+
+		$databases = $this->getParam('databases');
+		$params = isset($databases['elasticsearch']) ? $databases['elasticsearch'] : null;
+		if ($params === null || !isset($params['dsn'])) {
+			$this->markTestSkipped('No elasticsearch server connection configured.');
+		}
+		$dsn = explode('/', $params['dsn']);
+		$host = $dsn[2];
+		if (strpos($host, ':')===false) {
+			$host .= ':9200';
+		}
+		if(!@stream_socket_client($host, $errorNumber, $errorDescription, 0.5)) {
+			$this->markTestSkipped('No elasticsearch server running at ' . $params['dsn'] . ' : ' . $errorNumber . ' - ' . $errorDescription);
+		}
+
+		parent::setUp();
+	}
+
+	/**
+	 * @param bool $reset whether to clean up the test database
+	 * @return Connection
+	 */
+	public function getConnection($reset = true)
+	{
+		$databases = $this->getParam('databases');
+		$params = isset($databases['elasticsearch']) ? $databases['elasticsearch'] : array();
+		$db = new Connection();
+		if ($reset) {
+			$db->open();
+		}
+		return $db;
+	}
+}
\ No newline at end of file

tests/unit/extensions/elasticsearch/QueryTest.php

+<?php
+
+namespace yiiunit\extensions\elasticsearch;
+
+use yii\elasticsearch\Query;
+
+/**
+ * @group elasticsearch
+ */
+class QueryTest extends ElasticSearchTestCase
+{
+	protected function setUp()
+	{
+		parent::setUp();
+
+		$command = $this->getConnection()->createCommand();
+
+		$command->deleteAllIndexes();
+
+		$command->insert('test', 'user', ['name' => 'user1', 'email' => 'user1@example.com', 'status' => 1], 1);
+		$command->insert('test', 'user', ['name' => 'user2', 'email' => 'user2@example.com', 'status' => 1], 2);
+		$command->insert('test', 'user', ['name' => 'user3', 'email' => 'user3@example.com', 'status' => 2], 3);
+		$command->insert('test', 'user', ['name' => 'user4', 'email' => 'user4@example.com', 'status' => 1], 4);
+
+		$command->flushIndex();
+	}
+
+	public function testFields()
+	{
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$query->fields(['name', 'status']);
+		$this->assertEquals(['name', 'status'], $query->fields);
+
+		$query->fields('name', 'status');
+		$this->assertEquals(['name', 'status'], $query->fields);
+
+		$result = $query->one($this->getConnection());
+		$this->assertEquals(2, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+
+		$query->fields([]);
+		$this->assertEquals([], $query->fields);
+
+		$result = $query->one($this->getConnection());
+		$this->assertEquals([], $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+
+		$query->fields(null);
+		$this->assertNull($query->fields);
+
+		$result = $query->one($this->getConnection());
+		$this->assertEquals(3, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('email', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+	}
+
+	public function testOne()
+	{
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$result = $query->one($this->getConnection());
+		$this->assertEquals(3, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('email', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+
+		$result = $query->where(['name' => 'user1'])->one($this->getConnection());
+		$this->assertEquals(3, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('email', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+		$this->assertEquals(1, $result['_id']);
+
+		$result = $query->where(['name' => 'user5'])->one($this->getConnection());
+		$this->assertFalse($result);
+	}
+
+	public function testAll()
+	{
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$results = $query->all($this->getConnection());
+		$this->assertEquals(4, count($results));
+		$result = reset($results);
+		$this->assertEquals(3, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('email', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$results = $query->where(['name' => 'user1'])->all($this->getConnection());
+		$this->assertEquals(1, count($results));
+		$result = reset($results);
+		$this->assertEquals(3, count($result['_source']));
+		$this->assertArrayHasKey('status', $result['_source']);
+		$this->assertArrayHasKey('email', $result['_source']);
+		$this->assertArrayHasKey('name', $result['_source']);
+		$this->assertArrayHasKey('_id', $result);
+		$this->assertEquals(1, $result['_id']);
+
+		// indexBy
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$results = $query->indexBy('name')->all($this->getConnection());
+		$this->assertEquals(4, count($results));
+		ksort($results);
+		$this->assertEquals(['user1', 'user2', 'user3', 'user4'], array_keys($results));
+	}
+
+	public function testScalar()
+	{
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$result = $query->where(['name' => 'user1'])->scalar('name', $this->getConnection());
+		$this->assertEquals('user1', $result);
+		$result = $query->where(['name' => 'user1'])->scalar('noname', $this->getConnection());
+		$this->assertNull($result);
+		$result = $query->where(['name' => 'user5'])->scalar('name', $this->getConnection());
+		$this->assertNull($result);
+	}
+
+	public function testColumn()
+	{
+		$query = new Query;
+		$query->from('test', 'user');
+
+		$result = $query->orderBy(['name' => SORT_ASC])->column('name', $this->getConnection());
+		$this->assertEquals(['user1', 'user2', 'user3', 'user4'], $result);
+		$result = $query->column('noname', $this->getConnection());
+		$this->assertEquals([null, null, null, null], $result);
+		$result = $query->where(['name' => 'user5'])->scalar('name', $this->getConnection());
+		$this->assertNull($result);
+
+	}
+
+	// TODO test facets
+
+	// TODO test complex where() every edge of QueryBuilder
+
+	public function testOrder()
+	{
+		$query = new Query;
+		$query->orderBy('team');
+		$this->assertEquals(['team' => SORT_ASC], $query->orderBy);
+
+		$query->addOrderBy('company');
+		$this->assertEquals(['team' => SORT_ASC, 'company' => SORT_ASC], $query->orderBy);
+
+		$query->addOrderBy('age');
+		$this->assertEquals(['team' => SORT_ASC, 'company' => SORT_ASC, 'age' => SORT_ASC], $query->orderBy);
+
+		$query->addOrderBy(['age' => SORT_DESC]);
+		$this->assertEquals(['team' => SORT_ASC, 'company' => SORT_ASC, 'age' => SORT_DESC], $query->orderBy);
+
+		$query->addOrderBy('age ASC, company DESC');
+		$this->assertEquals(['team' => SORT_ASC, 'company' => SORT_DESC, 'age' => SORT_ASC], $query->orderBy);
+	}
+
+	public function testLimitOffset()
+	{
+		$query = new Query;
+		$query->limit(10)->offset(5);
+		$this->assertEquals(10, $query->limit);
+		$this->assertEquals(5, $query->offset);
+	}
+
+	public function testUnion()
+	{
+	}
+}