RoutineLoaderHelper::extractSyntax() - Code Metrics - Inspection of "Improve syntax detection." - DatabaseStratum/php-stratum-mysql - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 6f8879...b9048c )

by P.R.
created 2020-11-11 16:27 UTC
RoutineLoaderHelper::extractSyntax() A

↳ Parent: RoutineLoaderHelper
Complexity

Conditions	5
Paths	3
Size

Total Lines	19
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	5.3906
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	5
eloc	9
c	1
b	0
f	0
nc	3
nop	0
dl	0
loc	19
ccs	6
cts	8
cp	0.75
crap	5.3906
rs	9.6111
<?php
declare(strict_types=1);

namespace SetBased\Stratum\MySql\Helper;

use SetBased\Exception\FallenException;
use SetBased\Helper\Cast;
use SetBased\Helper\InvalidCastException;
use SetBased\Stratum\Backend\StratumStyle;
use SetBased\Stratum\Common\DocBlock\DocBlockReflection;
use SetBased\Stratum\Common\Exception\RoutineLoaderException;
use SetBased\Stratum\Middle\Exception\ResultException;
use SetBased\Stratum\MySql\Exception\MySqlQueryErrorException;
use SetBased\Stratum\MySql\MySqlMetaDataLayer;
use Symfony\Component\Console\Formatter\OutputFormatter;

/**
 * Class for loading a single stored routine into a MySQL instance from pseudo SQL file.
 */
class RoutineLoaderHelper
{
  //--------------------------------------------------------------------------------------------------------------------
  /**
   * MySQL's and MariaDB's SQL/PSM syntax.
   */
  const SQL_PSM_SYNTAX = 1;

  /**
   * Oracle PL/SQL syntax.
   */
  const PL_SQL_SYNTAX = 2;

  /**
   * The revision of the metadata of the stored routines.
   */
  const METADATA_REVISION = '3';

  /**
   * The metadata of the table columns of the table for bulk insert.
   *
   * @var array[]
   */
  private $bulkInsertColumns;

  /**
   * The keys in the nested array for bulk inserting data.
   *
   * @var string[]
   */
  private $bulkInsertKeys;

  /**
   * The name of table for bulk insert.
   *
   * @var string
   */
  private $bulkInsertTableName;

  /**
   * The default character set under which the stored routine will be loaded and run.
   *
   * @var string
   */
  private $characterSet;

  /**
   * The default collate under which the stored routine will be loaded and run.
   *
   * @var string
   */
  private $collate;

  /**
   * The designation type of the stored routine.
   *
   * @var string
   */
  private $designationType;

  /**
   * The meta data layer.
   *
   * @var MySqlMetaDataLayer
   */
  private $dl;

  /**
   * The DocBlock reflection object.
   *
   * @var DocBlockReflection|null
   */
  private $docBlockReflection;

  /**
   * The last modification time of the source file.
   *
   * @var int
   */
  private $filemtime;

  /**
   * The key or index columns (depending on the designation type) of the stored routine.
   *
   * @var string[]
   */
  private $indexColumns;

  /**
   * The Output decorator.
   *
   * @var StratumStyle
   */
  private $io;

  /**
   * The metadata of the stored routine. Note: this data is stored in the metadata file and is generated by PhpStratum.
   *
   * @var array
   */
  private $phpStratumMetadata;

  /**
   * The old metadata of the stored routine.  Note: this data comes from the metadata file.
   *
   * @var array
   */
  private $phpStratumOldMetadata;

  /**
   * The old metadata of the stored routine. Note: this data comes from information_schema.ROUTINES.
   *
   * @var array
   */
  private $rdbmsOldRoutineMetadata;

  /**
   * The replace pairs (i.e. placeholders and their actual values, see strst).
   *
   * @var array
   */
  private $replace = [];

  /**
   * A map from placeholders to their actual values.
   *
   * @var array
   */
  private $replacePairs;

  /**
   * The return type of the stored routine (only if designation type singleton0, singleton1, or function).
   *
   * @var string|null
   */
  private $returnType;

  /**
   * The name of the stored routine.
   *
   * @var string
   */
  private $routineName;

  /**
   * The routine parameters.
   *
   * @var RoutineParametersHelper|null
   */
  private $routineParameters = null;

  /**
   * The source code as a single string of the stored routine.
   *
   * @var string
   */
  private $routineSourceCode;

  /**
   * The source code as an array of lines string of the stored routine.
   *
   * @var array
   */
  private $routineSourceCodeLines;

  /**
   * The source filename holding the stored routine.
   *
   * @var string
   */
  private $sourceFilename;

  /**
   * The SQL mode helper object.
   *
   * @var SqlModeHelper
   */
  private $sqlModeHelper;

  /**
   * The syntax of the stored routine. Either SQL_PSM_SYNTAX or PL_SQL_SYNTAX.
   *
   * @var int
   */
  private $syntax;

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Object constructor.
   *
   * @param MySqlMetaDataLayer $dl                      The meta data layer.
   * @param StratumStyle       $io                      The output for log messages.
   * @param SqlModeHelper      $sqlModeHelper
   * @param string             $routineFilename         The filename of the source of the stored routine.
   * @param array              $phpStratumMetadata      The metadata of the stored routine from PhpStratum.
   * @param array              $replacePairs            A map from placeholders to their actual values.
   * @param array              $rdbmsOldRoutineMetadata The old metadata of the stored routine from MySQL.
   * @param string             $characterSet            The default character set under which the stored routine will
   *                                                    be loaded and run.
   * @param string             $collate                 The key or index columns (depending on the designation type) of
   *                                                    the stored routine.
   */
  public function __construct(MySqlMetaDataLayer $dl,
                              StratumStyle $io,
                              SqlModeHelper $sqlModeHelper,
                              string $routineFilename,
                              array $phpStratumMetadata,
                              array $replacePairs,
                              array $rdbmsOldRoutineMetadata,
                              string $characterSet,
                              string $collate)
  {
    $this->dl                      = $dl;
    $this->io                      = $io;
    $this->sqlModeHelper           = $sqlModeHelper;
    $this->sourceFilename          = $routineFilename;
    $this->phpStratumMetadata      = $phpStratumMetadata;
    $this->replacePairs            = $replacePairs;
    $this->rdbmsOldRoutineMetadata = $rdbmsOldRoutineMetadata;
    $this->characterSet            = $characterSet;
    $this->collate                 = $collate;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extract column metadata from the rows returned by the SQL statement 'describe table'.
   *
   * @param array $description The description of the table.
   *
   * @return array
   *
   * @throws InvalidCastException
   */
  private static function extractColumnsFromTableDescription(array $description): array
  {
    $ret = [];

    foreach ($description as $column)
    {
      preg_match('/^(?<data_type>\w+)(?<extra>.*)?$/', $column['Type'], $parts1);

      $tmp = ['column_name'       => $column['Field'],
              'data_type'         => $parts1['data_type'],
              'numeric_precision' => null,
              'numeric_scale'     => null,
              'dtd_identifier'    => $column['Type']];

      switch ($parts1[1])
      {
        case 'tinyint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 4);
          $tmp['numeric_scale']     = 0;
          break;

        case 'smallint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 6);
          $tmp['numeric_scale']     = 0;
          break;

        case 'mediumint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 9);
          $tmp['numeric_scale']     = 0;
          break;

        case 'int':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 11);
          $tmp['numeric_scale']     = 0;
          break;

        case 'bigint':
          preg_match('/^\((?<precision>\d+)\)/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 20);
          $tmp['numeric_scale']     = 0;
          break;

        case 'year':
          // Nothing to do.
          break;

        case 'float':
          $tmp['numeric_precision'] = 12;
          break;

        case 'double':
          $tmp['numeric_precision'] = 22;
          break;

        case 'binary':
        case 'char':
        case 'varbinary':
        case 'varchar':
          // Nothing to do (binary) strings.
          break;

        case 'decimal':
          preg_match('/^\((?<precision>\d+),(<?scale>\d+)\)$/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision'] ?? 65);
          $tmp['numeric_scale']     = Cast::toManInt($parts2['scale'] ?? 0);
          break;

        case 'time':
        case 'timestamp':
        case 'date':
        case 'datetime':
          // Nothing to do date and time.
          break;

        case 'enum':
        case 'set':
          // Nothing to do sets.
          break;

        case 'bit':
          preg_match('/^\((?<precision>\d+)\)$/', $parts1['extra'], $parts2);
          $tmp['numeric_precision'] = Cast::toManInt($parts2['precision']);
          break;

        case 'tinytext':
        case 'text':
        case 'mediumtext':
        case 'longtext':
        case 'tinyblob':
        case 'blob':
        case 'mediumblob':
        case 'longblob':
          // Nothing to do CLOBs and BLOBs.
          break;

        default:
          throw new FallenException('data type', $parts1[1]);
      }

      $ret[] = $tmp;
    }

    return $ret;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Loads the stored routine into the instance of MySQL and returns the metadata of the stored routine.
   *
   * @return array
   *
   * @throws RoutineLoaderException
   * @throws MySqlQueryErrorException
   * @throws ResultException
   * @throws InvalidCastException
   */
  public function loadStoredRoutine(): array
  {
    $this->routineName           = pathinfo($this->sourceFilename, PATHINFO_FILENAME);
    $this->phpStratumOldMetadata = $this->phpStratumMetadata;
    $this->filemtime             = filemtime($this->sourceFilename);

    $load = $this->mustLoadStoredRoutine();
    if ($load)
    {
      $this->io->text(sprintf('Loading routine <dbo>%s</dbo>', OutputFormatter::escape($this->routineName)));

      $this->readSourceCode();
      $this->extractPlaceholders();
      $this->extractDesignationType();
      $this->extractReturnType();
      $this->extractRoutineTypeAndName();
      $this->extractSyntax();
      $this->validateReturnType();

      $this->loadRoutineFile();

      $this->extractBulkInsertTableColumnsInfo();
      $this->extractParameters();
      $this->updateMetadata();
    }

    return $this->phpStratumMetadata;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Drops the stored routine if it exists.
   *
   * @throws MySqlQueryErrorException
   */
  private function dropRoutineIfExists(): void
  {
    if (!empty($this->rdbmsOldRoutineMetadata))
    {
      $this->dl->dropRoutine($this->rdbmsOldRoutineMetadata['routine_type'], $this->routineName);
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   *  Extracts the column names and column types of the current table for bulk insert.
   *
   * @throws InvalidCastException
   * @throws MySqlQueryErrorException
   * @throws ResultException
   * @throws RoutineLoaderException
   */
  private function extractBulkInsertTableColumnsInfo(): void
  {
    // Return immediately if designation type is not appropriate for this method.
    if ($this->designationType!='bulk_insert') return;

    // Check if table is a temporary table or a non-temporary table.
    $tableIsNonTemporary = $this->dl->checkTableExists($this->bulkInsertTableName);

    // Create temporary table if table is non-temporary table.
    if (!$tableIsNonTemporary)
    {
      $this->dl->callProcedure($this->routineName);
    }

    // Get information about the columns of the table.
    $description = $this->dl->describeTable($this->bulkInsertTableName);

    // Drop temporary table if table is non-temporary.
    if (!$tableIsNonTemporary)
    {
      $this->dl->dropTemporaryTable($this->bulkInsertTableName);
    }

    // Check number of columns in the table match the number of fields given in the designation type.
    $n1 = sizeof($this->bulkInsertKeys);
    $n2 = sizeof($description);
    if ($n1!=$n2)
    {
      throw new RoutineLoaderException("Number of fields %d and number of columns %d don't match.", $n1, $n2);
    }

    $this->bulkInsertColumns = self::extractColumnsFromTableDescription($description);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the designation type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function extractDesignationType(): void
  {
    $tags = $this->docBlockReflection->getTags('type');
    if (count($tags)===0)
    {
      throw new RoutineLoaderException('Tag @type not found in DocBlock.');
    }
    elseif (count($tags)>1)
    {
      throw new RoutineLoaderException('Multiple @type tags found in DocBlock.');
    }

    $tag                   = $tags[0];
    $this->designationType = $tag['arguments'][0];
    switch ($this->designationType)
    {
      case 'bulk_insert':
        if ($tag['arguments'][1]==='' || $tag['arguments'][2]==='' || $tag['description'][0]!='')
        {
          throw new RoutineLoaderException('Invalid @type tag. Expected: @type bulk_insert <table_name> <columns>');
        }
        $this->bulkInsertTableName = $tag['arguments'][1];
        $this->bulkInsertKeys      = explode(',', $tag['arguments'][2]);
        break;

      case 'rows_with_key':
      case 'rows_with_index':
        if ($tag['arguments'][1]==='' || $tag['arguments'][2]!=='')
        {
          throw new RoutineLoaderException('Invalid @type tag. Expected: @type %s <columns>', $this->designationType);
        }
        $this->indexColumns = explode(',', $tag['arguments'][1]);
        break;

      default:
        if ($tag['arguments'][1]!=='')
        {
          throw new RoutineLoaderException('Error: Expected: @type %s', $this->designationType);
        }
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts DocBlock parts to be used by the wrapper generator.
   */
  private function extractDocBlockPartsWrapper(): array
  {
    return ['short_description' => $this->docBlockReflection->getShortDescription(),
            'long_description'  => $this->docBlockReflection->getLongDescription(),
            'parameters'        => $this->routineParameters->extractDocBlockPartsWrapper()];
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts routine parameters.
   *
   * @throws MySqlQueryErrorException
   * @throws RoutineLoaderException
   */
  private function extractParameters()
  {
    $this->routineParameters = new RoutineParametersHelper($this->dl,
                                                           $this->io,
                                                           $this->docBlockReflection,
                                                           $this->routineName);

    $this->routineParameters->extractRoutineParameters();
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the placeholders from the stored routine source.
   *
   * @throws RoutineLoaderException
   */
  private function extractPlaceholders(): void
  {
    $unknown = [];

    preg_match_all('(@[A-Za-z0-9_.]+(%(type|sort))?@)', $this->routineSourceCode, $matches);
    if (!empty($matches[0]))
    {
      foreach ($matches[0] as $placeholder)
      {
        if (isset($this->replacePairs[strtoupper($placeholder)]))
        {
          $this->replace[$placeholder] = $this->replacePairs[strtoupper($placeholder)];
        }
        else
        {
          $unknown[] = $placeholder;
        }
      }
    }

    $this->logUnknownPlaceholders($unknown);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the return type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function extractReturnType(): void
  {
    $tags = $this->docBlockReflection->getTags('return');

    switch ($this->designationType)
    {
      case 'function':
      case 'singleton0':
      case 'singleton1':
        if (count($tags)===0)
        {
          throw new RoutineLoaderException('Tag @return not found in DocBlock.');
        }
        $tag = $tags[0];
        if ($tag['arguments'][0]==='')
        {
          throw new RoutineLoaderException('Invalid return tag. Expected: @return <type>.');
        }
        $this->returnType = $tag['arguments'][0];
        break;

      default:
        if (count($tags)!==0)
        {
          throw new RoutineLoaderException('Redundant @type tag found in DocBlock.');
        }
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Extracts the name of the stored routine and the stored routine type (i.e. procedure or function) source.
   *
   * @throws RoutineLoaderException
   */
  private function extractRoutineTypeAndName(): void
  {
    $n = preg_match('/create\\s+(procedure|function)\\s+([a-zA-Z0-9_]+)/i', $this->routineSourceCode, $matches);
    if ($n==1)
    {
      if ($this->routineName!=$matches[2])
      {
        throw new RoutineLoaderException("Stored routine name '%s' does not corresponds with filename", $matches[2]);
      }
    }
    else
    {
      throw new RoutineLoaderException('Unable to find the stored routine name and type');
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Detects the syntax of the stored procedure. Either SQL/PSM or PL/SQL.
   */
  private function extractSyntax(): void
  {
    if ($this->sqlModeHelper->hasOracleMode())
    {
      $key1 = $this->findFirstMatchingLine('/^\s*(as|is)\s*$/i');
      $key2 = $this->findFirstMatchingLine('/^\s*begin\s*$/i');

      if ($key1!==null && $key2!==null && $key1<$key2)
      {
        $this->syntax = self::PL_SQL_SYNTAX;
      }
      else
      {
        $this->syntax = self::SQL_PSM_SYNTAX;
      }
    }
    else
    {
      $this->syntax = self::SQL_PSM_SYNTAX;
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns the key of the source line that match a regex pattern.
   *
   * @param string $pattern The regex pattern.
   *
   * @return int|null
   */
  private function findFirstMatchingLine(string $pattern): ?int
  {
    foreach ($this->routineSourceCodeLines as $key => $line)
    {
      if (preg_match($pattern, $line)===1)
      {
        return $key;
      }
    }

    return null;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Loads the stored routine into the database.
   *
   * @throws MySqlQueryErrorException
   */
  private function loadRoutineFile(): void
  {
    if ($this->syntax===self::PL_SQL_SYNTAX)
    {
      $this->sqlModeHelper->addIfRequiredOracleMode();
    }
    else
    {
      $this->sqlModeHelper->removeIfRequiredOracleMode();
    }

    $routineSource = $this->substitutePlaceHolders();
    $this->dropRoutineIfExists();
    $this->dl->setCharacterSet($this->characterSet, $this->collate);
    $this->dl->loadRoutine($routineSource);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Logs the unknown placeholder (if any).
   *
   * @param array $unknown The unknown placeholders.
   *
   * @throws RoutineLoaderException
   */
  private function logUnknownPlaceholders(array $unknown): void
  {
    // Return immediately if there are no unknown placeholders.
    if (empty($unknown)) return;

    sort($unknown);
    $this->io->text('Unknown placeholder(s):');
    $this->io->listing($unknown);

    $replace = [];
    foreach ($unknown as $placeholder)
    {
      $replace[$placeholder] = '<error>'.$placeholder.'</error>';
    }
    $code = strtr(OutputFormatter::escape($this->routineSourceCode), $replace);

    $this->io->text(explode(PHP_EOL, $code));

    throw new RoutineLoaderException('Unknown placeholder(s) found');
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns true if the source file must be load or reloaded. Otherwise returns false.
   *
   * @return bool
   */
  private function mustLoadStoredRoutine(): bool
  {
    // If this is the first time we see the source file it must be loaded.
    if (empty($this->phpStratumOldMetadata)) return true;

    // If the source file has changed the source file must be loaded.
    if ($this->phpStratumOldMetadata['timestamp']!==$this->filemtime) return true;

    // If the value of a placeholder has changed the source file must be loaded.
    foreach ($this->phpStratumOldMetadata['replace'] as $placeHolder => $oldValue)
    {
      if (!isset($this->replacePairs[strtoupper($placeHolder)]) ||
        $this->replacePairs[strtoupper($placeHolder)]!==$oldValue)
      {
        return true;
      }
    }

    // If stored routine not exists in database the source file must be loaded.
    if (empty($this->rdbmsOldRoutineMetadata)) return true;

    // If current sql-mode is different the source file must reload.
    if (!$this->sqlModeHelper->compare($this->rdbmsOldRoutineMetadata['sql_mode'])) return true;

    // If current character set is different the source file must reload.
    if ($this->rdbmsOldRoutineMetadata['character_set_client']!==$this->characterSet) return true;

    // If current collation is different the source file must reload.
    if ($this->rdbmsOldRoutineMetadata['collation_connection']!==$this->collate) return true;

    return false;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Reads the source code of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function readSourceCode(): void
  {
    $this->routineSourceCode      = file_get_contents($this->sourceFilename);
    $this->routineSourceCodeLines = explode(PHP_EOL, $this->routineSourceCode);

    if ($this->routineSourceCodeLines===false)
    {
      throw new RoutineLoaderException('Source file is empty');
    }

    $start = $this->findFirstMatchingLine('/^\s*\/\*\*\s*$/');
    $end   = $this->findFirstMatchingLine('/^\s*\*\/\s*$/');
    if ($start!==null && $end!==null && $start<$end)
    {
      $lines    = array_slice($this->routineSourceCodeLines, $start, $end - $start + 1);
      $docBlock = implode(PHP_EOL, (array)$lines);
    }
    else
    {
      $docBlock = '';
    }

    DocBlockReflection::setTagParameters('param', 1);
    DocBlockReflection::setTagParameters('type', 3);
    DocBlockReflection::setTagParameters('return', 1);
    DocBlockReflection::setTagParameters('paramAddendum', 5);

    $this->docBlockReflection = new DocBlockReflection($docBlock);
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Returns the source of the routine with all placeholders substituted with their values.
   *
   * @return string
   */
  private function substitutePlaceHolders(): string
  {
    $realpath = realpath($this->sourceFilename);

    $this->replace['__FILE__']    = "'".$this->dl->realEscapeString($realpath)."'";
    $this->replace['__ROUTINE__'] = "'".$this->routineName."'";
    $this->replace['__DIR__']     = "'".$this->dl->realEscapeString(dirname($realpath))."'";

    $lines         = explode(PHP_EOL, $this->routineSourceCode);
    $routineSource = [];
    foreach ($lines as $i => $line)
    {
      $this->replace['__LINE__'] = $i + 1;
      $routineSource[$i]         = strtr($line, $this->replace);
    }
    $routineSource = implode(PHP_EOL, $routineSource);

    unset($this->replace['__FILE__']);
    unset($this->replace['__ROUTINE__']);
    unset($this->replace['__DIR__']);
    unset($this->replace['__LINE__']);

    return $routineSource;
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Updates the metadata for the stored routine.
   */
  private function updateMetadata(): void
  {
    $this->phpStratumMetadata['routine_name'] = $this->routineName;
    $this->phpStratumMetadata['designation']  = $this->designationType;
    $this->phpStratumMetadata['return']       = $this->returnType;
    $this->phpStratumMetadata['parameters']   = $this->routineParameters->getParameters();
    $this->phpStratumMetadata['timestamp']    = $this->filemtime;
    $this->phpStratumMetadata['replace']      = $this->replace;
    $this->phpStratumMetadata['phpdoc']       = $this->extractDocBlockPartsWrapper();

    if (in_array($this->designationType, ['rows_with_index', 'rows_with_key']))
    {
      $this->phpStratumMetadata['index_columns'] = $this->indexColumns;
    }

    if ($this->designationType==='bulk_insert')
    {
      $this->phpStratumMetadata['bulk_insert_table_name'] = $this->bulkInsertTableName;
      $this->phpStratumMetadata['bulk_insert_columns']    = $this->bulkInsertColumns;
      $this->phpStratumMetadata['bulk_insert_keys']       = $this->bulkInsertKeys;
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
  /**
   * Validates the specified return type of the stored routine.
   *
   * @throws RoutineLoaderException
   */
  private function validateReturnType(): void
  {
    // Return immediately if designation type is not appropriate for this method.
    if (!in_array($this->designationType, ['function', 'singleton0', 'singleton1'])) return;

    $types = explode('|', $this->returnType);
    $diff  = array_diff($types, ['string', 'int', 'float', 'double', 'bool', 'null']);

    if (!($this->returnType=='mixed' || $this->returnType=='bool' || empty($diff)))
    {
      throw new RoutineLoaderException("Return type must be 'mixed', 'bool', or a combination of 'int', 'float', 'string', and 'null'");
    }

    // The following tests are applicable for singleton0 routines only.
    if (!in_array($this->designationType, ['singleton0'])) return;

    // Return mixed is OK.
    if (in_array($this->returnType, ['bool', 'mixed'])) return;

    // In all other cases return type must contain null.
    $parts = explode('|', $this->returnType);
    $key   = array_search('null', $parts);
    if ($key===false)
    {
      throw new RoutineLoaderException("Return type must be 'mixed', 'bool', or contain 'null' (with a combination of 'int', 'float', and 'string')");
    }
  }

  //--------------------------------------------------------------------------------------------------------------------
}

//----------------------------------------------------------------------------------------------------------------------

DatabaseStratum / php-stratum-mysql

Push — master ( 6f8879...b9048c )

RoutineLoaderHelper::extractSyntax() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
