File SQLManager.php
has 1032 lines of code (exceeds 250 allowed). Consider refactoring. Open
<?php
/*******************************************************************************
Copyright 2009 Whole Foods Co-op
SQLManager
has 91 functions (exceeds 20 allowed). Consider refactoring. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
The class SQLManager has 74 non-getter- and setter-methods. Consider refactoring SQLManager to keep number of methods under 25. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
TooManyMethods
Since: 0.1
A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.
By default it ignores methods starting with 'get' or 'set'.
The default was changed from 10 to 25 in PHPMD 2.3.
Example
Source https://phpmd.org/rules/codesize.html#toomanymethods
The class SQLManager has 66 public methods. Consider refactoring SQLManager to keep number of public methods under 10. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
TooManyPublicMethods
Since: 0.1
A class with too many public methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects.
By default it ignores methods starting with 'get' or 'set'.
Example
Source https://phpmd.org/rules/codesize.html#toomanypublicmethods
The class SQLManager has an overall complexity of 287 which is very high. The configured complexity threshold is 50. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Exclude checks
Method transfer
has 45 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
return false;
Function transfer
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
return false;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method addConnection
has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
{
if (empty($type)) {
return false;
} elseif (strtolower($type) == 'postgres9') {
Method fieldType
has 30 lines of code (exceeds 25 allowed). Consider refactoring. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
The class SQLManager has 78 public methods and attributes. Consider reducing the number of public items to less than 45. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
ExcessivePublicCount
Since: 0.1
A large number of public methods and attributes declared in a class can indicate the class may need to be broken up as increased effort will be required to thoroughly test it.
Example
public class Foo {
public $value;
public $something;
public $var;
// [... more more public attributes ...]
public function doWork() {}
public function doMoreWork() {}
public function doWorkAgain() {}
// [... more more public methods ...]
}
Source https://phpmd.org/rules/codesize.html#excessivepubliccount
Function addConnection
has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
{
if (empty($type)) {
return false;
} elseif (strtolower($type) == 'postgres9') {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method addConnection
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
Method __construct
has 7 arguments (exceeds 4 allowed). Consider refactoring. Open
public function __construct($server,$type,$database,$username,$password='',$persistent=false, $new=false)
Function columnToArray
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
private function columnToArray($col)
{
$info = array();
$type = strtoupper($col->type);
if (property_exists($col, 'max_length') && $col->max_length != -1 && substr($type, -3) != 'INT') {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function fieldType
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Method connectAndCreate
has 5 arguments (exceeds 4 allowed). Consider refactoring. Open
private function connectAndCreate($server, $type, $username, $password, $database)
Function getValue
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
public function getValue($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function getDSN
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
private function getDSN($server, $type, $database)
{
if ($this->isPDO($type)) {
$dsn = substr(strtolower($type), 4) . ':';
if (strstr($server, ':')) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function getRow
has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring. Open
public function getRow($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function setDefaultDB
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_name])) {
return false;
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function executeAsTransaction
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function columnBooleanProperty
has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open
private function columnBooleanProperty($col, $prop)
{
if (property_exists($col, $prop) && $col->$prop) {
return true;
} else if (property_exists($col, $prop) && !$col->$prop) {
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
The class SQLManager has 1779 lines of code. Current threshold is 1000. Avoid really long classes. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Exclude checks
The method addConnection() has a Cyclomatic Complexity of 12. The configured cyclomatic complexity threshold is 10. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
{
if (empty($type)) {
return false;
} elseif (strtolower($type) == 'postgres9') {
- Read upRead up
- Exclude checks
CyclomaticComplexity
Since: 0.1
Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.
Example
// Cyclomatic Complexity = 11
class Foo {
1 public function example() {
2 if ($a == $b) {
3 if ($a1 == $b1) {
fiddle();
4 } elseif ($a2 == $b2) {
fiddle();
} else {
fiddle();
}
5 } elseif ($c == $d) {
6 while ($c == $d) {
fiddle();
}
7 } elseif ($e == $f) {
8 for ($n = 0; $n < $h; $n++) {
fiddle();
}
} else {
switch ($z) {
9 case 1:
fiddle();
break;
10 case 2:
fiddle();
break;
11 case 3:
fiddle();
break;
default:
fiddle();
break;
}
}
}
}
Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity
The method fieldType() has a Cyclomatic Complexity of 12. The configured cyclomatic complexity threshold is 10. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- Read upRead up
- Exclude checks
CyclomaticComplexity
Since: 0.1
Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.
Example
// Cyclomatic Complexity = 11
class Foo {
1 public function example() {
2 if ($a == $b) {
3 if ($a1 == $b1) {
fiddle();
4 } elseif ($a2 == $b2) {
fiddle();
} else {
fiddle();
}
5 } elseif ($c == $d) {
6 while ($c == $d) {
fiddle();
}
7 } elseif ($e == $f) {
8 for ($n = 0; $n < $h; $n++) {
fiddle();
}
} else {
switch ($z) {
9 case 1:
fiddle();
break;
10 case 2:
fiddle();
break;
11 case 3:
fiddle();
break;
default:
fiddle();
break;
}
}
}
}
Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity
The method columnToArray() has a Cyclomatic Complexity of 10. The configured cyclomatic complexity threshold is 10. Open
private function columnToArray($col)
{
$info = array();
$type = strtoupper($col->type);
if (property_exists($col, 'max_length') && $col->max_length != -1 && substr($type, -3) != 'INT') {
- Read upRead up
- Exclude checks
CyclomaticComplexity
Since: 0.1
Complexity is determined by the number of decision points in a method plus one for the method entry. The decision points are 'if', 'while', 'for', and 'case labels'. Generally, 1-4 is low complexity, 5-7 indicates moderate complexity, 8-10 is high complexity, and 11+ is very high complexity.
Example
// Cyclomatic Complexity = 11
class Foo {
1 public function example() {
2 if ($a == $b) {
3 if ($a1 == $b1) {
fiddle();
4 } elseif ($a2 == $b2) {
fiddle();
} else {
fiddle();
}
5 } elseif ($c == $d) {
6 while ($c == $d) {
fiddle();
}
7 } elseif ($e == $f) {
8 for ($n = 0; $n < $h; $n++) {
fiddle();
}
} else {
switch ($z) {
9 case 1:
fiddle();
break;
10 case 2:
fiddle();
break;
11 case 3:
fiddle();
break;
default:
fiddle();
break;
}
}
}
}
Source https://phpmd.org/rules/codesize.html#cyclomaticcomplexity
The method __construct has a boolean flag argument $persistent, which is a certain sign of a Single Responsibility Principle violation. Open
public function __construct($server,$type,$database,$username,$password='',$persistent=false, $new=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
The method addConnection has a boolean flag argument $new, which is a certain sign of a Single Responsibility Principle violation. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
Missing class import via use statement (line '248', column '28'). Open
$reflect = new \ReflectionClass($this->connections[$which_connection]);
- 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 query has a boolean flag argument $params, which is a certain sign of a Single Responsibility Principle violation. Open
public function query($query_text,$which_connection='',$params=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
The method __construct has a boolean flag argument $new, which is a certain sign of a Single Responsibility Principle violation. Open
public function __construct($server,$type,$database,$username,$password='',$persistent=false, $new=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
The method close has a boolean flag argument $force, which is a certain sign of a Single Responsibility Principle violation. Open
public function close($which_connection='', $force=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
Missing class import via use statement (line '372', column '27'). Open
throw new \Exception($errorMsg);
- 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 addConnection has a boolean flag argument $persistent, which is a certain sign of a Single Responsibility Principle violation. Open
public function addConnection($server,$type,$database,$username,$password='',$persistent=false,$new=false)
- Read upRead up
- Exclude checks
BooleanArgumentFlag
Since: 1.4.0
A boolean flag argument is a reliable indicator for a violation of the Single Responsibility Principle (SRP). You can fix this problem by extracting the logic in the boolean flag into its own class or method.
Example
class Foo {
public function bar($flag = true) {
}
}
Source https://phpmd.org/rules/cleancode.html#booleanargumentflag
Missing class import via use statement (line '1562', column '27'). Open
throw new \Exception('Record not found');
- 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 '1588', column '27'). Open
throw new \Exception('Record not found');
- 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 isConnected uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return false;
}
- 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 addConnection uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$connected = $conn->Connect($this->getDSN($server,$type,$database),$username,$password,$database);
}
- 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 connectAndCreate uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$this->last_connect_error = $conn->ErrorMsg();
$this->connections[$database] = false;
return false;
}
- 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 getDSN uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$dsn .= 'host=' . $server;
}
- 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 getDSN uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return $server;
}
- 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 executeAsTransaction uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$this->rollbackTransaction($which_connection);
}
- 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 cleanDateTime uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return date('Y-m-d H:i:s', $timestamp);
}
- 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 columnToArray uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$info['default'] = null;
}
- 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 columnBooleanProperty uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return null;
}
- 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 isView uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return false;
}
- 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 columnToArray uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$type .= '(' . $col->max_length . ')';
}
- 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 fieldName uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return '';
}
- 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 transfer uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
$big_values = '';
$big_args = 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 transfer uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return $this->executeAsTransaction($prep, $arg_sets, $dest_db);
}
- 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 getMatchingColumns uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return substr($ret, 0, strlen($ret)-1);
}
- 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 getRow uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
if ($this->throw_on_fail) {
throw new \Exception('Record not found');
} else {
return false;
- 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 smartInsert uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
// implication: column isn't in the table
}
- 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 getValue uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
if ($this->throw_on_fail) {
throw new \Exception('Record not found');
} else {
return false;
- 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 getValue uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return false;
}
- 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 using static access to class '\COREPOS\common\sql\CharSets' in method 'setCharSet'. Open
$db_charset = CharSets::get($type, $charset);
- Read upRead up
- Exclude checks
StaticAccess
Since: 1.4.0
Static access causes unexchangeable dependencies to other classes and leads to hard to test code. Avoid using static access at all costs and instead inject dependencies through the constructor. The only case when static access is acceptable is when used for factory methods.
Example
class Foo
{
public function bar()
{
Bar::baz();
}
}
Source https://phpmd.org/rules/cleancode.html#staticaccess
The method smartUpdate uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
// implication: column isn't in the table
}
- 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 getRow uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them. Open
} else {
return false;
}
- 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 '$which_connection'. Open
public function endQuery($result_object, $which_connection='')
- 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
Avoid unused local variables such as '$con'. Open
foreach ($this->connections as $db_name => $con) {
- Read upRead up
- Exclude checks
UnusedLocalVariable
Since: 0.2
Detects when a local variable is declared and/or assigned, but not used.
Example
class Foo {
public function doSomething()
{
$i = 5; // Unused
}
}
Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable
Avoid unused parameters such as '$which_connection'. Open
public function fetchObject($result_object,$which_connection='')
- 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
Avoid unused local variables such as '$group'. Open
if (preg_match($stdFmt,$str,$group)) {
- Read upRead up
- Exclude checks
UnusedLocalVariable
Since: 0.2
Detects when a local variable is declared and/or assigned, but not used.
Example
class Foo {
public function doSomething()
{
$i = 5; // Unused
}
}
Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable
The property $throw_on_fail is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The property $structure_cache is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The parameter $query_text is not named in camelCase. Open
public function queryAll($query_text)
{
$ret = true;
foreach ($this->connections as $db_name => $con) {
$ret = $this->query($query_text,$db_name);
- 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 property $last_connect_error is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The parameter $which_connection is not named in camelCase. Open
public function connectionType($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $which_connection is not named in camelCase. Open
public function endQuery($result_object, $which_connection='')
{
if (is_object($result_object) && method_exists($result_object, 'closeCursor')) {
$result_object->closeCursor();
}
- 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 $which_connection is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 property $QUERY_LOG is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The property $default_db is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The parameter $which_connection is not named in camelCase. Open
public function close($which_connection='', $force=false)
{
if (!$force) {
return true;
}
- 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 $db_name is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $query_text is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $query_text is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $which_connection is not named in camelCase. Open
public function isConnected($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function endQuery($result_object, $which_connection='')
{
if (is_object($result_object) && method_exists($result_object, 'closeCursor')) {
$result_object->closeCursor();
}
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 property $adapter_map is not named in camelCase. Open
class SQLManager
{
private $QUERY_LOG;
/** Array of connections **/
- Read upRead up
- Exclude checks
CamelCasePropertyName
Since: 0.2
It is considered best practice to use the camelCase notation to name attributes.
Example
class ClassName {
protected $property_name;
}
Source
The parameter $which_connection is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $query_text is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $which_connection is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $select_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function numFields($result_object,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function startTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $dest_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $result_object is not named in camelCase. Open
public function num_rows($result_object,$which_connection='')
{
return $this->numRows($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function fetch_array($result_object,$which_connection='')
{
return $this->fetchArray($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function now($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function seconddiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->seconddiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function dataSeek($result_object,$rownum,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function datediff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->datediff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function monthdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->monthdiff($date1, $date2);
- 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 $result_object is not named in camelCase. Open
public function fetchField($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetchObject($result_object,$which_connection='')
{
return $result_object->FetchNextObject(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 $which_connection is not named in camelCase. Open
public function curdate($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function yeardiff($date1, $date2, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->yeardiff($date1, $date2);
- 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 $result_object is not named in camelCase. Open
public function dataSeek($result_object,$rownum,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function numFields($result_object,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetch_row($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function commitTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $insert_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function num_rows($result_object,$which_connection='')
{
return $this->numRows($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function convert($expr,$type,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->convert($expr, $type);
- 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 $which_connection is not named in camelCase. Open
public function weekdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->weekdiff($date1, $date2);
- 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 $source_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function identifierEscape($str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->identifierEscape($str);
- 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 $which_connection is not named in camelCase. Open
public function fetchObject($result_object,$which_connection='')
{
return $result_object->FetchNextObject(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 $which_connection is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $which_connection is not named in camelCase. Open
public function curtime($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->curtime();
- 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 $which_connection is not named in camelCase. Open
public function locate($substr,$str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->locate($substr, $str);
- 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 $which_connection is not named in camelCase. Open
public function fetchField($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function fetchRow($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function rollbackTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $result_object is not named in camelCase. Open
public function fetch_array($result_object,$which_connection='')
{
return $this->fetchArray($result_object, $which_connection);
}
- 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 $result_object is not named in camelCase. Open
public function fetchRow($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function fetch_row($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function dateymd($date1,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dateymd($date1);
- 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 $which_connection is not named in camelCase. Open
public function fieldName($result_object,$index,$which_connection='')
{
$field = $this->fetchField($result_object, $index, $which_connection);
if (is_object($field) && property_exists($field, 'name')) {
- 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 $which_connection is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function week($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function sep($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($adapter == null) {
- 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
public function table_exists($table_name,$which_connection='')
{
return $this->tableExists($table_name, $which_connection);
}
- 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 $view_name is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $result_object is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function table_exists($table_name,$which_connection='')
{
return $this->tableExists($table_name, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $which_connection is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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
Avoid variables with short names like $c. Configured minimum length is 3. Open
function ($carry, $c) {
- Read upRead up
- Exclude checks
ShortVariable
Since: 0.2
Detects when a field, local, or parameter has a very short name.
Example
class Something {
private $q = 15; // VIOLATION - Field
public static function main( array $as ) { // VIOLATION - Formal
$r = 20 + $this->q; // VIOLATION - Local
for (int $i = 0; $i < 10; $i++) { // Not a Violation (inside FOR)
$r += $this->q;
}
}
}
Source https://phpmd.org/rules/naming.html#shortvariable
The parameter $table_name is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $arg_sets is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $result_object is not named in camelCase. Open
public function fieldName($result_object,$index,$which_connection='')
{
$field = $this->fetchField($result_object, $index, $which_connection);
if (is_object($field) && property_exists($field, 'name')) {
- 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 $which_connection is not named in camelCase. Open
public function getTables($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function dayofweek($field,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dayofweek($field);
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $which_connection is not named in camelCase. Open
public function currency($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->currency();
- 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 $which_connection is not named in camelCase. Open
public function hour($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $int_limit is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $which_connection is not named in camelCase. Open
public function dbmsName($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function getRow($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $input_array is not named in camelCase. Open
public function getRow($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function prepare($sql,$which_connection="")
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $input_array is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection1 is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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_clause is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $input_array is not named in camelCase. Open
public function getValue($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getValue($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection is not named in camelCase. Open
public function insertID($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection2 is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $source_table is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function error($which_connection='')
{
$con = $this->getNamedConnection($which_connection);
if (!is_object($con)) {
- 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
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function affectedRows($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function clearTableCache($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $dummy_value is not named in camelCase. Open
public function safeInClause($arr, $args=array(), $dummy_value=-999999)
{
if (count($arr) == 0) {
$arr = array($dummy_value);
}
- 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 variable $which_connection is not named in camelCase. Open
public function isConnected($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $which_connection is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $which_connection is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function connectionType($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $query_text is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $which_connection is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
public function queryAll($query_text)
{
$ret = true;
foreach ($this->connections as $db_name => $con) {
$ret = $this->query($query_text,$db_name);
- 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 $db_name is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $query_text is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $which_connection is not named in camelCase. Open
public function connectionType($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $current_db is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $which_connection is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $which_connection is not named in camelCase. Open
public function isConnected($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function close($which_connection='', $force=false)
{
if (!$force) {
return true;
}
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $which_connection is not named in camelCase. Open
public function isConnected($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function close($which_connection='', $force=false)
{
if (!$force) {
return true;
}
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $db_name is not named in camelCase. Open
private function setDBorSchema($db_name)
{
if (strtolower($this->connectionType($db_name)) === 'postgres9') {
$adapter = $this->getAdapter($this->connectionType($db_name));
$selectDbQuery = $adapter->useNamedDB($db_name);
- 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 $current_db is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
public function queryAll($query_text)
{
$ret = true;
foreach ($this->connections as $db_name => $con) {
$ret = $this->query($query_text,$db_name);
- 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 $which_connection is not named in camelCase. Open
public function connectionType($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $query_text is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $which_connection is not named in camelCase. Open
public function close($which_connection='', $force=false)
{
if (!$force) {
return true;
}
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $which_connection is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $query_text is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $which_connection is not named in camelCase. Open
public function connectionType($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function close($which_connection='', $force=false)
{
if (!$force) {
return true;
}
- 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 $which_connection is not named in camelCase. Open
public function selectDB($db_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $query_text is not named in camelCase. Open
public function query($query_text,$which_connection='',$params=false)
{
$con = $this->getNamedConnection($which_connection);
$result = (!is_object($con)) ? false : $con->Execute($query_text,$params);
- 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 $query_text is not named in camelCase. Open
protected function failedQueryMsg($query_text, $params, $which_connection)
{
if (is_array($query_text)) {
$query_text = $query_text[0];
}
- 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 $result_object is not named in camelCase. Open
public function endQuery($result_object, $which_connection='')
{
if (is_object($result_object) && method_exists($result_object, 'closeCursor')) {
$result_object->closeCursor();
}
- 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 $query_text is not named in camelCase. Open
public function queryAll($query_text)
{
$ret = true;
foreach ($this->connections as $db_name => $con) {
$ret = $this->query($query_text,$db_name);
- 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 $which_connection is not named in camelCase. Open
public function isConnected($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_name is not named in camelCase. Open
public function setDefaultDB($db_name)
{
/** verify connection **/
if (!isset($this->connections[$db_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 $which_connection is not named in camelCase. Open
private function getNamedConnection($which_connection)
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
return isset($this->connections[$which_connection]) ? $this->connections[$which_connection] : null;
}
- 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 $result_object is not named in camelCase. Open
public function endQuery($result_object, $which_connection='')
{
if (is_object($result_object) && method_exists($result_object, 'closeCursor')) {
$result_object->closeCursor();
}
- 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 $which_connection is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function endQuery($result_object, $which_connection='')
{
if (is_object($result_object) && method_exists($result_object, 'closeCursor')) {
$result_object->closeCursor();
}
- 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 $which_connection is not named in camelCase. Open
public function identifierEscape($str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->identifierEscape($str);
- 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 $which_connection is not named in camelCase. Open
public function dataSeek($result_object,$rownum,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $which_connection is not named in camelCase. Open
public function now($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function convert($expr,$type,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->convert($expr, $type);
- 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 $which_connection is not named in camelCase. Open
public function startTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $which_connection is not named in camelCase. Open
public function monthdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->monthdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function weekdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->weekdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function rollbackTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $select_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $query_text is not named in camelCase. Open
public function escape($query_text,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $which_connection is not named in camelCase. Open
public function num_rows($result_object,$which_connection='')
{
return $this->numRows($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function numFields($result_object,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function numFields($result_object,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $which_connection is not named in camelCase. Open
public function fetch_row($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $result_object is not named in camelCase. Open
public function fetchObject($result_object,$which_connection='')
{
return $result_object->FetchNextObject(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 $which_connection is not named in camelCase. Open
public function commitTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetch_row($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $source_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function datediff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->datediff($date1, $date2);
- 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 $big_args is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function seconddiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->seconddiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function dateymd($date1,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dateymd($date1);
- 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 $which_connection is not named in camelCase. Open
public function locate($substr,$str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->locate($substr, $str);
- 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 $which_connection is not named in camelCase. Open
public function yeardiff($date1, $date2, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->yeardiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function startTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function seconddiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->seconddiff($date1, $date2);
- 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 $big_args is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function locate($substr,$str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->locate($substr, $str);
- 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 $which_connection is not named in camelCase. Open
public function locate($substr,$str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->locate($substr, $str);
- 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 $which_connection is not named in camelCase. Open
public function commitTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function identifierEscape($str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->identifierEscape($str);
- 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 $which_connection is not named in camelCase. Open
public function datediff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->datediff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function datediff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->datediff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function monthdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->monthdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function convert($expr,$type,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->convert($expr, $type);
- 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 $which_connection is not named in camelCase. Open
public function startTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $source_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function dataSeek($result_object,$rownum,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function now($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function curtime($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->curtime();
- 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 $which_connection is not named in camelCase. Open
public function identifierEscape($str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->identifierEscape($str);
- 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 $which_connection is not named in camelCase. Open
public function monthdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->monthdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function seconddiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->seconddiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function locate($substr,$str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->locate($substr, $str);
- 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 $which_connection is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $which_connection is not named in camelCase. Open
public function curdate($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function curtime($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->curtime();
- 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 $which_connection is not named in camelCase. Open
public function identifierEscape($str,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->identifierEscape($str);
- 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 $which_connection is not named in camelCase. Open
public function datediff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->datediff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function concat()
{
$args = func_get_args();
$which_connection = array_pop($args);
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $which_connection is not named in camelCase. Open
public function commitTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function curdate($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function curtime($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->curtime();
- 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 $which_connection is not named in camelCase. Open
public function dateymd($date1,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dateymd($date1);
- 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 $which_connection is not named in camelCase. Open
public function concat()
{
$args = func_get_args();
$which_connection = array_pop($args);
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function fetchField($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function weekdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->weekdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function weekdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->weekdiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function weekdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->weekdiff($date1, $date2);
- 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 $source_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function num_rows($result_object,$which_connection='')
{
return $this->numRows($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function now($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function dateymd($date1,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dateymd($date1);
- 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 $which_connection is not named in camelCase. Open
public function fetchField($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function rollbackTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $big_args is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function yeardiff($date1, $date2, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->yeardiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function convert($expr,$type,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->convert($expr, $type);
- 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 $which_connection is not named in camelCase. Open
public function convert($expr,$type,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->convert($expr, $type);
- 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 $which_connection is not named in camelCase. Open
public function rollbackTransaction($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function dataSeek($result_object,$rownum,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function dateymd($date1,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dateymd($date1);
- 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 $source_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function fetchRow($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function monthdiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->monthdiff($date1, $date2);
- 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 $result_object is not named in camelCase. Open
public function numRows($result_object,$which_connection='')
{
if (!is_object($result_object)) {
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 $result_object is not named in camelCase. Open
public function fetch_array($result_object,$which_connection='')
{
return $this->fetchArray($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function curtime($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->curtime();
- 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 $which_connection is not named in camelCase. Open
public function yeardiff($date1, $date2, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->yeardiff($date1, $date2);
- 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 $which_connection is not named in camelCase. Open
public function seconddiff($date1,$date2,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->seconddiff($date1, $date2);
- 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 $result_object is not named in camelCase. Open
public function fetchField($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $big_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $result_object is not named in camelCase. Open
public function numFields($result_object,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $result_object is not named in camelCase. Open
public function fetchArray($result_object,$which_connection='')
{
if (is_null($result_object)) return false;
if ($result_object === false) 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 $which_connection is not named in camelCase. Open
public function fetch_array($result_object,$which_connection='')
{
return $this->fetchArray($result_object, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function fetchRow($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function curdate($which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function yeardiff($date1, $date2, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->yeardiff($date1, $date2);
- 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 $insert_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $insert_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $dest_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function currency($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->currency();
- 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 $which_connection is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $which_connection is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function hour($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $dest_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $lc_views is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $lc_views is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getTables($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $table_name is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $which_connection is not named in camelCase. Open
public function currency($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->currency();
- 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 $which_connection is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $view_name is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $big_query is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $arg_sets is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function week($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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
public function table_exists($table_name,$which_connection='')
{
return $this->tableExists($table_name, $which_connection);
}
- 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 $which_connection is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $lc_name is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function currency($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->currency();
- 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 $int_limit is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $result_object is not named in camelCase. Open
public function fieldName($result_object,$index,$which_connection='')
{
$field = $this->fetchField($result_object, $index, $which_connection);
if (is_object($field) && property_exists($field, 'name')) {
- 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 $which_connection is not named in camelCase. Open
public function dayofweek($field,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dayofweek($field);
- 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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function week($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $big_args is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function week($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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 $which_connection is not named in camelCase. Open
public function hour($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function sep($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($adapter == null) {
- 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 $which_connection is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function sep($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($adapter == null) {
- 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 $which_connection is not named in camelCase. Open
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $which_connection is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $dest_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function dayofweek($field,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dayofweek($field);
- 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 $which_connection is not named in camelCase. Open
public function currency($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->currency();
- 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 $which_connection is not named in camelCase. Open
private function lockTimeout($seconds, $which_connection)
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
- 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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $lc_name is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $big_prep is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function fieldName($result_object,$index,$which_connection='')
{
$field = $this->fetchField($result_object, $index, $which_connection);
if (is_object($field) && property_exists($field, 'name')) {
- 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 $which_connection is not named in camelCase. Open
public function dayofweek($field,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dayofweek($field);
- 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 $which_connection is not named in camelCase. Open
public function hour($field,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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 $which_connection is not named in camelCase. Open
public function getTables($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $big_prep is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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 $which_connection is not named in camelCase. Open
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $which_connection is not named in camelCase. Open
public function getTables($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $arg_sets is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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
public function tableExists($table_name,$which_connection='')
{
/**
Check whether the definition is in cache
*/
- 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 $which_connection is not named in camelCase. Open
public function table_exists($table_name,$which_connection='')
{
return $this->tableExists($table_name, $which_connection);
}
- 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 $view_name is not named in camelCase. Open
public function getViewDefinition($view_name, $which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
if (!$this->isView($view_name, $which_connection)) {
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function dayofweek($field,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->dayofweek($field);
- 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
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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
public function isView($table_name, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function detailedDefinition($table_name,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$conn = $this->connections[$which_connection];
$cols = $conn->MetaColumns($table_name);
- 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 $dest_db is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function tableDefinition($table_name,$which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function defaultDatabase($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($which_connection == '') {
- 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 $big_values is not named in camelCase. Open
public function transfer($source_db,$select_query,$dest_db,$insert_query)
{
$result = $this->query($select_query,$source_db);
if (!$result) {
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 $which_connection is not named in camelCase. Open
public function executeAsTransaction($query, $arg_sets, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$ret = true;
$statement = $this->prepare($query, $which_connection);
- 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 $result_object is not named in camelCase. Open
public function fieldType($result_object,$index,$which_connection='')
{
if ($which_connection == '') {
$which_connection = $this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $which_connection is not named in camelCase. Open
public function addSelectLimit($query,$int_limit,$which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
return $adapter->addSelectLimit($query, $int_limit);
- 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 $which_connection is not named in camelCase. Open
public function insertID($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $source_table is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $t_def is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function prepare($sql,$which_connection="")
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $input_array is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function dbmsName($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function affectedRows($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $t_def is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function prepare($sql,$which_connection="")
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function prepare($sql,$which_connection="")
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $input_array is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $input_array is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection2 is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function dbmsName($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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_clause is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $column_name is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $column_name is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function clearTableCache($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function sep($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($adapter == null) {
- 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 $which_connection is not named in camelCase. Open
public function affectedRows($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function getValue($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $col_name is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $t_def is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $t_def is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $input_array is not named in camelCase. Open
public function getValue($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $input_array is not named in camelCase. Open
public function getRow($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection1 is not named in camelCase. Open
public function getMatchingColumns($table1, $which_connection1, $table2, $which_connection2)
{
$def1 = $this->tableDefinition($table1, $which_connection1);
$def2 = $this->tableDefinition($table2, $which_connection2);
$ret = array_reduce(array_keys($def1),
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $which_connection is not named in camelCase. Open
public function affectedRows($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $input_array is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function clearTableCache($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $db_charset is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $t_def is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function matchingColumns($table1, $table2, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function cacheTableDefinition($table, $definition, $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function clearTableCache($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function sep($which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
if ($adapter == null) {
- 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
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $which_connection is not named in camelCase. Open
public function error($which_connection='')
{
$con = $this->getNamedConnection($which_connection);
if (!is_object($con)) {
- 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 $which_connection is not named in camelCase. Open
public function insertID($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function getRow($sql, $input_array=array(), $which_connection='')
{
$res = $this->execute($sql, $input_array, $which_connection);
if ($res && $this->numRows($res) > 0) {
$row = $this->fetchRow($res);
- 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 $which_connection is not named in camelCase. Open
public function temporaryTable($name, $source_table, $which_connection='')
{
$which_connection = $which_connection === '' ? $this->default_db : $which_connection;
$adapter = $this->getAdapter($this->connectionType($which_connection));
$query = $adapter->temporaryTable($name, $source_table);
- 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 $db_charset is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $db_charset is not named in camelCase. Open
public function setCharSet($charset, $which_connection='')
{
// validate connection
$con = $this->getNamedConnection($which_connection);
$type = $this->connectionType($which_connection);
- 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 $which_connection is not named in camelCase. Open
public function dbmsName($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $t_def is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function smartUpdate($table_name,$values,$where_clause,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $dummy_value is not named in camelCase. Open
public function safeInClause($arr, $args=array(), $dummy_value=-999999)
{
if (count($arr) == 0) {
$arr = array($dummy_value);
}
- 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 $which_connection is not named in camelCase. Open
public function insertID($which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 $which_connection is not named in camelCase. Open
public function smartInsert($table_name,$values,$which_connection='')
{
$which_connection = ($which_connection === '') ? $this->default_db : $which_connection;
$t_def = $this->tableDefinition($table_name, $which_connection);
- 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 $which_connection is not named in camelCase. Open
public function execute($sql, $input_array=array(), $which_connection='')
{
if ($which_connection == '') {
$which_connection=$this->default_db;
}
- 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 fetch_array is not named in camelCase. Open
public function fetch_array($result_object,$which_connection='')
{
return $this->fetchArray($result_object, $which_connection);
}
- 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
public function num_rows($result_object,$which_connection='')
{
return $this->numRows($result_object, $which_connection);
}
- 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
public function fetch_row($result_object,$which_connection='')
{
return $this->fetchArray($result_object,$which_connection);
}
- 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 table_exists is not named in camelCase. Open
public function table_exists($table_name,$which_connection='')
{
return $this->tableExists($table_name, $which_connection);
}
- 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() {
}
}