PromiseCommand::parseResultsetRow() - Code Metrics - Inspection of "Register type extensions manager" - PlasmaPHP/driver-mysql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dfd258...a1c6c3 )

by Charlotte

created 2018-11-24 16:34 UTC

PromiseCommand::parseResultsetRow() A

↳ Parent: PromiseCommand

Complexity

Conditions	3
Paths	3

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	3.0067

Importance

Changes

Metric	Value
cc	3
eloc	11
nc	3
nop	1
dl	0
loc	19
ccs	10
cts	11
cp	0.9091
crap	3.0067
rs	9.9
c	0
b	0
f	0

<?php
/**
 * Plasma Driver MySQL component
 * Copyright 2018 PlasmaPHP, All Rights Reserved
 *
 * Website: https://github.com/PlasmaPHP
 * License: https://github.com/PlasmaPHP/driver-mysql/blob/master/LICENSE
*/

namespace Plasma\Drivers\MySQL\Commands;

/**
 * Abstract command which has a promise.
 * @internal
 */
abstract class PromiseCommand implements CommandInterface {
    use \Evenement\EventEmitterTrait;
    
    /**
     * @var \Plasma\DriverInterface
     */
    protected $driver;
    
    /**
     * @var \React\Promise\Deferred
     */
    protected $deferred;
    
    /**
     * @var mixed
     */
    protected $resolveValue;
    
    /**
     * @var bool
     */
    protected $finished = false;
    
    /**
     * @var int|null
     */
    protected $fieldsCount;
    
    /**
     * Constructor.
     * @param \Plasma\DriverInterface  $driver
     */
    function __construct(\Plasma\DriverInterface $driver) {
        $this->driver = $driver;
        $this->deferred = new \React\Promise\Deferred();
        
        $this->once('error', function (\Throwable $error) {
            $this->deferred->reject($error);
        });
        
        $this->once('end', function () {
            // Let the event loop read the stream buffer before resolving
            $this->driver->getLoop()->futureTick(function () {
                $this->deferred->resolve($this->resolveValue);
                $this->resolveValue = null;
            });
        });
    }
    
    /**
     * Get the encoded message for writing to the database connection.
     * @return string
     */
    abstract function getEncodedMessage(): string;
    
    /**
     * Get the promise.
     * @return \React\Promise\PromiseInterface
     */
    function getPromise(): \React\Promise\PromiseInterface {
        return $this->deferred->promise();
    }
    
    /**
     * Sets the parser state, if necessary. If not, return `-1`.
     * @return int
     */
    function setParserState(): int {
        return -1;
    }
    
    /**
     * Sets the command as completed. This state gets reported back to the user.
     * @return void
     */
    function onComplete(): void {
        $this->finished = true;
        $this->emit('end');
    }
    
    /**
     * Sets the command as errored. This state gets reported back to the user.
     * @param \Throwable  $throwable
     * @return void
     */
    function onError(\Throwable $throwable): void {
        $this->finished = true;
        
        if($this->resolveValue !== null) {
            // Let the event loop read the stream buffer and resolve the promise before emitting
            // Works around a race condition, where the promise resolves
            // after receiving an error response packet
            // and therefore the user misses the error event
            $this->driver->getLoop()->futureTick(function () use (&$throwable) {
                $this->emit('error', array($throwable));
            });
            
            return;
        }
        
        $this->emit('error', array($throwable));
    }
    
    /**
     * Sends the next received value into the command.
     * @param mixed  $value
     * @return void
     */
    abstract function onNext($value): void;
    
    /**
     * Whether the command has finished.
     * @return bool
     */
    function hasFinished(): bool {
        return $this->finished;
    }
    
    /**
     * Whether this command sets the connection as busy.
     * @return bool
     */
    function waitForCompletion(): bool {
        return true;
    }
    
    /**
     * Whether the sequence ID should be resetted.
     * @return bool
     */
    abstract function resetSequence(): bool;
    
    /**
     * Handles the column definitions of query commands on next caller.
     * @param \Plasma\BinaryBuffer                  $buffer
     * @param \Plasma\Drivers\MySQL\ProtocolParser  $parser
     * @return \Plasma\ColumnDefinitionInterface|null
     */
    function handleQueryOnNextCallerColumns(\Plasma\BinaryBuffer $buffer, \Plasma\Drivers\MySQL\ProtocolParser $parser): ?\Plasma\ColumnDefinitionInterface {
        if($this->fieldsCount === null) {
            $fieldCount = $buffer->readIntLength();
            
            if($fieldCount === 0x00) {
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\OkResponseMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            } elseif($fieldCount === 0xFB) {
                // Handle it on future tick, so we can cleanly finish the buffer of this call
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\LocalInFileRequestMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            } elseif($fieldCount === 0xFF) {
                $this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
                    $msg = new \Plasma\Drivers\MySQL\Messages\ErrResponseMessage($parser);
                    $parser->handleMessage($buffer, $msg);
                });
                
                return null;
            }
            
            $this->fieldsCount = $fieldCount;
            return null;
        }
        
        return static::parseColumnDefinition($buffer);
    }
    
    /**
     * Parses the column definition.
     * @param \Plasma\BinaryBuffer  $buffer
     * @return \Plasma\ColumnDefinitionInterface
     */
    static function parseColumnDefinition(\Plasma\BinaryBuffer $buffer): \Plasma\ColumnDefinitionInterface {
        $buffer->readStringLength(); // catalog - always "def"
        $database = $buffer->readStringLength();
        
        $table = $buffer->readStringLength();
        $buffer->readStringLength(); // orgTable
        
        $name = $buffer->readStringLength();
        $buffer->readStringLength(); // orgName
        
        $buffer->read(1); // 0x0C
        
        $charset = $buffer->readInt2();
        $length = $buffer->readInt4();
        $type = $buffer->readInt1();
        $flags = $buffer->readInt2();
        $decimals = $buffer->readInt1();
        
        $buffer->read(2); // fillers
        
        /*if($this instanceof COM_FIELD_LIST) {
            $buffer->readStringLength();
        }*/
        
        $charset = \Plasma\Drivers\MySQL\CharacterSetFlags::CHARSET_MAP[$charset] ?? 'Unknown charset "'.$charset.'"';
        $type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
        $nullable = (($flags & \Plasma\Drivers\MySQL\FieldFlags::NOT_NULL_FLAG) === 0);
        
        return (new \Plasma\ColumnDefinition($database, $table, $name, $type, $charset, $length, $nullable, $flags, $decimals));
    }
    
    /**
     * Parses the text resultset row and returns the row.
     * @param \Plasma\BinaryBuffer  $buffer
     * @return array
     */
    protected function parseResultsetRow(\Plasma\BinaryBuffer $buffer): array {
        $row = array();
        
        /** @var \Plasma\ColumnDefinitionInterface  $column */
        foreach($this->fields as $column) {
            $rawValue = $buffer->readStringLength();
            
            try {
                $value = \Plasma\Types\TypeExtensionsManager::getManager('driver-mysql')
                    ->decodeType($column->getType(), $rawValue)
                    ->getValue();
            } catch (\Plasma\Exception $e) {
                $value = \Plasma\Drivers\MySQL\TextProtocolValues::decode($column, $rawValue);
            }
            
            $row[$column->getName()] = $value;
        }
        
        return $row;
    }
}


1		<?php
2		/**
3		* Plasma Driver MySQL component
4		* Copyright 2018 PlasmaPHP, All Rights Reserved
5		*
6		* Website: https://github.com/PlasmaPHP
7		* License: https://github.com/PlasmaPHP/driver-mysql/blob/master/LICENSE
8		*/
9
10		namespace Plasma\Drivers\MySQL\Commands;
11
12		/**
13		* Abstract command which has a promise.
14		* @internal
15		*/
16		abstract class PromiseCommand implements CommandInterface {
17		use \Evenement\EventEmitterTrait;
18
19		/**
20		* @var \Plasma\DriverInterface
21		*/
22		protected $driver;
23
24		/**
25		* @var \React\Promise\Deferred
26		*/
27		protected $deferred;
28
29		/**
30		* @var mixed
31		*/
32		protected $resolveValue;
33
34		/**
35		* @var bool
36		*/
37		protected $finished = false;
38
39		/**
40		* @var int\|null
41		*/
42		protected $fieldsCount;
43
44		/**
45		* Constructor.
46		* @param \Plasma\DriverInterface $driver
47		*/
48	61	function __construct(\Plasma\DriverInterface $driver) {
49	61	$this->driver = $driver;
50	61	$this->deferred = new \React\Promise\Deferred();
51
52		$this->once('error', function (\Throwable $error) {
53		$this->deferred->reject($error);
54	61	});
55
56		$this->once('end', function () {
57		// Let the event loop read the stream buffer before resolving
58		$this->driver->getLoop()->futureTick(function () {
59	47	$this->deferred->resolve($this->resolveValue);
60	47	$this->resolveValue = null;
61	47	});
62	61	});
63	61	}
64
65		/**
66		* Get the encoded message for writing to the database connection.
67		* @return string
68		*/
69		abstract function getEncodedMessage(): string;
70
71		/**
72		* Get the promise.
73		* @return \React\Promise\PromiseInterface
74		*/
75	54	function getPromise(): \React\Promise\PromiseInterface {
76	54	return $this->deferred->promise();
77		}
78
79		/**
80		* Sets the parser state, if necessary. If not, return `-1`.
81		* @return int
82		*/
83	52	function setParserState(): int {
84	52	return -1;
85		}
86
87		/**
88		* Sets the command as completed. This state gets reported back to the user.
89		* @return void
90		*/
91	47	function onComplete(): void {
92	47	$this->finished = true;
93	47	$this->emit('end');
94	47	}
95
96		/**
97		* Sets the command as errored. This state gets reported back to the user.
98		* @param \Throwable $throwable
99		* @return void
100		*/
101		function onError(\Throwable $throwable): void {
102		$this->finished = true;
103
104		if($this->resolveValue !== null) {
105		// Let the event loop read the stream buffer and resolve the promise before emitting
106		// Works around a race condition, where the promise resolves
107		// after receiving an error response packet
108		// and therefore the user misses the error event
109		$this->driver->getLoop()->futureTick(function () use (&$throwable) {
110		$this->emit('error', array($throwable));
111		});
112
113		return;
114		}
115
116		$this->emit('error', array($throwable));
117		}
118
119		/**
120		* Sends the next received value into the command.
121		* @param mixed $value
122		* @return void
123		*/
124		abstract function onNext($value): void;
125
126		/**
127		* Whether the command has finished.
128		* @return bool
129		*/
130	47	function hasFinished(): bool {
131	47	return $this->finished;
132		}
133
134		/**
135		* Whether this command sets the connection as busy.
136		* @return bool
137		*/
138	52	function waitForCompletion(): bool {
139	52	return true;
140		}
141
142		/**
143		* Whether the sequence ID should be resetted.
144		* @return bool
145		*/
146		abstract function resetSequence(): bool;
147
148		/**
149		* Handles the column definitions of query commands on next caller.
150		* @param \Plasma\BinaryBuffer $buffer
151		* @param \Plasma\Drivers\MySQL\ProtocolParser $parser
152		* @return \Plasma\ColumnDefinitionInterface\|null
153		*/
154	43	function handleQueryOnNextCallerColumns(\Plasma\BinaryBuffer $buffer, \Plasma\Drivers\MySQL\ProtocolParser $parser): ?\Plasma\ColumnDefinitionInterface {
155	43	if($this->fieldsCount === null) {
156	42	$fieldCount = $buffer->readIntLength();
157
158	42	if($fieldCount === 0x00) {
159		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
160		$msg = new \Plasma\Drivers\MySQL\Messages\OkResponseMessage($parser);
161		$parser->handleMessage($buffer, $msg);
162		});
163
164		return null;
165	42	} elseif($fieldCount === 0xFB) {
166		// Handle it on future tick, so we can cleanly finish the buffer of this call
167		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
168		$msg = new \Plasma\Drivers\MySQL\Messages\LocalInFileRequestMessage($parser);
169		$parser->handleMessage($buffer, $msg);
170		});
171
172		return null;
173	42	} elseif($fieldCount === 0xFF) {
174		$this->driver->getLoop()->futureTick(function () use (&$buffer, &$parser) {
175		$msg = new \Plasma\Drivers\MySQL\Messages\ErrResponseMessage($parser);
176		$parser->handleMessage($buffer, $msg);
177		});
178
179		return null;
180		}
181
182	42	$this->fieldsCount = $fieldCount;
183	42	return null;
184		}
185
186	43	return static::parseColumnDefinition($buffer);
187		}
188
189		/**
190		* Parses the column definition.
191		* @param \Plasma\BinaryBuffer $buffer
192		* @return \Plasma\ColumnDefinitionInterface
193		*/
194	43	static function parseColumnDefinition(\Plasma\BinaryBuffer $buffer): \Plasma\ColumnDefinitionInterface {
195	43	$buffer->readStringLength(); // catalog - always "def"
196	43	$database = $buffer->readStringLength();
197
198	43	$table = $buffer->readStringLength();
199	43	$buffer->readStringLength(); // orgTable
200
201	43	$name = $buffer->readStringLength();
202	43	$buffer->readStringLength(); // orgName
203
204	43	$buffer->read(1); // 0x0C
205
206	43	$charset = $buffer->readInt2();
207	43	$length = $buffer->readInt4();
208	43	$type = $buffer->readInt1();
209	43	$flags = $buffer->readInt2();
210	43	$decimals = $buffer->readInt1();
211
212	43	$buffer->read(2); // fillers
213
214		/*if($this instanceof COM_FIELD_LIST) {
215		$buffer->readStringLength();
216		}*/
217
218	43	$charset = \Plasma\Drivers\MySQL\CharacterSetFlags::CHARSET_MAP[$charset] ?? 'Unknown charset "'.$charset.'"';
219	43	$type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
220	43	$nullable = (($flags & \Plasma\Drivers\MySQL\FieldFlags::NOT_NULL_FLAG) === 0);
221
222	43	return (new \Plasma\ColumnDefinition($database, $table, $name, $type, $charset, $length, $nullable, $flags, $decimals));
223		}
224
225		/**
226		* Parses the text resultset row and returns the row.
227		* @param \Plasma\BinaryBuffer $buffer
228		* @return array
229		*/
230	7	protected function parseResultsetRow(\Plasma\BinaryBuffer $buffer): array {
231	7	$row = array();
232
233		/** @var \Plasma\ColumnDefinitionInterface $column */
234	7	foreach($this->fields as $column) {
235	7	$rawValue = $buffer->readStringLength();
236
237		try {
238	7	$value = \Plasma\Types\TypeExtensionsManager::getManager('driver-mysql')
239	7	->decodeType($column->getType(), $rawValue)
240		->getValue();
241	7	} catch (\Plasma\Exception $e) {
242	7	$value = \Plasma\Drivers\MySQL\TextProtocolValues::decode($column, $rawValue);
243		}
244
245	7	$row[$column->getName()] = $value;
246		}
247
248	7	return $row;
249		}
250		}
251

PlasmaPHP / driver-mysql

GitHub Access Token became invalid

Push — master ( dfd258...a1c6c3 )

PromiseCommand::parseResultsetRow() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like