thecodingmachine /
magic-query
| Conditions | 78 |
| Paths | 782 |
| Total Lines | 355 |
| Code Lines | 249 |
| Lines | 18 |
| Ratio | 5.07 % |
| Changes | 11 | ||
| Bugs | 0 | Features | 1 |
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 50 | public static function toObject(array $desc) |
||
| 51 | { |
||
| 52 | if (!isset($desc['expr_type'])) { |
||
| 53 | throw new \Exception('Invalid array. Could not find expression type: '.var_export($desc, true)); |
||
| 54 | } |
||
| 55 | |||
| 56 | switch ($desc['expr_type']) { |
||
| 57 | case ExpressionType::LIMIT_CONST: |
||
| 58 | if (substr($desc['base_expr'], 0, 1) == ':') { |
||
| 59 | $instance = new UnquotedParameter(); |
||
| 60 | $instance->setName(substr($desc['base_expr'], 1)); |
||
| 61 | } else { |
||
| 62 | $instance = new LimitNode(); |
||
| 63 | $expr = $desc['base_expr']; |
||
| 64 | if (strpos($expr, "'") === 0) { |
||
| 65 | $expr = substr($expr, 1); |
||
| 66 | } |
||
| 67 | View Code Duplication | if (strrpos($expr, "'") === strlen($expr) - 1) { |
|
|
|
|||
| 68 | $expr = substr($expr, 0, strlen($expr) - 1); |
||
| 69 | } |
||
| 70 | $expr = stripslashes($expr); |
||
| 71 | |||
| 72 | $instance->setValue($expr); |
||
| 73 | } |
||
| 74 | // Debug: |
||
| 75 | unset($desc['base_expr']); |
||
| 76 | unset($desc['expr_type']); |
||
| 77 | unset($desc['sub_tree']); |
||
| 78 | if (!empty($desc)) { |
||
| 79 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 80 | } |
||
| 81 | |||
| 82 | return $instance; |
||
| 83 | case ExpressionType::CONSTANT: |
||
| 84 | $const = new ConstNode(); |
||
| 85 | $expr = $desc['base_expr']; |
||
| 86 | if (strpos($expr, "'") === 0) { |
||
| 87 | $expr = substr($expr, 1); |
||
| 88 | } else { |
||
| 89 | $const->setIsString(false); |
||
| 90 | } |
||
| 91 | View Code Duplication | if (strrpos($expr, "'") === strlen($expr) - 1) { |
|
| 92 | $expr = substr($expr, 0, -1); |
||
| 93 | } |
||
| 94 | $expr = stripslashes($expr); |
||
| 95 | |||
| 96 | $const->setValue($expr); |
||
| 97 | |||
| 98 | // If the constant has an alias, it is declared in the columns section. |
||
| 99 | // If this is the case, let's wrap it in an "expression" |
||
| 100 | if (isset($desc['alias'])) { |
||
| 101 | $expression = new Expression(); |
||
| 102 | $expression->setBaseExpression($desc['base_expr']); |
||
| 103 | $expression->setSubTree($const); |
||
| 104 | $expression->setAlias($desc['alias']['name']); |
||
| 105 | $expression->setBrackets(false); |
||
| 106 | |||
| 107 | $const = $expression; |
||
| 108 | |||
| 109 | unset($desc['alias']); |
||
| 110 | } |
||
| 111 | |||
| 112 | // Debug: |
||
| 113 | unset($desc['base_expr']); |
||
| 114 | unset($desc['expr_type']); |
||
| 115 | unset($desc['sub_tree']); |
||
| 116 | |||
| 117 | if (!empty($desc)) { |
||
| 118 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 119 | } |
||
| 120 | |||
| 121 | return $const; |
||
| 122 | |||
| 123 | case ExpressionType::OPERATOR: |
||
| 124 | $operator = new Operator(); |
||
| 125 | $operator->setValue($desc['base_expr']); |
||
| 126 | // Debug: |
||
| 127 | unset($desc['base_expr']); |
||
| 128 | unset($desc['expr_type']); |
||
| 129 | View Code Duplication | if (!empty($desc['sub_tree'])) { |
|
| 130 | throw new \InvalidArgumentException('Unexpected operator with subtree: '.var_export($desc['sub_tree'], true)); |
||
| 131 | } |
||
| 132 | unset($desc['sub_tree']); |
||
| 133 | if (!empty($desc)) { |
||
| 134 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 135 | } |
||
| 136 | |||
| 137 | return $operator; |
||
| 138 | |||
| 139 | case ExpressionType::COLREF: |
||
| 140 | if (substr($desc['base_expr'], 0, 1) == ':') { |
||
| 141 | $instance = new Parameter(); |
||
| 142 | $instance->setName(substr($desc['base_expr'], 1)); |
||
| 143 | } else { |
||
| 144 | $instance = new ColRef(); |
||
| 145 | $lastDot = strrpos($desc['base_expr'], '.'); |
||
| 146 | if ($lastDot === false) { |
||
| 147 | $instance->setColumn(str_replace('`', '', $desc['base_expr'])); |
||
| 148 | } else { |
||
| 149 | $instance->setColumn(str_replace('`', '', substr($desc['base_expr'], $lastDot + 1))); |
||
| 150 | $instance->setTable(str_replace('`', '', substr($desc['base_expr'], 0, $lastDot))); |
||
| 151 | } |
||
| 152 | if (!empty($desc['alias'])) { |
||
| 153 | $instance->setAlias($desc['alias']['name']); |
||
| 154 | } |
||
| 155 | |||
| 156 | if (!empty($desc['direction'])) { |
||
| 157 | $instance->setDirection($desc['direction']); |
||
| 158 | } |
||
| 159 | } |
||
| 160 | |||
| 161 | // Debug: |
||
| 162 | unset($desc['direction']); |
||
| 163 | unset($desc['base_expr']); |
||
| 164 | unset($desc['expr_type']); |
||
| 165 | View Code Duplication | if (!empty($desc['sub_tree'])) { |
|
| 166 | throw new \InvalidArgumentException('Unexpected operator with subtree: '.var_export($desc['sub_tree'], true)); |
||
| 167 | } |
||
| 168 | unset($desc['sub_tree']); |
||
| 169 | unset($desc['alias']); |
||
| 170 | if (!empty($desc)) { |
||
| 171 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 172 | } |
||
| 173 | |||
| 174 | return $instance; |
||
| 175 | case ExpressionType::TABLE: |
||
| 176 | $expr = new Table(); |
||
| 177 | $expr->setTable(str_replace('`', '', $desc['table'])); |
||
| 178 | switch ($desc['join_type']) { |
||
| 179 | case 'CROSS': |
||
| 180 | $joinType = 'CROSS JOIN'; |
||
| 181 | break; |
||
| 182 | case 'JOIN': |
||
| 183 | $joinType = 'JOIN'; |
||
| 184 | break; |
||
| 185 | case 'LEFT': |
||
| 186 | $joinType = 'LEFT JOIN'; |
||
| 187 | break; |
||
| 188 | case 'RIGHT': |
||
| 189 | $joinType = 'RIGHT JOIN'; |
||
| 190 | break; |
||
| 191 | case 'INNER': |
||
| 192 | $joinType = 'INNER JOIN'; |
||
| 193 | break; |
||
| 194 | case 'OUTER': |
||
| 195 | $joinType = 'OUTER JOIN'; |
||
| 196 | break; |
||
| 197 | case 'NATURAL': |
||
| 198 | $joinType = 'NATURAL JOIN'; |
||
| 199 | break; |
||
| 200 | case ',': |
||
| 201 | $joinType = ','; |
||
| 202 | break; |
||
| 203 | default: |
||
| 204 | throw new \Exception("Unexpected join type: '".$desc['join_type']."'"); |
||
| 205 | } |
||
| 206 | $expr->setJoinType($joinType); |
||
| 207 | |||
| 208 | if (isset($desc['alias'])) { |
||
| 209 | $expr->setAlias($desc['alias']['name']); |
||
| 210 | } |
||
| 211 | $subTreeNodes = self::buildFromSubtree($desc['ref_clause']); |
||
| 212 | if ($subTreeNodes) { |
||
| 213 | $expr->setRefClause(self::simplify($subTreeNodes)); |
||
| 214 | } |
||
| 215 | |||
| 216 | // Debug: |
||
| 217 | unset($desc['base_expr']); |
||
| 218 | unset($desc['expr_type']); |
||
| 219 | View Code Duplication | if (!empty($desc['sub_tree'])) { |
|
| 220 | throw new \InvalidArgumentException('Unexpected operator with subtree: '.var_export($desc['sub_tree'], true)); |
||
| 221 | } |
||
| 222 | unset($desc['sub_tree']); |
||
| 223 | unset($desc['join_type']); |
||
| 224 | unset($desc['alias']); |
||
| 225 | unset($desc['table']); |
||
| 226 | unset($desc['ref_type']); |
||
| 227 | unset($desc['ref_clause']); |
||
| 228 | if (!empty($desc)) { |
||
| 229 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 230 | } |
||
| 231 | |||
| 232 | return $expr; |
||
| 233 | case ExpressionType::SUBQUERY: |
||
| 234 | $expr = new SubQuery(); |
||
| 235 | |||
| 236 | $expr->setSubQuery(self::buildFromSubtree($desc['sub_tree'])); |
||
| 237 | |||
| 238 | if (isset($desc['join_type'])) { |
||
| 239 | $expr->setJoinType($desc['join_type']); |
||
| 240 | } |
||
| 241 | |||
| 242 | if (isset($desc['alias'])) { |
||
| 243 | $expr->setAlias($desc['alias']['name']); |
||
| 244 | } |
||
| 245 | |||
| 246 | if (isset($desc['ref_clause'])) { |
||
| 247 | $subTreeNodes = self::buildFromSubtree($desc['ref_clause']); |
||
| 248 | if ($subTreeNodes) { |
||
| 249 | $expr->setRefClause(self::simplify($subTreeNodes)); |
||
| 250 | } |
||
| 251 | } |
||
| 252 | |||
| 253 | // Debug: |
||
| 254 | unset($desc['base_expr']); |
||
| 255 | unset($desc['expr_type']); |
||
| 256 | unset($desc['sub_tree']); |
||
| 257 | unset($desc['join_type']); |
||
| 258 | unset($desc['alias']); |
||
| 259 | unset($desc['sub_tree']); |
||
| 260 | unset($desc['ref_type']); |
||
| 261 | unset($desc['ref_clause']); |
||
| 262 | if (!empty($desc)) { |
||
| 263 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 264 | } |
||
| 265 | |||
| 266 | return $expr; |
||
| 267 | case ExpressionType::AGGREGATE_FUNCTION: |
||
| 268 | $expr = new AggregateFunction(); |
||
| 269 | $expr->setFunctionName($desc['base_expr']); |
||
| 270 | |||
| 271 | $expr->setSubTree(self::buildFromSubtree($desc['sub_tree'])); |
||
| 272 | |||
| 273 | if (isset($desc['alias'])) { |
||
| 274 | $expr->setAlias($desc['alias']); |
||
| 275 | } |
||
| 276 | |||
| 277 | // Debug: |
||
| 278 | unset($desc['base_expr']); |
||
| 279 | unset($desc['expr_type']); |
||
| 280 | unset($desc['sub_tree']); |
||
| 281 | unset($desc['alias']); |
||
| 282 | if (!empty($desc)) { |
||
| 283 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 284 | } |
||
| 285 | |||
| 286 | return $expr; |
||
| 287 | case ExpressionType::SIMPLE_FUNCTION: |
||
| 288 | $expr = new SimpleFunction(); |
||
| 289 | $expr->setBaseExpression($desc['base_expr']); |
||
| 290 | |||
| 291 | if (isset($desc['sub_tree'])) { |
||
| 292 | $expr->setSubTree(self::buildFromSubtree($desc['sub_tree'])); |
||
| 293 | } |
||
| 294 | |||
| 295 | if (isset($desc['alias'])) { |
||
| 296 | $expr->setAlias($desc['alias']['name']); |
||
| 297 | } |
||
| 298 | if (isset($desc['direction'])) { |
||
| 299 | $expr->setDirection($desc['direction']); |
||
| 300 | } |
||
| 301 | |||
| 302 | // Debug: |
||
| 303 | unset($desc['base_expr']); |
||
| 304 | unset($desc['expr_type']); |
||
| 305 | unset($desc['sub_tree']); |
||
| 306 | unset($desc['alias']); |
||
| 307 | unset($desc['direction']); |
||
| 308 | if (!empty($desc)) { |
||
| 309 | throw new \InvalidArgumentException('Unexpected parameters in simple function: '.var_export($desc, true)); |
||
| 310 | } |
||
| 311 | |||
| 312 | return $expr; |
||
| 313 | case ExpressionType::RESERVED: |
||
| 314 | if (in_array(strtoupper($desc['base_expr']), ['CASE', 'WHEN', 'THEN', 'ELSE', 'END'])) { |
||
| 315 | $operator = new Operator(); |
||
| 316 | $operator->setValue($desc['base_expr']); |
||
| 317 | // Debug: |
||
| 318 | unset($desc['base_expr']); |
||
| 319 | unset($desc['expr_type']); |
||
| 320 | View Code Duplication | if (!empty($desc['sub_tree'])) { |
|
| 321 | throw new \InvalidArgumentException('Unexpected operator with subtree: '.var_export($desc['sub_tree'], true)); |
||
| 322 | } |
||
| 323 | unset($desc['sub_tree']); |
||
| 324 | if (!empty($desc)) { |
||
| 325 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 326 | } |
||
| 327 | |||
| 328 | return $operator; |
||
| 329 | } else { |
||
| 330 | $res = new Reserved(); |
||
| 331 | $res->setBaseExpression($desc['base_expr']); |
||
| 332 | |||
| 333 | if ($desc['expr_type'] == ExpressionType::BRACKET_EXPRESSION) { |
||
| 334 | $res->setBrackets(true); |
||
| 335 | } |
||
| 336 | |||
| 337 | // Debug: |
||
| 338 | unset($desc['base_expr']); |
||
| 339 | unset($desc['expr_type']); |
||
| 340 | unset($desc['sub_tree']); |
||
| 341 | unset($desc['alias']); |
||
| 342 | unset($desc['direction']); |
||
| 343 | if (!empty($desc)) { |
||
| 344 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 345 | } |
||
| 346 | |||
| 347 | return $res; |
||
| 348 | } |
||
| 349 | case ExpressionType::USER_VARIABLE: |
||
| 350 | case ExpressionType::SESSION_VARIABLE: |
||
| 351 | case ExpressionType::GLOBAL_VARIABLE: |
||
| 352 | case ExpressionType::LOCAL_VARIABLE: |
||
| 353 | case ExpressionType::EXPRESSION: |
||
| 354 | case ExpressionType::BRACKET_EXPRESSION: |
||
| 355 | case ExpressionType::TABLE_EXPRESSION: |
||
| 356 | |||
| 357 | case ExpressionType::IN_LIST: |
||
| 358 | |||
| 359 | case ExpressionType::SIGN: |
||
| 360 | case ExpressionType::RECORD: |
||
| 361 | |||
| 362 | case ExpressionType::MATCH_ARGUMENTS: |
||
| 363 | case ExpressionType::MATCH_MODE: |
||
| 364 | |||
| 365 | case ExpressionType::ALIAS: |
||
| 366 | case ExpressionType::POSITION: |
||
| 367 | |||
| 368 | case ExpressionType::TEMPORARY_TABLE: |
||
| 369 | case ExpressionType::VIEW: |
||
| 370 | case ExpressionType::DATABASE: |
||
| 371 | case ExpressionType::SCHEMA: |
||
| 372 | $expr = new Expression(); |
||
| 373 | $expr->setBaseExpression($desc['base_expr']); |
||
| 374 | |||
| 375 | if (isset($desc['sub_tree'])) { |
||
| 376 | $expr->setSubTree(self::buildFromSubtree($desc['sub_tree'])); |
||
| 377 | } |
||
| 378 | |||
| 379 | if (isset($desc['alias'])) { |
||
| 380 | $expr->setAlias($desc['alias']['name']); |
||
| 381 | } |
||
| 382 | if (isset($desc['direction'])) { |
||
| 383 | $expr->setDirection($desc['direction']); |
||
| 384 | } |
||
| 385 | |||
| 386 | if ($desc['expr_type'] == ExpressionType::BRACKET_EXPRESSION) { |
||
| 387 | $expr->setBrackets(true); |
||
| 388 | } |
||
| 389 | |||
| 390 | // Debug: |
||
| 391 | unset($desc['base_expr']); |
||
| 392 | unset($desc['expr_type']); |
||
| 393 | unset($desc['sub_tree']); |
||
| 394 | unset($desc['alias']); |
||
| 395 | unset($desc['direction']); |
||
| 396 | if (!empty($desc)) { |
||
| 397 | throw new \InvalidArgumentException('Unexpected parameters in exception: '.var_export($desc, true)); |
||
| 398 | } |
||
| 399 | |||
| 400 | return $expr; |
||
| 401 | default: |
||
| 402 | throw new \Exception('Unknown expression type'); |
||
| 403 | } |
||
| 404 | } |
||
| 405 | |||
| 839 |
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.