← Back to branch summary

~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 08:30:05 UTC
  • Revision ID: deivinsontejeda@gmail.com-20100122083005-7r7jvx8zuxki2pdk
      Añadiendo ResultSet ahora se puede probar con el Metodo sql() de ActiveRecord...
      ejemplos...
      Modelo
          public function getSql()
          {
              return $this->sql('select * from prueba where id > :id', array('id'=>2));
          }
      
      $xx = Load::model('modelo')->getSql();
      foreach ($xx as $xxx) {
          var_dump($xxx);
      }
      
      por defecto devuelve objeto, pero se puede pedir un fetchArray
      foreach ($xx->fetchArray() as $xxx) {
          var_dump($xxx);
      }

Show diffs side-by-side

added added

removed removed

Lines of Context:
active_record2/active_record2.php
22
22
/**
23
23
 * @see KumbiaModel
24
24
 */
25
 
require_once CORE_PATH.'libs/ActiveRecord/active_record2/kumbia_model.php';
26
 
 
 
25
require_once CORE_PATH . 'libs/ActiveRecord/active_record2/kumbia_model.php';
 
26
/**
 
27
 * @see ResultSet
 
28
 */
 
29
require_once CORE_PATH . 'libs/ActiveRecord/db_pool/result_set.php';
27
30
/**
28
31
 * ActiveRecord Clase para el Mapeo Objeto Relacional
29
32
 *
44
47
     * @var strings
45
48
     **/
46
49
    protected $_connection = null;
47
 
 
48
50
    /**
49
51
     * Tabla origen de datos
50
52
     *
51
53
     * @var string
52
 
     **/
 
54
     */
53
55
    protected $_table = null;
54
 
    
55
56
    /**
56
57
     * Esquema de datos
57
58
     *
58
59
     * @var string
59
 
     **/
 
60
     */
60
61
    protected $_schema = null;
61
 
 
 
62
    /**
 
63
     * Objeto DbQuery para implementar chain
 
64
     * 
 
65
     * @var Obj
 
66
     */
 
67
    protected $_dbQuery = NULL;
 
68
    /**
 
69
     * Constructor de la class
 
70
     */
 
71
    public function __constructor ($data = null)
 
72
    {
 
73
        if (is_array($data)) {
 
74
            foreach ($data as $k => $v) {
 
75
                $this->$k = $v;
 
76
            }
 
77
        }
 
78
    }
62
79
    /**
63
80
     * Efectua una busqueda
64
81
     *
65
82
     * @param string|array parametros de busqueda 
66
83
     **/
67
 
    public function find($params=NULL)
 
84
    public function find ($params = NULL)
68
85
    {
69
 
        // nuevo contenedor de consulta
70
 
        $dbQuery = new DbQuery();
71
 
    
 
86
        if(!$this->_dbQuery){
 
87
            // nuevo contenedor de consulta
 
88
            $dbQuery = new DbQuery();
 
89
        }
 
90
        
72
91
        // asigna la tabla
73
92
        $dbQuery->table($this->_table);
74
 
        
75
93
        // asigna el esquema si existe
76
 
        if($this->_schema) {
 
94
        if ($this->_schema) {
77
95
            $dbQuery->schema($this->_schema);
78
96
        }
79
 
    
80
 
        // si no se indican parametros de consulta
81
 
        if(!$params) {
82
 
            return $this->findBySql($dbQuery->select());
83
 
        }
84
 
        
85
97
        // obtiene los parametros de consulta indicados
86
 
        if(!is_array($params)) {
 
98
        if (! is_array($params)) {
87
99
            $params = Util::getParams(func_get_args());
88
 
            $dbQuery->select(implode(',',$params));
 
100
            $dbQuery->select(implode(', ', $params));
89
101
            return $this->findBySql($dbQuery);
90
102
        }
91
 
        
92
 
    }
93
 
    
 
103
    }
 
104
    public function all ()
 
105
    {}
 
106
    /**
 
107
     * Devuelve la instancia para realizar chain
 
108
     * 
 
109
     * @return Obj DbQuery
 
110
     */
 
111
    public function get ()
 
112
    {
 
113
        return $this->_dbQuery = new DbQuery();
 
114
    }
94
115
    /**
95
116
     * Efectua una busqueda de una consulta sql
96
117
     *
97
118
     * @param string | DbQuery $sql
98
119
     **/
99
 
    public function findBySql($sql)
 
120
    public function findBySql ($sql)
100
121
    {
101
122
        // carga el adaptador especifico para la conexion
102
123
        $adapter = DbAdapter::factory($this->_connection);
103
 
    
104
124
        // si no es un string, entonces es DbQuery
105
 
        if(!is_string($sql)) {
 
125
        if (! is_string($sql)) {
106
126
            $sql = $adapter->query($sql);
107
127
        }
108
128
        // ejecuta la consulta
110
130
    }
111
131
    /**
112
132
     * Ejecuta una setencia SQL aplicando Prepared Statement
 
133
     * 
113
134
     * @param string $sql Setencia SQL
114
135
     * @param array $params parametros que seran enlazados al SQL
115
 
     * @param int tipo de Fetch a retornar
 
136
     * @return ResulSet
116
137
     */
117
 
    public function sql($sql, $params=NULL, $fetch=PDO::FETCH_CLASS)
 
138
    public function sql ($sql, $params = NULL)
118
139
    {
119
140
        // carga el adaptador especifico para la conexion
120
141
        $adapter = DbAdapter::factory($this->_connection);
121
 
        
122
142
        $prepare = $adapter->pdo()->prepare($sql);
123
 
        if($prepare->execute($params)){
124
 
            return $prepare->fetchAll($fetch);
 
143
        if ($prepare->execute($params)) {
 
144
            return new ResultSet($prepare);
125
145
        }
126
 
        
127
146
        return FALSE;
128
147
    }
129
 
}
 
 
b'\\ No newline at end of file'
 
148
    /**
 
149
     * Realiza un insert sobre la tabla
 
150
     * 
 
151
     * @param array $data información a ser guardada
 
152
     * @return Bool 
 
153
     */
 
154
    public function insert ($data = null)
 
155
    {
 
156
        // nuevo contenedor de consulta
 
157
        $dbQuery = new DbQuery();
 
158
        // asigna la tabla
 
159
        $dbQuery->table($this->_table);
 
160
        // asigna el esquema si existe
 
161
        if ($this->_schema) {
 
162
            $dbQuery->schema($this->_schema);
 
163
        }
 
164
        $dbQuery->insert($data);
 
165
        $adapter = DbAdapter::factory($this->_connection);
 
166
        try {
 
167
            $prepare = $adapter->pdo()->prepare($adapter->query($dbQuery));
 
168
            return $prepare->execute($data);
 
169
        } catch (PDOException $e) {    //echo $prepare->errorCode();die;
 
170
        }
 
171
        //return FALSE;
 
172
    }
 
173
}