public/main/inc/lib/database.lib.php
The method Database::update() calls the typical debug function var_dump() which is mostly only used during development. Open
Open
var_dump($attributes);- Read upRead up
- Exclude checks
DevelopmentCodeFragment
Since: 2.3.0
Functions like vardump(), printr() etc. are normally only used during development and therefore such calls in production code are a good indicator that they were just forgotten.
Example
class SuspectCode {
public function doSomething(array $items)
{
foreach ($items as $i => $item) {
// …
if ('qafoo' == $item) var_dump($i);
// …
}
}
}Source https://phpmd.org/rules/design.html#developmentcodefragment
The method Database::select() calls the typical debug function var_dump() which is mostly only used during development. Open
Open
var_dump($sql);- Read upRead up
- Exclude checks
DevelopmentCodeFragment
Since: 2.3.0
Functions like vardump(), printr() etc. are normally only used during development and therefore such calls in production code are a good indicator that they were just forgotten.
Example
class SuspectCode {
public function doSomething(array $items)
{
foreach ($items as $i => $item) {
// …
if ('qafoo' == $item) var_dump($i);
// …
}
}
}Source https://phpmd.org/rules/design.html#developmentcodefragment
The method Database::insert() calls the typical debug function var_dump() which is mostly only used during development. Open
Open
var_dump($sql);- Read upRead up
- Exclude checks
DevelopmentCodeFragment
Since: 2.3.0
Functions like vardump(), printr() etc. are normally only used during development and therefore such calls in production code are a good indicator that they were just forgotten.
Example
class SuspectCode {
public function doSomething(array $items)
{
foreach ($items as $i => $item) {
// …
if ('qafoo' == $item) var_dump($i);
// …
}
}
}Source https://phpmd.org/rules/design.html#developmentcodefragment
The method Database::update() calls the typical debug function var_dump() which is mostly only used during development. Open
Open
var_dump($whereConditions);- Read upRead up
- Exclude checks
DevelopmentCodeFragment
Since: 2.3.0
Functions like vardump(), printr() etc. are normally only used during development and therefore such calls in production code are a good indicator that they were just forgotten.
Example
class SuspectCode {
public function doSomething(array $items)
{
foreach ($items as $i => $item) {
// …
if ('qafoo' == $item) var_dump($i);
// …
}
}
}Source https://phpmd.org/rules/design.html#developmentcodefragment
The method Database::update() calls the typical debug function var_dump() which is mostly only used during development. Open
Open
var_dump($sql);- Read upRead up
- Exclude checks
DevelopmentCodeFragment
Since: 2.3.0
Functions like vardump(), printr() etc. are normally only used during development and therefore such calls in production code are a good indicator that they were just forgotten.
Example
class SuspectCode {
public function doSomething(array $items)
{
foreach ($items as $i => $item) {
// …
if ('qafoo' == $item) var_dump($i);
// …
}
}
}Source https://phpmd.org/rules/design.html#developmentcodefragment
The method select() has an NPath complexity of 288. The configured NPath complexity threshold is 200. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
NPathComplexity
Since: 0.1
The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.
Example
class Foo {
function bar() {
// lots of complicated code
}
}Source https://phpmd.org/rules/codesize.html#npathcomplexity
The class Database has a coupling between objects value of 19. Consider to reduce the number of dependencies under 13. Open
Open
class Database
{
private static EntityManager $em;
private static Connection $connection;
- Read upRead up
- Exclude checks
CouplingBetweenObjects
Since: 1.1.0
A class with too many dependencies has negative impacts on several quality aspects of a class. This includes quality criteria like stability, maintainability and understandability
Example
class Foo {
/**
* @var \foo\bar\X
*/
private $x = null;
/**
* @var \foo\bar\Y
*/
private $y = null;
/**
* @var \foo\bar\Z
*/
private $z = null;
public function setFoo(\Foo $foo) {}
public function setBar(\Bar $bar) {}
public function setBaz(\Baz $baz) {}
/**
* @return \SplObjectStorage
* @throws \OutOfRangeException
* @throws \InvalidArgumentException
* @throws \ErrorException
*/
public function process(\Iterator $it) {}
// ...
}Source https://phpmd.org/rules/design.html#couplingbetweenobjects
Missing class import via use statement (line '201', column '23'). Open
Open
$object = new stdClass();- Read upRead up
- Exclude checks
MissingImport
Since: 2.7.0
Importing all external classes in a file through use statements makes them clearly visible.
Example
function make() {
return new \stdClass();
}Source http://phpmd.org/rules/cleancode.html#MissingImport
Missing class import via use statement (line '50', column '28'). Open
Open
$driverChain = new \Doctrine\Persistence\Mapping\Driver\MappingDriverChain();- Read upRead up
- Exclude checks
MissingImport
Since: 2.7.0
Importing all external classes in a file through use statements makes them clearly visible.
Example
function make() {
return new \stdClass();
}Source http://phpmd.org/rules/cleancode.html#MissingImport
Missing class import via use statement (line '39', column '33'). Open
Open
$annotationReader = new Doctrine\Common\Annotations\AnnotationReader();- Read upRead up
- Exclude checks
MissingImport
Since: 2.7.0
Importing all external classes in a file through use statements makes them clearly visible.
Example
function make() {
return new \stdClass();
}Source http://phpmd.org/rules/cleancode.html#MissingImport
Missing class import via use statement (line '46', column '38'). Open
Open
$timestampableListener = new Gedmo\Timestampable\TimestampableListener();- Read upRead up
- Exclude checks
MissingImport
Since: 2.7.0
Importing all external classes in a file through use statements makes them clearly visible.
Example
function make() {
return new \stdClass();
}Source http://phpmd.org/rules/cleancode.html#MissingImport
The method handleError uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
error_log($e->getMessage());
api_not_allowed(false, get_lang('An error has occurred. Please contact your system administrator.'));
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method parse_conditions uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
//by default DESC
$temp_value[] = ' `'.$element[0].'` DESC ';
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method select uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
$clean_columns = (string) $columns;
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method parse_conditions uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
$return_value .= ' LIMIT '.intval($limit_array[0]);
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method parse_conditions uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
$value_array = self::escape_string($value_array);
$clean_values = [$value_array];
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method select uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
if ('*' === $columns) {
$clean_columns = '*';
} else {
$clean_columns = (string) $columns;- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method select uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
$array = self::fetch_array($result);
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
The method select uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
Open
} else {
$array[] = $row;
}- Read upRead up
- Exclude checks
ElseExpression
Since: 1.4.0
An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.
Example
class Foo
{
public function bar($flag)
{
if ($flag) {
// one branch
} else {
// another branch
}
}
}Source https://phpmd.org/rules/cleancode.html#elseexpression
Avoid unused parameters such as '$option'. Open
Open
string $option = 'ASSOC',- Read upRead up
- Exclude checks
UnusedFormalParameter
Since: 0.2
Avoid passing parameters to methods or constructors and then not using those parameters.
Example
class Foo
{
private function bar($howdy)
{
// $howdy is not used
}
}Source https://phpmd.org/rules/unusedcode.html#unusedformalparameter
The parameter $show_query is not named in camelCase. Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int
{
if (empty($attributes) || empty($table_name)) {
return false;
}- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
The parameter $type_result is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
The parameter $show_query is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
The parameter $table_name is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
The parameter $where_conditions is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
The parameter $table_name is not named in camelCase. Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int
{
if (empty($attributes) || empty($table_name)) {
return false;
}- Read upRead up
- Exclude checks
CamelCaseParameterName
Since: 0.2
It is considered best practice to use the camelCase notation to name parameters.
Example
class ClassName {
public function doSomething($user_name) {
}
}Source
Missing function doc comment Open
Open
public static function setManager(EntityManager $em)- Exclude checks
Method name "Database::insert_id" is not in camel caps format Open
Open
public static function insert_id(): int- Exclude checks
Variable "show_query" is not in valid camel caps format Open
Open
if ($show_query) {- Exclude checks
Variable "type_result" is not in valid camel caps format Open
Open
if ('count' === $type_result) {- Exclude checks
Variable "condition_data" is not in valid camel caps format Open
Open
$limit_array = explode(',', $condition_data);- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
$return_value .= ' LIMIT '.intval($limit_array[0]).' , '.intval($limit_array[1]);- Exclude checks
Variable "show_query" is not in valid camel caps format Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int- Exclude checks
Missing function doc comment Open
Open
public static function setConnection(Connection $connection)- Exclude checks
Method name "Database::store_result" is not in camel caps format Open
Open
public static function store_result(\Doctrine\DBAL\Result $result, $option = 'BOTH'): array- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
$return_value = " WHERE $where_return";- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
$return_value .= ' LIMIT '.intval($limit_array[0]).' , '.intval($limit_array[1]);- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
$return_value .= ' LIMIT '.intval($limit_array[0]);- Exclude checks
Method name "Database::fetch_row" is not in camel caps format Open
Open
public static function fetch_row(\Doctrine\DBAL\Result $result): array- Exclude checks
Method name "Database::num_rows" is not in camel caps format Open
Open
public static function num_rows(\Doctrine\DBAL\Result $result): int- Exclude checks
Variable "type_result" is not in valid camel caps format Open
Open
if ('count' === $type_result) {- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
$return_value .= ' LIMIT '.intval($limit_array[0]).' , '.intval($limit_array[1]);- Exclude checks
Method name "Database::affected_rows" is not in camel caps format Open
Open
public static function affected_rows(\Doctrine\DBAL\Result $result): int- Exclude checks
Variable "clean_columns" is not in valid camel caps format Open
Open
$sql = "SELECT $clean_columns FROM $table_name $conditions";- Exclude checks
Variable "temp_value" is not in valid camel caps format Open
Open
$return_value .= ' ORDER BY '.implode(', ', $temp_value);- Exclude checks
Method name "Database::escape_string" is not in camel caps format Open
Open
public static function escape_string(mixed $string): string- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
foreach ($condition_data as $condition => $value_array) {- Exclude checks
Variable "clean_values" is not in valid camel caps format Open
Open
if (!empty($condition) && '' != $clean_values) {- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
$where_return .= $condition;- Exclude checks
Variable "order_array" is not in valid camel caps format Open
Open
$order_array = self::escape_string($order_array);- Exclude checks
Variable "order_array" is not in valid camel caps format Open
Open
$order_array = self::escape_string($order_array);- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
foreach ($value_array as $item) {- Exclude checks
Variable "condition_data" is not in valid camel caps format Open
Open
$order_array = $condition_data;- Exclude checks
Missing function doc comment Open
Open
public static function getConnection(): Connection- Exclude checks
Variable "clean_columns" is not in valid camel caps format Open
Open
$clean_columns = implode(',', $columns);- Exclude checks
Variable "type_result" is not in valid camel caps format Open
Open
if ('count' === $type_result) {- Exclude checks
Variable "condition_data" is not in valid camel caps format Open
Open
foreach ($conditions as $type_condition => $condition_data) {- Exclude checks
Method name "Database::get_course_table" is not in camel caps format Open
Open
public static function get_course_table(string $table): string- Exclude checks
Variable "table_name" is not in valid camel caps format Open
Open
if (empty($attributes) || empty($table_name)) {- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
$return_value = $where_return = '';- Exclude checks
Variable "type_condition" is not in valid camel caps format Open
Open
switch ($type_condition) {- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
if (is_array($value_array)) {- Exclude checks
Variable "clean_values" is not in valid camel caps format Open
Open
$clean_values = [];- Exclude checks
Variable "order_array" is not in valid camel caps format Open
Open
if (!empty($order_array)) {- Exclude checks
Variable "condition_data" is not in valid camel caps format Open
Open
if (false == $condition_data) {- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
$return_value .= ' ORDER BY '.implode(', ', $temp_value);- Exclude checks
Missing function doc comment Open
Open
public static function escapeField($field): string- Exclude checks
Variable "clean_values" is not in valid camel caps format Open
Open
$clean_values[] = $item;- Exclude checks
Method name "Database::fetch_array" is not in camel caps format Open
Open
public static function fetch_array(\Doctrine\DBAL\Result $result): mixed- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
$value_array = self::escape_string($value_array);- Exclude checks
Variable "clean_values" is not in valid camel caps format Open
Open
$clean_values = [$value_array];- Exclude checks
Method name "Database::fetch_assoc" is not in camel caps format Open
Open
public static function fetch_assoc(\Doctrine\DBAL\Result $result): array|bool- Exclude checks
Variable "new_order_array" is not in valid camel caps format Open
Open
foreach ($new_order_array as $element) {- Exclude checks
Method name "Database::parse_conditions" is not in camel caps format Open
Open
public static function parse_conditions(array $conditions): string- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
return $return_value;- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
$clean_values = [$value_array];- Exclude checks
Missing function doc comment Open
Open
public static function getManager(): EntityManager- Exclude checks
Variable "type_result" is not in valid camel caps format Open
Open
if ('all' === $type_result) {- Exclude checks
Variable "condition_data" is not in valid camel caps format Open
Open
foreach ($condition_data as $condition => $value_array) {- Exclude checks
Variable "clean_values" is not in valid camel caps format Open
Open
$condition = vsprintf($condition, $clean_values);- Exclude checks
Variable "order_array" is not in valid camel caps format Open
Open
$order_array = $condition_data;- Exclude checks
Variable "temp_value" is not in valid camel caps format Open
Open
if (!empty($temp_value)) {- Exclude checks
Variable "where_conditions" is not in valid camel caps format Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int- Exclude checks
Variable "show_query" is not in valid camel caps format Open
Open
if ($show_query) {- Exclude checks
Method name "Database::get_main_table" is not in camel caps format Open
Open
public static function get_main_table(string $table): string- Exclude checks
Method name "Database::count_rows" is not in camel caps format Open
Open
public static function count_rows(string $table): int- Exclude checks
Variable "table_name" is not in valid camel caps format Open
Open
string $table_name,- Exclude checks
Variable "type_result" is not in valid camel caps format Open
Open
string $type_result = 'all',- Exclude checks
Variable "clean_columns" is not in valid camel caps format Open
Open
$clean_columns = (string) $columns;- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
$return_value = " WHERE $where_return";- Exclude checks
Variable "temp_value" is not in valid camel caps format Open
Open
$temp_value = [];- Exclude checks
Variable "temp_value" is not in valid camel caps format Open
Open
$temp_value[] = ' `'.$element[0].'` '.$order.' ';- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
$where_return = self::parse_where_conditions($where_conditions);- Exclude checks
Variable "where_conditions" is not in valid camel caps format Open
Open
$where_return = self::parse_where_conditions($where_conditions);- Exclude checks
Variable "table_name" is not in valid camel caps format Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int- Exclude checks
Variable "clean_columns" is not in valid camel caps format Open
Open
$clean_columns = '*';- Exclude checks
Variable "return_value" is not in valid camel caps format Open
Open
$return_value = $where_return = '';- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
if (!empty($limit_array)) {- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
if (count($limit_array) > 1) {- Exclude checks
Method name "Database::parse_where_conditions" is not in camel caps format Open
Open
public static function parse_where_conditions(array $conditions): string- Exclude checks
Method name "Database::get_main_database" is not in camel caps format Open
Open
public static function get_main_database(): bool|string|null- Exclude checks
Method name "Database::fetch_object" is not in camel caps format Open
Open
public static function fetch_object(\Doctrine\DBAL\Result $result): ?stdClass- Exclude checks
Variable "clean_columns" is not in valid camel caps format Open
Open
$clean_columns = ' count(*) count ';- Exclude checks
Variable "table_name" is not in valid camel caps format Open
Open
$sql = "SELECT $clean_columns FROM $table_name $conditions";- Exclude checks
Variable "type_condition" is not in valid camel caps format Open
Open
$type_condition = strtolower($type_condition);- Exclude checks
Variable "temp_value" is not in valid camel caps format Open
Open
$temp_value[] = ' `'.$element[0].'` DESC ';- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
$sql = "DELETE FROM $tableName $where_return ";- Exclude checks
Variable "table_name" is not in valid camel caps format Open
Open
$sql = 'INSERT INTO '.$table_name.' ('.implode(',', $params).')- Exclude checks
Variable "type_condition" is not in valid camel caps format Open
Open
foreach ($conditions as $type_condition => $condition_data) {- Exclude checks
Variable "type_condition" is not in valid camel caps format Open
Open
$type_condition = strtolower($type_condition);- Exclude checks
Variable "value_array" is not in valid camel caps format Open
Open
$value_array = self::escape_string($value_array);- Exclude checks
Variable "order_array" is not in valid camel caps format Open
Open
$new_order_array = explode(',', $order_array);- Exclude checks
Missing class doc comment Open
Open
class Database- Exclude checks
Variable "show_query" is not in valid camel caps format Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int- Exclude checks
Variable "where_return" is not in valid camel caps format Open
Open
if (!empty($where_return)) {- Exclude checks
Variable "new_order_array" is not in valid camel caps format Open
Open
$new_order_array = explode(',', $order_array);- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
$limit_array = explode(',', $condition_data);- Exclude checks
Variable "limit_array" is not in valid camel caps format Open
Open
$return_value .= ' LIMIT '.intval($limit_array[0]);- Exclude checks
Missing function doc comment Open
Open
public static function parse_where_conditions(array $conditions): string- Exclude checks
The variable $clean_columns is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $condition_data is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_values is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_values is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $table_name is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $show_query is not named in camelCase. Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int
{
if (empty($attributes) || empty($table_name)) {
return false;
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_columns is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $condition_data is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_condition is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_values is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $new_order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_conditions is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_columns is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_result is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_values is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $temp_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $show_query is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_columns is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_result is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $condition_data is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_condition is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_values is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_result is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $condition_data is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $new_order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $temp_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function delete(string $tableName, array $where_conditions, bool $show_query = false): int
{
$where_return = self::parse_where_conditions($where_conditions);
$sql = "DELETE FROM $tableName $where_return ";
if ($show_query) {- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $table_name is not named in camelCase. Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int
{
if (empty($attributes) || empty($table_name)) {
return false;
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_condition is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $where_return is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $condition_data is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_result is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $type_condition is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $order_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $temp_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $return_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $table_name is not named in camelCase. Open
Open
public static function insert(string $table_name, array $attributes, bool $show_query = false): bool|int
{
if (empty($attributes) || empty($table_name)) {
return false;
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $clean_columns is not named in camelCase. Open
Open
public static function select(
string|array $columns,
string $table_name,
array $conditions = [],
string $type_result = 'all',- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $value_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $temp_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $temp_value is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The variable $limit_array is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseVariableName
Since: 0.2
It is considered best practice to use the camelCase notation to name variables.
Example
class ClassName {
public function doSomething() {
$data_module = new DataModule();
}
}Source
The method count_rows is not named in camelCase. Open
Open
public static function count_rows(string $table): int
{
$result = self::query("SELECT COUNT(*) AS n FROM $table");
return (int) $result->fetchOne();- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method affected_rows is not named in camelCase. Open
Open
public static function affected_rows(\Doctrine\DBAL\Result $result): int
{
return $result->rowCount();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method insert_id is not named in camelCase. Open
Open
public static function insert_id(): int
{
return (int) self::getManager()->getConnection()->lastInsertId();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method fetch_array is not named in camelCase. Open
Open
public static function fetch_array(\Doctrine\DBAL\Result $result): mixed
{
$data = $result->fetchAssociative();
if (empty($data)) {- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method fetch_assoc is not named in camelCase. Open
Open
public static function fetch_assoc(\Doctrine\DBAL\Result $result): array|bool
{
return $result->fetchAssociative();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method store_result is not named in camelCase. Open
Open
public static function store_result(\Doctrine\DBAL\Result $result, $option = 'BOTH'): array
{
if ('NUM' === $option) {
return $result->fetchAllNumeric();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method get_main_table is not named in camelCase. Open
Open
public static function get_main_table(string $table): string
{
return $table;
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method num_rows is not named in camelCase. Open
Open
public static function num_rows(\Doctrine\DBAL\Result $result): int
{
return $result->rowCount();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method parse_conditions is not named in camelCase. Open
Open
public static function parse_conditions(array $conditions): string
{
if (empty($conditions)) {
return '';
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method parse_where_conditions is not named in camelCase. Open
Open
public static function parse_where_conditions(array $conditions): string
{
return self::parse_conditions(['where' => $conditions]);
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method escape_string is not named in camelCase. Open
Open
public static function escape_string(mixed $string): string
{
$string = self::getManager()->getConnection()->quote($string);
// The quote method from PDO also adds quotes around the string, which
// is not how the legacy mysql_real_escape_string() was used in- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method fetch_object is not named in camelCase. Open
Open
public static function fetch_object(\Doctrine\DBAL\Result $result): ?stdClass
{
$data = $result->fetchAssociative();
if (empty($data)) {- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method fetch_row is not named in camelCase. Open
Open
public static function fetch_row(\Doctrine\DBAL\Result $result): array
{
$row = $result->fetchNumeric();
return empty($row) ? [] : $row;- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method get_course_table is not named in camelCase. Open
Open
public static function get_course_table(string $table): string
{
return DB_COURSE_PREFIX.$table;
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}Source
The method get_main_database is not named in camelCase. Open
Open
public static function get_main_database(): bool|string|null
{
return self::getManager()->getConnection()->getDatabase();
}- Read upRead up
- Exclude checks
CamelCaseMethodName
Since: 0.2
It is considered best practice to use the camelCase notation to name methods.
Example
class ClassName {
public function get_name() {
}
}