~desarrollokumbia/kumbia/ActiveRecord

« back to all changes in this revision

Viewing changes to db_pool/adapters/db_adapter.php

  • Committer: Deivinson Tejeda
  • Date: 2010-01-22 22:44:49 UTC
  • Revision ID: deivinsontejeda@gmail.com-20100122224449-8a03r26ppfuz3963
1->Arreglando el find() para que funcione con y sin chain
2->En el DbQuery 
        ->En el método where se recibe un array para realizar las consultas preparadas (Prepared Statement)
        ->se agrega método para obetener los params para enlazar al SQL
        ->Se agrega método column para indicar las columnas que se quiere en la consulta

3->En el DbAdapter en la construcción del Query en el where se hace un implode directo ya que la consulta es preparada

Ejemplo
//Modelo
    public function buscar()
    {
        $this->get()->columns('nombre, id')
                    ->where(array('id > ?'=>2, 'id<?'=>5))
                    ->limit(2);

        //ejecuta un find() personalizado via chain
        return $this->find();
                         
    }

//Otra forma
    public function buscar()
    {
        //ejecuta un find() por defecto
        return $this->find();
    }

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
        
37
30
    /**
38
31
     * Nombre de conexion
39
32
     *
40
33
     * @var string
41
 
     */
 
34
     **/
42
35
    protected $_connection;
43
36
    
44
37
    /**
47
40
     * @param string $table tabla
48
41
     * @param string $schema schema
49
42
     * @return array
50
 
     */
 
43
     **/
51
44
    abstract public function describe($table, $schema=NULL);
52
45
 
53
46
    /**
54
47
     * Constructor
55
48
     *
56
49
     * @param string $connection nombre de conexion en databases.ini
57
 
     */
 
50
     **/
58
51
    public function __construct($connection)
59
52
    {
60
53
        $this->_connection = $connection;
61
54
    }
62
55
 
63
56
    /**
64
 
     * Obtiene instancia de adaptador en funcion de la conexion (utiliza Singleton)
 
57
     * Obtiene instancia de query en funcion de la conexion
65
58
     *
66
59
     * @param string $connection conexion a base de datos en databases.ini
67
60
     * @return DbAdapter
68
61
     * @throw KumbiaException
69
 
     */
70
 
    public static function factory($connection = NULL)
 
62
     **/
 
63
    public static function factory($connection=NULL)
71
64
    {
72
 
        // Carga la conexion por defecto
 
65
        // carga la conexion por defecto
73
66
        if (!$connection) {
74
67
            $connection = Config::get('config.application.database');
75
68
        }
76
69
    
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
 
       
 
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
    
105
101
    /**
106
102
     * Genera la consulta sql concreta
107
103
     *
108
104
     * @param DbQuery $dbQuery
109
105
     * @return string
110
 
         * @throw KumbiaException
111
 
     */
 
106
     **/
112
107
    public function query($dbQuery)
113
108
    {
114
109
        $sqlArray = $dbQuery->getSqlArray();
115
110
        
116
 
        // Verifica si se indico una table
 
111
        // verifica si se indico una table
117
112
        if(!isset($sqlArray['table'])) {
118
113
            throw new KumbiaException("Debe indicar una tabla para efectuar la consulta");
119
114
        }
120
 
                
121
 
        if(isset($sqlArray['command'])) {
122
 
            return $this->{"_{$sqlArray['command']}"}($sqlArray);            
 
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);
123
127
        }
124
128
        
125
 
        throw new KumbiaException("Debe indicar un comando de consulta SQL");
 
129
        return NULL;
126
130
    }
127
131
    
128
132
    /**
130
134
     *
131
135
     * @param array $sqlArray
132
136
     * @return string
133
 
     */
 
137
     **/
134
138
    protected function _select($sqlArray)
135
139
    {
136
 
        // Verifica si esta definido el esquema
 
140
        // verifica si esta definido el eschema
137
141
        if(isset($sqlArray['schema'])) {
138
142
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
139
143
        } else {
145
149
            $select .= ' DISTINCT';
146
150
        }
147
151
        
148
 
                // Columnas en consulta
149
 
                $columns = isset($sqlArray['columns']) ? $sqlArray['columns']: '*';
150
 
                
151
 
        return $this->_joinClausules($sqlArray, "$select $columns FROM $source");
 
152
        return $this->_joinClausules($sqlArray, "$select {$sqlArray['select']} FROM $source");
152
153
    }
153
154
    
154
155
    /**
156
157
     *
157
158
     * @param array $sqlArray
158
159
     * @return string
159
 
     */
 
160
     **/
160
161
    protected function _insert($sqlArray)
161
162
    {
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
 
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
168
188
        if(isset($sqlArray['schema'])) {
169
189
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
170
190
        } else {
171
191
            $source = $sqlArray['table'];
172
192
        }
 
193
        
173
194
        return "INSERT INTO $source ($columns) VALUES ($values)";
174
195
    }
175
196
    
178
199
     *
179
200
     * @param array $sqlArray
180
201
     * @return string
181
 
     */
 
202
     **/
182
203
    protected function _update($sqlArray)
183
204
    {
184
 
                // Construye la pareja clave, valor para SQL PS
185
 
        $values = array();
186
 
        foreach(array_keys($sqlArray['data']) as $k) {
187
 
            $values[] = "$k = :$k";
 
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'];
188
219
        }
189
 
        $values = implode(', ', $values);
190
220
        
191
 
        // Verifica si esta definido el eschema
 
221
        // verifica si esta definido el eschema
192
222
        if(isset($sqlArray['schema'])) {
193
223
            $source = "{$sqlArray['schema']}.{$sqlArray['table']}";
194
224
        } else {
203
233
     *
204
234
     * @param array $sqlArray
205
235
     * @return string
206
 
     */
 
236
     **/
207
237
    protected function _delete($sqlArray)
208
238
    {
209
239
        // verifica si esta definido el eschema
222
252
     * @param array $sqlArray array de condiciones
223
253
     * @param string $sql consulta sql donde se unira las clausulas
224
254
     * @return string
225
 
     */
 
255
     **/
226
256
    protected function _joinClausules($sqlArray, $sql)
227
257
    {
228
 
        // Para inner join
 
258
        // para inner join
229
259
        if(isset($sqlArray['join'])) {
230
260
            foreach($sqlArray['join'] as $join) {
231
261
                $sql .= " INNER JOIN {$join['table']} ON ({$join['conditions']})";
232
262
            }
233
263
        }
234
264
 
235
 
        // Para left outer join
 
265
        // para left outer join
236
266
        if(isset($sqlArray['leftJoin'])) {
237
267
            foreach($sqlArray['leftJoin'] as $join) {
238
268
                $sql .= " LEFT OUTER JOIN {$join['table']} ON ({$join['conditions']})";
239
269
            }
240
270
        }
241
271
 
242
 
        // Para right outer join
 
272
        // para right outer join
243
273
        if(isset($sqlArray['rightJoin'])) {
244
274
            foreach($sqlArray['rightJoin'] as $join) {
245
275
                $sql .= " RIGHT OUTER JOIN {$join['table']} ON ({$join['conditions']})";
246
276
            }
247
277
        }
248
278
 
249
 
        // Para full join
 
279
        // para full join
250
280
        if(isset($sqlArray['fullJoin'])) {
251
281
            foreach($sqlArray['fullJoin'] as $join) {
252
282
                $sql .= " FULL JOIN {$join['table']} ON ({$join['conditions']})";
255
285
 
256
286
        if(isset($sqlArray['where'])) {
257
287
            if(is_array($sqlArray['where'])) {
258
 
                $where = NULL;
259
 
                $where = ' ' .  implode(' ', $sqlArray['where']);                
 
288
                // obtiene la conexion pdo
 
289
                $pdo = $this->pdo();
 
290
            
 
291
                // genera la condicion where partiendo de un array
 
292
                $where = array();
 
293
                /*foreach($sqlArray['where'] as $k) {
 
294
                    //$where[] = "$k=" . $pdo->quote($v);
 
295
                    $where[] = $k;
 
296
                }*/
 
297
                $where = implode(' AND ', $sqlArray['where']);
260
298
            } else {
261
299
                $where = $sqlArray['where'];
262
300
            }
285
323
        
286
324
        return $sql;
287
325
    }
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
 
        }
322
326
}