← Back to branch summary

~desarrollokumbia/kumbia/ActiveRecord

« back to all changes in this revision

Viewing changes to db_pool/adapters/db_adapter.php

  • Committer: Emilio Silveira
  • Date: 2010-07-30 03:22:48 UTC
  • Revision ID: emilio.rst@gmail.com-20100730032248-9n4vnvcist5rjze1
Cambios multiples.

Implementado en ActiveRecord create y update con validaciones y 
disparadores before y after

Show diffs side-by-side

added added

removed removed

Lines of Context:
db_pool/adapters/db_adapter.php
22
22
 
23
23
/**
24
24
 * @see TableMetadata
25
 
 **/
 
25
 */
26
26
//require CORE_PATH . 'libs/ActiveRecord/db_pool/table_meta_data.php';
27
27
 
28
28
abstract class DbAdapter
29
29
{
 
30
        /**
 
31
         * Instancias de adaptadores por conexion
 
32
         * 
 
33
         * @var array
 
34
         */
 
35
        private static $_adapters = array();
 
36
        
30
37
    /**
31
38
     * Nombre de conexion
32
39
     *
33
40
     * @var string
34
 
     **/
 
41
     */
35
42
    protected $_connection;
36
43
    
37
44
    /**
40
47
     * @param string $table tabla
41
48
     * @param string $schema schema
42
49
     * @return array
43
 
     **/
 
50
     */
44
51
    abstract public function describe($table, $schema=NULL);
45
52
 
46
53
    /**
47
54
     * Constructor
48
55
     *
49
56
     * @param string $connection nombre de conexion en databases.ini
50
 
     **/
 
57
     */
51
58
    public function __construct($connection)
52
59
    {
53
60
        $this->_connection = $connection;
54
61
    }
55
62
 
56
63
    /**
57
 
     * Obtiene instancia de query en funcion de la conexion
 
64
     * Obtiene instancia de adaptador en funcion de la conexion (utiliza Singleton)
58
65
     *
59
66
     * @param string $connection conexion a base de datos en databases.ini
60
67
     * @return DbAdapter
61
68
     * @throw KumbiaException
62
 
     **/
63
 
    public static function factory($connection=NULL)
 
69
     */
 
70
    public static function factory($connection = NULL)
64
71
    {
65
 
        // carga la conexion por defecto
 
72
        // Carga la conexion por defecto
66
73
        if (!$connection) {
67
74
            $connection = Config::get('config.application.database');
68
75
        }
69
76
    
70
 
        // lee la configuracion de base de datos
71
 
        $databases = Config::read('databases');
72
 
        
73
 
        if(!isset($databases[$connection])) {
74
 
            throw new KumbiaException("No existe la conexion $connection en databases.ini");
75
 
        }
76
 
    
77
 
        $database = $databases[$connection];
78
 
    
79
 
        // genera el nombre de clase
80
 
        $Class = ucfirst($database['type']) . 'Db';
81
 
    
82
 
        // si no existe la clase la carga
83
 
        if(!class_exists($Class, FALSE)) {
84
 
            // carga la clase
85
 
            require CORE_PATH . "libs/ActiveRecord/db_pool/adapters/{$database['type']}_db.php";
86
 
        }
87
 
        
88
 
        return new $Class($connection);
89
 
    }
90
 
    
91
 
    /**
92
 
     * Genera el objeto pdo para la conexion
93
 
     *
94
 
     * @return PDO
95
 
     **/
96
 
    public function pdo()
97
 
    {
98
 
        return DbPool::factory($this->_connection);
99
 
    }
100
 
    
 
77
                // Si no existe el Singleton
 
78
                if(!isset(self::$_adapters[$connection])) {
 
79
                        // Lee la configuracion de base de datos
 
80
                        $databases = Config::read('databases');
 
81
                        
 
82
                        if(!isset($databases[$connection])) {
 
83
                                throw new KumbiaException("No existe la conexion $connection en databases.ini");
 
84
                        }
 
85
                
 
86
                        $database = $databases[$connection];
 
87
                
 
88
                        // Genera el nombre de clase
 
89
                        $Class = ucfirst($database['type']) . 'Db';
 
90
                
 
91
                        // Si no existe la clase la carga
 
92
                        if(!class_exists($Class, FALSE)) {
 
93
                                // Carga la clase
 
94
                                require CORE_PATH . "libs/ActiveRecord/db_pool/adapters/{$database['type']}_db.php";
 
95
                        }
 
96
                        
 
97
                        // Instancia el adaptador
 
98
                        self::$_adapters[$connection] = new $Class($connection);
 
99
                }
 
100
                
 
101
                // Retorna el adaptador
 
102
        return self::$_adapters[$connection];
 
103
    }
 
104
       
101
105
    /**
102
106
     * Genera la consulta sql concreta
103
107
     *
104
108
     * @param DbQuery $dbQuery
105
109
     * @return string
106
 
     **/
 
110
         * @throw KumbiaException
 
111
     */
107
112
    public function query($dbQuery)
108
113
    {
109
114
        $sqlArray = $dbQuery->getSqlArray();
110
115
        
111
 
        // verifica si se indico una table
 
116
        // Verifica si se indico una table
112
117
        if(!isset($sqlArray['table'])) {
113
118
            throw new KumbiaException("Debe indicar una tabla para efectuar la consulta");
114
119
        }
115
 
        
116
 
        if(isset($sqlArray['select'])) {
117
 
            return $this->_select($sqlArray);
118
 
            
119
 
        } elseif(isset($sqlArray['insert'])) {
120
 
            return $this->_insert($sqlArray);
121
 
            
122
 
        } elseif(isset($sqlArray['update'])) {
123
 
            return $this->_update($sqlArray);
124
 
            
125
 
        } elseif(isset($sqlArray['delete'])) {
126
 
            return $this->_delete($sqlArray);
 
120
                
 
121
        if(isset($sqlArray['command'])) {
 
122
            return $this->{"_{$sqlArray['command']}"}($sqlArray);            
127
123
        }
128
124
        
129
 
        return NULL;
 
125
        throw new KumbiaException("Debe indicar un comando de consulta SQL");
130
126
    }
131
127
    
132
128
    /**
134
130
     *
135
131
     * @param array $sqlArray
136
132
     * @return string
137
 
     **/
 
133
     */
138
134
    protected function _select($sqlArray)
139
135
    {
140
 
        // verifica si esta definido el eschema
 
136
        // Verifica si esta definido el esquema
141
137
        if(isset($sqlArray['schema'])) {
142
138
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
143
139
        } else {
149
145
            $select .= ' DISTINCT';
150
146
        }
151
147
        
152
 
        return $this->_joinClausules($sqlArray, "$select {$sqlArray['select']} FROM $source");
 
148
                // Columnas en consulta
 
149
                $columns = isset($sqlArray['columns']) ? $sqlArray['columns']: '*';
 
150
                
 
151
        return $this->_joinClausules($sqlArray, "$select $columns FROM $source");
153
152
    }
154
153
    
155
154
    /**
157
156
     *
158
157
     * @param array $sqlArray
159
158
     * @return string
160
 
     **/
 
159
     */
161
160
    protected function _insert($sqlArray)
162
161
    {
163
 
        // alias para manejar mas facil
164
 
        $insert = $sqlArray['insert'];
165
 
        
166
 
        // si se paso array
167
 
        if(is_array($insert['columns'])) {
168
 
            // obtiene la conexion pdo
169
 
            $pdo = $this->pdo();
170
 
        
171
 
            $columns = array();
172
 
            $values = array();
173
 
            
174
 
            foreach($insert['columns'] as $k => $v) {
175
 
                $columns[] = $k;
176
 
                //$values[] = $pdo->quote($v);
177
 
                $values[] = ":$k";
178
 
            }
179
 
            
180
 
            $columns = implode(', ', $columns);
181
 
            $values = implode(', ', $values);
182
 
        } else {
183
 
            $columns = $insert['columns'];
184
 
            $values = $insert['values'];
185
 
        }
186
 
        
187
 
        // verifica si esta definido el eschema
 
162
        // Obtiene las columns
 
163
        $columns = implode(', ', array_keys($sqlArray['data']));
 
164
        // Parámetros enlazados para SQL PS
 
165
        $values = implode(', ', array_keys($sqlArray['bind']));
 
166
        
 
167
        // Verifica si esta definido el eschema
188
168
        if(isset($sqlArray['schema'])) {
189
169
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
190
170
        } else {
191
171
            $source = $sqlArray['table'];
192
172
        }
193
 
        
194
173
        return "INSERT INTO $source ($columns) VALUES ($values)";
195
174
    }
196
175
    
199
178
     *
200
179
     * @param array $sqlArray
201
180
     * @return string
202
 
     **/
 
181
     */
203
182
    protected function _update($sqlArray)
204
183
    {
205
 
        // si se paso array
206
 
        if(is_array($sqlArray['update'])) {
207
 
            // obtiene la conexion pdo
208
 
            $pdo = $this->pdo();
209
 
            
210
 
            $values = array();
211
 
            
212
 
            foreach($sqlArray['update'] as $k => $v) {
213
 
                $values[] = "$k=" . $pdo->quote($v);
214
 
            }
215
 
            
216
 
            $values = implode(', ', $values);
217
 
        } else {
218
 
            $values = $sqlArray['update'];
 
184
                // Construye la pareja clave, valor para SQL PS
 
185
        $values = array();
 
186
        foreach(array_keys($sqlArray['data']) as $k) {
 
187
            $values[] = "$k = :$k";
219
188
        }
 
189
        $values = implode(', ', $values);
220
190
        
221
 
        // verifica si esta definido el eschema
 
191
        // Verifica si esta definido el eschema
222
192
        if(isset($sqlArray['schema'])) {
223
193
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
224
194
        } else {
233
203
     *
234
204
     * @param array $sqlArray
235
205
     * @return string
236
 
     **/
 
206
     */
237
207
    protected function _delete($sqlArray)
238
208
    {
239
209
        // verifica si esta definido el eschema
252
222
     * @param array $sqlArray array de condiciones
253
223
     * @param string $sql consulta sql donde se unira las clausulas
254
224
     * @return string
255
 
     **/
 
225
     */
256
226
    protected function _joinClausules($sqlArray, $sql)
257
227
    {
258
 
        // para inner join
 
228
        // Para inner join
259
229
        if(isset($sqlArray['join'])) {
260
230
            foreach($sqlArray['join'] as $join) {
261
231
                $sql .= " INNER JOIN {$join['table']} ON ({$join['conditions']})";
262
232
            }
263
233
        }
264
234
 
265
 
        // para left outer join
 
235
        // Para left outer join
266
236
        if(isset($sqlArray['leftJoin'])) {
267
237
            foreach($sqlArray['leftJoin'] as $join) {
268
238
                $sql .= " LEFT OUTER JOIN {$join['table']} ON ({$join['conditions']})";
269
239
            }
270
240
        }
271
241
 
272
 
        // para right outer join
 
242
        // Para right outer join
273
243
        if(isset($sqlArray['rightJoin'])) {
274
244
            foreach($sqlArray['rightJoin'] as $join) {
275
245
                $sql .= " RIGHT OUTER JOIN {$join['table']} ON ({$join['conditions']})";
276
246
            }
277
247
        }
278
248
 
279
 
        // para full join
 
249
        // Para full join
280
250
        if(isset($sqlArray['fullJoin'])) {
281
251
            foreach($sqlArray['fullJoin'] as $join) {
282
252
                $sql .= " FULL JOIN {$join['table']} ON ({$join['conditions']})";
315
285
        
316
286
        return $sql;
317
287
    }
 
288
        
 
289
        /**
 
290
     * Genera el objeto PDO para la conexion
 
291
     *
 
292
     * @return PDO
 
293
     */
 
294
    public function pdo()
 
295
    {
 
296
        return DbPool::factory($this->_connection);
 
297
    }
 
298
        
 
299
        /**
 
300
         * Prepara la consulta SQL
 
301
         * 
 
302
         * @param string $sql
 
303
         * @return PDOStatement
 
304
         */
 
305
        public function prepare($sql)
 
306
        {
 
307
                // PDOStatement
 
308
                return $this->pdo()->prepare($sql);
 
309
        }
 
310
        
 
311
        /**
 
312
         * Prepara la consulta SQL asociada al objeto dbQuery
 
313
         * 
 
314
         * @param DbQuery objeto de consulta
 
315
         * @return PDOStatement
 
316
         */
 
317
        public function prepareDbQuery($dbQuery)
 
318
        {
 
319
                // Prepara el dbQuery
 
320
                return $this->pdo()->prepare($this->query($dbQuery));
 
321
        }
318
322
}