ifsnop /
mysqldump-php
| Conditions | 1 |
| Paths | 1 |
| Total Lines | 3 |
| Code Lines | 1 |
| Lines | 0 |
| Ratio | 0 % |
| Changes | 0 | ||
| Metric | Value |
|---|---|
| cc | 1 |
| eloc | 1 |
| c | 0 |
| b | 0 |
| f | 0 |
| nc | 1 |
| nop | 1 |
| dl | 0 |
| loc | 3 |
| rs | 10 |
| 1 | <?php |
||||
|
0 ignored issues
–
show
Coding Style
introduced
by
 Loading history...
|
|||||
| 2 | |||||
| 3 | /** |
||||
| 4 | * PHP version of mysqldump cli that comes with MySQL |
||||
| 5 | * |
||||
| 6 | * mysql mysqldump pdo php7 php5 database php sql |
||||
|
0 ignored issues
–
show
|
|||||
| 7 | * |
||||
| 8 | * @category Library |
||||
|
0 ignored issues
–
show
|
|||||
| 9 | * @package Ifsnop\Mysqldump |
||||
|
0 ignored issues
–
show
|
|||||
| 10 | * @author Diego Torres <[email protected]> |
||||
|
0 ignored issues
–
show
|
|||||
| 11 | * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License |
||||
|
0 ignored issues
–
show
|
|||||
| 12 | * @link https://github.com/ifsnop/mysqldump-php |
||||
| 13 | * |
||||
| 14 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 15 | |||||
| 16 | namespace Ifsnop\Mysqldump; |
||||
| 17 | |||||
| 18 | use Exception; |
||||
| 19 | use PDO; |
||||
| 20 | use PDOException; |
||||
| 21 | |||||
| 22 | /** |
||||
| 23 | * PHP version of mysqldump cli that comes with MySQL |
||||
| 24 | * |
||||
| 25 | * mysql mysqldump pdo php7 php5 database php sql |
||||
|
0 ignored issues
–
show
|
|||||
| 26 | * |
||||
| 27 | * @category Library |
||||
|
0 ignored issues
–
show
|
|||||
| 28 | * @package Ifsnop\Mysqldump |
||||
|
0 ignored issues
–
show
|
|||||
| 29 | * @author Diego Torres <[email protected]> |
||||
|
0 ignored issues
–
show
|
|||||
| 30 | * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License |
||||
|
0 ignored issues
–
show
|
|||||
| 31 | * @link https://github.com/ifsnop/mysqldump-php |
||||
|
0 ignored issues
–
show
|
|||||
| 32 | * |
||||
| 33 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 34 | class Mysqldump |
||||
| 35 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 36 | |||||
| 37 | // Same as mysqldump |
||||
|
0 ignored issues
–
show
|
|||||
| 38 | const MAXLINESIZE = 1000000; |
||||
| 39 | |||||
| 40 | // Available compression methods as constants |
||||
|
0 ignored issues
–
show
|
|||||
| 41 | const GZIP = 'Gzip'; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 42 | const BZIP2 = 'Bzip2'; |
||||
| 43 | const NONE = 'None'; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 44 | |||||
| 45 | // Available connection strings |
||||
|
0 ignored issues
–
show
|
|||||
| 46 | const UTF8 = 'utf8'; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 47 | const UTF8MB4 = 'utf8mb4'; |
||||
| 48 | |||||
| 49 | /** |
||||
| 50 | * Database username |
||||
| 51 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 52 | */ |
||||
| 53 | public $user; |
||||
| 54 | /** |
||||
| 55 | * Database password |
||||
| 56 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 57 | */ |
||||
| 58 | public $pass; |
||||
|
0 ignored issues
–
show
|
|||||
| 59 | /** |
||||
| 60 | * Connection string for PDO |
||||
| 61 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 62 | */ |
||||
| 63 | public $dsn; |
||||
|
0 ignored issues
–
show
|
|||||
| 64 | /** |
||||
| 65 | * Destination filename, defaults to stdout |
||||
| 66 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 67 | */ |
||||
| 68 | public $fileName = 'php://output'; |
||||
|
0 ignored issues
–
show
|
|||||
| 69 | |||||
| 70 | // Internal stuff |
||||
|
0 ignored issues
–
show
|
|||||
| 71 | private $tables = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 72 | private $views = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 73 | private $triggers = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 74 | private $procedures = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 75 | private $events = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 76 | private $dbHandler = null; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 77 | private $dbType = ""; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 78 | private $compressManager; |
||||
|
0 ignored issues
–
show
|
|||||
| 79 | private $typeAdapter; |
||||
|
0 ignored issues
–
show
|
|||||
| 80 | private $dumpSettings = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 81 | private $pdoSettings = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 82 | private $version; |
||||
|
0 ignored issues
–
show
|
|||||
| 83 | private $tableColumnTypes = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 84 | private $transformColumnValueCallable; |
||||
|
0 ignored issues
–
show
|
|||||
| 85 | /** |
||||
| 86 | * database name, parsed from dsn |
||||
|
0 ignored issues
–
show
|
|||||
| 87 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 88 | */ |
||||
| 89 | private $dbName; |
||||
|
0 ignored issues
–
show
|
|||||
| 90 | /** |
||||
| 91 | * host name, parsed from dsn |
||||
|
0 ignored issues
–
show
|
|||||
| 92 | * @var string |
||||
|
0 ignored issues
–
show
|
|||||
| 93 | */ |
||||
| 94 | private $host; |
||||
|
0 ignored issues
–
show
|
|||||
| 95 | /** |
||||
| 96 | * dsn string parsed as an array |
||||
|
0 ignored issues
–
show
|
|||||
| 97 | * @var array |
||||
|
0 ignored issues
–
show
|
|||||
| 98 | */ |
||||
| 99 | private $dsnArray = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 100 | |||||
| 101 | /** |
||||
| 102 | * Keyed on table name, with the value as the conditions |
||||
| 103 | * e.g. - 'users' => 'date_registered > NOW() - INTERVAL 6 MONTH' |
||||
| 104 | * |
||||
| 105 | * @var array |
||||
| 106 | */ |
||||
| 107 | private $tableWheres = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 108 | |||||
| 109 | /** |
||||
| 110 | * Constructor of Mysqldump. Note that in the case of an SQLite database |
||||
| 111 | * connection, the filename must be in the $db parameter. |
||||
| 112 | * |
||||
| 113 | * @param string $dsn PDO DSN connection string |
||||
|
0 ignored issues
–
show
|
|||||
| 114 | * @param string $user SQL account username |
||||
|
0 ignored issues
–
show
|
|||||
| 115 | * @param string $pass SQL account password |
||||
|
0 ignored issues
–
show
|
|||||
| 116 | * @param array $dumpSettings SQL database settings |
||||
|
0 ignored issues
–
show
|
|||||
| 117 | * @param array $pdoSettings PDO configured attributes |
||||
|
0 ignored issues
–
show
|
|||||
| 118 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 119 | public function __construct( |
||||
|
0 ignored issues
–
show
|
|||||
| 120 | $dsn = '', |
||||
| 121 | $user = '', |
||||
| 122 | $pass = '', |
||||
| 123 | $dumpSettings = array(), |
||||
|
0 ignored issues
–
show
|
|||||
| 124 | $pdoSettings = array() |
||||
|
0 ignored issues
–
show
|
|||||
| 125 | ) { |
||||
|
0 ignored issues
–
show
|
|||||
| 126 | $dumpSettingsDefault = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 127 | 'include-tables' => array(), |
||||
|
0 ignored issues
–
show
|
|||||
| 128 | 'exclude-tables' => array(), |
||||
|
0 ignored issues
–
show
|
|||||
| 129 | 'compress' => Mysqldump::NONE, |
||||
|
0 ignored issues
–
show
As per coding style,
self should be used for accessing local static members.
This check looks for accesses to local static members using the fully qualified name instead
of <?php
class Certificate {
const TRIPLEDES_CBC = 'ASDFGHJKL';
private $key;
public function __construct()
{
$this->key = Certificate::TRIPLEDES_CBC;
}
}
While this is perfectly valid, the fully qualified name of Loading history...
|
|||||
| 130 | 'init_commands' => array(), |
||||
|
0 ignored issues
–
show
|
|||||
| 131 | 'no-data' => array(), |
||||
|
0 ignored issues
–
show
|
|||||
| 132 | 'reset-auto-increment' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 133 | 'add-drop-database' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 134 | 'add-drop-table' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 135 | 'add-drop-trigger' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 136 | 'add-locks' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 137 | 'complete-insert' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 138 | 'databases' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 139 | 'default-character-set' => Mysqldump::UTF8, |
||||
|
0 ignored issues
–
show
As per coding style,
self should be used for accessing local static members.
This check looks for accesses to local static members using the fully qualified name instead
of <?php
class Certificate {
const TRIPLEDES_CBC = 'ASDFGHJKL';
private $key;
public function __construct()
{
$this->key = Certificate::TRIPLEDES_CBC;
}
}
While this is perfectly valid, the fully qualified name of Loading history...
|
|||||
| 140 | 'disable-keys' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 141 | 'extended-insert' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 142 | 'events' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 143 | 'hex-blob' => true, /* faster than escaped content */ |
||||
|
0 ignored issues
–
show
|
|||||
| 144 | 'insert-ignore' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 145 | 'net_buffer_length' => self::MAXLINESIZE, |
||||
|
0 ignored issues
–
show
|
|||||
| 146 | 'no-autocommit' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 147 | 'no-create-info' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 148 | 'lock-tables' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 149 | 'routines' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 150 | 'single-transaction' => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 151 | 'skip-triggers' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 152 | 'skip-tz-utc' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 153 | 'skip-comments' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 154 | 'skip-dump-date' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 155 | 'skip-definer' => false, |
||||
|
0 ignored issues
–
show
|
|||||
| 156 | 'where' => '', |
||||
|
0 ignored issues
–
show
|
|||||
| 157 | /* deprecated */ |
||||
|
0 ignored issues
–
show
|
|||||
| 158 | 'disable-foreign-keys-check' => true |
||||
|
0 ignored issues
–
show
|
|||||
| 159 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 160 | |||||
| 161 | $pdoSettingsDefault = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 162 | PDO::ATTR_PERSISTENT => true, |
||||
|
0 ignored issues
–
show
|
|||||
| 163 | PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, |
||||
|
0 ignored issues
–
show
|
|||||
| 164 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 165 | |||||
| 166 | $this->user = $user; |
||||
| 167 | $this->pass = $pass; |
||||
| 168 | $this->parseDsn($dsn); |
||||
| 169 | |||||
| 170 | // this drops MYSQL dependency, only use the constant if it's defined |
||||
|
0 ignored issues
–
show
|
|||||
| 171 | if ("mysql" === $this->dbType) { |
||||
|
0 ignored issues
–
show
The string literal
mysql does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 172 | $pdoSettingsDefault[PDO::MYSQL_ATTR_USE_BUFFERED_QUERY] = false; |
||||
|
0 ignored issues
–
show
|
|||||
| 173 | } |
||||
| 174 | |||||
| 175 | $this->pdoSettings = self::array_replace_recursive($pdoSettingsDefault, $pdoSettings); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 21 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 176 | $this->dumpSettings = self::array_replace_recursive($dumpSettingsDefault, $dumpSettings); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 20 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 177 | $this->dumpSettings['init_commands'][] = "SET NAMES ".$this->dumpSettings['default-character-set']; |
||||
|
0 ignored issues
–
show
The string literal
SET NAMES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 178 | |||||
| 179 | if (false === $this->dumpSettings['skip-tz-utc']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 180 | $this->dumpSettings['init_commands'][] = "SET TIME_ZONE='+00:00'"; |
||||
| 181 | } |
||||
| 182 | |||||
| 183 | $diff = array_diff(array_keys($this->dumpSettings), array_keys($dumpSettingsDefault)); |
||||
| 184 | if (count($diff) > 0) { |
||||
| 185 | throw new Exception("Unexpected value in dumpSettings: (".implode(",", $diff).")"); |
||||
|
0 ignored issues
–
show
The string literal
Unexpected value in dumpSettings: ( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 186 | } |
||||
| 187 | |||||
| 188 | if (!is_array($this->dumpSettings['include-tables']) || |
||||
|
0 ignored issues
–
show
|
|||||
| 189 | !is_array($this->dumpSettings['exclude-tables'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 190 | throw new Exception("Include-tables and exclude-tables should be arrays"); |
||||
|
0 ignored issues
–
show
The string literal
Include-tables and exclude-tables should be arrays does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 191 | } |
||||
| 192 | |||||
| 193 | // Dump the same views as tables, mimic mysqldump behaviour |
||||
|
0 ignored issues
–
show
|
|||||
| 194 | $this->dumpSettings['include-views'] = $this->dumpSettings['include-tables']; |
||||
| 195 | |||||
| 196 | // Create a new compressManager to manage compressed output |
||||
|
0 ignored issues
–
show
|
|||||
| 197 | $this->compressManager = CompressManagerFactory::create($this->dumpSettings['compress']); |
||||
| 198 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 199 | |||||
| 200 | /** |
||||
| 201 | * Destructor of Mysqldump. Unsets dbHandlers and database objects. |
||||
| 202 | * |
||||
| 203 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 204 | public function __destruct() |
||||
| 205 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 206 | $this->dbHandler = null; |
||||
|
0 ignored issues
–
show
|
|||||
| 207 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 208 | |||||
| 209 | /** |
||||
| 210 | * Custom array_replace_recursive to be used if PHP < 5.3 |
||||
| 211 | * Replaces elements from passed arrays into the first array recursively |
||||
| 212 | * |
||||
| 213 | * @param array $array1 The array in which elements are replaced |
||||
|
0 ignored issues
–
show
|
|||||
| 214 | * @param array $array2 The array from which elements will be extracted |
||||
|
0 ignored issues
–
show
|
|||||
| 215 | * |
||||
| 216 | * @return array Returns an array, or NULL if an error occurs. |
||||
| 217 | */ |
||||
| 218 | public static function array_replace_recursive($array1, $array2) |
||||
|
0 ignored issues
–
show
|
|||||
| 219 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 220 | if (function_exists('array_replace_recursive')) { |
||||
| 221 | return array_replace_recursive($array1, $array2); |
||||
|
0 ignored issues
–
show
|
|||||
| 222 | } |
||||
| 223 | |||||
| 224 | foreach ($array2 as $key => $value) { |
||||
|
0 ignored issues
–
show
|
|||||
| 225 | if (is_array($value)) { |
||||
| 226 | $array1[$key] = self::array_replace_recursive($array1[$key], $value); |
||||
|
0 ignored issues
–
show
|
|||||
| 227 | } else { |
||||
| 228 | $array1[$key] = $value; |
||||
|
0 ignored issues
–
show
|
|||||
| 229 | } |
||||
| 230 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 231 | return $array1; |
||||
|
0 ignored issues
–
show
|
|||||
| 232 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 233 | |||||
| 234 | /** |
||||
| 235 | * Keyed by table name, with the value as the conditions: |
||||
| 236 | * e.g. 'users' => 'date_registered > NOW() - INTERVAL 6 MONTH AND deleted=0' |
||||
| 237 | * |
||||
| 238 | * @param array $tableWheres |
||||
|
0 ignored issues
–
show
|
|||||
| 239 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 240 | public function setTableWheres(array $tableWheres) |
||||
| 241 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 242 | $this->tableWheres = $tableWheres; |
||||
| 243 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 244 | |||||
| 245 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 246 | * @param $tableName |
||||
|
0 ignored issues
–
show
|
|||||
| 247 | * |
||||
| 248 | * @return bool|mixed |
||||
|
0 ignored issues
–
show
|
|||||
| 249 | */ |
||||
| 250 | public function getTableWhere($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 251 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 252 | if (!empty($this->tableWheres[$tableName])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 253 | return $this->tableWheres[$tableName]; |
||||
| 254 | } elseif ($this->dumpSettings['where']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 255 | return $this->dumpSettings['where']; |
||||
| 256 | } |
||||
| 257 | |||||
| 258 | return false; |
||||
|
0 ignored issues
–
show
|
|||||
| 259 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 260 | |||||
| 261 | /** |
||||
| 262 | * Parse DSN string and extract dbname value |
||||
| 263 | * Several examples of a DSN string |
||||
| 264 | * mysql:host=localhost;dbname=testdb |
||||
| 265 | * mysql:host=localhost;port=3307;dbname=testdb |
||||
| 266 | * mysql:unix_socket=/tmp/mysql.sock;dbname=testdb |
||||
| 267 | * |
||||
| 268 | * @param string $dsn dsn string to parse |
||||
|
0 ignored issues
–
show
|
|||||
| 269 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 270 | private function parseDsn($dsn) |
||||
|
0 ignored issues
–
show
|
|||||
| 271 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 272 | if (empty($dsn) || (false === ($pos = strpos($dsn, ":")))) { |
||||
|
0 ignored issues
–
show
The string literal
: does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 273 | throw new Exception("Empty DSN string"); |
||||
|
0 ignored issues
–
show
The string literal
Empty DSN string does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 274 | } |
||||
| 275 | |||||
| 276 | $this->dsn = $dsn; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 277 | $this->dbType = strtolower(substr($dsn, 0, $pos)); // always returns a string |
||||
|
0 ignored issues
–
show
|
|||||
| 278 | |||||
| 279 | if (empty($this->dbType)) { |
||||
| 280 | throw new Exception("Missing database type from DSN string"); |
||||
|
0 ignored issues
–
show
The string literal
Missing database type from DSN string does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 281 | } |
||||
| 282 | |||||
| 283 | $dsn = substr($dsn, $pos + 1); |
||||
|
0 ignored issues
–
show
|
|||||
| 284 | |||||
| 285 | foreach (explode(";", $dsn) as $kvp) { |
||||
|
0 ignored issues
–
show
The string literal
; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 286 | $kvpArr = explode("=", $kvp); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 33 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
The string literal
= does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 287 | $this->dsnArray[strtolower($kvpArr[0])] = $kvpArr[1]; |
||||
| 288 | } |
||||
| 289 | |||||
| 290 | if (empty($this->dsnArray['host']) && |
||||
| 291 | empty($this->dsnArray['unix_socket'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 292 | throw new Exception("Missing host from DSN string"); |
||||
|
0 ignored issues
–
show
The string literal
Missing host from DSN string does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 293 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 294 | $this->host = (!empty($this->dsnArray['host'])) ? |
||||
|
0 ignored issues
–
show
|
|||||
| 295 | $this->dsnArray['host'] : $this->dsnArray['unix_socket']; |
||||
| 296 | |||||
| 297 | if (empty($this->dsnArray['dbname'])) { |
||||
| 298 | throw new Exception("Missing database name from DSN string"); |
||||
|
0 ignored issues
–
show
The string literal
Missing database name from DSN string does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 299 | } |
||||
| 300 | |||||
| 301 | $this->dbName = $this->dsnArray['dbname']; |
||||
| 302 | |||||
| 303 | return true; |
||||
|
0 ignored issues
–
show
|
|||||
| 304 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 305 | |||||
| 306 | /** |
||||
| 307 | * Connect with PDO |
||||
| 308 | * |
||||
| 309 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 310 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 311 | private function connect() |
||||
|
0 ignored issues
–
show
|
|||||
| 312 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 313 | // Connecting with PDO |
||||
|
0 ignored issues
–
show
|
|||||
| 314 | try { |
||||
| 315 | switch ($this->dbType) { |
||||
| 316 | case 'sqlite': |
||||
|
0 ignored issues
–
show
|
|||||
| 317 | $this->dbHandler = @new PDO("sqlite:".$this->dbName, null, null, $this->pdoSettings); |
||||
|
0 ignored issues
–
show
The string literal
sqlite: does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 318 | break; |
||||
|
0 ignored issues
–
show
|
|||||
| 319 | case 'mysql': |
||||
|
0 ignored issues
–
show
|
|||||
| 320 | case 'pgsql': |
||||
|
0 ignored issues
–
show
|
|||||
| 321 | case 'dblib': |
||||
|
0 ignored issues
–
show
|
|||||
| 322 | $this->dbHandler = @new PDO( |
||||
|
0 ignored issues
–
show
|
|||||
| 323 | $this->dsn, |
||||
| 324 | $this->user, |
||||
| 325 | $this->pass, |
||||
| 326 | $this->pdoSettings |
||||
| 327 | ); |
||||
| 328 | // Execute init commands once connected |
||||
|
0 ignored issues
–
show
|
|||||
| 329 | foreach ($this->dumpSettings['init_commands'] as $stmt) { |
||||
|
0 ignored issues
–
show
|
|||||
| 330 | $this->dbHandler->exec($stmt); |
||||
| 331 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 332 | // Store server version |
||||
|
0 ignored issues
–
show
|
|||||
| 333 | $this->version = $this->dbHandler->getAttribute(PDO::ATTR_SERVER_VERSION); |
||||
| 334 | break; |
||||
|
0 ignored issues
–
show
|
|||||
| 335 | default: |
||||
|
0 ignored issues
–
show
|
|||||
| 336 | throw new Exception("Unsupported database type (".$this->dbType.")"); |
||||
|
0 ignored issues
–
show
The string literal
Unsupported database type ( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
Are you sure
$this->dbType of type mixed can be used in concatenation?
(
Ignorable by Annotation
)
If this is a false-positive, you can also ignore this issue in your code via the
Loading history...
|
|||||
| 337 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 338 | } catch (PDOException $e) { |
||||
| 339 | throw new Exception( |
||||
| 340 | "Connection to ".$this->dbType." failed with message: ". |
||||
|
0 ignored issues
–
show
The string literal
Connection to does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
failed with message: does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 341 | $e->getMessage() |
||||
| 342 | ); |
||||
| 343 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 344 | |||||
| 345 | if (is_null($this->dbHandler)) { |
||||
| 346 | throw new Exception("Connection to ".$this->dbType."failed"); |
||||
|
0 ignored issues
–
show
The string literal
Connection to does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
failed does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 347 | } |
||||
| 348 | |||||
| 349 | $this->dbHandler->setAttribute(PDO::ATTR_ORACLE_NULLS, PDO::NULL_NATURAL); |
||||
| 350 | $this->typeAdapter = TypeAdapterFactory::create($this->dbType, $this->dbHandler, $this->dumpSettings); |
||||
|
0 ignored issues
–
show
|
|||||
| 351 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 352 | |||||
| 353 | /** |
||||
| 354 | * Main call |
||||
| 355 | * |
||||
| 356 | * @param string $filename Name of file to write sql dump to |
||||
|
0 ignored issues
–
show
|
|||||
| 357 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 358 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 359 | public function start($filename = '') |
||||
| 360 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 361 | // Output file can be redefined here |
||||
|
0 ignored issues
–
show
|
|||||
| 362 | if (!empty($filename)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 363 | $this->fileName = $filename; |
||||
| 364 | } |
||||
| 365 | |||||
| 366 | // Connect to database |
||||
|
0 ignored issues
–
show
|
|||||
| 367 | $this->connect(); |
||||
| 368 | |||||
| 369 | // Create output file |
||||
|
0 ignored issues
–
show
|
|||||
| 370 | $this->compressManager->open($this->fileName); |
||||
| 371 | |||||
| 372 | // Write some basic info to output file |
||||
|
0 ignored issues
–
show
|
|||||
| 373 | $this->compressManager->write($this->getDumpFileHeader()); |
||||
| 374 | |||||
| 375 | // Store server settings and use sanner defaults to dump |
||||
|
0 ignored issues
–
show
|
|||||
| 376 | $this->compressManager->write( |
||||
| 377 | $this->typeAdapter->backup_parameters() |
||||
| 378 | ); |
||||
| 379 | |||||
| 380 | if ($this->dumpSettings['databases']) { |
||||
| 381 | $this->compressManager->write( |
||||
| 382 | $this->typeAdapter->getDatabaseHeader($this->dbName) |
||||
| 383 | ); |
||||
| 384 | if ($this->dumpSettings['add-drop-database']) { |
||||
| 385 | $this->compressManager->write( |
||||
| 386 | $this->typeAdapter->add_drop_database($this->dbName) |
||||
| 387 | ); |
||||
| 388 | } |
||||
| 389 | } |
||||
| 390 | |||||
| 391 | // Get table, view, trigger, procedures and events |
||||
| 392 | // structures from database |
||||
|
0 ignored issues
–
show
|
|||||
| 393 | $this->getDatabaseStructureTables(); |
||||
| 394 | $this->getDatabaseStructureViews(); |
||||
| 395 | $this->getDatabaseStructureTriggers(); |
||||
| 396 | $this->getDatabaseStructureProcedures(); |
||||
| 397 | $this->getDatabaseStructureEvents(); |
||||
| 398 | |||||
| 399 | if ($this->dumpSettings['databases']) { |
||||
| 400 | $this->compressManager->write( |
||||
| 401 | $this->typeAdapter->databases($this->dbName) |
||||
| 402 | ); |
||||
| 403 | } |
||||
| 404 | |||||
| 405 | // If there still are some tables/views in include-tables array, |
||||
| 406 | // that means that some tables or views weren't found. |
||||
| 407 | // Give proper error and exit. |
||||
| 408 | // This check will be removed once include-tables supports regexps |
||||
|
0 ignored issues
–
show
|
|||||
| 409 | if (0 < count($this->dumpSettings['include-tables'])) { |
||||
| 410 | $name = implode(",", $this->dumpSettings['include-tables']); |
||||
|
0 ignored issues
–
show
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 411 | throw new Exception("Table (".$name.") not found in database"); |
||||
|
0 ignored issues
–
show
The string literal
Table ( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) not found in database does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 412 | } |
||||
| 413 | |||||
| 414 | $this->exportTables(); |
||||
| 415 | $this->exportTriggers(); |
||||
| 416 | $this->exportViews(); |
||||
| 417 | $this->exportProcedures(); |
||||
| 418 | $this->exportEvents(); |
||||
| 419 | |||||
| 420 | // Restore saved parameters |
||||
|
0 ignored issues
–
show
|
|||||
| 421 | $this->compressManager->write( |
||||
| 422 | $this->typeAdapter->restore_parameters() |
||||
| 423 | ); |
||||
| 424 | // Write some stats to output file |
||||
|
0 ignored issues
–
show
|
|||||
| 425 | $this->compressManager->write($this->getDumpFileFooter()); |
||||
| 426 | // Close output file |
||||
|
0 ignored issues
–
show
|
|||||
| 427 | $this->compressManager->close(); |
||||
| 428 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 429 | |||||
| 430 | /** |
||||
| 431 | * Returns header for dump file |
||||
| 432 | * |
||||
| 433 | * @return string |
||||
| 434 | */ |
||||
| 435 | private function getDumpFileHeader() |
||||
|
0 ignored issues
–
show
|
|||||
| 436 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 437 | $header = ''; |
||||
| 438 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 439 | // Some info about software, source and time |
||||
|
0 ignored issues
–
show
|
|||||
| 440 | $header = "-- mysqldump-php https://github.com/ifsnop/mysqldump-php".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- mysqldump-php https:/...om/ifsnop/mysqldump-php does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 441 | "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 442 | "-- Host: {$this->host}\tDatabase: {$this->dbName}".PHP_EOL. |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $this instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 443 | "-- ------------------------------------------------------".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- ---------------------...----------------------- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 444 | |||||
| 445 | if (!empty($this->version)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 446 | $header .= "-- Server version \t".$this->version.PHP_EOL; |
||||
| 447 | } |
||||
| 448 | |||||
| 449 | if (!$this->dumpSettings['skip-dump-date']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 450 | $header .= "-- Date: ".date('r').PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- Date: does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 451 | } |
||||
| 452 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 453 | return $header; |
||||
| 454 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 455 | |||||
| 456 | /** |
||||
| 457 | * Returns footer for dump file |
||||
| 458 | * |
||||
| 459 | * @return string |
||||
| 460 | */ |
||||
| 461 | private function getDumpFileFooter() |
||||
|
0 ignored issues
–
show
|
|||||
| 462 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 463 | $footer = ''; |
||||
| 464 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 465 | $footer .= '-- Dump completed'; |
||||
| 466 | if (!$this->dumpSettings['skip-dump-date']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 467 | $footer .= ' on: '.date('r'); |
||||
| 468 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 469 | $footer .= PHP_EOL; |
||||
| 470 | } |
||||
| 471 | |||||
| 472 | return $footer; |
||||
| 473 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 474 | |||||
| 475 | /** |
||||
| 476 | * Reads table names from database. |
||||
| 477 | * Fills $this->tables array so they will be dumped later. |
||||
| 478 | * |
||||
| 479 | * @return null |
||||
| 480 | */ |
||||
| 481 | private function getDatabaseStructureTables() |
||||
|
0 ignored issues
–
show
|
|||||
| 482 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 483 | // Listing all tables from database |
||||
|
0 ignored issues
–
show
|
|||||
| 484 | if (empty($this->dumpSettings['include-tables'])) { |
||||
| 485 | // include all tables for now, blacklisting happens later |
||||
|
0 ignored issues
–
show
|
|||||
| 486 | foreach ($this->dbHandler->query($this->typeAdapter->show_tables($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 487 | array_push($this->tables, current($row)); |
||||
| 488 | } |
||||
| 489 | } else { |
||||
| 490 | // include only the tables mentioned in include-tables |
||||
|
0 ignored issues
–
show
|
|||||
| 491 | foreach ($this->dbHandler->query($this->typeAdapter->show_tables($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 492 | if (in_array(current($row), $this->dumpSettings['include-tables'], true)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 493 | array_push($this->tables, current($row)); |
||||
| 494 | $elem = array_search( |
||||
| 495 | current($row), |
||||
| 496 | $this->dumpSettings['include-tables'] |
||||
| 497 | ); |
||||
| 498 | unset($this->dumpSettings['include-tables'][$elem]); |
||||
| 499 | } |
||||
| 500 | } |
||||
| 501 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 502 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 503 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 504 | |||||
| 505 | /** |
||||
| 506 | * Reads view names from database. |
||||
| 507 | * Fills $this->tables array so they will be dumped later. |
||||
| 508 | * |
||||
| 509 | * @return null |
||||
| 510 | */ |
||||
| 511 | private function getDatabaseStructureViews() |
||||
|
0 ignored issues
–
show
|
|||||
| 512 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 513 | // Listing all views from database |
||||
|
0 ignored issues
–
show
|
|||||
| 514 | if (empty($this->dumpSettings['include-views'])) { |
||||
| 515 | // include all views for now, blacklisting happens later |
||||
|
0 ignored issues
–
show
|
|||||
| 516 | foreach ($this->dbHandler->query($this->typeAdapter->show_views($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 517 | array_push($this->views, current($row)); |
||||
| 518 | } |
||||
| 519 | } else { |
||||
| 520 | // include only the tables mentioned in include-tables |
||||
|
0 ignored issues
–
show
|
|||||
| 521 | foreach ($this->dbHandler->query($this->typeAdapter->show_views($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 522 | if (in_array(current($row), $this->dumpSettings['include-views'], true)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 523 | array_push($this->views, current($row)); |
||||
| 524 | $elem = array_search( |
||||
| 525 | current($row), |
||||
| 526 | $this->dumpSettings['include-views'] |
||||
| 527 | ); |
||||
| 528 | unset($this->dumpSettings['include-views'][$elem]); |
||||
| 529 | } |
||||
| 530 | } |
||||
| 531 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 532 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 533 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 534 | |||||
| 535 | /** |
||||
| 536 | * Reads trigger names from database. |
||||
| 537 | * Fills $this->tables array so they will be dumped later. |
||||
| 538 | * |
||||
| 539 | * @return null |
||||
| 540 | */ |
||||
| 541 | private function getDatabaseStructureTriggers() |
||||
|
0 ignored issues
–
show
|
|||||
| 542 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 543 | // Listing all triggers from database |
||||
|
0 ignored issues
–
show
|
|||||
| 544 | if (false === $this->dumpSettings['skip-triggers']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 545 | foreach ($this->dbHandler->query($this->typeAdapter->show_triggers($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 546 | array_push($this->triggers, $row['Trigger']); |
||||
| 547 | } |
||||
| 548 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 549 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 550 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 551 | |||||
| 552 | /** |
||||
| 553 | * Reads procedure names from database. |
||||
| 554 | * Fills $this->tables array so they will be dumped later. |
||||
| 555 | * |
||||
| 556 | * @return null |
||||
| 557 | */ |
||||
| 558 | private function getDatabaseStructureProcedures() |
||||
|
0 ignored issues
–
show
|
|||||
| 559 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 560 | // Listing all procedures from database |
||||
|
0 ignored issues
–
show
|
|||||
| 561 | if ($this->dumpSettings['routines']) { |
||||
| 562 | foreach ($this->dbHandler->query($this->typeAdapter->show_procedures($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 563 | array_push($this->procedures, $row['procedure_name']); |
||||
| 564 | } |
||||
| 565 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 566 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 567 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 568 | |||||
| 569 | /** |
||||
| 570 | * Reads event names from database. |
||||
| 571 | * Fills $this->tables array so they will be dumped later. |
||||
| 572 | * |
||||
| 573 | * @return null |
||||
| 574 | */ |
||||
| 575 | private function getDatabaseStructureEvents() |
||||
|
0 ignored issues
–
show
|
|||||
| 576 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 577 | // Listing all events from database |
||||
|
0 ignored issues
–
show
|
|||||
| 578 | if ($this->dumpSettings['events']) { |
||||
| 579 | foreach ($this->dbHandler->query($this->typeAdapter->show_events($this->dbName)) as $row) { |
||||
|
0 ignored issues
–
show
|
|||||
| 580 | array_push($this->events, $row['event_name']); |
||||
| 581 | } |
||||
| 582 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 583 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 584 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 585 | |||||
| 586 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 587 | * Compare if $table name matches with a definition inside $arr |
||||
| 588 | * @param $table string |
||||
|
0 ignored issues
–
show
|
|||||
| 589 | * @param $arr array with strings or patterns |
||||
|
0 ignored issues
–
show
|
|||||
| 590 | * @return bool |
||||
|
0 ignored issues
–
show
|
|||||
| 591 | */ |
||||
| 592 | private function matches($table, $arr) |
||||
|
0 ignored issues
–
show
|
|||||
| 593 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 594 | $match = false; |
||||
|
0 ignored issues
–
show
|
|||||
| 595 | |||||
| 596 | foreach ($arr as $pattern) { |
||||
| 597 | if ('/' != $pattern[0]) { |
||||
|
0 ignored issues
–
show
|
|||||
| 598 | continue; |
||||
| 599 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 600 | if (1 == preg_match($pattern, $table)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 601 | $match = true; |
||||
|
0 ignored issues
–
show
|
|||||
| 602 | } |
||||
| 603 | } |
||||
| 604 | |||||
| 605 | return in_array($table, $arr) || $match; |
||||
|
0 ignored issues
–
show
|
|||||
| 606 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 607 | |||||
| 608 | /** |
||||
| 609 | * Exports all the tables selected from database |
||||
| 610 | * |
||||
| 611 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 612 | */ |
||||
| 613 | private function exportTables() |
||||
|
0 ignored issues
–
show
|
|||||
| 614 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 615 | // Exporting tables one by one |
||||
|
0 ignored issues
–
show
|
|||||
| 616 | foreach ($this->tables as $table) { |
||||
| 617 | if ($this->matches($table, $this->dumpSettings['exclude-tables'])) { |
||||
| 618 | continue; |
||||
| 619 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 620 | $this->getTableStructure($table); |
||||
| 621 | if (false === $this->dumpSettings['no-data']) { // don't break compatibility with old trigger |
||||
|
0 ignored issues
–
show
|
|||||
| 622 | $this->listValues($table); |
||||
| 623 | } elseif (true === $this->dumpSettings['no-data'] |
||||
|
0 ignored issues
–
show
|
|||||
| 624 | || $this->matches($table, $this->dumpSettings['no-data'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 625 | continue; |
||||
| 626 | } else { |
||||
| 627 | $this->listValues($table); |
||||
| 628 | } |
||||
| 629 | } |
||||
| 630 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 631 | |||||
| 632 | /** |
||||
| 633 | * Exports all the views found in database |
||||
| 634 | * |
||||
| 635 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 636 | */ |
||||
| 637 | private function exportViews() |
||||
|
0 ignored issues
–
show
|
|||||
| 638 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 639 | if (false === $this->dumpSettings['no-create-info']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 640 | // Exporting views one by one |
||||
|
0 ignored issues
–
show
|
|||||
| 641 | foreach ($this->views as $view) { |
||||
| 642 | if ($this->matches($view, $this->dumpSettings['exclude-tables'])) { |
||||
| 643 | continue; |
||||
| 644 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 645 | $this->tableColumnTypes[$view] = $this->getTableColumnTypes($view); |
||||
| 646 | $this->getViewStructureTable($view); |
||||
| 647 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 648 | foreach ($this->views as $view) { |
||||
| 649 | if ($this->matches($view, $this->dumpSettings['exclude-tables'])) { |
||||
| 650 | continue; |
||||
| 651 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 652 | $this->getViewStructureView($view); |
||||
| 653 | } |
||||
| 654 | } |
||||
| 655 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 656 | |||||
| 657 | /** |
||||
| 658 | * Exports all the triggers found in database |
||||
| 659 | * |
||||
| 660 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 661 | */ |
||||
| 662 | private function exportTriggers() |
||||
|
0 ignored issues
–
show
|
|||||
| 663 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 664 | // Exporting triggers one by one |
||||
|
0 ignored issues
–
show
|
|||||
| 665 | foreach ($this->triggers as $trigger) { |
||||
| 666 | $this->getTriggerStructure($trigger); |
||||
| 667 | } |
||||
| 668 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 669 | |||||
| 670 | /** |
||||
| 671 | * Exports all the procedures found in database |
||||
| 672 | * |
||||
| 673 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 674 | */ |
||||
| 675 | private function exportProcedures() |
||||
|
0 ignored issues
–
show
|
|||||
| 676 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 677 | // Exporting triggers one by one |
||||
|
0 ignored issues
–
show
|
|||||
| 678 | foreach ($this->procedures as $procedure) { |
||||
| 679 | $this->getProcedureStructure($procedure); |
||||
| 680 | } |
||||
| 681 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 682 | |||||
| 683 | /** |
||||
| 684 | * Exports all the events found in database |
||||
| 685 | * |
||||
| 686 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 687 | */ |
||||
| 688 | private function exportEvents() |
||||
|
0 ignored issues
–
show
|
|||||
| 689 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 690 | // Exporting triggers one by one |
||||
|
0 ignored issues
–
show
|
|||||
| 691 | foreach ($this->events as $event) { |
||||
| 692 | $this->getEventStructure($event); |
||||
| 693 | } |
||||
| 694 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 695 | |||||
| 696 | /** |
||||
| 697 | * Table structure extractor |
||||
| 698 | * |
||||
| 699 | * @todo move specific mysql code to typeAdapter |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 700 | * @param string $tableName Name of table to export |
||||
|
0 ignored issues
–
show
|
|||||
| 701 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 702 | */ |
||||
| 703 | private function getTableStructure($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 704 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 705 | if (!$this->dumpSettings['no-create-info']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 706 | $ret = ''; |
||||
| 707 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 708 | $ret = "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 709 | "-- Table structure for table `$tableName`".PHP_EOL. |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 710 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 711 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 712 | $stmt = $this->typeAdapter->show_create_table($tableName); |
||||
| 713 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 714 | $this->compressManager->write($ret); |
||||
| 715 | if ($this->dumpSettings['add-drop-table']) { |
||||
| 716 | $this->compressManager->write( |
||||
| 717 | $this->typeAdapter->drop_table($tableName) |
||||
| 718 | ); |
||||
| 719 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 720 | $this->compressManager->write( |
||||
| 721 | $this->typeAdapter->create_table($r) |
||||
| 722 | ); |
||||
| 723 | break; |
||||
| 724 | } |
||||
| 725 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 726 | $this->tableColumnTypes[$tableName] = $this->getTableColumnTypes($tableName); |
||||
| 727 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 728 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 729 | |||||
| 730 | /** |
||||
| 731 | * Store column types to create data dumps and for Stand-In tables |
||||
| 732 | * |
||||
| 733 | * @param string $tableName Name of table to export |
||||
|
0 ignored issues
–
show
|
|||||
| 734 | * @return array type column types detailed |
||||
|
0 ignored issues
–
show
|
|||||
| 735 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 736 | |||||
| 737 | private function getTableColumnTypes($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 738 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 739 | $columnTypes = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 740 | $columns = $this->dbHandler->query( |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 741 | $this->typeAdapter->show_columns($tableName) |
||||
| 742 | ); |
||||
| 743 | $columns->setFetchMode(PDO::FETCH_ASSOC); |
||||
| 744 | |||||
| 745 | foreach ($columns as $key => $col) { |
||||
| 746 | $types = $this->typeAdapter->parseColumnType($col); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 22 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 747 | $columnTypes[$col['Field']] = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 748 | 'is_numeric'=> $types['is_numeric'], |
||||
|
0 ignored issues
–
show
|
|||||
| 749 | 'is_blob' => $types['is_blob'], |
||||
|
0 ignored issues
–
show
|
|||||
| 750 | 'type' => $types['type'], |
||||
|
0 ignored issues
–
show
|
|||||
| 751 | 'type_sql' => $col['Type'], |
||||
|
0 ignored issues
–
show
|
|||||
| 752 | 'is_virtual' => $types['is_virtual'] |
||||
|
0 ignored issues
–
show
|
|||||
| 753 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 754 | } |
||||
| 755 | |||||
| 756 | return $columnTypes; |
||||
| 757 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 758 | |||||
| 759 | /** |
||||
| 760 | * View structure extractor, create table (avoids cyclic references) |
||||
| 761 | * |
||||
| 762 | * @todo move mysql specific code to typeAdapter |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 763 | * @param string $viewName Name of view to export |
||||
|
0 ignored issues
–
show
|
|||||
| 764 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 765 | */ |
||||
| 766 | private function getViewStructureTable($viewName) |
||||
|
0 ignored issues
–
show
|
|||||
| 767 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 768 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 769 | $ret = "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 770 | "-- Stand-In structure for view `${viewName}`".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 771 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 772 | $this->compressManager->write($ret); |
||||
| 773 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 774 | $stmt = $this->typeAdapter->show_create_view($viewName); |
||||
| 775 | |||||
| 776 | // create views as tables, to resolve dependencies |
||||
|
0 ignored issues
–
show
|
|||||
| 777 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 778 | if ($this->dumpSettings['add-drop-table']) { |
||||
| 779 | $this->compressManager->write( |
||||
| 780 | $this->typeAdapter->drop_view($viewName) |
||||
| 781 | ); |
||||
| 782 | } |
||||
| 783 | |||||
| 784 | $this->compressManager->write( |
||||
| 785 | $this->createStandInTable($viewName) |
||||
| 786 | ); |
||||
| 787 | break; |
||||
| 788 | } |
||||
| 789 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 790 | |||||
| 791 | /** |
||||
| 792 | * Write a create table statement for the table Stand-In, show create |
||||
| 793 | * table would return a create algorithm when used on a view |
||||
| 794 | * |
||||
| 795 | * @param string $viewName Name of view to export |
||||
|
0 ignored issues
–
show
|
|||||
| 796 | * @return string create statement |
||||
|
0 ignored issues
–
show
|
|||||
| 797 | */ |
||||
| 798 | public function createStandInTable($viewName) |
||||
| 799 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 800 | $ret = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 801 | foreach ($this->tableColumnTypes[$viewName] as $k => $v) { |
||||
| 802 | $ret[] = "`${k}` ${v['type_sql']}"; |
||||
| 803 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 804 | $ret = implode(PHP_EOL.",", $ret); |
||||
|
0 ignored issues
–
show
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 805 | |||||
| 806 | $ret = "CREATE TABLE IF NOT EXISTS `$viewName` (". |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $viewName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 807 | PHP_EOL.$ret.PHP_EOL.");".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
); does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 808 | |||||
| 809 | return $ret; |
||||
| 810 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 811 | |||||
| 812 | /** |
||||
| 813 | * View structure extractor, create view |
||||
| 814 | * |
||||
| 815 | * @todo move mysql specific code to typeAdapter |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 816 | * @param string $viewName Name of view to export |
||||
|
0 ignored issues
–
show
|
|||||
| 817 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 818 | */ |
||||
| 819 | private function getViewStructureView($viewName) |
||||
|
0 ignored issues
–
show
|
|||||
| 820 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 821 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 822 | $ret = "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 823 | "-- View structure for view `${viewName}`".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 824 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 825 | $this->compressManager->write($ret); |
||||
| 826 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 827 | $stmt = $this->typeAdapter->show_create_view($viewName); |
||||
| 828 | |||||
| 829 | // create views, to resolve dependencies |
||||
|
0 ignored issues
–
show
|
|||||
| 830 | // replacing tables with views |
||||
|
0 ignored issues
–
show
|
|||||
| 831 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 832 | // because we must replace table with view, we should delete it |
||||
|
0 ignored issues
–
show
|
|||||
| 833 | $this->compressManager->write( |
||||
| 834 | $this->typeAdapter->drop_view($viewName) |
||||
| 835 | ); |
||||
| 836 | $this->compressManager->write( |
||||
| 837 | $this->typeAdapter->create_view($r) |
||||
| 838 | ); |
||||
| 839 | break; |
||||
| 840 | } |
||||
| 841 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 842 | |||||
| 843 | /** |
||||
| 844 | * Trigger structure extractor |
||||
| 845 | * |
||||
| 846 | * @param string $triggerName Name of trigger to export |
||||
|
0 ignored issues
–
show
|
|||||
| 847 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 848 | */ |
||||
| 849 | private function getTriggerStructure($triggerName) |
||||
|
0 ignored issues
–
show
|
|||||
| 850 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 851 | $stmt = $this->typeAdapter->show_create_trigger($triggerName); |
||||
| 852 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 853 | if ($this->dumpSettings['add-drop-trigger']) { |
||||
| 854 | $this->compressManager->write( |
||||
| 855 | $this->typeAdapter->add_drop_trigger($triggerName) |
||||
| 856 | ); |
||||
| 857 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 858 | $this->compressManager->write( |
||||
| 859 | $this->typeAdapter->create_trigger($r) |
||||
| 860 | ); |
||||
| 861 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 862 | } |
||||
| 863 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 864 | |||||
| 865 | /** |
||||
| 866 | * Procedure structure extractor |
||||
| 867 | * |
||||
| 868 | * @param string $procedureName Name of procedure to export |
||||
|
0 ignored issues
–
show
|
|||||
| 869 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 870 | */ |
||||
| 871 | private function getProcedureStructure($procedureName) |
||||
|
0 ignored issues
–
show
|
|||||
| 872 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 873 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 874 | $ret = "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 875 | "-- Dumping routines for database '".$this->dbName."'".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 876 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 877 | $this->compressManager->write($ret); |
||||
| 878 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 879 | $stmt = $this->typeAdapter->show_create_procedure($procedureName); |
||||
| 880 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 881 | $this->compressManager->write( |
||||
| 882 | $this->typeAdapter->create_procedure($r) |
||||
| 883 | ); |
||||
| 884 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 885 | } |
||||
| 886 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 887 | |||||
| 888 | /** |
||||
| 889 | * Event structure extractor |
||||
| 890 | * |
||||
| 891 | * @param string $eventName Name of event to export |
||||
|
0 ignored issues
–
show
|
|||||
| 892 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 893 | */ |
||||
| 894 | private function getEventStructure($eventName) |
||||
|
0 ignored issues
–
show
|
|||||
| 895 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 896 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 897 | $ret = "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 898 | "-- Dumping events for database '".$this->dbName."'".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 899 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 900 | $this->compressManager->write($ret); |
||||
| 901 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 902 | $stmt = $this->typeAdapter->show_create_event($eventName); |
||||
| 903 | foreach ($this->dbHandler->query($stmt) as $r) { |
||||
| 904 | $this->compressManager->write( |
||||
| 905 | $this->typeAdapter->create_event($r) |
||||
| 906 | ); |
||||
| 907 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 908 | } |
||||
| 909 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 910 | |||||
| 911 | /** |
||||
| 912 | * Prepare values for output |
||||
| 913 | * |
||||
| 914 | * @param string $tableName Name of table which contains rows |
||||
|
0 ignored issues
–
show
|
|||||
| 915 | * @param array $row Associative array of column names and values to be |
||||
|
0 ignored issues
–
show
|
|||||
| 916 | * quoted |
||||
|
0 ignored issues
–
show
|
|||||
| 917 | * |
||||
| 918 | * @return array |
||||
| 919 | */ |
||||
| 920 | private function prepareColumnValues($tableName, $row) |
||||
|
0 ignored issues
–
show
|
|||||
| 921 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 922 | $ret = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 9 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 923 | $columnTypes = $this->tableColumnTypes[$tableName]; |
||||
| 924 | foreach ($row as $colName => $colValue) { |
||||
| 925 | $colValue = $this->hookTransformColumnValue($tableName, $colName, $colValue, $row); |
||||
| 926 | $ret[] = $this->escape($colValue, $columnTypes[$colName]); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 927 | } |
||||
| 928 | |||||
| 929 | return $ret; |
||||
| 930 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 931 | |||||
| 932 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 933 | * Escape values with quotes when needed |
||||
| 934 | * |
||||
| 935 | * @param string $tableName Name of table which contains rows |
||||
|
0 ignored issues
–
show
|
|||||
| 936 | * @param array $row Associative array of column names and values to be quoted |
||||
|
0 ignored issues
–
show
|
|||||
| 937 | * |
||||
| 938 | * @return string |
||||
| 939 | */ |
||||
| 940 | private function escape($colValue, $colType) |
||||
|
0 ignored issues
–
show
|
|||||
| 941 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 942 | if (is_null($colValue)) { |
||||
| 943 | return "NULL"; |
||||
|
0 ignored issues
–
show
The string literal
NULL does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 944 | } elseif ($this->dumpSettings['hex-blob'] && $colType['is_blob']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 945 | if ($colType['type'] == 'bit' || !empty($colValue)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 946 | return "0x${colValue}"; |
||||
| 947 | } else { |
||||
| 948 | return "''"; |
||||
| 949 | } |
||||
| 950 | } elseif ($colType['is_numeric']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 951 | return $colValue; |
||||
| 952 | } |
||||
| 953 | |||||
| 954 | return $this->dbHandler->quote($colValue); |
||||
| 955 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 956 | |||||
| 957 | /** |
||||
| 958 | * Set a callable that will will be used to transform column values. |
||||
| 959 | * |
||||
| 960 | * @param callable $callable |
||||
|
0 ignored issues
–
show
|
|||||
| 961 | * |
||||
| 962 | * @return void |
||||
| 963 | */ |
||||
| 964 | public function setTransformColumnValueHook($callable) |
||||
|
0 ignored issues
–
show
|
|||||
| 965 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 966 | $this->transformColumnValueCallable = $callable; |
||||
| 967 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 968 | |||||
| 969 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 970 | * Give extending classes an opportunity to transform column values |
||||
| 971 | * |
||||
| 972 | * @param string $tableName Name of table which contains rows |
||||
|
0 ignored issues
–
show
|
|||||
| 973 | * @param string $colName Name of the column in question |
||||
|
0 ignored issues
–
show
|
|||||
| 974 | * @param string $colValue Value of the column in question |
||||
|
0 ignored issues
–
show
|
|||||
| 975 | * |
||||
| 976 | * @return string |
||||
| 977 | */ |
||||
| 978 | protected function hookTransformColumnValue($tableName, $colName, $colValue, $row) |
||||
| 979 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 980 | if (!$this->transformColumnValueCallable) { |
||||
|
0 ignored issues
–
show
|
|||||
| 981 | return $colValue; |
||||
| 982 | } |
||||
| 983 | |||||
| 984 | return call_user_func_array($this->transformColumnValueCallable, array( |
||||
|
0 ignored issues
–
show
|
|||||
| 985 | $tableName, |
||||
|
0 ignored issues
–
show
|
|||||
| 986 | $colName, |
||||
|
0 ignored issues
–
show
|
|||||
| 987 | $colValue, |
||||
|
0 ignored issues
–
show
|
|||||
| 988 | $row |
||||
|
0 ignored issues
–
show
|
|||||
| 989 | )); |
||||
|
0 ignored issues
–
show
For multi-line function calls, the closing parenthesis should be on a new line.
If a function call spawns multiple lines, the coding standard suggests to move the closing parenthesis to a new line: someFunctionCall(
$firstArgument,
$secondArgument,
$thirdArgument
); // Closing parenthesis on a new line.
Loading history...
|
|||||
| 990 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 991 | |||||
| 992 | /** |
||||
| 993 | * Table rows extractor |
||||
| 994 | * |
||||
| 995 | * @param string $tableName Name of table to export |
||||
|
0 ignored issues
–
show
|
|||||
| 996 | * |
||||
| 997 | * @return null |
||||
|
0 ignored issues
–
show
|
|||||
| 998 | */ |
||||
| 999 | private function listValues($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1000 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1001 | $this->prepareListValues($tableName); |
||||
| 1002 | |||||
| 1003 | $onlyOnce = true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1004 | $lineSize = 0; |
||||
| 1005 | |||||
| 1006 | // colStmt is used to form a query to obtain row values |
||||
|
0 ignored issues
–
show
|
|||||
| 1007 | $colStmt = $this->getColumnStmt($tableName); |
||||
| 1008 | // colNames is used to get the name of the columns when using complete-insert |
||||
|
0 ignored issues
–
show
|
|||||
| 1009 | if ($this->dumpSettings['complete-insert']) { |
||||
| 1010 | $colNames = $this->getColumnNames($tableName); |
||||
| 1011 | } |
||||
| 1012 | |||||
| 1013 | $stmt = "SELECT ".implode(",", $colStmt)." FROM `$tableName`"; |
||||
|
0 ignored issues
–
show
The string literal
SELECT does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1014 | |||||
| 1015 | // Table specific conditions override the default 'where' |
||||
|
0 ignored issues
–
show
|
|||||
| 1016 | $condition = $this->getTableWhere($tableName); |
||||
| 1017 | |||||
| 1018 | if ($condition) { |
||||
| 1019 | $stmt .= " WHERE {$condition}"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $condition instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1020 | } |
||||
| 1021 | |||||
| 1022 | $resultSet = $this->dbHandler->query($stmt); |
||||
| 1023 | $resultSet->setFetchMode(PDO::FETCH_ASSOC); |
||||
| 1024 | |||||
| 1025 | $ignore = $this->dumpSettings['insert-ignore'] ? ' IGNORE' : ''; |
||||
|
0 ignored issues
–
show
|
|||||
| 1026 | |||||
| 1027 | $count = 0; |
||||
| 1028 | foreach ($resultSet as $row) { |
||||
| 1029 | $count++; |
||||
| 1030 | $vals = $this->prepareColumnValues($tableName, $row); |
||||
| 1031 | if ($onlyOnce || !$this->dumpSettings['extended-insert']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1032 | if ($this->dumpSettings['complete-insert']) { |
||||
| 1033 | $lineSize += $this->compressManager->write( |
||||
| 1034 | "INSERT$ignore INTO `$tableName` (". |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $ignore instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1035 | implode(", ", $colNames). |
||||
|
0 ignored issues
–
show
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1036 | ") VALUES (".implode(",", $vals).")" |
||||
|
0 ignored issues
–
show
The string literal
) VALUES ( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1037 | ); |
||||
| 1038 | } else { |
||||
| 1039 | $lineSize += $this->compressManager->write( |
||||
| 1040 | "INSERT$ignore INTO `$tableName` VALUES (".implode(",", $vals).")" |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $ignore instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1041 | ); |
||||
| 1042 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1043 | $onlyOnce = false; |
||||
|
0 ignored issues
–
show
|
|||||
| 1044 | } else { |
||||
| 1045 | $lineSize += $this->compressManager->write(",(".implode(",", $vals).")"); |
||||
|
0 ignored issues
–
show
The string literal
,( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
, does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1046 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1047 | if (($lineSize > $this->dumpSettings['net_buffer_length']) || |
||||
| 1048 | !$this->dumpSettings['extended-insert']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1049 | $onlyOnce = true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1050 | $lineSize = $this->compressManager->write(";".PHP_EOL); |
||||
|
0 ignored issues
–
show
The string literal
; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1051 | } |
||||
| 1052 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1053 | $resultSet->closeCursor(); |
||||
| 1054 | |||||
| 1055 | if (!$onlyOnce) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1056 | $this->compressManager->write(";".PHP_EOL); |
||||
|
0 ignored issues
–
show
The string literal
; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1057 | } |
||||
| 1058 | |||||
| 1059 | $this->endListValues($tableName, $count); |
||||
| 1060 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1061 | |||||
| 1062 | /** |
||||
| 1063 | * Table rows extractor, append information prior to dump |
||||
| 1064 | * |
||||
| 1065 | * @param string $tableName Name of table to export |
||||
|
0 ignored issues
–
show
|
|||||
| 1066 | * |
||||
| 1067 | * @return null |
||||
| 1068 | */ |
||||
| 1069 | public function prepareListValues($tableName) |
||||
| 1070 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1071 | if (!$this->dumpSettings['skip-comments']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1072 | $this->compressManager->write( |
||||
| 1073 | "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1074 | "-- Dumping data for table `$tableName`".PHP_EOL. |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1075 | "--".PHP_EOL.PHP_EOL |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1076 | ); |
||||
| 1077 | } |
||||
| 1078 | |||||
| 1079 | if ($this->dumpSettings['single-transaction']) { |
||||
| 1080 | $this->dbHandler->exec($this->typeAdapter->setup_transaction()); |
||||
| 1081 | $this->dbHandler->exec($this->typeAdapter->start_transaction()); |
||||
| 1082 | } |
||||
| 1083 | |||||
| 1084 | if ($this->dumpSettings['lock-tables']) { |
||||
| 1085 | $this->typeAdapter->lock_table($tableName); |
||||
| 1086 | } |
||||
| 1087 | |||||
| 1088 | if ($this->dumpSettings['add-locks']) { |
||||
| 1089 | $this->compressManager->write( |
||||
| 1090 | $this->typeAdapter->start_add_lock_table($tableName) |
||||
| 1091 | ); |
||||
| 1092 | } |
||||
| 1093 | |||||
| 1094 | if ($this->dumpSettings['disable-keys']) { |
||||
| 1095 | $this->compressManager->write( |
||||
| 1096 | $this->typeAdapter->start_add_disable_keys($tableName) |
||||
| 1097 | ); |
||||
| 1098 | } |
||||
| 1099 | |||||
| 1100 | // Disable autocommit for faster reload |
||||
|
0 ignored issues
–
show
|
|||||
| 1101 | if ($this->dumpSettings['no-autocommit']) { |
||||
| 1102 | $this->compressManager->write( |
||||
| 1103 | $this->typeAdapter->start_disable_autocommit() |
||||
| 1104 | ); |
||||
| 1105 | } |
||||
| 1106 | |||||
| 1107 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 1108 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1109 | |||||
| 1110 | /** |
||||
| 1111 | * Table rows extractor, close locks and commits after dump |
||||
| 1112 | * |
||||
| 1113 | * @param string $tableName Name of table to export. |
||||
|
0 ignored issues
–
show
|
|||||
| 1114 | * @param integer $count Number of rows inserted. |
||||
|
0 ignored issues
–
show
|
|||||
| 1115 | * |
||||
| 1116 | * @return void |
||||
| 1117 | */ |
||||
| 1118 | public function endListValues($tableName, $count = 0) |
||||
| 1119 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1120 | if ($this->dumpSettings['disable-keys']) { |
||||
| 1121 | $this->compressManager->write( |
||||
| 1122 | $this->typeAdapter->end_add_disable_keys($tableName) |
||||
| 1123 | ); |
||||
| 1124 | } |
||||
| 1125 | |||||
| 1126 | if ($this->dumpSettings['add-locks']) { |
||||
| 1127 | $this->compressManager->write( |
||||
| 1128 | $this->typeAdapter->end_add_lock_table($tableName) |
||||
| 1129 | ); |
||||
| 1130 | } |
||||
| 1131 | |||||
| 1132 | if ($this->dumpSettings['single-transaction']) { |
||||
| 1133 | $this->dbHandler->exec($this->typeAdapter->commit_transaction()); |
||||
| 1134 | } |
||||
| 1135 | |||||
| 1136 | if ($this->dumpSettings['lock-tables']) { |
||||
| 1137 | $this->typeAdapter->unlock_table($tableName); |
||||
| 1138 | } |
||||
| 1139 | |||||
| 1140 | // Commit to enable autocommit |
||||
|
0 ignored issues
–
show
|
|||||
| 1141 | if ($this->dumpSettings['no-autocommit']) { |
||||
| 1142 | $this->compressManager->write( |
||||
| 1143 | $this->typeAdapter->end_disable_autocommit() |
||||
| 1144 | ); |
||||
| 1145 | } |
||||
| 1146 | |||||
| 1147 | $this->compressManager->write(PHP_EOL); |
||||
| 1148 | |||||
| 1149 | if (! $this->dumpSettings['skip-comments']) { |
||||
| 1150 | $this->compressManager->write( |
||||
| 1151 | "-- Dumped table `" . $tableName . "` with $count row(s)".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- Dumped table ` does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
As per coding-style, please use concatenation or
sprintf for the variable $count instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1152 | '--'.PHP_EOL.PHP_EOL |
||||
| 1153 | ); |
||||
| 1154 | } |
||||
| 1155 | |||||
| 1156 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 1157 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1158 | |||||
| 1159 | /** |
||||
| 1160 | * Build SQL List of all columns on current table which will be used for selecting |
||||
| 1161 | * |
||||
| 1162 | * @param string $tableName Name of table to get columns |
||||
|
0 ignored issues
–
show
|
|||||
| 1163 | * |
||||
| 1164 | * @return array SQL sentence with columns for select |
||||
| 1165 | */ |
||||
| 1166 | public function getColumnStmt($tableName) |
||||
| 1167 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1168 | $colStmt = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 1169 | foreach ($this->tableColumnTypes[$tableName] as $colName => $colType) { |
||||
| 1170 | if ($colType['type'] == 'bit' && $this->dumpSettings['hex-blob']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1171 | $colStmt[] = "LPAD(HEX(`${colName}`),2,'0') AS `${colName}`"; |
||||
| 1172 | } elseif ($colType['is_blob'] && $this->dumpSettings['hex-blob']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1173 | $colStmt[] = "HEX(`${colName}`) AS `${colName}`"; |
||||
| 1174 | } elseif ($colType['is_virtual']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1175 | $this->dumpSettings['complete-insert'] = true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1176 | continue; |
||||
| 1177 | } else { |
||||
| 1178 | $colStmt[] = "`${colName}`"; |
||||
| 1179 | } |
||||
| 1180 | } |
||||
| 1181 | |||||
| 1182 | return $colStmt; |
||||
| 1183 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1184 | |||||
| 1185 | /** |
||||
| 1186 | * Build SQL List of all columns on current table which will be used for inserting |
||||
| 1187 | * |
||||
| 1188 | * @param string $tableName Name of table to get columns |
||||
|
0 ignored issues
–
show
|
|||||
| 1189 | * |
||||
| 1190 | * @return array columns for sql sentence for insert |
||||
| 1191 | */ |
||||
| 1192 | public function getColumnNames($tableName) |
||||
| 1193 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1194 | $colNames = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 1195 | foreach ($this->tableColumnTypes[$tableName] as $colName => $colType) { |
||||
| 1196 | if ($colType['is_virtual']) { |
||||
| 1197 | $this->dumpSettings['complete-insert'] = true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1198 | continue; |
||||
| 1199 | } else { |
||||
| 1200 | $colNames[] = "`${colName}`"; |
||||
| 1201 | } |
||||
| 1202 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1203 | return $colNames; |
||||
| 1204 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1205 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1206 | |||||
| 1207 | /** |
||||
| 1208 | * Enum with all available compression methods |
||||
| 1209 | * |
||||
| 1210 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1211 | abstract class CompressMethod |
||||
|
0 ignored issues
–
show
|
|||||
| 1212 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1213 | public static $enums = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 1214 | "None", |
||||
|
0 ignored issues
–
show
The string literal
None does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1215 | "Gzip", |
||||
|
0 ignored issues
–
show
The string literal
Gzip does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1216 | "Bzip2" |
||||
|
0 ignored issues
–
show
The string literal
Bzip2 does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1217 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 1218 | |||||
| 1219 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1220 | * @param string $c |
||||
|
0 ignored issues
–
show
|
|||||
| 1221 | * @return boolean |
||||
| 1222 | */ |
||||
| 1223 | public static function isValid($c) |
||||
|
0 ignored issues
–
show
|
|||||
| 1224 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1225 | return in_array($c, self::$enums); |
||||
| 1226 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1227 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1228 | |||||
| 1229 | abstract class CompressManagerFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1230 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1231 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1232 | * @param string $c |
||||
|
0 ignored issues
–
show
|
|||||
| 1233 | * @return CompressBzip2|CompressGzip|CompressNone |
||||
| 1234 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1235 | public static function create($c) |
||||
|
0 ignored issues
–
show
|
|||||
| 1236 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1237 | $c = ucfirst(strtolower($c)); |
||||
| 1238 | if (!CompressMethod::isValid($c)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1239 | throw new Exception("Compression method ($c) is not defined yet"); |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $c instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1240 | } |
||||
| 1241 | |||||
| 1242 | $method = __NAMESPACE__."\\"."Compress".$c; |
||||
|
0 ignored issues
–
show
The string literal
\\ does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
Compress does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1243 | |||||
| 1244 | return new $method; |
||||
| 1245 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1246 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1247 | |||||
| 1248 | class CompressBzip2 extends CompressManagerFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1249 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1250 | private $fileHandler = null; |
||||
|
0 ignored issues
–
show
|
|||||
| 1251 | |||||
| 1252 | public function __construct() |
||||
|
0 ignored issues
–
show
|
|||||
| 1253 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1254 | if (!function_exists("bzopen")) { |
||||
|
0 ignored issues
–
show
The string literal
bzopen does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1255 | throw new Exception("Compression is enabled, but bzip2 lib is not installed or configured properly"); |
||||
|
0 ignored issues
–
show
The string literal
Compression is enabled, ... or configured properly does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1256 | } |
||||
| 1257 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1258 | |||||
| 1259 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1260 | * @param string $filename |
||||
|
0 ignored issues
–
show
|
|||||
| 1261 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1262 | public function open($filename) |
||||
| 1263 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1264 | $this->fileHandler = bzopen($filename, "w"); |
||||
|
0 ignored issues
–
show
The string literal
w does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1265 | if (false === $this->fileHandler) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1266 | throw new Exception("Output file is not writable"); |
||||
|
0 ignored issues
–
show
The string literal
Output file is not writable does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1267 | } |
||||
| 1268 | |||||
| 1269 | return true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1270 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1271 | |||||
| 1272 | public function write($str) |
||||
|
0 ignored issues
–
show
|
|||||
| 1273 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1274 | if (false === ($bytesWritten = bzwrite($this->fileHandler, $str))) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1275 | throw new Exception("Writting to file failed! Probably, there is no more free space left?"); |
||||
|
0 ignored issues
–
show
The string literal
Writting to file failed!...o more free space left? does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1276 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1277 | return $bytesWritten; |
||||
| 1278 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1279 | |||||
| 1280 | public function close() |
||||
|
0 ignored issues
–
show
|
|||||
| 1281 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1282 | return bzclose($this->fileHandler); |
||||
| 1283 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1284 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1285 | |||||
| 1286 | class CompressGzip extends CompressManagerFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1287 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1288 | private $fileHandler = null; |
||||
|
0 ignored issues
–
show
|
|||||
| 1289 | |||||
| 1290 | public function __construct() |
||||
|
0 ignored issues
–
show
|
|||||
| 1291 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1292 | if (!function_exists("gzopen")) { |
||||
|
0 ignored issues
–
show
The string literal
gzopen does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1293 | throw new Exception("Compression is enabled, but gzip lib is not installed or configured properly"); |
||||
|
0 ignored issues
–
show
The string literal
Compression is enabled, ... or configured properly does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1294 | } |
||||
| 1295 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1296 | |||||
| 1297 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1298 | * @param string $filename |
||||
|
0 ignored issues
–
show
|
|||||
| 1299 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1300 | public function open($filename) |
||||
| 1301 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1302 | $this->fileHandler = gzopen($filename, "wb"); |
||||
|
0 ignored issues
–
show
The string literal
wb does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1303 | if (false === $this->fileHandler) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1304 | throw new Exception("Output file is not writable"); |
||||
|
0 ignored issues
–
show
The string literal
Output file is not writable does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1305 | } |
||||
| 1306 | |||||
| 1307 | return true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1308 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1309 | |||||
| 1310 | public function write($str) |
||||
|
0 ignored issues
–
show
|
|||||
| 1311 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1312 | if (false === ($bytesWritten = gzwrite($this->fileHandler, $str))) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1313 | throw new Exception("Writting to file failed! Probably, there is no more free space left?"); |
||||
|
0 ignored issues
–
show
The string literal
Writting to file failed!...o more free space left? does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1314 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1315 | return $bytesWritten; |
||||
| 1316 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1317 | |||||
| 1318 | public function close() |
||||
|
0 ignored issues
–
show
|
|||||
| 1319 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1320 | return gzclose($this->fileHandler); |
||||
| 1321 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1322 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1323 | |||||
| 1324 | class CompressNone extends CompressManagerFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1325 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1326 | private $fileHandler = null; |
||||
|
0 ignored issues
–
show
|
|||||
| 1327 | |||||
| 1328 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1329 | * @param string $filename |
||||
|
0 ignored issues
–
show
|
|||||
| 1330 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1331 | public function open($filename) |
||||
|
0 ignored issues
–
show
|
|||||
| 1332 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1333 | $this->fileHandler = fopen($filename, "wb"); |
||||
|
0 ignored issues
–
show
The string literal
wb does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1334 | if (false === $this->fileHandler) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1335 | throw new Exception("Output file is not writable"); |
||||
|
0 ignored issues
–
show
The string literal
Output file is not writable does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1336 | } |
||||
| 1337 | |||||
| 1338 | return true; |
||||
|
0 ignored issues
–
show
|
|||||
| 1339 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1340 | |||||
| 1341 | public function write($str) |
||||
|
0 ignored issues
–
show
|
|||||
| 1342 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1343 | if (false === ($bytesWritten = fwrite($this->fileHandler, $str))) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1344 | throw new Exception("Writting to file failed! Probably, there is no more free space left?"); |
||||
|
0 ignored issues
–
show
The string literal
Writting to file failed!...o more free space left? does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1345 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1346 | return $bytesWritten; |
||||
| 1347 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1348 | |||||
| 1349 | public function close() |
||||
|
0 ignored issues
–
show
|
|||||
| 1350 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1351 | return fclose($this->fileHandler); |
||||
| 1352 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1353 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1354 | |||||
| 1355 | /** |
||||
| 1356 | * Enum with all available TypeAdapter implementations |
||||
| 1357 | * |
||||
| 1358 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1359 | abstract class TypeAdapter |
||||
|
0 ignored issues
–
show
|
|||||
| 1360 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1361 | public static $enums = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 1362 | "Sqlite", |
||||
|
0 ignored issues
–
show
The string literal
Sqlite does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1363 | "Mysql" |
||||
|
0 ignored issues
–
show
The string literal
Mysql does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1364 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 1365 | |||||
| 1366 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1367 | * @param string $c |
||||
|
0 ignored issues
–
show
|
|||||
| 1368 | * @return boolean |
||||
| 1369 | */ |
||||
| 1370 | public static function isValid($c) |
||||
|
0 ignored issues
–
show
|
|||||
| 1371 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1372 | return in_array($c, self::$enums); |
||||
| 1373 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1374 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1375 | |||||
| 1376 | /** |
||||
| 1377 | * TypeAdapter Factory |
||||
| 1378 | * |
||||
| 1379 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1380 | abstract class TypeAdapterFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1381 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1382 | protected $dbHandler = null; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1383 | protected $dumpSettings = array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 1384 | |||||
| 1385 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1386 | * @param string $c Type of database factory to create (Mysql, Sqlite,...) |
||||
|
0 ignored issues
–
show
|
|||||
| 1387 | * @param PDO $dbHandler |
||||
|
0 ignored issues
–
show
|
|||||
| 1388 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1389 | public static function create($c, $dbHandler = null, $dumpSettings = array()) |
||||
|
0 ignored issues
–
show
|
|||||
| 1390 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1391 | $c = ucfirst(strtolower($c)); |
||||
| 1392 | if (!TypeAdapter::isValid($c)) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1393 | throw new Exception("Database type support for ($c) not yet available"); |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $c instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1394 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1395 | $method = __NAMESPACE__."\\"."TypeAdapter".$c; |
||||
|
0 ignored issues
–
show
The string literal
\\ does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
TypeAdapter does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1396 | return new $method($dbHandler, $dumpSettings); |
||||
| 1397 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1398 | |||||
| 1399 | public function __construct($dbHandler = null, $dumpSettings = array()) |
||||
|
0 ignored issues
–
show
|
|||||
| 1400 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1401 | $this->dbHandler = $dbHandler; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1402 | $this->dumpSettings = $dumpSettings; |
||||
| 1403 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1404 | |||||
| 1405 | /** |
||||
| 1406 | * function databases Add sql to create and use database |
||||
|
0 ignored issues
–
show
|
|||||
| 1407 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1408 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1409 | public function databases() |
||||
| 1410 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1411 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1412 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1413 | |||||
| 1414 | public function show_create_table($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1415 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1416 | return "SELECT tbl_name as 'Table', sql as 'Create Table' ". |
||||
|
0 ignored issues
–
show
|
|||||
| 1417 | "FROM sqlite_master ". |
||||
|
0 ignored issues
–
show
The string literal
FROM sqlite_master does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1418 | "WHERE type='table' AND tbl_name='$tableName'"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1419 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1420 | |||||
| 1421 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1422 | * function create_table Get table creation code from database |
||||
|
0 ignored issues
–
show
|
|||||
| 1423 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1424 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1425 | public function create_table($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1426 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1427 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1428 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1429 | |||||
| 1430 | public function show_create_view($viewName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1431 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1432 | return "SELECT tbl_name as 'View', sql as 'Create View' ". |
||||
|
0 ignored issues
–
show
|
|||||
| 1433 | "FROM sqlite_master ". |
||||
|
0 ignored issues
–
show
The string literal
FROM sqlite_master does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1434 | "WHERE type='view' AND tbl_name='$viewName'"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $viewName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1435 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1436 | |||||
| 1437 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1438 | * function create_view Get view creation code from database |
||||
|
0 ignored issues
–
show
|
|||||
| 1439 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1440 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1441 | public function create_view($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1442 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1443 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1444 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1445 | |||||
| 1446 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1447 | * function show_create_trigger Get trigger creation code from database |
||||
|
0 ignored issues
–
show
|
|||||
| 1448 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1449 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1450 | public function show_create_trigger($triggerName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1451 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1452 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1453 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1454 | |||||
| 1455 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1456 | * function create_trigger Modify trigger code, add delimiters, etc |
||||
|
0 ignored issues
–
show
|
|||||
| 1457 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1458 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1459 | public function create_trigger($triggerName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1460 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1461 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1462 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1463 | |||||
| 1464 | /** |
||||
|
0 ignored issues
–
show
|
|||||
| 1465 | * function create_procedure Modify procedure code, add delimiters, etc |
||||
|
0 ignored issues
–
show
|
|||||
| 1466 | * @todo make it do something with sqlite |
||||
|
0 ignored issues
–
show
Comment refers to a TODO task
This check looks ``TODO``s show that something is left unfinished and should be attended to. Loading history...
|
|||||
| 1467 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1468 | public function create_procedure($procedureName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1469 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1470 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1471 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1472 | |||||
| 1473 | public function show_tables() |
||||
|
0 ignored issues
–
show
|
|||||
| 1474 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1475 | return "SELECT tbl_name FROM sqlite_master WHERE type='table'"; |
||||
| 1476 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1477 | |||||
| 1478 | public function show_views() |
||||
|
0 ignored issues
–
show
|
|||||
| 1479 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1480 | return "SELECT tbl_name FROM sqlite_master WHERE type='view'"; |
||||
| 1481 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1482 | |||||
| 1483 | public function show_triggers() |
||||
|
0 ignored issues
–
show
|
|||||
| 1484 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1485 | return "SELECT name FROM sqlite_master WHERE type='trigger'"; |
||||
| 1486 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1487 | |||||
| 1488 | public function show_columns() |
||||
|
0 ignored issues
–
show
|
|||||
| 1489 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1490 | if (func_num_args() != 1) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1491 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1492 | } |
||||
| 1493 | |||||
| 1494 | $args = func_get_args(); |
||||
| 1495 | |||||
| 1496 | return "pragma table_info(${args[0]})"; |
||||
| 1497 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1498 | |||||
| 1499 | public function show_procedures() |
||||
|
0 ignored issues
–
show
|
|||||
| 1500 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1501 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1502 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1503 | |||||
| 1504 | public function show_events() |
||||
|
0 ignored issues
–
show
|
|||||
| 1505 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1506 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1507 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1508 | |||||
| 1509 | public function setup_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1510 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1511 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1512 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1513 | |||||
| 1514 | public function start_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1515 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1516 | return "BEGIN EXCLUSIVE"; |
||||
|
0 ignored issues
–
show
The string literal
BEGIN EXCLUSIVE does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1517 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1518 | |||||
| 1519 | public function commit_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1520 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1521 | return "COMMIT"; |
||||
|
0 ignored issues
–
show
The string literal
COMMIT does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1522 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1523 | |||||
| 1524 | public function lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1525 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1526 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1527 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1528 | |||||
| 1529 | public function unlock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1530 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1531 | return ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1532 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1533 | |||||
| 1534 | public function start_add_lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1535 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1536 | return PHP_EOL; |
||||
| 1537 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1538 | |||||
| 1539 | public function end_add_lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1540 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1541 | return PHP_EOL; |
||||
| 1542 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1543 | |||||
| 1544 | public function start_add_disable_keys() |
||||
|
0 ignored issues
–
show
|
|||||
| 1545 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1546 | return PHP_EOL; |
||||
| 1547 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1548 | |||||
| 1549 | public function end_add_disable_keys() |
||||
|
0 ignored issues
–
show
|
|||||
| 1550 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1551 | return PHP_EOL; |
||||
| 1552 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1553 | |||||
| 1554 | public function start_disable_foreign_keys_check() |
||||
|
0 ignored issues
–
show
|
|||||
| 1555 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1556 | return PHP_EOL; |
||||
| 1557 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1558 | |||||
| 1559 | public function end_disable_foreign_keys_check() |
||||
|
0 ignored issues
–
show
|
|||||
| 1560 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1561 | return PHP_EOL; |
||||
| 1562 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1563 | |||||
| 1564 | public function add_drop_database() |
||||
|
0 ignored issues
–
show
|
|||||
| 1565 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1566 | return PHP_EOL; |
||||
| 1567 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1568 | |||||
| 1569 | public function add_drop_trigger() |
||||
|
0 ignored issues
–
show
|
|||||
| 1570 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1571 | return PHP_EOL; |
||||
| 1572 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1573 | |||||
| 1574 | public function drop_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1575 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1576 | return PHP_EOL; |
||||
| 1577 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1578 | |||||
| 1579 | public function drop_view() |
||||
|
0 ignored issues
–
show
|
|||||
| 1580 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1581 | return PHP_EOL; |
||||
| 1582 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1583 | |||||
| 1584 | /** |
||||
| 1585 | * Decode column metadata and fill info structure. |
||||
| 1586 | * type, is_numeric and is_blob will always be available. |
||||
| 1587 | * |
||||
| 1588 | * @param array $colType Array returned from "SHOW COLUMNS FROM tableName" |
||||
|
0 ignored issues
–
show
|
|||||
| 1589 | * @return array |
||||
|
0 ignored issues
–
show
|
|||||
| 1590 | */ |
||||
| 1591 | public function parseColumnType($colType) |
||||
|
0 ignored issues
–
show
|
|||||
| 1592 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1593 | return array(); |
||||
|
0 ignored issues
–
show
|
|||||
| 1594 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1595 | |||||
| 1596 | public function backup_parameters() |
||||
|
0 ignored issues
–
show
|
|||||
| 1597 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1598 | return PHP_EOL; |
||||
| 1599 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1600 | |||||
| 1601 | public function restore_parameters() |
||||
|
0 ignored issues
–
show
|
|||||
| 1602 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1603 | return PHP_EOL; |
||||
| 1604 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1605 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1606 | |||||
| 1607 | class TypeAdapterPgsql extends TypeAdapterFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1608 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1609 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1610 | |||||
| 1611 | class TypeAdapterDblib extends TypeAdapterFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1612 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1613 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1614 | |||||
| 1615 | class TypeAdapterSqlite extends TypeAdapterFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1616 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1617 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1618 | |||||
| 1619 | class TypeAdapterMysql extends TypeAdapterFactory |
||||
|
0 ignored issues
–
show
|
|||||
| 1620 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1621 | const DEFINER_RE = 'DEFINER=`(?:[^`]|``)*`@`(?:[^`]|``)*`'; |
||||
| 1622 | |||||
| 1623 | |||||
| 1624 | // Numerical Mysql types |
||||
|
0 ignored issues
–
show
|
|||||
| 1625 | public $mysqlTypes = array( |
||||
|
0 ignored issues
–
show
|
|||||
| 1626 | 'numerical' => array( |
||||
|
0 ignored issues
–
show
|
|||||
| 1627 | 'bit', |
||||
|
0 ignored issues
–
show
|
|||||
| 1628 | 'tinyint', |
||||
|
0 ignored issues
–
show
|
|||||
| 1629 | 'smallint', |
||||
|
0 ignored issues
–
show
|
|||||
| 1630 | 'mediumint', |
||||
|
0 ignored issues
–
show
|
|||||
| 1631 | 'int', |
||||
|
0 ignored issues
–
show
|
|||||
| 1632 | 'integer', |
||||
|
0 ignored issues
–
show
|
|||||
| 1633 | 'bigint', |
||||
|
0 ignored issues
–
show
|
|||||
| 1634 | 'real', |
||||
|
0 ignored issues
–
show
|
|||||
| 1635 | 'double', |
||||
|
0 ignored issues
–
show
|
|||||
| 1636 | 'float', |
||||
|
0 ignored issues
–
show
|
|||||
| 1637 | 'decimal', |
||||
|
0 ignored issues
–
show
|
|||||
| 1638 | 'numeric' |
||||
|
0 ignored issues
–
show
|
|||||
| 1639 | ), |
||||
|
0 ignored issues
–
show
|
|||||
| 1640 | 'blob' => array( |
||||
|
0 ignored issues
–
show
|
|||||
| 1641 | 'tinyblob', |
||||
|
0 ignored issues
–
show
|
|||||
| 1642 | 'blob', |
||||
|
0 ignored issues
–
show
|
|||||
| 1643 | 'mediumblob', |
||||
|
0 ignored issues
–
show
|
|||||
| 1644 | 'longblob', |
||||
|
0 ignored issues
–
show
|
|||||
| 1645 | 'binary', |
||||
|
0 ignored issues
–
show
|
|||||
| 1646 | 'varbinary', |
||||
|
0 ignored issues
–
show
|
|||||
| 1647 | 'bit', |
||||
|
0 ignored issues
–
show
|
|||||
| 1648 | 'geometry', /* http://bugs.mysql.com/bug.php?id=43544 */ |
||||
|
0 ignored issues
–
show
|
|||||
| 1649 | 'point', |
||||
|
0 ignored issues
–
show
|
|||||
| 1650 | 'linestring', |
||||
|
0 ignored issues
–
show
|
|||||
| 1651 | 'polygon', |
||||
|
0 ignored issues
–
show
|
|||||
| 1652 | 'multipoint', |
||||
|
0 ignored issues
–
show
|
|||||
| 1653 | 'multilinestring', |
||||
|
0 ignored issues
–
show
|
|||||
| 1654 | 'multipolygon', |
||||
|
0 ignored issues
–
show
|
|||||
| 1655 | 'geometrycollection', |
||||
|
0 ignored issues
–
show
|
|||||
| 1656 | ) |
||||
|
0 ignored issues
–
show
|
|||||
| 1657 | ); |
||||
|
0 ignored issues
–
show
|
|||||
| 1658 | |||||
| 1659 | public function databases() |
||||
|
0 ignored issues
–
show
|
|||||
| 1660 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1661 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1662 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1663 | $databaseName = $args[0]; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 47 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1664 | |||||
| 1665 | $resultSet = $this->dbHandler->query("SHOW VARIABLES LIKE 'character_set_database';"); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1666 | $characterSet = $resultSet->fetchColumn(1); |
||||
| 1667 | $resultSet->closeCursor(); |
||||
| 1668 | |||||
| 1669 | $resultSet = $this->dbHandler->query("SHOW VARIABLES LIKE 'collation_database';"); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 3 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1670 | $collationDb = $resultSet->fetchColumn(1); |
||||
| 1671 | $resultSet->closeCursor(); |
||||
| 1672 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1673 | |||||
| 1674 | $ret .= "CREATE DATABASE /*!32312 IF NOT EXISTS*/ `${databaseName}`". |
||||
|
0 ignored issues
–
show
|
|||||
| 1675 | " /*!40100 DEFAULT CHARACTER SET ${characterSet} ". |
||||
|
0 ignored issues
–
show
|
|||||
| 1676 | " COLLATE ${collationDb} */;".PHP_EOL.PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 1677 | "USE `${databaseName}`;".PHP_EOL.PHP_EOL; |
||||
| 1678 | |||||
| 1679 | return $ret; |
||||
| 1680 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1681 | |||||
| 1682 | public function show_create_table($tableName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1683 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1684 | return "SHOW CREATE TABLE `$tableName`"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $tableName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1685 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1686 | |||||
| 1687 | public function show_create_view($viewName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1688 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1689 | return "SHOW CREATE VIEW `$viewName`"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $viewName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1690 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1691 | |||||
| 1692 | public function show_create_trigger($triggerName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1693 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1694 | return "SHOW CREATE TRIGGER `$triggerName`"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $triggerName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1695 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1696 | |||||
| 1697 | public function show_create_procedure($procedureName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1698 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1699 | return "SHOW CREATE PROCEDURE `$procedureName`"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $procedureName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1700 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1701 | |||||
| 1702 | public function show_create_event($eventName) |
||||
|
0 ignored issues
–
show
|
|||||
| 1703 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1704 | return "SHOW CREATE EVENT `$eventName`"; |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $eventName instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 1705 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1706 | |||||
| 1707 | public function create_table($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1708 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1709 | if (!isset($row['Create Table'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1710 | throw new Exception("Error getting table code, unknown output"); |
||||
|
0 ignored issues
–
show
The string literal
Error getting table code, unknown output does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1711 | } |
||||
| 1712 | |||||
| 1713 | $createTable = $row['Create Table']; |
||||
| 1714 | if ($this->dumpSettings['reset-auto-increment']) { |
||||
| 1715 | $match = "/AUTO_INCREMENT=[0-9]+/s"; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
The string literal
/AUTO_INCREMENT=[0-9]+/s does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1716 | $replace = ""; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1717 | $createTable = preg_replace($match, $replace, $createTable); |
||||
| 1718 | } |
||||
| 1719 | |||||
| 1720 | $ret = "/*!40101 SET @saved_cs_client = @@character_set_client */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET @saved_cs_c...haracter_set_client */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1721 | "/*!40101 SET character_set_client = ".$this->dumpSettings['default-character-set']." */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET character_set_client = does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
*/; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1722 | $createTable.";".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1723 | "/*!40101 SET character_set_client = @saved_cs_client */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET character_s... = @saved_cs_client */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1724 | PHP_EOL; |
||||
| 1725 | return $ret; |
||||
| 1726 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1727 | |||||
| 1728 | public function create_view($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1729 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1730 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1731 | if (!isset($row['Create View'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1732 | throw new Exception("Error getting view structure, unknown output"); |
||||
|
0 ignored issues
–
show
The string literal
Error getting view structure, unknown output does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1733 | } |
||||
| 1734 | |||||
| 1735 | $viewStmt = $row['Create View']; |
||||
| 1736 | |||||
| 1737 | $definerStr = $this->dumpSettings['skip-definer'] ? '' : '/*!50013 \2 */'.PHP_EOL; |
||||
|
0 ignored issues
–
show
|
|||||
| 1738 | |||||
| 1739 | if ($viewStmtReplaced = preg_replace( |
||||
|
0 ignored issues
–
show
|
|||||
| 1740 | '/^(CREATE(?:\s+ALGORITHM=(?:UNDEFINED|MERGE|TEMPTABLE))?)\s+(' |
||||
| 1741 | .self::DEFINER_RE.'(?:\s+SQL SECURITY DEFINER|INVOKER)?)?\s+(VIEW .+)$/', |
||||
|
0 ignored issues
–
show
|
|||||
| 1742 | '/*!50001 \1 */'.PHP_EOL.$definerStr.'/*!50001 \3 */', |
||||
| 1743 | $viewStmt, |
||||
| 1744 | 1 |
||||
| 1745 | )) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1746 | $viewStmt = $viewStmtReplaced; |
||||
| 1747 | }; |
||||
| 1748 | |||||
| 1749 | $ret .= $viewStmt.';'.PHP_EOL.PHP_EOL; |
||||
| 1750 | return $ret; |
||||
| 1751 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1752 | |||||
| 1753 | public function create_trigger($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1754 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1755 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1756 | if (!isset($row['SQL Original Statement'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1757 | throw new Exception("Error getting trigger code, unknown output"); |
||||
|
0 ignored issues
–
show
The string literal
Error getting trigger code, unknown output does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1758 | } |
||||
| 1759 | |||||
| 1760 | $triggerStmt = $row['SQL Original Statement']; |
||||
| 1761 | $definerStr = $this->dumpSettings['skip-definer'] ? '' : '/*!50017 \2*/ '; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1762 | if ($triggerStmtReplaced = preg_replace( |
||||
|
0 ignored issues
–
show
|
|||||
| 1763 | '/^(CREATE)\s+('.self::DEFINER_RE.')?\s+(TRIGGER\s.*)$/s', |
||||
| 1764 | '/*!50003 \1*/ '.$definerStr.'/*!50003 \3 */', |
||||
| 1765 | $triggerStmt, |
||||
| 1766 | 1 |
||||
| 1767 | )) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1768 | $triggerStmt = $triggerStmtReplaced; |
||||
| 1769 | } |
||||
| 1770 | |||||
| 1771 | $ret .= "DELIMITER ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1772 | $triggerStmt.";;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1773 | "DELIMITER ;".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1774 | return $ret; |
||||
| 1775 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1776 | |||||
| 1777 | public function create_procedure($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1778 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1779 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1780 | if (!isset($row['Create Procedure'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1781 | throw new Exception("Error getting procedure code, unknown output. ". |
||||
|
0 ignored issues
–
show
The string literal
Error getting procedure code, unknown output. does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1782 | "Please check 'https://bugs.mysql.com/bug.php?id=14564'"); |
||||
|
0 ignored issues
–
show
For multi-line function calls, the closing parenthesis should be on a new line.
If a function call spawns multiple lines, the coding standard suggests to move the closing parenthesis to a new line: someFunctionCall(
$firstArgument,
$secondArgument,
$thirdArgument
); // Closing parenthesis on a new line.
Loading history...
|
|||||
| 1783 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1784 | $procedureStmt = $row['Create Procedure']; |
||||
| 1785 | |||||
| 1786 | $ret .= "/*!50003 DROP PROCEDURE IF EXISTS `". |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 DROP PROCEDURE IF EXISTS ` does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1787 | $row['Procedure']."` */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
` */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1788 | "/*!40101 SET @saved_cs_client = @@character_set_client */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET @saved_cs_c...haracter_set_client */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1789 | "/*!40101 SET character_set_client = ".$this->dumpSettings['default-character-set']." */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET character_set_client = does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
*/; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1790 | "DELIMITER ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1791 | $procedureStmt." ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1792 | "DELIMITER ;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1793 | "/*!40101 SET character_set_client = @saved_cs_client */;".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET character_s... = @saved_cs_client */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1794 | |||||
| 1795 | return $ret; |
||||
| 1796 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1797 | |||||
| 1798 | public function create_event($row) |
||||
|
0 ignored issues
–
show
|
|||||
| 1799 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1800 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1801 | if (!isset($row['Create Event'])) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1802 | throw new Exception("Error getting event code, unknown output. ". |
||||
|
0 ignored issues
–
show
The string literal
Error getting event code, unknown output. does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1803 | "Please check 'http://stackoverflow.com/questions/10853826/mysql-5-5-create-event-gives-syntax-error'"); |
||||
|
0 ignored issues
–
show
For multi-line function calls, the closing parenthesis should be on a new line.
If a function call spawns multiple lines, the coding standard suggests to move the closing parenthesis to a new line: someFunctionCall(
$firstArgument,
$secondArgument,
$thirdArgument
); // Closing parenthesis on a new line.
Loading history...
|
|||||
| 1804 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1805 | $eventName = $row['Event']; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1806 | $eventStmt = $row['Create Event']; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1807 | $sqlMode = $row['sql_mode']; |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1808 | $definerStr = $this->dumpSettings['skip-definer'] ? '' : '/*!50117 \2*/ '; |
||||
|
0 ignored issues
–
show
|
|||||
| 1809 | |||||
| 1810 | if ($eventStmtReplaced = preg_replace( |
||||
|
0 ignored issues
–
show
|
|||||
| 1811 | '/^(CREATE)\s+('.self::DEFINER_RE.')?\s+(EVENT .*)$/', |
||||
| 1812 | '/*!50106 \1*/ '.$definerStr.'/*!50106 \3 */', |
||||
| 1813 | $eventStmt, |
||||
| 1814 | 1 |
||||
| 1815 | )) { |
||||
|
0 ignored issues
–
show
|
|||||
| 1816 | $eventStmt = $eventStmtReplaced; |
||||
| 1817 | } |
||||
| 1818 | |||||
| 1819 | $ret .= "/*!50106 SET @save_time_zone= @@TIME_ZONE */ ;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50106 SET @save_time_zone= @@TIME_ZONE */ ; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1820 | "/*!50106 DROP EVENT IF EXISTS `".$eventName."` */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50106 DROP EVENT IF EXISTS ` does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
` */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1821 | "DELIMITER ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1822 | "/*!50003 SET @saved_cs_client = @@character_set_client */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET @saved_cs_c...racter_set_client */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1823 | "/*!50003 SET @saved_cs_results = @@character_set_results */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET @saved_cs_r...acter_set_results */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1824 | "/*!50003 SET @saved_col_connection = @@collation_connection */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET @saved_col_...lation_connection */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1825 | "/*!50003 SET character_set_client = utf8 */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET character_set_client = utf8 */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1826 | "/*!50003 SET character_set_results = utf8 */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET character_set_results = utf8 */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1827 | "/*!50003 SET collation_connection = utf8_general_ci */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET collation_c...= utf8_general_ci */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1828 | "/*!50003 SET @saved_sql_mode = @@sql_mode */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET @saved_sql_... = @@sql_mode */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1829 | "/*!50003 SET sql_mode = '".$sqlMode."' */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 1830 | "/*!50003 SET @saved_time_zone = @@time_zone */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET @saved_time... = @@time_zone */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1831 | "/*!50003 SET time_zone = 'SYSTEM' */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 1832 | $eventStmt." ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1833 | "/*!50003 SET time_zone = @saved_time_zone */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET time_zone ... @saved_time_zone */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1834 | "/*!50003 SET sql_mode = @saved_sql_mode */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET sql_mode ...= @saved_sql_mode */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1835 | "/*!50003 SET character_set_client = @saved_cs_client */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET character_s... @saved_cs_client */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1836 | "/*!50003 SET character_set_results = @saved_cs_results */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET character_s...@saved_cs_results */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1837 | "/*!50003 SET collation_connection = @saved_col_connection */ ;;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!50003 SET collation_c...ed_col_connection */ ;; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1838 | "DELIMITER ;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
DELIMITER ; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1839 | "/*!50106 SET TIME_ZONE= @save_time_zone */ ;".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!50106 SET TIME_ZONE= @save_time_zone */ ; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1840 | // Commented because we are doing this in restore_parameters() |
||||
| 1841 | // "/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;" . PHP_EOL . PHP_EOL; |
||||
|
0 ignored issues
–
show
|
|||||
| 1842 | |||||
| 1843 | return $ret; |
||||
| 1844 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1845 | |||||
| 1846 | public function show_tables() |
||||
|
0 ignored issues
–
show
|
|||||
| 1847 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1848 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1849 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1850 | return "SELECT TABLE_NAME AS tbl_name ". |
||||
|
0 ignored issues
–
show
The string literal
SELECT TABLE_NAME AS tbl_name does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1851 | "FROM INFORMATION_SCHEMA.TABLES ". |
||||
|
0 ignored issues
–
show
The string literal
FROM INFORMATION_SCHEMA.TABLES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1852 | "WHERE TABLE_TYPE='BASE TABLE' AND TABLE_SCHEMA='${args[0]}'"; |
||||
| 1853 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1854 | |||||
| 1855 | public function show_views() |
||||
|
0 ignored issues
–
show
|
|||||
| 1856 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1857 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1858 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1859 | return "SELECT TABLE_NAME AS tbl_name ". |
||||
|
0 ignored issues
–
show
The string literal
SELECT TABLE_NAME AS tbl_name does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1860 | "FROM INFORMATION_SCHEMA.TABLES ". |
||||
|
0 ignored issues
–
show
The string literal
FROM INFORMATION_SCHEMA.TABLES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1861 | "WHERE TABLE_TYPE='VIEW' AND TABLE_SCHEMA='${args[0]}'"; |
||||
| 1862 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1863 | |||||
| 1864 | public function show_triggers() |
||||
|
0 ignored issues
–
show
|
|||||
| 1865 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1866 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1867 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1868 | return "SHOW TRIGGERS FROM `${args[0]}`;"; |
||||
| 1869 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1870 | |||||
| 1871 | public function show_columns() |
||||
|
0 ignored issues
–
show
|
|||||
| 1872 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1873 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1874 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1875 | return "SHOW COLUMNS FROM `${args[0]}`;"; |
||||
| 1876 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1877 | |||||
| 1878 | public function show_procedures() |
||||
|
0 ignored issues
–
show
|
|||||
| 1879 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1880 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1881 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1882 | return "SELECT SPECIFIC_NAME AS procedure_name ". |
||||
|
0 ignored issues
–
show
The string literal
SELECT SPECIFIC_NAME AS procedure_name does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1883 | "FROM INFORMATION_SCHEMA.ROUTINES ". |
||||
|
0 ignored issues
–
show
The string literal
FROM INFORMATION_SCHEMA.ROUTINES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1884 | "WHERE ROUTINE_TYPE='PROCEDURE' AND ROUTINE_SCHEMA='${args[0]}'"; |
||||
| 1885 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1886 | |||||
| 1887 | /** |
||||
| 1888 | * Get query string to ask for names of events from current database. |
||||
| 1889 | * |
||||
| 1890 | * @param string Name of database |
||||
|
0 ignored issues
–
show
The type
Ifsnop\Mysqldump\Name was not found. Maybe you did not declare it correctly or list all dependencies?
The issue could also be caused by a filter entry in the build configuration.
If the path has been excluded in your configuration, e.g. filter:
dependency_paths: ["lib/*"]
For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
|
|||||
| 1891 | * @return string |
||||
|
0 ignored issues
–
show
|
|||||
| 1892 | */ |
||||
| 1893 | public function show_events() |
||||
|
0 ignored issues
–
show
|
|||||
| 1894 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1895 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1896 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1897 | return "SELECT EVENT_NAME AS event_name ". |
||||
|
0 ignored issues
–
show
The string literal
SELECT EVENT_NAME AS event_name does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1898 | "FROM INFORMATION_SCHEMA.EVENTS ". |
||||
|
0 ignored issues
–
show
The string literal
FROM INFORMATION_SCHEMA.EVENTS does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1899 | "WHERE EVENT_SCHEMA='${args[0]}'"; |
||||
| 1900 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1901 | |||||
| 1902 | public function setup_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1903 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1904 | return "SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ"; |
||||
|
0 ignored issues
–
show
The string literal
SET SESSION TRANSACTION ...N LEVEL REPEATABLE READ does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1905 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1906 | |||||
| 1907 | public function start_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1908 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1909 | return "START TRANSACTION"; |
||||
|
0 ignored issues
–
show
The string literal
START TRANSACTION does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1910 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1911 | |||||
| 1912 | public function commit_transaction() |
||||
|
0 ignored issues
–
show
|
|||||
| 1913 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1914 | return "COMMIT"; |
||||
|
0 ignored issues
–
show
The string literal
COMMIT does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1915 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1916 | |||||
| 1917 | public function lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1918 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1919 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1920 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1921 | return $this->dbHandler->exec("LOCK TABLES `${args[0]}` READ LOCAL"); |
||||
| 1922 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1923 | |||||
| 1924 | public function unlock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1925 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1926 | return $this->dbHandler->exec("UNLOCK TABLES"); |
||||
|
0 ignored issues
–
show
The string literal
UNLOCK TABLES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1927 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1928 | |||||
| 1929 | public function start_add_lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1930 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1931 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1932 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1933 | return "LOCK TABLES `${args[0]}` WRITE;".PHP_EOL; |
||||
| 1934 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1935 | |||||
| 1936 | public function end_add_lock_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1937 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1938 | return "UNLOCK TABLES;".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
UNLOCK TABLES; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1939 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1940 | |||||
| 1941 | public function start_add_disable_keys() |
||||
|
0 ignored issues
–
show
|
|||||
| 1942 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1943 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1944 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1945 | return "/*!40000 ALTER TABLE `${args[0]}` DISABLE KEYS */;". |
||||
|
0 ignored issues
–
show
|
|||||
| 1946 | PHP_EOL; |
||||
| 1947 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1948 | |||||
| 1949 | public function end_add_disable_keys() |
||||
|
0 ignored issues
–
show
|
|||||
| 1950 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1951 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1952 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1953 | return "/*!40000 ALTER TABLE `${args[0]}` ENABLE KEYS */;". |
||||
|
0 ignored issues
–
show
|
|||||
| 1954 | PHP_EOL; |
||||
| 1955 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1956 | |||||
| 1957 | public function start_disable_autocommit() |
||||
|
0 ignored issues
–
show
|
|||||
| 1958 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1959 | return "SET autocommit=0;".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
SET autocommit=0; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1960 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1961 | |||||
| 1962 | public function end_disable_autocommit() |
||||
|
0 ignored issues
–
show
|
|||||
| 1963 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1964 | return "COMMIT;".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
COMMIT; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 1965 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1966 | |||||
| 1967 | public function add_drop_database() |
||||
|
0 ignored issues
–
show
|
|||||
| 1968 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1969 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1970 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1971 | return "/*!40000 DROP DATABASE IF EXISTS `${args[0]}`*/;". |
||||
|
0 ignored issues
–
show
|
|||||
| 1972 | PHP_EOL.PHP_EOL; |
||||
| 1973 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1974 | |||||
| 1975 | public function add_drop_trigger() |
||||
|
0 ignored issues
–
show
|
|||||
| 1976 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1977 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1978 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1979 | return "DROP TRIGGER IF EXISTS `${args[0]}`;".PHP_EOL; |
||||
| 1980 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1981 | |||||
| 1982 | public function drop_table() |
||||
|
0 ignored issues
–
show
|
|||||
| 1983 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1984 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1985 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1986 | return "DROP TABLE IF EXISTS `${args[0]}`;".PHP_EOL; |
||||
| 1987 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1988 | |||||
| 1989 | public function drop_view() |
||||
|
0 ignored issues
–
show
|
|||||
| 1990 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1991 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 1992 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 1993 | return "DROP TABLE IF EXISTS `${args[0]}`;".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 1994 | "/*!50001 DROP VIEW IF EXISTS `${args[0]}`*/;".PHP_EOL; |
||||
| 1995 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 1996 | |||||
| 1997 | public function getDatabaseHeader() |
||||
|
0 ignored issues
–
show
|
|||||
| 1998 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 1999 | $this->check_parameters(func_num_args(), $expected_num_args = 1, __METHOD__); |
||||
|
0 ignored issues
–
show
|
|||||
| 2000 | $args = func_get_args(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 55 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 2001 | return "--".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2002 | "-- Current Database: `${args[0]}`".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 2003 | "--".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
-- does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2004 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2005 | |||||
| 2006 | /** |
||||
| 2007 | * Decode column metadata and fill info structure. |
||||
| 2008 | * type, is_numeric and is_blob will always be available. |
||||
| 2009 | * |
||||
| 2010 | * @param array $colType Array returned from "SHOW COLUMNS FROM tableName" |
||||
|
0 ignored issues
–
show
|
|||||
| 2011 | * @return array |
||||
|
0 ignored issues
–
show
|
|||||
| 2012 | */ |
||||
| 2013 | public function parseColumnType($colType) |
||||
|
0 ignored issues
–
show
|
|||||
| 2014 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 2015 | $colInfo = array(); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 2 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 2016 | $colParts = explode(" ", $colType['Type']); |
||||
|
0 ignored issues
–
show
The string literal
does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2017 | |||||
| 2018 | if ($fparen = strpos($colParts[0], "(")) { |
||||
|
0 ignored issues
–
show
The string literal
( does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2019 | $colInfo['type'] = substr($colParts[0], 0, $fparen); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 2020 | $colInfo['length'] = str_replace(")", "", substr($colParts[0], $fparen + 1)); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 5 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
The string literal
) does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2021 | $colInfo['attributes'] = isset($colParts[1]) ? $colParts[1] : null; |
||||
|
0 ignored issues
–
show
|
|||||
| 2022 | } else { |
||||
| 2023 | $colInfo['type'] = $colParts[0]; |
||||
| 2024 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2025 | $colInfo['is_numeric'] = in_array($colInfo['type'], $this->mysqlTypes['numerical']); |
||||
| 2026 | $colInfo['is_blob'] = in_array($colInfo['type'], $this->mysqlTypes['blob']); |
||||
|
0 ignored issues
–
show
Equals sign not aligned with surrounding assignments; expected 4 spaces but found 1 space
This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a";
$ab = "ab";
$abc = "abc";
will produce issues in the first and second line, while this second example $a = "a";
$ab = "ab";
$abc = "abc";
will produce no issues. Loading history...
|
|||||
| 2027 | // for virtual columns that are of type 'Extra', column type |
||||
|
0 ignored issues
–
show
|
|||||
| 2028 | // could by "STORED GENERATED" or "VIRTUAL GENERATED" |
||||
| 2029 | // MySQL reference: https://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.html |
||||
|
0 ignored issues
–
show
|
|||||
| 2030 | $colInfo['is_virtual'] = strpos($colType['Extra'], "VIRTUAL GENERATED") !== false || strpos($colType['Extra'], "STORED GENERATED") !== false; |
||||
|
0 ignored issues
–
show
The string literal
VIRTUAL GENERATED does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
STORED GENERATED does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2031 | |||||
| 2032 | return $colInfo; |
||||
| 2033 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2034 | |||||
| 2035 | public function backup_parameters() |
||||
|
0 ignored issues
–
show
|
|||||
| 2036 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 2037 | $ret = "/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET @OLD_CHARAC...HARACTER_SET_CLIENT */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2038 | "/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET @OLD_CHARAC...ARACTER_SET_RESULTS */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2039 | "/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET @OLD_COLLAT...OLLATION_CONNECTION */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2040 | "/*!40101 SET NAMES ".$this->dumpSettings['default-character-set']." */;".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET NAMES does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
The string literal
*/; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2041 | |||||
| 2042 | if (false === $this->dumpSettings['skip-tz-utc']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 2043 | $ret .= "/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2044 | "/*!40103 SET TIME_ZONE='+00:00' */;".PHP_EOL; |
||||
| 2045 | } |
||||
| 2046 | |||||
| 2047 | $ret .= "/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40014 SET @OLD_UNIQUE...KS, UNIQUE_CHECKS=0 */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2048 | "/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40014 SET @OLD_FOREIG...OREIGN_KEY_CHECKS=0 */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2049 | "/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
|
|||||
| 2050 | "/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!40111 SET @OLD_SQL_NO..._NOTES, SQL_NOTES=0 */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2051 | |||||
| 2052 | return $ret; |
||||
| 2053 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2054 | |||||
| 2055 | public function restore_parameters() |
||||
|
0 ignored issues
–
show
|
|||||
| 2056 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 2057 | $ret = ""; |
||||
|
0 ignored issues
–
show
The string literal
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2058 | |||||
| 2059 | if (false === $this->dumpSettings['skip-tz-utc']) { |
||||
|
0 ignored issues
–
show
|
|||||
| 2060 | $ret .= "/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;".PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2061 | } |
||||
| 2062 | |||||
| 2063 | $ret .= "/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2064 | "/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40014 SET FOREIGN_KEY..._FOREIGN_KEY_CHECKS */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2065 | "/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2066 | "/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET CHARACTER_S...HARACTER_SET_CLIENT */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2067 | "/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET CHARACTER_S...ARACTER_SET_RESULTS */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2068 | "/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;".PHP_EOL. |
||||
|
0 ignored issues
–
show
The string literal
/*!40101 SET COLLATION_C...OLLATION_CONNECTION */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2069 | "/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;".PHP_EOL.PHP_EOL; |
||||
|
0 ignored issues
–
show
The string literal
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */; does not require double quotes, as per coding-style, please use single quotes.
PHP provides two ways to mark string literals. Either with single quotes String literals in single quotes on the other hand are evaluated very literally and the only two
characters that needs escaping in the literal are the single quote itself ( Double quoted string literals may contain other variables or more complex escape sequences. <?php
$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";
print $doubleQuoted;
will print an indented: If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
|
|||||
| 2070 | |||||
| 2071 | return $ret; |
||||
| 2072 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2073 | |||||
| 2074 | /** |
||||
| 2075 | * Check number of parameters passed to function, useful when inheriting. |
||||
| 2076 | * Raise exception if unexpected. |
||||
| 2077 | * |
||||
| 2078 | * @param integer $num_args |
||||
|
0 ignored issues
–
show
|
|||||
| 2079 | * @param integer $expected_num_args |
||||
|
0 ignored issues
–
show
|
|||||
| 2080 | * @param string $method_name |
||||
|
0 ignored issues
–
show
|
|||||
| 2081 | */ |
||||
|
0 ignored issues
–
show
|
|||||
| 2082 | private function check_parameters($num_args, $expected_num_args, $method_name) |
||||
|
0 ignored issues
–
show
This method is not in camel caps format.
This check looks for method names that are not written in camelCase. In camelCase names are written without any punctuation, the start of each new
word being marked by a capital letter. Thus the name
database connection seeker becomes Loading history...
|
|||||
| 2083 | { |
||||
|
0 ignored issues
–
show
|
|||||
| 2084 | if ($num_args != $expected_num_args) { |
||||
|
0 ignored issues
–
show
|
|||||
| 2085 | throw new Exception("Unexpected parameter passed to $method_name"); |
||||
|
0 ignored issues
–
show
As per coding-style, please use concatenation or
sprintf for the variable $method_name instead of interpolation.
It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of
$x = "foo $bar $baz";
// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
Loading history...
|
|||||
| 2086 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2087 | return; |
||||
|
0 ignored issues
–
show
|
|||||
| 2088 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2089 | } |
||||
|
0 ignored issues
–
show
|
|||||
| 2090 |
