~desarrollokumbia/kumbia/ActiveRecord

« back to all changes in this revision

Viewing changes to active_record2/active_record2.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:
19
19
 * @copyright  Copyright (c) 2005-2009 Kumbia Team (http://www.kumbiaphp.com)
20
20
 * @license    http://wiki.kumbiaphp.com/Licencia     New BSD License
21
21
 */
22
 
 
23
 
// @see KumbiaModel
 
22
/**
 
23
 * @see KumbiaModel
 
24
 */
24
25
require_once CORE_PATH . 'libs/ActiveRecord/active_record2/kumbia_model.php';
25
 
 
 
26
/**
 
27
 * @see ResultSet
 
28
 */
 
29
require_once CORE_PATH . 'libs/ActiveRecord/db_pool/result_set.php';
26
30
/**
27
31
 * ActiveRecord Clase para el Mapeo Objeto Relacional
28
32
 *
35
39
 * la tabla de la base de datos. Cuando se modifican los atributos del
36
40
 * objeto, se actualiza la fila de la base de datos.
37
41
 */
38
 
class ActiveRecord2 extends KumbiaModel implements Iterator
 
42
class ActiveRecord2 extends KumbiaModel
39
43
{
40
 
        /**
41
 
         * Obtener datos cargados en objeto del Modelo
42
 
         * 
43
 
         */
44
 
        const FETCH_MODEL = 'model';
45
 
        
46
 
        /**
47
 
         * Obtener datos cargados en objeto
48
 
         * 
49
 
         */
50
 
        const FETCH_OBJ = 'obj';
51
 
        
52
 
        /**
53
 
         * Obtener datos cargados en array
54
 
         * 
55
 
         */
56
 
        const FETCH_ARRAY = 'array';
57
 
                
58
44
    /**
59
45
     * Conexion a base datos que se utilizara
60
46
     *
61
47
     * @var strings
62
 
     */
63
 
    protected $_connection = NULL;
64
 
        
 
48
     **/
 
49
    protected $_connection = null;
65
50
    /**
66
51
     * Tabla origen de datos
67
52
     *
68
53
     * @var string
69
54
     */
70
 
    protected $_table = NULL;
71
 
        
 
55
    protected $_table = null;
72
56
    /**
73
57
     * Esquema de datos
74
58
     *
75
59
     * @var string
76
60
     */
77
 
    protected $_schema = NULL;
78
 
        
 
61
    protected $_schema = null;
79
62
    /**
80
63
     * Objeto DbQuery para implementar chain
81
64
     * 
82
65
     * @var Obj
83
66
     */
84
67
    protected $_dbQuery = NULL;
85
 
    
86
 
        /**
87
 
         * Posicion en el iterador
88
 
         *
89
 
         * @var int
90
 
         */
91
 
        private $_pointer = 0;
92
 
        
93
 
    /**
94
 
     * ResulSet PDOStatement
95
 
     * 
96
 
     * @var PDOStatement
97
 
     */
98
 
    protected $_resultSet = NULL;
99
 
        
100
 
        /**
101
 
         * Modo de obtener datos
102
 
         * 
103
 
         * @var integer
104
 
         */
105
 
        protected $_fetchMode = self::FETCH_MODEL;
106
 
        
107
68
    /**
108
69
     * Constructor de la class
109
 
         * 
110
70
     */
111
 
    public function __construct ($data = NULL)
 
71
    public function __constructor ($data = null)
112
72
    {
113
73
        if (is_array($data)) {
114
 
            $this->dump($data);
115
 
        }
116
 
    }
117
 
        
118
 
        /**
119
 
         * Carga el array como atributos del objeto
120
 
         * 
121
 
         * @param array $data
122
 
         */
123
 
        public function dump($data)
124
 
        {
125
 
                foreach ($data as $k => $v) {
126
 
                        $this->$k = $v;
127
 
                }
128
 
        }
129
 
        
130
 
        /**
131
 
         * Callback antes de crear
132
 
         * 
133
 
         * @return boolean
134
 
         */
135
 
        protected function _beforeCreate()
136
 
        {}
137
 
        
138
 
        /**
139
 
         * Callback despues de crear
140
 
         * 
141
 
         * @return boolean
142
 
         */
143
 
        protected function _afterCreate()
144
 
        {}
145
 
        
146
 
        /**
147
 
         * Callback antes de actualizar
148
 
         * 
149
 
         * @return boolean
150
 
         */
151
 
        protected function _beforeUpdate()
152
 
        {}
153
 
        
154
 
        /**
155
 
         * Callback despues de actualizar
156
 
         * 
157
 
         * @return boolean
158
 
         */
159
 
        protected function _afterUpdate()
160
 
        {}
161
 
        
162
 
        /**
163
 
         * Modo de obtener datos 
164
 
         * 
165
 
         * @param integer $mode
166
 
         * @return ActiveRecord
167
 
         */
168
 
        public function setFetchMode($mode) 
169
 
        {
170
 
                $this->_fetchMode = $mode;
171
 
                return $this;
172
 
        }
173
 
        
174
 
    /**
175
 
     * reset result set pointer 
176
 
     * (implementation required by 'rewind()' method in Iterator interface)
177
 
     */
178
 
    public function rewind ()
179
 
    {
180
 
        $this->_pointer = 0;
181
 
    }
182
 
        
183
 
    /**
184
 
     * get current row set in result set 
185
 
     * (implementation required by 'current()' method in Iterator interface)
186
 
     */
187
 
    public function current ()
188
 
    {
189
 
        if (! $this->valid()) {
190
 
            throw new KumbiaException('No se pude obtener la fila actual');
191
 
        }
192
 
        return $this->_resultSet->fetch();
193
 
    }
194
 
        
195
 
    /**
196
 
     * Obtiene la posición actual del Puntero 
197
 
     * 
198
 
     */
199
 
    public function key ()
200
 
    {
201
 
        return $this->_pointer;
202
 
    }
203
 
        
204
 
    /**
205
 
     * Mueve el puntero a la siguiente posición 
206
 
     * 
207
 
     */
208
 
    public function next ()
209
 
    {
210
 
        ++ $this->_pointer;
211
 
    }
212
 
        
213
 
    /**
214
 
     * Determina si el puntero del ResultSet es valido 
215
 
     * 
216
 
     */
217
 
    public function valid ()
218
 
    {
219
 
        return $this->_pointer < $this->_resultSet->rowCount();
220
 
    }
221
 
        
222
 
        /**
223
 
         * Indica el modo de obtener datos al ResultSet actual
224
 
         * 
225
 
         */
226
 
        protected function _fetchMode($fetchMode = NULL)
227
 
        {
228
 
                // Si no se especifica toma el por defecto
229
 
                if(!$fetchMode) {
230
 
                        $fetchMode = $this->_fetchMode;
231
 
                }
232
 
                
233
 
                switch ($fetchMode) {
234
 
                        // Obtener instancias del mismo modelo
235
 
                        case self::FETCH_MODEL:
236
 
                                // Instancias de un nuevo modelo, por lo tanto libre de los atributos de la instancia actual
237
 
                                $this->_resultSet->setFetchMode(PDO::FETCH_INTO, new self());
238
 
                                break;
239
 
                                
240
 
                        // Obtener instancias de objetos simples
241
 
                        case self::FETCH_OBJ:
242
 
                                $this->_resultSet->setFetchMode(PDO::FETCH_OBJ);
243
 
                                break;
244
 
                                
245
 
                        // Obtener arrays
246
 
                        case self::FETCH_ARRAY:
247
 
                                $this->_resultSet->setFetchMode(PDO::FETCH_ASSOC);
248
 
                                break;
249
 
                }
250
 
        }
251
 
        
252
 
        /**
253
 
         * Asigna la tabla fuente de datos
254
 
         * 
255
 
         * @param string $table
256
 
         * @return ActiveRecord
257
 
         */
258
 
        public function setTable($table)
259
 
        {
260
 
                $this->_table = $table;
261
 
                return $this;
262
 
        }
263
 
        
264
 
        /**
265
 
         * Obtiene la tabla fuente de datos
266
 
         * 
267
 
         * @return string
268
 
         */
269
 
        public function getTable()
270
 
        {
271
 
        // Asigna la tabla
272
 
                if(!$this->_table) {
273
 
                        $this->_table = Util::smallcase(get_class($this));
274
 
                }
275
 
                
276
 
                // Tabla
277
 
                return $this->_table;   
278
 
        }
279
 
        
280
 
        /**
281
 
         * Asigna el schema
282
 
         * 
283
 
         * @param string $schema
284
 
         * @return ActiveRecord
285
 
         */
286
 
        public function setSchema($schema)
287
 
        {
288
 
                $this->_schema = $schema;
289
 
                return $this;
290
 
        }
291
 
        
292
 
        /**
293
 
         * Obtiene el schema
294
 
         * 
295
 
         * @return string
296
 
         */
297
 
        public function getSchema()
298
 
        {
299
 
                return $this->_schema;  
300
 
        }
301
 
        
302
 
        /**
303
 
         * Asigna la conexion
304
 
         * 
305
 
         * @param string $conn
306
 
         * @return ActiveRecord
307
 
         */
308
 
        public function setConnection($conn)
309
 
        {
310
 
                $this->_connection = $conn;
311
 
                return $this;
312
 
        }
313
 
        
314
 
        /**
315
 
         * Obtiene la conexion
316
 
         * 
317
 
         * @return string
318
 
         */
319
 
        public function getConnection()
320
 
        {
321
 
                return $this->_connection;      
322
 
        }
323
 
        
 
74
            foreach ($data as $k => $v) {
 
75
                $this->$k = $v;
 
76
            }
 
77
        }
 
78
    }
 
79
    /**
 
80
     * Efectua una busqueda
 
81
     *
 
82
     * @param string|array parametros de busqueda
 
83
     * @return ResultSet
 
84
     **/
 
85
    public function find ()
 
86
    {
 
87
        if(!$this->_dbQuery){
 
88
            // nuevo contenedor de consulta
 
89
            $this->_dbQuery = new DbQuery();
 
90
            $this->_dbQuery->select();
 
91
        }
 
92
        
 
93
        // asigna la tabla
 
94
        $this->_dbQuery->table($this->_table);
 
95
        // asigna el esquema si existe
 
96
        if ($this->_schema) {
 
97
            $this->_dbQuery->schema($this->_schema);
 
98
        }
 
99
        //var_dump($this->_dbQuery->columns('nombre')); die;
 
100
        return $this->findBySql($this->_dbQuery);
 
101
    }
 
102
    public function all ()
 
103
    {}
 
104
    /**
 
105
     * Devuelve la instancia para realizar chain
 
106
     * 
 
107
     * @return DbQuery
 
108
     */
 
109
    public function get ()
 
110
    {
 
111
       $this->_dbQuery = new DbQuery();
 
112
       return $this->_dbQuery->select();
 
113
    }
 
114
    /**
 
115
     * Efectua una busqueda de una consulta sql
 
116
     *
 
117
     * @param string | DbQuery $sql
 
118
     * @return ResultSet
 
119
     **/
 
120
    public function findBySql ($sql)
 
121
    {
 
122
        $params = $sql->params();
 
123
        // carga el adaptador especifico para la conexion
 
124
        $adapter = DbAdapter::factory($this->_connection);
 
125
        // si no es un string, entonces es DbQuery
 
126
        if (! is_string($sql)) {
 
127
            $sql = $adapter->query($sql);
 
128
        }
 
129
        // ejecuta la consulta
 
130
        $prepare = $adapter->pdo()->prepare($sql);
 
131
        if ($prepare->execute($params)) {
 
132
            return new ResultSet($prepare);
 
133
        }
 
134
        return FALSE;
 
135
    }
324
136
    /**
325
137
     * Ejecuta una setencia SQL aplicando Prepared Statement
326
138
     * 
327
139
     * @param string $sql Setencia SQL
328
140
     * @param array $params parametros que seran enlazados al SQL
329
 
         * @param string $fetchMode
330
 
     * @return ActiveRecord
 
141
     * @return ResulSet
331
142
     */
332
 
    public function sql ($sql, $params = NULL, $fetchMode = NULL)
 
143
    public function sql ($sql, $params = NULL)
333
144
    {
334
 
                try {                   
335
 
                        // Obtiene una instancia del adaptador y prepara la consulta
336
 
            $this->_resultSet = DbAdapter::factory($this->_connection)->prepare($sql);
337
 
                        
338
 
                        // Indica el modo de obtener los datos en el ResultSet
339
 
                        $this->_fetchMode($fetchMode);
340
 
                        
341
 
                        // Ejecuta la consulta
342
 
            $this->_resultSet->execute($params);
343
 
            return $this;
344
 
        } catch (PDOException $e) {
345
 
            // Aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
346
 
            echo $this->_resultSet->errorCode();
 
145
        // carga el adaptador especifico para la conexion
 
146
        $adapter = DbAdapter::factory($this->_connection);
 
147
        $prepare = $adapter->pdo()->prepare($sql);
 
148
        if ($prepare->execute($params)) {
 
149
            return new ResultSet($prepare);
347
150
        }
348
 
                
349
151
        return FALSE;
350
152
    }
351
 
                
352
 
    /**
353
 
     * Ejecuta una consulta de dbQuery
354
 
     * 
355
 
     * @param DbQuery $dbQuery Objeto de consulta
356
 
         * @param string $fetchMode
357
 
     * @return ActiveRecord
358
 
     */
359
 
        public function query($dbQuery, $fetchMode = NULL) 
360
 
        {        
361
 
        $dbQuery->table($this->getTable());
362
 
                
363
 
        // Asigna el esquema si existe
364
 
        if ($this->_schema) {
365
 
            $dbQuery->schema($this->_schema);
366
 
        }
367
 
                   
368
 
                try {                   
369
 
                        // Obtiene una instancia del adaptador y prepara la consulta
370
 
            $this->_resultSet = DbAdapter::factory($this->_connection)->prepareDbQuery($dbQuery);
371
 
                        
372
 
                        // Indica el modo de obtener los datos en el ResultSet
373
 
                        $this->_fetchMode($fetchMode);
374
 
                        
375
 
                        // Ejecuta la consulta
376
 
            $this->_resultSet->execute($dbQuery->getBind());
377
 
            return $this;
378
 
        } catch (PDOException $e) {
379
 
            // Aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
380
 
            echo $this->_resultSet->errorCode();
381
 
        }
382
 
        }
383
 
        
384
 
    /**
385
 
     * Devuelve la instancia para realizar chain
386
 
     * 
387
 
     * @return DbQuery
388
 
     */
389
 
    public function get ()
390
 
    {
391
 
                // Crea la instancia de DbQuery
392
 
        $this->_dbQuery = new DbQuery();
393
 
                                
394
 
        return $this->_dbQuery;
395
 
    }
396
 
        
397
 
    /**
398
 
     * Efectua una busqueda
399
 
     *
400
 
         * @param string $fetchMode
401
 
     * @return ActiveRecord
402
 
     */
403
 
    public function find ($fetchMode = NULL)
404
 
    {
405
 
        if (! $this->_dbQuery) {
406
 
            $this->get();
407
 
        }
408
 
        return $this->query($this->_dbQuery->select(), $fetchMode);
409
 
    }
410
 
        
411
 
        /**
412
 
         * Obtiene un array con los items resultantes de la busqueda
413
 
         * 
414
 
         * @param string $fetchMode
415
 
         * @return array
416
 
         */
417
 
    public function all ($fetchMode = NULL)
418
 
    {
419
 
                return $this->find($fetchMode)->_resultSet->fetchAll();
420
 
        }
421
 
        
422
 
        /**
423
 
         * Obtiene el primer elemento de la busqueda
424
 
         * 
425
 
         * @param string $fetchMode
426
 
         * @return ActiveRecord
427
 
         */
428
 
    public function first ($fetchMode = NULL)
429
 
    {
430
 
        if (! $this->_dbQuery) {
431
 
            $this->get();
432
 
        }
433
 
                
434
 
                // Realiza la busqueda y retorna el objeto ActiveRecord
435
 
                return $this->query($this->_dbQuery->select()->limit(1)->offset(0), $fetchMode)->_resultSet->fetch();
436
 
        }
437
 
                
438
 
        /**
439
 
         * Busca por medio de una columna especifica
440
 
         * 
441
 
         * @param string $column columna de busqueda
442
 
         * @param string $value valor para la busqueda
443
 
         * @param string $fetchMode
444
 
         * @return ActiveRecord
445
 
         */
446
 
        public function findBy($column, $value, $fetchMode = NULL)
447
 
        {
448
 
                $this->get()->where("$column = :value")->bindValue('value', $value);
449
 
                return $this->first($fetchMode);
450
 
        }
451
 
                
452
 
        /**
453
 
         * Busca por medio de una columna especifica y obtiene todas la coincidencias
454
 
         * 
455
 
         * @param string $column columna de busqueda
456
 
         * @param string $value valor para la busqueda
457
 
         * @param string $fetchMode
458
 
         * @return ActiveRecord
459
 
         */
460
 
        public function findAllBy($column, $value, $fetchMode = NULL)
461
 
        {
462
 
                $this->get()->where("$column = :value")->bindValue('value', $value);
463
 
                return $this->find($fetchMode);
464
 
        }
465
 
        
466
 
        /**
467
 
         * Obtiene la clave primaria
468
 
         * 
469
 
         * @return string
470
 
         */
471
 
        public function getPK()
472
 
        {
473
 
                return DbAdapter::factory($this->_connection)->describe($this->getTable(), $this->_schema)->getPK();
474
 
        }
475
 
        
476
 
        /**
477
 
         * Buscar por medio de la clave primaria
478
 
         * 
479
 
         * @param string $value
480
 
         * @param string $fetchMode
481
 
         * @return ActiveRecord
482
 
         */
483
 
        public function findByPK($value, $fetchMode = NULL)
484
 
        {
485
 
                return $this->findBy($this->getPK(), $value, $fetchMode);
486
 
        }
487
 
        
488
 
        /**
489
 
         * Obtiene un array de los atributos que corresponden a columnas
490
 
         * en la tabla
491
 
         * 
492
 
         * @return array
493
 
         */
494
 
        private function _getTableValues()
495
 
        {
496
 
                $data = array();
497
 
                
498
 
                // Itera en cada atributo
499
 
                foreach(DbAdapter::factory($this->_connection)
500
 
                                        ->describe($this->getTable(), $this->_schema)
501
 
                                        ->getAttributesList() as $attr) {
502
 
                                                
503
 
                        if(property_exists($this, $attr)) {
504
 
                                if($this->$attr === '') {
505
 
                                        $data[$attr] = NULL;
506
 
                                } else {
507
 
                                        $data[$attr] = $this->$attr;
508
 
                                }
509
 
                        } else {
510
 
                                $data[$attr] = NULL;
511
 
                        }
512
 
                }
513
 
                
514
 
                return $data;
515
 
        }
516
 
        
517
153
    /**
518
154
     * Realiza un insert sobre la tabla
519
155
     * 
520
156
     * @param array $data información a ser guardada
521
 
     * @return ActiveRecord 
 
157
     * @return Bool 
522
158
     */
523
 
    public function create ($data = NULL)
524
 
    {           
525
 
                // Si es un array, se cargan los atributos en el objeto
526
 
        if (is_array($data)) {
527
 
            $this->dump($data);
528
 
        }
529
 
                                
530
 
                // @see ActiveRecordValidator
531
 
                require_once CORE_PATH . 'libs/ActiveRecord/active_record2/active_record_validator.php';
532
 
                
533
 
                // Ejecuta la validacion
534
 
                if(ActiveRecordValidator::validateOnCreate($this) === FALSE) {
535
 
                        return FALSE;
536
 
                }
537
 
                
538
 
                // Callback antes de crear
539
 
                if($this->_beforeCreate() === FALSE) {
540
 
                        return FALSE;
541
 
                }
542
 
                
543
 
                // Nuevo contenedor de consulta
 
159
    public function insert ($data = null)
 
160
    {
 
161
        // nuevo contenedor de consulta
544
162
        $dbQuery = new DbQuery();
545
 
                
546
 
                // Ejecuta la consulta
547
 
                if($this->query($dbQuery->insert($this->_getTableValues()))) {
548
 
                        // Callback despues de crear
549
 
                        $this->_afterCreate();
550
 
                        return $this;
551
 
                }
552
 
                
553
 
                return FALSE;
554
 
    }
555
 
        
556
 
        /**
557
 
     * Realiza un update sobre la tabla
558
 
     * 
559
 
     * @param array $data información a ser guardada
560
 
     * @return Bool
561
 
     */
562
 
    public function updateAll ($data)
563
 
    {
564
 
        if (! $this->_dbQuery) {
565
 
            $this->get();
566
 
        }
567
 
                
568
 
                // Ejecuta la consulta
569
 
                return $this->query($this->_dbQuery->update($data));
570
 
    }
571
 
        
572
 
        /**
573
 
     * Realiza un delete sobre la tabla
574
 
     * 
575
 
     * @return Bool
576
 
     */
577
 
    public function deleteAll ()
578
 
    {
579
 
        if (! $this->_dbQuery) {
580
 
            $this->get();
581
 
        }
582
 
                
583
 
                // Ejecuta la consulta
584
 
                return $this->query($this->_dbQuery->delete());
585
 
    }
586
 
        
587
 
        /**
588
 
         * Validadores
589
 
         * 
590
 
         * @return array
591
 
         */
592
 
        public function validators()
593
 
        {}
594
 
        
595
 
        /**
596
 
         * Cuenta las apariciones de filas
597
 
         * 
598
 
         * @param string $column
599
 
         * @return integer
600
 
         */ 
601
 
        public function count($column = '*')
602
 
        {
603
 
        if (! $this->_dbQuery) {
604
 
            $this->get();
605
 
        }
606
 
                
607
 
                $this->_dbQuery->columns("COUNT($column) AS n");
608
 
                return $this->first(self::FETCH_OBJ)->n;
609
 
        }
610
 
        
611
 
        /**
612
 
         * Verifica si existe al menos una fila con las condiciones indicadas
613
 
         * 
614
 
         * @return boolean
615
 
         */ 
616
 
        public function existsOne()
617
 
        {
618
 
        return $this->count() > 0;
619
 
        }
620
 
        
621
 
        /**
622
 
         * Establece condicion de busqueda con clave primaria
623
 
         * 
624
 
         * @param DbQuery $dbQuery
625
 
         */
626
 
        protected function _wherePK($dbQuery)
627
 
        {
628
 
                // Obtiene la clave primaria
629
 
                $pk = $this->getPK();
630
 
                
631
 
                // Si es clave primaria compuesta
632
 
                if(is_array($pk)) {
633
 
                        foreach($pk as $k) {
634
 
                                if(!isset($this->$k)) {
635
 
                                        throw new KumbiaException("Debe definir valor para la columna $k de la clave primaria");
636
 
                                }
637
 
                                
638
 
                                $dbQuery->where("$k = :pk_$k")->bindValue("pk_$k", $this->$k);
639
 
                        }
640
 
                } else {
641
 
                        if(!isset($this->$pk)) {
642
 
                                throw new KumbiaException("Debe definir valor para la clave primaria");
643
 
                        }
644
 
                        
645
 
                        $dbQuery->where("$pk = :pk_$pk")->bindValue("pk_$pk", $this->$pk);
646
 
                }
647
 
        }
648
 
        
649
 
        /**
650
 
         * Verifica si esta persistente en la BD el objeto actual en la bd
651
 
         * 
652
 
         * @return boolean
653
 
         */
654
 
        public function exists()
655
 
        {
656
 
                // Objeto de consulta
657
 
                $dbQuery = $this->get();
658
 
                
659
 
                // Establece condicion de busqueda con clave primaria
660
 
                $this->_wherePK($dbQuery);
661
 
                
662
 
                return $this->existsOne();
663
 
        }
664
 
        
665
 
        /**
666
 
     * Realiza un update del registro sobre la tabla
667
 
     * 
668
 
     * @param array $data información a ser guardada
669
 
     * @return Bool 
670
 
     */
671
 
        public function update($data = NULL)
672
 
        {                               
673
 
                // Si es un array, se cargan los atributos en el objeto
674
 
        if (is_array($data)) {
675
 
            $this->dump($data);
676
 
        }
677
 
                                
678
 
                // @see ActiveRecordValidator
679
 
                require_once CORE_PATH . 'libs/ActiveRecord/active_record2/active_record_validator.php';
680
 
                
681
 
                // Ejecuta la validacion
682
 
                if(ActiveRecordValidator::validateOnUpdate($this) === FALSE) {
683
 
                        return FALSE;
684
 
                }
685
 
                
686
 
                // Callback antes de actualizar
687
 
                if($this->_beforeUpdate() === FALSE) {
688
 
                        return FALSE;
689
 
                }
690
 
                
691
 
                // Si no existe el registro
692
 
                if(!$this->exists()) {
693
 
                        return FALSE;
694
 
                }
695
 
 
696
 
                // Objeto de consulta
697
 
                $dbQuery = new DbQuery();
698
 
                // Establece condicion de busqueda con clave primaria
699
 
                $this->_wherePK($dbQuery);
700
 
                
701
 
                // Ejecuta la consulta con el query utilizado para el exists
702
 
                if($this->query($dbQuery->update($this->_getTableValues()))) {
703
 
                        // Callback despues de actualizar
704
 
                        $this->_afterUpdate();
705
 
                        return $this;
706
 
                }
707
 
                
708
 
                return FALSE;
709
 
        }
 
163
        // asigna la tabla
 
164
        $dbQuery->table($this->_table);
 
165
        // asigna el esquema si existe
 
166
        if ($this->_schema) {
 
167
            $dbQuery->schema($this->_schema);
 
168
        }
 
169
        $dbQuery->insert($data);
 
170
        $adapter = DbAdapter::factory($this->_connection);
 
171
        try {
 
172
            $prepare = $adapter->pdo()->prepare($adapter->query($dbQuery));
 
173
            return $prepare->execute($data);
 
174
        } catch (PDOException $e) {    //echo $prepare->errorCode();die;
 
175
        }
 
176
        //return FALSE;
 
177
    }
 
178
    
710
179
}