« back to all changes in this revision
Viewing changes to active_record2/active_record2.php
- browse files at revision 41
- compare with another revision
- download diff
- download tarball
- view history from revision 41
- Committer: Emilio Silveira
- Date: 2010-06-16 03:20:43 UTC
- Revision ID: emilio.rst@gmail.com-20100616032043-coxo4mz6l0nlzv8y
Puliendo codigo y corrigiendo bugs
added
removed
active_record2/active_record2.php
37
37
*/
38
38
class ActiveRecord2 extends KumbiaModel implements Iterator
39
39
{
40
/**
41
* Obtener datos cargados en objeto del Modelo
42
*
43
*/
44
const FETCH_MODEL = 1;
45
46
/**
47
* Obtener datos cargados en objeto
48
*
49
*/
50
const FETCH_OBJ = 2;
51
52
/**
53
* Obtener datos cargados en array
54
*
55
*/
56
const FETCH_ARRAY = 3;
57
40
58
/**
41
59
* Conexion a base datos que se utilizara
42
60
*
75
93
/**
76
94
* ResulSet PDOStatement
77
95
*
78
* @var Obj
96
* @var PDOStatement
79
97
*/
80
98
private $_resultSet = NULL;
81
99
100
/**
101
* Modo de obtener datos
102
*
103
* @var integer
104
*/
105
protected $_fetchMode = self::FETCH_MODEL;
106
82
107
/**
83
108
* Constructor de la class
109
*
84
110
*/
85
111
public function __construct ($data = null)
86
112
{
87
113
if (is_array($data)) {
88
foreach ($data as $k => $v) {
89
$this->$k = $v;
90
}
91
}
92
}
93
94
/**
95
* Efectua una busqueda
96
*
97
* @return ResultSet
98
*/
99
public function find ()
100
{
101
if (! $this->_dbQuery) {
102
$this->get();
103
}
104
return $this->findBySql($this->_dbQuery);
105
}
106
107
public function all ()
108
{}
109
110
/**
111
* Devuelve la instancia para realizar chain
112
*
113
* @return DbQuery
114
*/
115
public function get ()
116
{
117
// crea la instancia de DbQuery
118
$this->_dbQuery = new DbQuery();
119
120
// asigna la tabla
121
$this->_dbQuery->table($this->_table);
122
123
// asigna el esquema si existe
124
if ($this->_schema) {
125
$this->_dbQuery->schema($this->_schema);
126
}
127
128
return $this->_dbQuery->select();
129
}
130
131
/**
132
* Efectua una busqueda de una consulta sql
133
*
134
* @param string | DbQuery $sql
135
* @param array $params parametros que seran enlazados al SQL
136
* @return ResultSet
137
*/
138
public function findBySql ($sql, $params = NULL)
139
{
140
// carga el adaptador especifico para la conexion
141
$adapter = DbAdapter::factory($this->_connection);
142
143
// si no es un string, entonces es DbQuery
144
if (! is_string($sql)) {
145
$sql = $adapter->query($sql);
146
$params = $sql->getBind();
147
}
148
149
// ejecuta la consulta
150
$this->_resultSet = $adapter->pdo()->prepare($sql);
151
if ($this->_resultSet->execute($params)) {
152
return $this;
153
}
154
return FALSE;
155
}
156
157
/**
158
* Ejecuta una setencia SQL aplicando Prepared Statement
159
*
160
* @param string $sql Setencia SQL
161
* @param array $params parametros que seran enlazados al SQL
162
* @return ResulSet
163
*/
164
public function sql ($sql, $params = NULL)
165
{
166
// carga el adaptador especifico para la conexion
167
$adapter = DbAdapter::factory($this->_connection);
168
$this->_resultSet = $adapter->pdo()->prepare($sql);
169
if ($this->_resultSet->execute($params)) {
170
return $this;
171
}
172
return FALSE;
173
}
174
175
/**
176
* Realiza un insert sobre la tabla
177
*
178
* @param array $data información a ser guardada
179
* @return Bool
180
*/
181
public function create ($data = NULL)
182
{
183
// nuevo contenedor de consulta
184
$dbQuery = new DbQuery();
185
// asigna la tabla
186
$dbQuery->table($this->_table);
187
// asigna el esquema si existe
188
if ($this->_schema) {
189
$dbQuery->schema($this->_schema);
190
}
191
$adapter = DbAdapter::factory($this->_connection);
192
try {
193
$this->_resultSet = $adapter->pdo()->prepare($adapter->query($dbQuery->insert($data)));
194
$this->_resultSet->execute($dbQuery->getBind());
195
return $this;
196
} catch (PDOException $e) {
197
//aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
198
echo $this->_resultSet->errorCode();
199
}
200
}
201
202
/**
203
* Realiza un update sobre la tabla
204
*
205
* @param array $data información a ser guardada
206
* @return Bool
207
*/
208
public function updateAll ($data)
209
{
210
if (! $this->_dbQuery) {
211
$this->get();
212
}
213
214
$adapter = DbAdapter::factory($this->_connection);
215
try {
216
$this->_resultSet = $adapter->pdo()->prepare($adapter->query($this->_dbQuery->update($data)));
217
$this->_resultSet->execute($this->_dbQuery->getBind());
218
return $this;
219
} catch (PDOException $e) {
220
//aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
221
echo $this->_resultSet->errorCode();
222
}
223
}
224
225
/**
226
* Realiza un delete sobre la tabla
227
*
228
* @return Bool
229
*/
230
public function deleteAll ()
231
{
232
if (! $this->_dbQuery) {
233
$this->get();
234
}
235
236
$adapter = DbAdapter::factory($this->_connection);
237
try {
238
$this->_resultSet = $adapter->pdo()->prepare($adapter->query($this->_dbQuery->delete()));
239
$this->_resultSet->execute($this->_dbQuery->getBind());
240
return $this;
241
} catch (PDOException $e) {
242
//aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
243
echo $this->_resultSet->errorCode();
244
}
245
}
246
247
/**
248
* Fetch Object
249
*
250
* @param string Class
251
* @return Array
252
*/
253
public function fetchObject ()
254
{
255
$this->_resultSet->setFetchMode(PDO::FETCH_INTO, $this);
256
return $this->_resultSet->fetch();
257
}
114
$this->_dump($data);
115
}
116
}
117
118
/**
119
* Carga el array como atributos del objeto
120
*
121
* @param array $data
122
*/
123
protected function _dump($data)
124
{
125
foreach ($data as $k => $v) {
126
$this->$k = $v;
127
}
128
}
129
130
/**
131
* Modo de obtener datos
132
*
133
* @param integer $mode
134
* @return ActiveRecord
135
*/
136
public function setFetchMode($mode)
137
{
138
$this->_fetchMode = $mode;
139
return $this;
140
}
258
141
259
142
/**
260
143
* reset result set pointer
272
155
public function current ()
273
156
{
274
157
if (! $this->valid()) {
275
throw new KumbiaException('Unable to retrieve current row.');
158
throw new KumbiaException('No se pude obtener la fila actual');
276
159
}
277
return $this->fetchObject();
160
return $this->_resultSet->fetch();
278
161
}
279
162
280
163
/**
303
186
{
304
187
return $this->_pointer < $this->_resultSet->rowCount();
305
188
}
189
190
/**
191
* Indica el modo de obtener datos al ResultSet actual
192
*
193
*/
194
protected function _fetchMode()
195
{
196
switch ($this->_fetchMode) {
197
// Obtener instancias del mismo modelo
198
case self::FETCH_MODEL:
199
$this->_resultSet->setFetchMode(PDO::FETCH_INTO, new self());
200
break;
201
202
// Obtener instancias de objetos simples
203
case self::FETCH_OBJ:
204
$this->_resultSet->setFetchMode(PDO::FETCH_OBJ);
205
break;
206
207
// Obtener arrays
208
case self::FETCH_ARRAY:
209
$this->_resultSet->setFetchMode(PDO::FETCH_ASSOC);
210
break;
211
}
212
}
213
214
/**
215
* Asigna la tabla fuente de datos
216
*
217
* @param string $table
218
* @return ActiveRecord
219
*/
220
public function setTable($table)
221
{
222
$this->_table = $table;
223
return $this;
224
}
225
226
/**
227
* Obtiene la tabla fuente de datos
228
*
229
* @return string
230
*/
231
public function getTable()
232
{
233
// Asigna la tabla
234
if(!$this->_table) {
235
$this->_table = Util::smallcase(get_class($this));
236
}
237
238
// Tabla
239
return $this->_table;
240
}
241
242
/**
243
* Asigna el schema
244
*
245
* @param string $schema
246
* @return ActiveRecord
247
*/
248
public function setSchema($schema)
249
{
250
$this->_schema = $schema;
251
return $this;
252
}
253
254
/**
255
* Obtiene el schema
256
*
257
* @return string
258
*/
259
public function getSchema()
260
{
261
return $this->_schema;
262
}
263
264
/**
265
* Ejecuta una setencia SQL aplicando Prepared Statement
266
*
267
* @param string $sql Setencia SQL
268
* @param array $params parametros que seran enlazados al SQL
269
* @return ActiveRecord
270
*/
271
public function sql ($sql, $params = NULL)
272
{
273
// Obtiene una instancia del adaptador
274
$adapter = DbAdapter::factory($this->_connection);
275
276
try {
277
// Prepara la consulta
278
$this->_resultSet = $adapter->prepare($sql);
279
280
// Indica el modo de obtener los datos en el ResultSet
281
$this->_fetchMode();
282
283
// Ejecuta la consulta
284
$this->_resultSet->execute($params);
285
return $this;
286
} catch (PDOException $e) {
287
// Aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
288
echo $this->_resultSet->errorCode();
289
}
290
291
return FALSE;
292
}
293
294
/**
295
* Ejecuta una consulta de dbQuery
296
*
297
* @param DbQuery $dbQuery Objeto de consulta
298
* @return ActiveRecord
299
*/
300
public function query($dbQuery)
301
{
302
$dbQuery->table($this->getTable());
303
304
// Asigna el esquema si existe
305
if ($this->_schema) {
306
$dbQuery->schema($this->_schema);
307
}
308
309
// Obtiene una instancia del adaptador
310
$adapter = DbAdapter::factory($this->_connection);
311
312
try {
313
// Prepara la consulta
314
$this->_resultSet = $adapter->prepareDbQuery($dbQuery);
315
316
// Indica el modo de obtener los datos en el ResultSet
317
$this->_fetchMode();
318
319
// Ejecuta la consulta
320
$this->_resultSet->execute($dbQuery->getBind());
321
return $this;
322
} catch (PDOException $e) {
323
// Aqui debemos ir a cada adapter y verificar el código de error SQLSTATE
324
echo $this->_resultSet->errorCode();
325
}
326
}
327
328
/**
329
* Devuelve la instancia para realizar chain
330
*
331
* @return DbQuery
332
*/
333
public function get ()
334
{
335
// Crea la instancia de DbQuery
336
$this->_dbQuery = new DbQuery();
337
338
return $this->_dbQuery;
339
}
340
341
/**
342
* Efectua una busqueda
343
*
344
* @return ActiveRecord
345
*/
346
public function find ()
347
{
348
if (! $this->_dbQuery) {
349
$this->get();
350
}
351
return $this->query($this->_dbQuery->select());
352
}
353
354
/**
355
* Obtiene un array con los items resultantes de la busqueda
356
*
357
* @return array
358
*/
359
public function all ()
360
{
361
return $this->find()->_resultSet->fetchAll();
362
}
363
364
/**
365
* Obtiene el primer elemento de la busqueda
366
*
367
* @return ActiveRecord
368
*/
369
public function first ()
370
{
371
if (! $this->_dbQuery) {
372
$this->get();
373
}
374
375
// Realiza la busqueda y retorna el objeto ActiveRecord
376
return $this->query($this->_dbQuery->select()->limit(1)->offset(0))->_resultSet->fetch();
377
}
378
379
/**
380
* Busca por medio de una columna especifica
381
*
382
* @param string $column columna de busqueda
383
* @param string $value valor para la busqueda
384
* @return ActiveRecord
385
*/
386
public function findBy($column, $value)
387
{
388
$this->get()->where("$column = :value")->bind(array('value' => $value));
389
return $this->first();
390
}
391
392
/**
393
* Busca por medio de una columna especifica y obtiene todas la coincidencias
394
*
395
* @param string $column columna de busqueda
396
* @param string $value valor para la busqueda
397
* @return ActiveRecord
398
*/
399
public function findAllBy($column, $value)
400
{
401
$this->get()->where("$column = :value")->bind(array('value' => $value));
402
return $this->find();
403
}
404
405
/**
406
* Buscar por medio de la clave primaria
407
*
408
* @param string $value
409
*/
410
public function findByPK($value)
411
{
412
// Obtiene una instancia del adaptador
413
$adapter = DbAdapter::factory($this->_connection);
414
$metadata = $adapter->describe($this->getTable(), $this->_schema);
415
416
return $this->findBy($metadata->getPK(), $value);
417
}
418
419
/**
420
* Realiza un insert sobre la tabla
421
*
422
* @param array $data información a ser guardada
423
* @return Bool
424
*/
425
public function create ($data = NULL)
426
{
427
// Nuevo contenedor de consulta
428
$dbQuery = new DbQuery();
429
430
// Ejecuta la consulta
431
return $this->query($dbQuery->insert($data));
432
}
433
434
/**
435
* Realiza un update sobre la tabla
436
*
437
* @param array $data información a ser guardada
438
* @return Bool
439
*/
440
public function updateAll ($data)
441
{
442
if (! $this->_dbQuery) {
443
$this->get();
444
}
445
446
// Ejecuta la consulta
447
return $this->query($this->_dbQuery->update($data));
448
}
449
450
/**
451
* Realiza un delete sobre la tabla
452
*
453
* @return Bool
454
*/
455
public function deleteAll ()
456
{
457
if (! $this->_dbQuery) {
458
$this->get();
459
}
460
461
// Ejecuta la consulta
462
return $this->query($this->_dbQuery->delete());
463
}
306
464
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1