ColumnDTO::make() - Code Metrics - Moln/php-mysql-replication - Measure and Improve Code Quality continuously with Scrutinizer

ColumnDTO::make() C
last analyzed 2024-01-19 06:08 UTC

↳ Parent: ColumnDTO

Complexity

Conditions	17
Paths	14

Size

Total Lines	63
Code Lines	53

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	52
CRAP Score	17.0019

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
cc	17
eloc	53
c	2
b	1
f	0
nc	14
nop	3
dl	0
loc	63
ccs	52
cts	53
cp	0.9811
crap	17.0019
rs	5.2166

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace MySQLReplication\Event\RowEvent;

use MySQLReplication\BinaryDataReader\BinaryDataReader;
use MySQLReplication\Definitions\ConstFieldType;
use MySQLReplication\Repository\FieldDTO;

class ColumnDTO
{
    private $fieldDTO;
    private $maxLength;
    private $size;
    private $fsp;
    private $lengthSize;
    private $precision;
    private $decimals;
    private $bits;
    private $bytes;
    private $type;

    public function __construct(
        FieldDTO $fieldDTO,
        int $type,
        int $maxLength,
        int $size,
        int $fsp,
        int $lengthSize,
        int $precision,
        int $decimals,
        int $bits,
        int $bytes
    ) {
        $this->fieldDTO = $fieldDTO;
        $this->type = $type;
        $this->maxLength = $maxLength;
        $this->size = $size;
        $this->fsp = $fsp;
        $this->lengthSize = $lengthSize;
        $this->precision = $precision;
        $this->decimals = $decimals;
        $this->bits = $bits;
        $this->bytes = $bytes;
    }

    public static function make(
        int $columnType,
        FieldDTO $fieldDTO,
        BinaryDataReader $binaryDataReader
    ): self {
        $maxLength = 0;
        $size = 0;
        $fsp = 0;
        $lengthSize = 0;
        $precision = 0;
        $decimals = 0;
        $bits = 0;
        $bytes = 0;

        if ($columnType === ConstFieldType::VARCHAR) {
            $maxLength = $binaryDataReader->readUInt16();
        } elseif ($columnType === ConstFieldType::DOUBLE) {
            $size = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::FLOAT) {
            $size = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::TIMESTAMP2) {
            $fsp = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::DATETIME2) {
            $fsp = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::TIME2) {
            $fsp = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::VAR_STRING || $columnType === ConstFieldType::STRING) {
            $metadata = ($binaryDataReader->readUInt8() << 8) + $binaryDataReader->readUInt8();
            $realType = $metadata >> 8;
            if ($realType === ConstFieldType::SET || $realType === ConstFieldType::ENUM) {
                $columnType = $realType;
                $size = $metadata & 0x00ff;
            } else {
                $maxLength = ((($metadata >> 4) & 0x300) ^ 0x300) + ($metadata & 0x00ff);
            }
        } elseif ($columnType === ConstFieldType::BLOB || $columnType === ConstFieldType::IGNORE) {
            $lengthSize = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::GEOMETRY) {
            $lengthSize = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::JSON) {
            $lengthSize = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::NEWDECIMAL) {
            $precision = $binaryDataReader->readUInt8();
            $decimals = $binaryDataReader->readUInt8();
        } elseif ($columnType === ConstFieldType::BIT) {
            $bits = $binaryDataReader->readUInt8();
            $bytes = $binaryDataReader->readUInt8();

            $bits = ($bytes * 8) + $bits;
            $bytes = (int)(($bits + 7) / 8);
        }

        return new self(
            $fieldDTO,
            $columnType,
            $maxLength,
            $size,
            $fsp,
            $lengthSize,
            $precision,
            $decimals,
            $bits,
            $bytes
        );
    }

    public function getFieldDTO(): FieldDTO
    {
        return $this->fieldDTO;
    }

    public function getMaxLength(): int
    {
        return $this->maxLength;
    }

    public function getSize(): int
    {
        return $this->size;
    }

    public function getFsp(): int
    {
        return $this->fsp;
    }

    public function getLengthSize(): int
    {
        return $this->lengthSize;
    }

    public function getPrecision(): int
    {
        return $this->precision;
    }

    public function getDecimals(): int
    {
        return $this->decimals;
    }

    public function getBits(): int
    {
        return $this->bits;
    }

    public function getBytes(): int
    {
        return $this->bytes;
    }

    public function getType(): int
    {
        return $this->type;
    }

    public function getName(): string
    {
        return $this->fieldDTO->getColumnName();
    }

    public function getEnumValues(): array
    {
        if ($this->type === ConstFieldType::ENUM) {
            return explode(',', str_replace(['enum(', ')', '\''], '', $this->fieldDTO->getColumnType()));
        }

        return [];
    }

    public function getSetValues(): array
    {
        if ($this->type === ConstFieldType::SET) {
            return explode(',', str_replace(['set(', ')', '\''], '', $this->fieldDTO->getColumnType()));
        }

        return [];
    }

    public function isUnsigned(): bool
    {
        return ! (stripos($this->fieldDTO->getColumnType(), 'unsigned') === false);
    }

    public function isPrimary(): bool
    {
        return $this->fieldDTO->getColumnKey() === 'PRI';
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace MySQLReplication\Event\RowEvent;
6
7		use MySQLReplication\BinaryDataReader\BinaryDataReader;
8		use MySQLReplication\Definitions\ConstFieldType;
9		use MySQLReplication\Repository\FieldDTO;
10
11		class ColumnDTO
12		{
13		private $fieldDTO;
14		private $maxLength;
15		private $size;
16		private $fsp;
17		private $lengthSize;
18		private $precision;
19		private $decimals;
20		private $bits;
21		private $bytes;
22		private $type;
23
24	53	public function __construct(
25		FieldDTO $fieldDTO,
26		int $type,
27		int $maxLength,
28		int $size,
29		int $fsp,
30		int $lengthSize,
31		int $precision,
32		int $decimals,
33		int $bits,
34		int $bytes
35		) {
36	53	$this->fieldDTO = $fieldDTO;
37	53	$this->type = $type;
38	53	$this->maxLength = $maxLength;
39	53	$this->size = $size;
40	53	$this->fsp = $fsp;
41	53	$this->lengthSize = $lengthSize;
42	53	$this->precision = $precision;
43	53	$this->decimals = $decimals;
44	53	$this->bits = $bits;
45	53	$this->bytes = $bytes;
46		}
47
48	53	public static function make(
49		int $columnType,
50		FieldDTO $fieldDTO,
51		BinaryDataReader $binaryDataReader
52		): self {
53	53	$maxLength = 0;
54	53	$size = 0;
55	53	$fsp = 0;
56	53	$lengthSize = 0;
57	53	$precision = 0;
58	53	$decimals = 0;
59	53	$bits = 0;
60	53	$bytes = 0;
61
62	53	if ($columnType === ConstFieldType::VARCHAR) {
63	6	$maxLength = $binaryDataReader->readUInt16();
64	51	} elseif ($columnType === ConstFieldType::DOUBLE) {
65	1	$size = $binaryDataReader->readUInt8();
66	50	} elseif ($columnType === ConstFieldType::FLOAT) {
67	1	$size = $binaryDataReader->readUInt8();
68	49	} elseif ($columnType === ConstFieldType::TIMESTAMP2) {
69	2	$fsp = $binaryDataReader->readUInt8();
70	47	} elseif ($columnType === ConstFieldType::DATETIME2) {
71	4	$fsp = $binaryDataReader->readUInt8();
72	44	} elseif ($columnType === ConstFieldType::TIME2) {
73	2	$fsp = $binaryDataReader->readUInt8();
74	43	} elseif ($columnType === ConstFieldType::VAR_STRING \|\| $columnType === ConstFieldType::STRING) {
75	5	$metadata = ($binaryDataReader->readUInt8() << 8) + $binaryDataReader->readUInt8();
76	5	$realType = $metadata >> 8;
77	5	if ($realType === ConstFieldType::SET \|\| $realType === ConstFieldType::ENUM) {
78	2	$columnType = $realType;
79	2	$size = $metadata & 0x00ff;
80		} else {
81	5	$maxLength = ((($metadata >> 4) & 0x300) ^ 0x300) + ($metadata & 0x00ff);
82		}
83	38	} elseif ($columnType === ConstFieldType::BLOB \|\| $columnType === ConstFieldType::IGNORE) {
84	5	$lengthSize = $binaryDataReader->readUInt8();
85	34	} elseif ($columnType === ConstFieldType::GEOMETRY) {
86	1	$lengthSize = $binaryDataReader->readUInt8();
87	33	} elseif ($columnType === ConstFieldType::JSON) {
88		$lengthSize = $binaryDataReader->readUInt8();
89	33	} elseif ($columnType === ConstFieldType::NEWDECIMAL) {
90	10	$precision = $binaryDataReader->readUInt8();
91	10	$decimals = $binaryDataReader->readUInt8();
92	23	} elseif ($columnType === ConstFieldType::BIT) {
93	1	$bits = $binaryDataReader->readUInt8();
94	1	$bytes = $binaryDataReader->readUInt8();
95
96	1	$bits = ($bytes * 8) + $bits;
97	1	$bytes = (int)(($bits + 7) / 8);
98		}
99
100	53	return new self(
101	53	$fieldDTO,
102	53	$columnType,
103	53	$maxLength,
104	53	$size,
105	53	$fsp,
106	53	$lengthSize,
107	53	$precision,
108	53	$decimals,
109	53	$bits,
110	53	$bytes
111	53	);
112		}
113
114		public function getFieldDTO(): FieldDTO
115		{
116		return $this->fieldDTO;
117		}
118
119	8	public function getMaxLength(): int
120		{
121	8	return $this->maxLength;
122		}
123
124	2	public function getSize(): int
125		{
126	2	return $this->size;
127		}
128
129	8	public function getFsp(): int
130		{
131	8	return $this->fsp;
132		}
133
134	6	public function getLengthSize(): int
135		{
136	6	return $this->lengthSize;
137		}
138
139	10	public function getPrecision(): int
140		{
141	10	return $this->precision;
142		}
143
144	10	public function getDecimals(): int
145		{
146	10	return $this->decimals;
147		}
148
149	1	public function getBits(): int
150		{
151	1	return $this->bits;
152		}
153
154	1	public function getBytes(): int
155		{
156	1	return $this->bytes;
157		}
158
159	52	public function getType(): int
160		{
161	52	return $this->type;
162		}
163
164	52	public function getName(): string
165		{
166	52	return $this->fieldDTO->getColumnName();
167		}
168
169	1	public function getEnumValues(): array
170		{
171	1	if ($this->type === ConstFieldType::ENUM) {
172	1	return explode(',', str_replace(['enum(', ')', '\''], '', $this->fieldDTO->getColumnType()));
173		}
174
175		return [];
176		}
177
178	1	public function getSetValues(): array
179		{
180	1	if ($this->type === ConstFieldType::SET) {
181	1	return explode(',', str_replace(['set(', ')', '\''], '', $this->fieldDTO->getColumnType()));
182		}
183
184		return [];
185		}
186
187	18	public function isUnsigned(): bool
188		{
189	18	return ! (stripos($this->fieldDTO->getColumnType(), 'unsigned') === false);
190		}
191
192		public function isPrimary(): bool
193		{
194		return $this->fieldDTO->getColumnKey() === 'PRI';
195		}
196		}
197

Moln / php-mysql-replication

ColumnDTO::make() C last analyzed 2024-01-19 06:08 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ColumnDTO::make() C
last analyzed 2024-01-19 06:08 UTC