Database::appendQueryToStack() - Code Metrics - evseevnn/php-cassandra-binary - Measure and Improve Code Quality continuously with Scrutinizer

Database::appendQueryToStack() B
last analyzed 2017-02-09 10:18 UTC

↳ Parent: Database

Complexity

Conditions	5
Paths	6

Size

Total Lines	19
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	14
nc	6
nop	2

<?php
namespace evseevnn\Cassandra;
use evseevnn\Cassandra\Enum\ConsistencyEnum;
use evseevnn\Cassandra\Enum\OpcodeEnum;
use evseevnn\Cassandra\Exception\CassandraException;
use evseevnn\Cassandra\Exception\ConnectionException;
use evseevnn\Cassandra\Exception\QueryException;
use evseevnn\Cassandra\Protocol\RequestFactory;
use evseevnn\Cassandra\Protocol\Response\Rows;

class Database {

	const POSTFIX_DUPLICATE_QUERY_VARIABLE = '_prefix';

	/**
	 * @var Cluster
	 */
	private $cluster;

	/**
	 * @var Connection
	 */
	private $connection;

	/**
	 * Connection options
	 * @var array
	 */
	private $options = [
		'CQL_VERSION' => '3.0.0'
	];

	/**
	 * @var string
	 */
	private $keyspace;

	/**
	 * @var string
	 */
	private $batchQuery = '';

	/**
	 * @var array
	 */
	private $batchQueryData = [];

	/**
	 * @param array $nodes
	 * @param string $keyspace
	 * @param array $options
	 */
	public function __construct(array $nodes, $keyspace = '', array $options = []) {
		$this->cluster = new Cluster($nodes);
		$this->connection = new Connection($this->cluster);
		$this->options = array_merge($this->options, $options);
		$this->keyspace = $keyspace;
	}

	/**
	 * Connect to database
	 * @throws Exception\ConnectionException
	 * @throws Exception\CassandraException
	 * @return bool
	 */
	public function connect() {
		if ($this->connection->isConnected()) return true;
		$this->connection->connect();
		$response = $this->connection->sendRequest(
			RequestFactory::startup($this->options)
		);
		$responseType = $response->getType();
		switch($responseType) {
			case OpcodeEnum::ERROR:
				throw new ConnectionException($response->getData());

			case OpcodeEnum::AUTHENTICATE:
				$nodeOptions = $this->connection->getNode()->getOptions();
				$response = $this->connection->sendRequest(
					RequestFactory::credentials(
						$nodeOptions['username'],
						$nodeOptions['password']
					)
				);
				$responseType = $response->getType();
		}
		if ($responseType === OpcodeEnum::ERROR) throw new ConnectionException($response->getData());
		if (!empty($this->keyspace)) $this->setKeyspace($this->keyspace);

		return true;
	}

	/**
	 * Disconnect to database
	 * @return bool
	 */
	public function disconnect() {
		if ($this->connection->isConnected()) return $this->connection->disconnect();
		return true;
	}

	/**
	 * Start transaction
	 */
	public function beginBatch() {
		if (!$this->batchQuery) {
			$this->batchQuery = "BEGIN BATCH\n";
			$this->batchQueryData = [];
		}
	}

	/**
	 * Start counter transaction
	 */
	public function beginCounterBatch() {
		if (!$this->batchQuery) {
			$this->batchQuery = "BEGIN COUNTER BATCH\n";
			$this->batchQueryData = [];
		}
	}

	/**
	 * Start unlogged transaction
	 */
	public function beginUnloggedBatch() {
		if (!$this->batchQuery) {
			$this->batchQuery = "BEGIN UNLOGGED BATCH\n";
			$this->batchQueryData = [];
		}
	}

	/**
	 * Exec transaction
	 */
	public function applyBatch($consistency = ConsistencyEnum::CONSISTENCY_QUORUM) {
		$this->batchQuery .= 'APPLY BATCH;';
		// exec
		$result = $this->query($this->batchQuery, $this->batchQueryData, $consistency);
		// cleaning
		$this->batchQuery = '';
		$this->batchQueryData = [];
		return $result;
	}

	/**
	 * @param string $cql
	 * @param array $values
	 */
	private function appendQueryToStack($cql, array $values) {
		$valuesModified = false;
		foreach($values as $key => $value) {
			if (is_string($key) && isset($this->batchQueryData[$key])) {
				$newFieldName = $key . self::POSTFIX_DUPLICATE_QUERY_VARIABLE;
				$cql = str_replace(":{$key}", ":{$newFieldName}", $cql);
				unset($values[$key]);
				$values[$newFieldName] = $value;
				$valuesModified = true;
			}
		}
		if ($valuesModified) {
			// Retry
			$this->appendQueryToStack($cql, $values);
		} else {
			$this->batchQuery .= rtrim($cql, ';') . ";\n";
			$this->batchQueryData = array_merge($this->batchQueryData, $values);
		}
	}

	/**
	 * Send query into database
	 * @param string $cql
	 * @param array $values
	 * @param int $consistency
	 * @throws Exception\QueryException
	 * @throws Exception\CassandraException
	 * @return array|null
	 */
	public function query($cql, array $values = [], $consistency = ConsistencyEnum::CONSISTENCY_QUORUM) {
		if ($this->batchQuery && in_array(substr($cql, 0, 6), ['INSERT', 'UPDATE', 'DELETE'])) {
			$this->appendQueryToStack($cql, $values);
			return true;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
		}
		if (empty($values)) {
			$response = $this->connection->sendRequest(RequestFactory::query($cql, $consistency));
		} else {
			$response = $this->connection->sendRequest(RequestFactory::prepare($cql));
			$responseType = $response->getType();
			if ($responseType !== OpcodeEnum::RESULT) {
				throw new QueryException($response->getData());
			} else {
				$preparedData = $response->getData();
			}
			$response = $this->connection->sendRequest(
				RequestFactory::execute($preparedData, $values, $consistency)
			);
		}

		if ($response->getType() === OpcodeEnum::ERROR) {
			throw new CassandraException($response->getData());
		} else {
			$data = $response->getData();
			if ($data instanceof Rows) {
				return $data->asArray();
			}
		}

		return !empty($data) ? $data : $response->getType() === OpcodeEnum::RESULT;
	}

	/**
	 * @param string $keyspace
	 * @throws Exception\CassandraException
	 */
	public function setKeyspace($keyspace) {
		$this->keyspace = $keyspace;
		if ($this->connection->isConnected()) {
			$response = $this->connection->sendRequest(
				RequestFactory::query("USE {$this->keyspace};", ConsistencyEnum::CONSISTENCY_QUORUM)
			);
			if ($response->getType() === OpcodeEnum::ERROR) throw new CassandraException($response->getData());
		}
	}
}


1			<?php
2			namespace evseevnn\Cassandra;
3			use evseevnn\Cassandra\Enum\ConsistencyEnum;
4			use evseevnn\Cassandra\Enum\OpcodeEnum;
5			use evseevnn\Cassandra\Exception\CassandraException;
6			use evseevnn\Cassandra\Exception\ConnectionException;
7			use evseevnn\Cassandra\Exception\QueryException;
8			use evseevnn\Cassandra\Protocol\RequestFactory;
9			use evseevnn\Cassandra\Protocol\Response\Rows;
10
11			class Database {
12
13			const POSTFIX_DUPLICATE_QUERY_VARIABLE = '_prefix';
14
15			/**
16			* @var Cluster
17			*/
18			private $cluster;
19
20			/**
21			* @var Connection
22			*/
23			private $connection;
24
25			/**
26			* Connection options
27			* @var array
28			*/
29			private $options = [
30			'CQL_VERSION' => '3.0.0'
31			];
32
33			/**
34			* @var string
35			*/
36			private $keyspace;
37
38			/**
39			* @var string
40			*/
41			private $batchQuery = '';
42
43			/**
44			* @var array
45			*/
46			private $batchQueryData = [];
47
48			/**
49			* @param array $nodes
50			* @param string $keyspace
51			* @param array $options
52			*/
53			public function __construct(array $nodes, $keyspace = '', array $options = []) {
54			$this->cluster = new Cluster($nodes);
55			$this->connection = new Connection($this->cluster);
56			$this->options = array_merge($this->options, $options);
57			$this->keyspace = $keyspace;
58			}
59
60			/**
61			* Connect to database
62			* @throws Exception\ConnectionException
63			* @throws Exception\CassandraException
64			* @return bool
65			*/
66			public function connect() {
67			if ($this->connection->isConnected()) return true;
68			$this->connection->connect();
69			$response = $this->connection->sendRequest(
70			RequestFactory::startup($this->options)
71			);
72			$responseType = $response->getType();
73			switch($responseType) {
74			case OpcodeEnum::ERROR:
75			throw new ConnectionException($response->getData());
76
77			case OpcodeEnum::AUTHENTICATE:
78			$nodeOptions = $this->connection->getNode()->getOptions();
79			$response = $this->connection->sendRequest(
80			RequestFactory::credentials(
81			$nodeOptions['username'],
82			$nodeOptions['password']
83			)
84			);
85			$responseType = $response->getType();
86			}
87			if ($responseType === OpcodeEnum::ERROR) throw new ConnectionException($response->getData());
88			if (!empty($this->keyspace)) $this->setKeyspace($this->keyspace);
89
90			return true;
91			}
92
93			/**
94			* Disconnect to database
95			* @return bool
96			*/
97			public function disconnect() {
98			if ($this->connection->isConnected()) return $this->connection->disconnect();
99			return true;
100			}
101
102			/**
103			* Start transaction
104			*/
105			public function beginBatch() {
106			if (!$this->batchQuery) {
107			$this->batchQuery = "BEGIN BATCH\n";
108			$this->batchQueryData = [];
109			}
110			}
111
112			/**
113			* Start counter transaction
114			*/
115			public function beginCounterBatch() {
116			if (!$this->batchQuery) {
117			$this->batchQuery = "BEGIN COUNTER BATCH\n";
118			$this->batchQueryData = [];
119			}
120			}
121
122			/**
123			* Start unlogged transaction
124			*/
125			public function beginUnloggedBatch() {
126			if (!$this->batchQuery) {
127			$this->batchQuery = "BEGIN UNLOGGED BATCH\n";
128			$this->batchQueryData = [];
129			}
130			}
131
132			/**
133			* Exec transaction
134			*/
135			public function applyBatch($consistency = ConsistencyEnum::CONSISTENCY_QUORUM) {
136			$this->batchQuery .= 'APPLY BATCH;';
137			// exec
138			$result = $this->query($this->batchQuery, $this->batchQueryData, $consistency);
139			// cleaning
140			$this->batchQuery = '';
141			$this->batchQueryData = [];
142			return $result;
143			}
144
145			/**
146			* @param string $cql
147			* @param array $values
148			*/
149			private function appendQueryToStack($cql, array $values) {
150			$valuesModified = false;
151			foreach($values as $key => $value) {
152			if (is_string($key) && isset($this->batchQueryData[$key])) {
153			$newFieldName = $key . self::POSTFIX_DUPLICATE_QUERY_VARIABLE;
154			$cql = str_replace(":{$key}", ":{$newFieldName}", $cql);
155			unset($values[$key]);
156			$values[$newFieldName] = $value;
157			$valuesModified = true;
158			}
159			}
160			if ($valuesModified) {
161			// Retry
162			$this->appendQueryToStack($cql, $values);
163			} else {
164			$this->batchQuery .= rtrim($cql, ';') . ";\n";
165			$this->batchQueryData = array_merge($this->batchQueryData, $values);
166			}
167			}
168
169			/**
170			* Send query into database
171			* @param string $cql
172			* @param array $values
173			* @param int $consistency
174			* @throws Exception\QueryException
175			* @throws Exception\CassandraException
176			* @return array\|null
177			*/
178			public function query($cql, array $values = [], $consistency = ConsistencyEnum::CONSISTENCY_QUORUM) {
179			if ($this->batchQuery && in_array(substr($cql, 0, 6), ['INSERT', 'UPDATE', 'DELETE'])) {
180			$this->appendQueryToStack($cql, $values);
181			return true;
			0 ignored issues – show Bug Best Practice introduced 2017-02-09 10:18 UTC by Report Bug Copy Issue Report The return type of `return true;` (`boolean`) is incompatible with the return type documented by `evseevnn\Cassandra\Database::query` of type `array\|null`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
182			}
183			if (empty($values)) {
184			$response = $this->connection->sendRequest(RequestFactory::query($cql, $consistency));
185			} else {
186			$response = $this->connection->sendRequest(RequestFactory::prepare($cql));
187			$responseType = $response->getType();
188			if ($responseType !== OpcodeEnum::RESULT) {
189			throw new QueryException($response->getData());
190			} else {
191			$preparedData = $response->getData();
192			}
193			$response = $this->connection->sendRequest(
194			RequestFactory::execute($preparedData, $values, $consistency)
195			);
196			}
197
198			if ($response->getType() === OpcodeEnum::ERROR) {
199			throw new CassandraException($response->getData());
200			} else {
201			$data = $response->getData();
202			if ($data instanceof Rows) {
203			return $data->asArray();
204			}
205			}
206
207			return !empty($data) ? $data : $response->getType() === OpcodeEnum::RESULT;
208			}
209
210			/**
211			* @param string $keyspace
212			* @throws Exception\CassandraException
213			*/
214			public function setKeyspace($keyspace) {
215			$this->keyspace = $keyspace;
216			if ($this->connection->isConnected()) {
217			$response = $this->connection->sendRequest(
218			RequestFactory::query("USE {$this->keyspace};", ConsistencyEnum::CONSISTENCY_QUORUM)
219			);
220			if ($response->getType() === OpcodeEnum::ERROR) throw new CassandraException($response->getData());
221			}
222			}
223			}
224

evseevnn / php-cassandra-binary

Database::appendQueryToStack() B last analyzed 2017-02-09 10:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Database::appendQueryToStack() B
last analyzed 2017-02-09 10:18 UTC