AbsractAdapter::getAllTables() - Code Metrics - Inspection of "fix style code" - pedro151/orm-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (0fd339)

by Pedro

created 2016-04-25 21:46 UTC

AbsractAdapter::getAllTables() A

↳ Parent: AbsractAdapter

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

namespace Classes\AdaptersDriver;

use Classes\AdapterConfig\AbstractAdapter;
use Classes\Db\Constrant;
use Classes\Db\DbTable;

/**
 * Adapter com funcoes de analise das consultas
 *
 * @author Pedro Alarcao <[email protected]>
 * @link   https://github.com/pedro151/ORM-Generator
 */
abstract class AbsractAdapter
{

    /**
     * @var void variavel com tipo de dados para serem convertida
     */
    protected $dataTypes;

    /**
     * @type \PDO
     */
    protected $_pdo;

    /**
     * @var int
     */
    protected $port;

    /**
     * @var string
     */
    protected $host;

    /**
     * @type string
     */
    protected $username;

    /**
     * @type string
     */
    protected $password;

    /**
     * @var string
     */
    protected $database;

    /**
     * @type string
     */
    protected $socket;

    /**
     * @type \Classes\Db\DbTable[][]
     */
    private $objDbTables = array ();

    /**
     * @var AbstractAdapter
     */
    protected $config;

    /**
     * @type int
     */
    protected $totalTables;

    /**
     * analisa e popula as Foreing keys, Primary keys e dependencias do banco nos objetos
     */
    protected function parseConstrants ()
    {
        foreach ( $this->getListConstrant () as $constrant )
        {

            $schema = $constrant[ 'table_schema' ];
            $table_name = $constrant [ 'table_name' ];
            $this->populateForeignAndPrimaryKeys ( $constrant , $table_name , $schema );
            unset( $table_name , $schema );

            if ( $constrant[ 'constraint_type' ] == "FOREIGN KEY" )
            {
                $schema = $constrant[ 'foreign_schema' ];
                $table_name = $constrant [ 'foreign_table' ];
                $this->populateDependece ( $constrant , $table_name , $schema );
                unset( $table_name , $schema );
            }
        }
    }

    /**
     * @param array  $constrant
     * @param string $table_name
     * @param int    $schema
     */
    private function populateForeignAndPrimaryKeys ( $constrant , $table_name , $schema = 0 )
    {
        if ( $this->hasTable ( $table_name , $schema ) )
        {
            $table = $this->getTable ( $table_name , $schema );
            if ( $table->hasColumn ( $constrant[ "column_name" ] ) )
            {
                $objConstrant = Constrant::getInstance ()
                                         ->populate (
                                             array (
                                                 'constrant' => $constrant[ 'constraint_name' ] ,
                                                 'schema'    => $constrant[ 'foreign_schema' ] ,
                                                 'table'     => $constrant[ 'foreign_table' ] ,
                                                 'column'    => $constrant[ 'foreign_column' ]
                                             )
                                         );

                switch ( $constrant[ 'constraint_type' ] )
                {
                    case "FOREIGN KEY":
                        $table->getColumn ( $constrant[ "column_name" ] )
                              ->addRefFk ( $objConstrant );
                        break;
                    case"PRIMARY KEY":
switch (true) {
    case!isset($a):  //wrong
        doSomething();
        break;
    case !isset($b):  //right
        doSomething();
        break;
}
                        $table->getColumn ( $constrant[ "column_name" ] )
                              ->setPrimaryKey ( $objConstrant )
                              ->setSequence (
                                  $this->getSequence (
                                      $schema . '.' . $table_name ,
                                      $constrant[ "column_name" ]
                                  )
                              );
                        break;
                }
            }
        }
    }

    /**
     * @param array  $constrant
     * @param string $table_name
     * @param int    $schema
     */
    private function populateDependece ( $constrant , $table_name , $schema = 0 )
    {
        if ( $this->hasTable ( $table_name , $schema ) )
        {
            $table = $this->getTable ( $table_name , $schema );
            if ( $table->hasColumn ( $constrant[ "foreign_column" ] ) )
            {
                $table->getColumn ( $constrant[ "foreign_column" ] )
                      ->createDependece (
                          $constrant[ 'constraint_name' ] ,
                          $constrant[ 'table_name' ] ,
                          $constrant[ 'column_name' ] ,
                          $constrant[ 'table_schema' ]
                      );
            }
        }
    }

    /**
     * cria um Array com nome das tabelas
     */
    protected abstract function parseTables ();


    /**
     * retorna o numero total de tabelas
     *
     * @return int
     */
    public abstract function getTotalTables ();


    /**
     * Retorna o Nome da Sequence da tabela
     *
     * @param $table
     * @param $column
     *
     * @return string
     */
    public abstract function getSequence ( $table , $column );


    /**
     * @return array
     */
    public abstract function getListConstrant ();


    /**
     * @param string $str
     *
     * @return string
     */
    protected function convertTypeToPhp ( $str )
    {
        if ( isset( $this->dataTypes[ $str ] ) )
        {
            return $this->dataTypes[ $str ];
        }

        return 'string';
    }

    /**
     * @return string
     */
    public abstract function getPDOString ();


    /**
     * @return string
     */
    public abstract function getPDOSocketString ();


    /**
     * @param     $nameTable
     * @param int $schema
     *
     * @return \Classes\Db\DbTable
     */
    public function createTable ( $nameTable , $schema = 0 )
    {
        $this->objDbTables[ $schema ][ trim ( $nameTable ) ] = DbTable::getInstance ()
                                                                      ->populate (
                                                                          array (
                                                                              'table'    => $nameTable ,
                                                                              'schema'   => $schema ,
                                                                              'database' => $this->database
                                                                          )
                                                                      );

        return $this;
    }

    /**
     * Retorna um Array Assoc com a chave com nome da tabela e o valor com objeto tables
     *
     * @return \Classes\Db\DbTable[]
     */
    public function getTables ( $schema = 0 )
    {
        if ( ! isset( $this->objDbTables[ $schema ] ) )
        {
            return array ();
        }

        return $this->objDbTables[ $schema ];
    }

    public function getAllTables ()
    {
        return $this->objDbTables;
    }

    public function hasTables ()
    {
        return ! empty( $this->objDbTables );
    }

    /**
     * retorna a tabela especifica
     *
     * @param $nameTable Nome da tabela
     *
     * @return \Classes\Db\DbTable
     */
    public function getTable ( $nameTable , $schema = 0 )
    {
        return $this->objDbTables[ $schema ][ trim ( $nameTable ) ];
    }

    /**
     * @param string     $nameTable
     * @param int|string $schema
     *
     * @return bool
     */
    public function hasTable ( $nameTable , $schema = 0 )
    {
        return isset( $this->objDbTables[ $schema ][ trim ( $nameTable ) ] );
    }

    /**
     * retorna multiplos arrays com dados da column em array
     *
     * @return array[]
     */
    public abstract function getListColumns ();


    /**
     * Retorna um Array com nome das tabelas
     *
     * @return string[]
     */
    public abstract function getListNameTable ();


    /**
     * @param \Classes\AdapterConfig\AbstractAdapter $adapterConfig
     */
    public function __construct ( AbstractAdapter $adapterConfig )
    {
        $this->config = $adapterConfig;
        $this->host = $adapterConfig->getHost ();
        $this->database = $adapterConfig->getDatabase ();
        $this->port = $adapterConfig->hasPort () ? $adapterConfig->getPort ()
            : $this->port;
        $this->username = $adapterConfig->getUser ();
        $this->password = $adapterConfig->getPassword ();
        $this->socket = $adapterConfig->getSocket ();

    }

    /**
     * Executa as consultas do banco de dados
     */
    public function runDatabase ()
    {
        $this->parseTables ();
        $this->parseConstrants ();
    }

    /**
     *
     * @return \PDO
     */
    public function getPDO ()
    {
        if ( is_null ( $this->_pdo ) )
        {
            if ( ! empty( $this->socket ) )
            {
                $pdoString = $this->getPDOSocketString ();
            } else
            {
                $pdoString = $this->getPDOString ();
            }

            try
            {
                $this->_pdo = new \PDO (
                    $pdoString , $this->username , $this->password
                );
            } catch ( \Exception $e )
            {
                die ( "pdo error: " . $e->getMessage () . "\n" );

            }
        }

        return $this->_pdo;
    }
}


1			<?php
2
3			namespace Classes\AdaptersDriver;
4
5			use Classes\AdapterConfig\AbstractAdapter;
6			use Classes\Db\Constrant;
7			use Classes\Db\DbTable;
8
9			/**
10			* Adapter com funcoes de analise das consultas
11			*
12			* @author Pedro Alarcao <[email protected]>
13			* @link https://github.com/pedro151/ORM-Generator
14			*/
15			abstract class AbsractAdapter
16			{
17
18			/**
19			* @var void variavel com tipo de dados para serem convertida
20			*/
21			protected $dataTypes;
22
23			/**
24			* @type \PDO
25			*/
26			protected $_pdo;
27
28			/**
29			* @var int
30			*/
31			protected $port;
32
33			/**
34			* @var string
35			*/
36			protected $host;
37
38			/**
39			* @type string
40			*/
41			protected $username;
42
43			/**
44			* @type string
45			*/
46			protected $password;
47
48			/**
49			* @var string
50			*/
51			protected $database;
52
53			/**
54			* @type string
55			*/
56			protected $socket;
57
58			/**
59			* @type \Classes\Db\DbTable[][]
60			*/
61			private $objDbTables = array ();
62
63			/**
64			* @var AbstractAdapter
65			*/
66			protected $config;
67
68			/**
69			* @type int
70			*/
71			protected $totalTables;
72
73			/**
74			* analisa e popula as Foreing keys, Primary keys e dependencias do banco nos objetos
75			*/
76			protected function parseConstrants ()
77			{
78			foreach ( $this->getListConstrant () as $constrant )
79			{
80
81			$schema = $constrant[ 'table_schema' ];
82			$table_name = $constrant [ 'table_name' ];
83			$this->populateForeignAndPrimaryKeys ( $constrant , $table_name , $schema );
84			unset( $table_name , $schema );
85
86			if ( $constrant[ 'constraint_type' ] == "FOREIGN KEY" )
87			{
88			$schema = $constrant[ 'foreign_schema' ];
89			$table_name = $constrant [ 'foreign_table' ];
90			$this->populateDependece ( $constrant , $table_name , $schema );
91			unset( $table_name , $schema );
92			}
93			}
94			}
95
96			/**
97			* @param array $constrant
98			* @param string $table_name
99			* @param int $schema
100			*/
101			private function populateForeignAndPrimaryKeys ( $constrant , $table_name , $schema = 0 )
102			{
103			if ( $this->hasTable ( $table_name , $schema ) )
104			{
105			$table = $this->getTable ( $table_name , $schema );
106			if ( $table->hasColumn ( $constrant[ "column_name" ] ) )
107			{
108			$objConstrant = Constrant::getInstance ()
109			->populate (
110			array (
111			'constrant' => $constrant[ 'constraint_name' ] ,
112			'schema' => $constrant[ 'foreign_schema' ] ,
113			'table' => $constrant[ 'foreign_table' ] ,
114			'column' => $constrant[ 'foreign_column' ]
115			)
116			);
117
118			switch ( $constrant[ 'constraint_type' ] )
119			{
120			case "FOREIGN KEY":
121			$table->getColumn ( $constrant[ "column_name" ] )
122			->addRefFk ( $objConstrant );
123			break;
124			case"PRIMARY KEY":
			0 ignored issues – show Coding Style introduced 2016-04-25 21:47 UTC by Report Bug Copy Issue Report As per coding-style, `case` should be followed by a single space. As per the PSR-2 coding standard, there must be a space after the `case` keyword, instead of the test immediately following it. switch (true) { case!isset($a): //wrong doSomething(); break; case !isset($b): //right doSomething(); break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
125			$table->getColumn ( $constrant[ "column_name" ] )
126			->setPrimaryKey ( $objConstrant )
127			->setSequence (
128			$this->getSequence (
129			$schema . '.' . $table_name ,
130			$constrant[ "column_name" ]
131			)
132			);
133			break;
134			}
135			}
136			}
137			}
138
139			/**
140			* @param array $constrant
141			* @param string $table_name
142			* @param int $schema
143			*/
144			private function populateDependece ( $constrant , $table_name , $schema = 0 )
145			{
146			if ( $this->hasTable ( $table_name , $schema ) )
147			{
148			$table = $this->getTable ( $table_name , $schema );
149			if ( $table->hasColumn ( $constrant[ "foreign_column" ] ) )
150			{
151			$table->getColumn ( $constrant[ "foreign_column" ] )
152			->createDependece (
153			$constrant[ 'constraint_name' ] ,
154			$constrant[ 'table_name' ] ,
155			$constrant[ 'column_name' ] ,
156			$constrant[ 'table_schema' ]
157			);
158			}
159			}
160			}
161
162			/**
163			* cria um Array com nome das tabelas
164			*/
165			protected abstract function parseTables ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
166
167			/**
168			* retorna o numero total de tabelas
169			*
170			* @return int
171			*/
172			public abstract function getTotalTables ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
173
174			/**
175			* Retorna o Nome da Sequence da tabela
176			*
177			* @param $table
178			* @param $column
179			*
180			* @return string
181			*/
182			public abstract function getSequence ( $table , $column );
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
183
184			/**
185			* @return array
186			*/
187			public abstract function getListConstrant ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
188
189			/**
190			* @param string $str
191			*
192			* @return string
193			*/
194			protected function convertTypeToPhp ( $str )
195			{
196			if ( isset( $this->dataTypes[ $str ] ) )
197			{
198			return $this->dataTypes[ $str ];
199			}
200
201			return 'string';
202			}
203
204			/**
205			* @return string
206			*/
207			public abstract function getPDOString ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
208
209			/**
210			* @return string
211			*/
212			public abstract function getPDOSocketString ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
213
214			/**
215			* @param $nameTable
216			* @param int $schema
217			*
218			* @return \Classes\Db\DbTable
219			*/
220			public function createTable ( $nameTable , $schema = 0 )
221			{
222			$this->objDbTables[ $schema ][ trim ( $nameTable ) ] = DbTable::getInstance ()
223			->populate (
224			array (
225			'table' => $nameTable ,
226			'schema' => $schema ,
227			'database' => $this->database
228			)
229			);
230
231			return $this;
232			}
233
234			/**
235			* Retorna um Array Assoc com a chave com nome da tabela e o valor com objeto tables
236			*
237			* @return \Classes\Db\DbTable[]
238			*/
239			public function getTables ( $schema = 0 )
240			{
241			if ( ! isset( $this->objDbTables[ $schema ] ) )
242			{
243			return array ();
244			}
245
246			return $this->objDbTables[ $schema ];
247			}
248
249			public function getAllTables ()
250			{
251			return $this->objDbTables;
252			}
253
254			public function hasTables ()
255			{
256			return ! empty( $this->objDbTables );
257			}
258
259			/**
260			* retorna a tabela especifica
261			*
262			* @param $nameTable Nome da tabela
263			*
264			* @return \Classes\Db\DbTable
265			*/
266			public function getTable ( $nameTable , $schema = 0 )
267			{
268			return $this->objDbTables[ $schema ][ trim ( $nameTable ) ];
269			}
270
271			/**
272			* @param string $nameTable
273			* @param int\|string $schema
274			*
275			* @return bool
276			*/
277			public function hasTable ( $nameTable , $schema = 0 )
278			{
279			return isset( $this->objDbTables[ $schema ][ trim ( $nameTable ) ] );
280			}
281
282			/**
283			* retorna multiplos arrays com dados da column em array
284			*
285			* @return array[]
286			*/
287			public abstract function getListColumns ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
288
289			/**
290			* Retorna um Array com nome das tabelas
291			*
292			* @return string[]
293			*/
294			public abstract function getListNameTable ();
			0 ignored issues – show Coding Style introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The abstract declaration must precede the visibility declaration Loading history...
295
296			/**
297			* @param \Classes\AdapterConfig\AbstractAdapter $adapterConfig
298			*/
299			public function __construct ( AbstractAdapter $adapterConfig )
300			{
301			$this->config = $adapterConfig;
302			$this->host = $adapterConfig->getHost ();
303			$this->database = $adapterConfig->getDatabase ();
304			$this->port = $adapterConfig->hasPort () ? $adapterConfig->getPort ()
305			: $this->port;
306			$this->username = $adapterConfig->getUser ();
307			$this->password = $adapterConfig->getPassword ();
308			$this->socket = $adapterConfig->getSocket ();
309
310			}
311
312			/**
313			* Executa as consultas do banco de dados
314			*/
315			public function runDatabase ()
316			{
317			$this->parseTables ();
318			$this->parseConstrants ();
319			}
320
321			/**
322			*
323			* @return \PDO
324			*/
325			public function getPDO ()
326			{
327			if ( is_null ( $this->_pdo ) )
328			{
329			if ( ! empty( $this->socket ) )
330			{
331			$pdoString = $this->getPDOSocketString ();
332			} else
333			{
334			$pdoString = $this->getPDOString ();
335			}
336
337			try
338			{
339			$this->_pdo = new \PDO (
340			$pdoString , $this->username , $this->password
341			);
342			} catch ( \Exception $e )
343			{
344			die ( "pdo error: " . $e->getMessage () . "\n" );
			0 ignored issues – show Coding Style Compatibility introduced 2016-04-25 13:41 UTC by Report Bug Copy Issue Report The method `getPDO()` contains an exit expression. An exit expression should only be used in rare cases. For example, if you write a short command line script. In most cases however, using an `exit` expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage. Loading history...
345			}
346			}
347
348			return $this->_pdo;
349			}
350			}
351

pedro151 / orm-generator

GitHub Access Token became invalid

Branch — master (0fd339)

AbsractAdapter::getAllTables() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like