]> git.mxchange.org Git - core.git/blob - framework/main/middleware/database/class_DatabaseConnection.php
Some updates:
[core.git] / framework / main / middleware / database / class_DatabaseConnection.php
1 <?php
2 // Own namespace
3 namespace Org\Mxchange\CoreFramework\Connection\Database;
4
5 // Import framework stuff
6 use Org\Mxchange\CoreFramework\Connector\Database\DatabaseConnector;
7 use Org\Mxchange\CoreFramework\Criteria\Criteria;
8 use Org\Mxchange\CoreFramework\Criteria\Storing\StoreableCriteria;
9 use Org\Mxchange\CoreFramework\Database\Backend\DatabaseBackend;
10 use Org\Mxchange\CoreFramework\Registry\Registerable;
11 use Org\Mxchange\CoreFramework\Middleware\BaseMiddleware;
12 use Org\Mxchange\CoreFramework\Middleware\Debug\DebugMiddleware;
13
14 /**
15  * Database selector class
16  *
17  * @author              Roland Haeder <webmaster@shipsimu.org>
18  * @version             0.0.0
19 <<<<<<< HEAD:framework/main/middleware/database/class_DatabaseConnection.php
20  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Core Developer Team
21 =======
22  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2016 Core Developer Team
23 >>>>>>> Some updates::inc/main/middleware/database/class_DatabaseConnection.php
24  * @license             GNU GPL 3.0 or any newer version
25  * @link                http://www.shipsimu.org
26  *
27  * This program is free software: you can redistribute it and/or modify
28  * it under the terms of the GNU General Public License as published by
29  * the Free Software Foundation, either version 3 of the License, or
30  * (at your option) any later version.
31  *
32  * This program is distributed in the hope that it will be useful,
33  * but WITHOUT ANY WARRANTY; without even the implied warranty of
34  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
35  * GNU General Public License for more details.
36  *
37  * You should have received a copy of the GNU General Public License
38  * along with this program. If not, see <http://www.gnu.org/licenses/>.
39  */
40 class DatabaseConnection extends BaseMiddleware implements DatabaseConnector, Registerable {
41         /**
42          * Array for connection data
43          */
44         private $connectData = array(
45                 'login' => '',
46                 'pass'  => '',
47                 'dbase' => '',
48                 'host'  => ''
49         );
50
51         /**
52          * The real database layer
53          */
54         private $dbLayer = NULL;
55
56         /**
57          * An instance of this class
58          */
59         private static $selfInstance = NULL;
60
61         /**
62          * Protected constructor
63          */
64         protected function __construct () {
65                 // Call parent constructor
66                 parent::__construct(__CLASS__);
67         }
68
69         /**
70          * Creates a new database connection layer
71          *
72          * @param       $debugInstance  An instance of a DebugMiddleware class
73          * @param       $dbLayer                An instance of a DatabaseBackend class
74          * @todo        $debugInstance is currently not used
75          */
76         public static final function createDatabaseConnection (DebugMiddleware $debugInstance, DatabaseBackend $dbLayer) {
77                 // Get instance
78                 $databaseInstance = new DatabaseConnection();
79
80                 // Set database layer
81                 $databaseInstance->setDatabaseLayer($dbLayer);
82
83                 // Set db instance
84                 self::$selfInstance = $databaseInstance;
85
86                 // Return instance
87                 return $databaseInstance;
88         }
89
90         /**
91          * Getter for this class
92          *
93          * @return      $selfInstance   An instance of this class
94          */
95         public static final function getSelfInstance () {
96                 return self::$selfInstance;
97         }
98
99         /**
100          * Setter for all database connection data. All these parameters may be
101          * supported by the underlaying backend.
102          *
103          * @param       $login  Login name to database
104          * @param       $pass   Passwort for above login
105          * @param       $dbase  Name of used database
106          * @param       $host   Host to connect to (default: 127.0.0.1)
107          * @return      void
108          */
109         public final function setConnectionData ($login, $pass, $dbase, $host = '127.0.0.1') {
110                 // Transfer connection data
111                 $this->connectData['login'] = (string) $login;
112                 $this->connectData['pass']  = (string) $pass;
113                 $this->connectData['dbase'] = (string) $dbase;
114                 $this->connectData['host']  = (string) $host;
115         }
116
117         /**
118          * Getter for connection data
119          *
120          * @return      $connectData    Connection data stored with this clas
121          */
122         public final function getConnectionData () {
123                 return $this->connectData;
124         }
125
126         /**
127          * Setter for the real database layer
128          * @param       $dbLayer        An instance of the real database layer
129          * @return      void
130          */
131         public final function setDatabaseLayer (DatabaseBackend $dbLayer) {
132                 $this->dbLayer = $dbLayer;
133         }
134
135         /**
136          * Getter for index key
137          *
138          * @return      $indexKey       Index key
139          */
140         public final function getIndexKey () {
141                 return $this->dbLayer->getIndexKey();
142         }
143
144         /**
145          * Runs a 'select' statement on the database layer with given table name
146          * and criteria. If this doesn't fail the result will be returned
147          *
148          * @param       $tableName                      Name of the 'table' we shall query
149          * @param       $criteriaInstance       An instance of a Criteria class
150          * @return      $result                         The result as an array
151          */
152         public function doSelectByTableCriteria ($tableName, Criteria $criteriaInstance) {
153                 // Connect to the database
154                 $this->dbLayer->connectToDatabase();
155
156                 // Get result from query
157                 $result = $this->dbLayer->querySelect($tableName, $criteriaInstance);
158
159                 // Return the result
160                 return $result;
161         }
162
163         /**
164          * Getter for last exception
165          *
166          * @return      $exceptionInstance      Last thrown exception
167          */
168         public final function getLastException () {
169                 $exceptionInstance = $this->dbLayer->getLastException();
170                 return $exceptionInstance;
171         }
172
173         /**
174          * 'Inserts' a data set instance into a local file database folder
175          *
176          * @param       $dataSetInstance        A storeable data set
177          * @return      void
178          */
179         public function queryInsertDataSet (StoreableCriteria $dataSetInstance) {
180                 // Connect to the database
181                 $this->dbLayer->connectToDatabase();
182
183                 // Ask the database layer
184                 $this->dbLayer->queryInsertDataSet($dataSetInstance);
185         }
186
187         /**
188          * 'Updates' a data set instance with a database layer
189          *
190          * @param       $dataSetInstance        A storeable data set
191          * @return      void
192          */
193         public function queryUpdateDataSet (StoreableCriteria $dataSetInstance) {
194                 // Connect to the database
195                 $this->dbLayer->connectToDatabase();
196
197                 // Ask the database layer
198                 $this->dbLayer->queryUpdateDataSet($dataSetInstance);
199         }
200
201         /**
202          * Getter for primary key column of specified table name
203          *
204          * @param       $tableName              Name of table we need the primary key column from
205          * @return      $primaryKey             Primary key column of requested table
206          */
207         public function getPrimaryKeyOfTable ($tableName) {
208                 // Connect to the database
209                 $this->dbLayer->connectToDatabase();
210
211                 // Ask the database layer
212                 $primaryKey = $this->dbLayer->getPrimaryKeyOfTable($tableName);
213
214                 // Return the value
215                 return $primaryKey;
216         }
217
218         /**
219          * Removes non-public data from given array.
220          *
221          * @param       $data   An array with possible non-public data that needs to be removed.
222          * @return      $data   A cleaned up array with only public data.
223          */
224         public function removeNonPublicDataFromArray (array $data) {
225                 // Connect to the database
226                 $this->dbLayer->connectToDatabase();
227
228                 // Call database backend
229                 //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('DB-CONNECTION[' . $this->__toString() . ']: Calling this->dbLayer->removeNonPublicDataFromArray(data) ...');
230                 $data = $this->dbLayer->removeNonPublicDataFromArray($data);
231
232                 //* NOISY-DEBUG: */ self::createDebugInstance(__CLASS__, __LINE__)->debugOutput('DB-CONNECTION[' . $this->__toString() . ']: data[]=' . gettype($data));
233                 return $data;
234         }
235
236         /**
237          * Count total table rows
238          *
239          * @param       $tableName      Table name
240          * @return      $count          Total row count
241          */
242         public function countTotalRows ($tableName) {
243                 // Connect to the database
244                 $this->dbLayer->connectToDatabase();
245
246                 // Ask the database layer
247                 $count = $this->dbLayer->countTotalRows($tableName);
248
249                 // Return the value
250                 return $count;
251         }
252
253 }