PromiseCommand::parseColumnDefinition() - Code Metrics - Inspection of "Fix column definition building" - PlasmaPHP/driver-mysql - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( b4dd81...80eb77 )

by Charlotte

created 2019-06-21 07:50 UTC

PromiseCommand::parseColumnDefinition() A

↳ Parent: PromiseCommand

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	16
nc	1
nop	1
dl	0
loc	28
ccs	17
cts	17
cp	1
crap	1
rs	9.7333
c	0
b	0
f	0

<?php
/**
 * Plasma Driver MySQL component
 * Copyright 2018-2019 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"
        $buffer->readStringLength(); // database
        
        $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] ?? null;
        $type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
        
        return (new \Plasma\Drivers\MySQL\ColumnDefinition($table, $name, $type, $charset, $length, $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-2019 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	62	function __construct(\Plasma\DriverInterface $driver) {
49	62	$this->driver = $driver;
50	62	$this->deferred = new \React\Promise\Deferred();
51
52		$this->once('error', function (\Throwable $error) {
53	2	$this->deferred->reject($error);
54	62	});
55
56		$this->once('end', function () {
57		// Let the event loop read the stream buffer before resolving
58		$this->driver->getLoop()->futureTick(function () {
59	60	$this->deferred->resolve($this->resolveValue);
60	60	$this->resolveValue = null;
61	60	});
62	62	});
63	62	}
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	61	function getPromise(): \React\Promise\PromiseInterface {
76	61	return $this->deferred->promise();
77		}
78
79		/**
80		* Sets the parser state, if necessary. If not, return `-1`.
81		* @return int
82		*/
83	61	function setParserState(): int {
84	61	return -1;
85		}
86
87		/**
88		* Sets the command as completed. This state gets reported back to the user.
89		* @return void
90		*/
91	60	function onComplete(): void {
92	60	$this->finished = true;
93	60	$this->emit('end');
94	60	}
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	2	function onError(\Throwable $throwable): void {
102	2	$this->finished = true;
103
104	2	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	2	$this->emit('error', array($throwable));
117	2	}
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	60	function hasFinished(): bool {
131	60	return $this->finished;
132		}
133
134		/**
135		* Whether this command sets the connection as busy.
136		* @return bool
137		*/
138	61	function waitForCompletion(): bool {
139	61	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	48	function handleQueryOnNextCallerColumns(\Plasma\BinaryBuffer $buffer, \Plasma\Drivers\MySQL\ProtocolParser $parser): ?\Plasma\ColumnDefinitionInterface {
155	48	if($this->fieldsCount === null) {
156	47	$fieldCount = $buffer->readIntLength();
157
158	47	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	47	} 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	47	} 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	47	$this->fieldsCount = $fieldCount;
183	47	return null;
184		}
185
186	48	return static::parseColumnDefinition($buffer);
187		}
188
189		/**
190		* Parses the column definition.
191		* @param \Plasma\BinaryBuffer $buffer
192		* @return \Plasma\ColumnDefinitionInterface
193		*/
194	48	static function parseColumnDefinition(\Plasma\BinaryBuffer $buffer): \Plasma\ColumnDefinitionInterface {
195	48	$buffer->readStringLength(); // catalog - always "def"
196	48	$buffer->readStringLength(); // database
197
198	48	$table = $buffer->readStringLength();
199	48	$buffer->readStringLength(); // orgTable
200
201	48	$name = $buffer->readStringLength();
202	48	$buffer->readStringLength(); // orgName
203
204	48	$buffer->read(1); // 0x0C
205
206	48	$charset = $buffer->readInt2();
207	48	$length = $buffer->readInt4();
208	48	$type = $buffer->readInt1();
209	48	$flags = $buffer->readInt2();
210	48	$decimals = $buffer->readInt1();
211
212	48	$buffer->read(2); // fillers
213
214		/*if($this instanceof COM_FIELD_LIST) {
215		$buffer->readStringLength();
216		}*/
217
218	48	$charset = \Plasma\Drivers\MySQL\CharacterSetFlags::CHARSET_MAP[$charset] ?? null;
219	48	$type = \Plasma\Drivers\MySQL\FieldFlags::TYPE_MAP[$type] ?? 'Unknown type "'.$type.'"';
220
221	48	return (new \Plasma\Drivers\MySQL\ColumnDefinition($table, $name, $type, $charset, $length, $flags, $decimals));
222		}
223
224		/**
225		* Parses the text resultset row and returns the row.
226		* @param \Plasma\BinaryBuffer $buffer
227		* @return array
228		*/
229	10	protected function parseResultsetRow(\Plasma\BinaryBuffer $buffer): array {
230	10	$row = array();
231
232		/** @var \Plasma\ColumnDefinitionInterface $column */
233	10	foreach($this->fields as $column) {
234	10	$rawValue = $buffer->readStringLength();
235
236		try {
237	10	$value = \Plasma\Types\TypeExtensionsManager::getManager('driver-mysql')
238	10	->decodeType($column->getType(), $rawValue)
239		->getValue();
240	10	} catch (\Plasma\Exception $e) {
241	10	$value = \Plasma\Drivers\MySQL\TextProtocolValues::decode($column, $rawValue);
242		}
243
244	10	$row[$column->getName()] = $value;
245		}
246
247	10	return $row;
248		}
249		}
250

PlasmaPHP / driver-mysql

GitHub Access Token became invalid

Push — master ( b4dd81...80eb77 )

PromiseCommand::parseColumnDefinition() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like