CodeIgniter-最佳模型方法

Question

This has been bothering me for quite some time now.

Controller, on my take, is where I do validation, model calls, and displaying of data. And on the Model, which has only one purpose, is where I make my SQL queries.

But what is the best approach on Model. Do I have to make a lot of functions, with different conditions/approaches, or do I have to do it all in a single function, dedicated to a single table in my database. Take the code below for example:

Multiple Functions:

class Sword_model extends CI_Model {

    public function __construct()
    {
        $this->load->database();
        $this->load->library('session');
        $this->load->helper('url_helper');
    }

    public function getsword($swordid = NULL)
    {
        if($swordid === NULL){
            $query = $this->db->query("SELECT * FROM sword_tb");
            return $query->result_array();
        }

        $query = $this->db->query("SELECT * FROM sword_tb WHERE sword_id = ?", array($swordid));
        return $query->row_array();
    }

    public function getstrongswords($strong = NULL)
    {

        if($strong === NULL){
            return false;
        }

        $query = $this->db->query("SELECT * FROM sword_tb WHERE strong = ?", array($strong));
        return $query->result_array();

    }

    /*** AND MORE SUCCEEDING FUNCTIONS BELOW FOR DIFFERENT COLUMNS/CONDITIONS ***/
}

Pros: This is straight through and easier to understand (and I think is faster)
Cons: You have to manually create functions for different conditions/columns

---

Single Function:

class Sword_model extends CI_Model {

    public function __construct()
    {
        $this->load->database();
        $this->load->library('session');
        $this->load->helper('url_helper');
    }

    public function getsword($column = NULL, $value = NULL, $condition = 'AND')
    {

        $query = 'SELECT * FROM sword_tb';
        $count = count($column);
        for($x = 0; $x < $count; $x++){
            if($x > 0){
                $query .= ' '.$condition;
            } else {
                $query .= ' WHERE (';
            }
            $query .= ' '.$column[$x].' = ?';
        }
        $query .= ' ORDER BY sword_name';

        $query = $this->db->query($query, $value);
        return $query->result_array();

    }

}

with this single function approach, you can call this function by putting arrays as parameters like this:

$this->Sword_model->getsword(array('sword', 'strong'), array(3, 1), 'OR');

And the query will look like this:

SELECT * FROM sword WHERE (sword = ? OR strong = ?) ORDER BY sword_name

And if you left it behind blank, the query will look like this:

SELECT * FROM sword ORDER BY sword_name

Pros: Flexible
Cons: Slower (?) than the first approach

What is more ideal between the two? Or is there any other more ideal way?

Answer 1

I prefer to have each table to have it's own model with different preferable methods as you do in "Multiple Model". This way it is more maintainable and easier to approach & understand the codes. The second one is though it's harder to approach and it may not be useful on all scenario.

I have been using Codeigniter MVC & HMVC for more than 2 years. First one is my choice for so far and it helps me to check and maintain my codes and also helps in my future updates/codes.

Answer 2

You can try ORM ( Object-relational mapping )

Datamapper is an ORM library .It is designed to map your Database tables into easy to work with objects .

After successful installation of Datamapper

If you have a table called users

Create a model with name user

<?php

class User extends DataMapper {

    function __construct($id = NULL)
    {
        parent::__construct($id);
    }
}

In your controller, you can simply access data by

    $u = new user(); // Singular of model name is required
    $u->get();

    foreach ($u as $user => $value) 
    {
        echo $user->name;
    }

By this method you have to create each models for your tables and access data through your controller

Answer 3

I prefer one generic model using which I can execute all mysql queries (which are not so complex, otherwise you need to write a query string and get it executed in few cases if there is a need of some too much complex query.) Otherwise you can call the models' generic functions from your controller by passing data array and table name and rest will be managed by the model. Here is the generic model I use:

<?php

/*
  All user module related databse functions
  Author : Himanshu Upadhyay (himanshuvarun@gmail.com)
 */

if (!defined('BASEPATH'))
    exit('No direct script access allowed');

class User_Model extends MY_Model {

    public function __construct() {
        parent::__construct();
    }

    public function get_rows($filters = array(), $table = TBL_USER) {
        return parent::get_rows($filters, $table);
    }

    public function get_columns($table = TBL_USER) {
        return parent::get_columns($table);
    }

    public function update_table($data, $where, $table = TBL_USER, $set = '') {
        return parent::update_table($data, $where, $table, $set = '');
    }

    public function get_count($filters = array(), $table = TBL_USER) {
        return parent::get_count($filters, $table);
    }

    public function insert($data, $table = TBL_USER) {
        return parent::insert($data, $table);
    }

    public function delete($where, $table = TBL_USER) {
        return parent::delete($where, $table);
    }
/* End of file user_model.php */
/* Location: ./application/models/user_model.php */
?>

And in your controller, you can call the model function like :

$user_data['first_name'] = 'ABC';
$user_data['last_name'] = 'XYZ';
$this->user_model->insert($user_data, 'tbl_users');  // This is calling `insert` function of user model with first array argument with the data with column names as keys of the array and 2nd argument is the table name.

Conclusion: So by this approach, you can load user_model in all the controllers and you can use all its generic functions in all of the controllers. So this approach avoids redundant model functions to fetch, insert and update the data as well as it saves us by defining different models for each tables.

Answer 4

Most of the time multiple functions are easier to debug, comprehend and maintain.

That said, you could make your multi-method model code a lot less repetitive. Consider the following. ( __construct() not shown cause yours is fine.)

class Sword_model extends CI_Model
{
    protected $get_all_sql = 'SELECT * FROM sword_tb';
    protected $get_where_sql = "SELECT * FROM sword_tb WHERE sword_id = ?";

    public function getsword($swordid = NULL)
    {
        $sql = isset($swordid) ? $this->get_where_sql : $this->get_all_sql;
        $bind = isset($swordid) ? $swordid : FALSE;
        return $this->do_Query($sql, $bind);
    }

    public function getstrongswords($strong = NULL)
    {
        if(isset($strong))
        {
            return $this->do_Query($this->get_where_sql, $strong);
        }
        //Returning an empty array means the controller can skip doing a conditional 
        //check for a model return === FALSE.
        //foreach() won't choke on an empty array, but it will choke if passed FALSE
        return array();
    }

    protected function do_Query($sql, $binds = FALSE)
    {
        $query = $this->db->query($sql, $binds);
        return $query->result_array();
    }
}

However, the "flexible" approach can be useful is certain circumstances.

The speed difference between "singles" vs "flexible" is negligible and not a consideration. What does need to be considered is that "flexible" quickly becomes unwieldy as you try to respond to more "conditions".

There is something that will make writing "flexible" model methods easier - easier to write, comprehend, debug and maintain. Instead of manually constructing query strings and passing them to $this->db->query() use Query Builder . It is designed exactly for situations where you need to conditionally build a query statement.

Your "flexible" version of getsword() has at least one limitation and that is that you cannot SELECT columns that are not part of the WHERE clause.

Using Query Builder here is one way you could implement a flexible method that builds queries for both AND WHERE and OR WHERE clauses. Hopefully the DocBlock before the method will provide some insight.

class Sword_model extends CI_Model
{
    protected $get_all_sql = 'SELECT * FROM sword_tb';
    protected $get_where_sql = "SELECT * FROM sword_tb WHERE sword_id = ?";

    /**
     * 
     * @param mixed $columns The columns to retrieve. Can be either a string 
     * e.g. 'title, content, date',
     * or it can be an array e.g. array('title', 'content', 'date') 
     * 
     * @param array $where If provided, must be an associative array where 
     * the key => value is 'field_name' => value_to_match, e.g. 
     * array('title' => "Kill Bill") 
     * $where requires a different structure when the $condition argument is 
     * "OR". In this case the value part should provide multiple values. 
     * These values can be provided either in an array 
     * or a comma separated string list. For instance:
     *    As an array, $where = array('field_name' => array('val1', 'val2'));

     *    As a string, $where = array('field_name' => 'val1, val2'));
     * 
     * @param string $condition For this example can be either 'AND' (default) or 'OR'
     */
    public function getsword($columns = NULL, $where = NULL, $condition = 'AND')
    {
        if(!empty($columns)) //No $columns means SELECT *
        {
            $this->db->select($columns);
        }

        $condition = strtoupper($condition); //Don't assume
        if(!empty($where))
        {
            if($condition === 'OR')
            {
                foreach($where as $key => $values)
                {
                    if(is_string($values))
                    {
                        $values = explode(', ', $values);
                    }
                    if(is_array($values))
                    {
                        foreach($values as $matching)
                        {
                            $match = [$key => $matching];
                            $this->db->or_where($match);
                        }
                    }
                    else
                    {
                        $this->db->or_where($key, $values);
                    }
                }
            }
            else
            {
                $this->db->where($where);
            }
        }

        return $this->db
          ->order_by('sword_name')
          ->get("sword_tb")
          ->result_array();
    }

}

You might look at the block

                        foreach($values as $matching)
                        {
                            $match = [$key => $matching];
                            $this->db->or_where($match);
                        }

and question the use of or_where() before calling where() . Query Builder is smart enough to know if any other WHEREs have been added and won't put "OR" in front of "WHERE" if it's not needed.

Let's look at some usage examples.

$this->sword_model->getsword();

Produces the query statement

SELECT * FROM sword_tb ORDER BY sword_name

$this->sword_model->getsword('model, sword_name, cost', array('model' => 'Broad'));

produces

SELECT model, sword_name, cost FROM sword_tb WHERE model = Broad ORDER BY sword_name

$this->sword_model->getsword(NULL, array('model' => 'Broad', 'cost <' => 100));

SELECT * FROM sword_tb WHERE model = Broad AND cost < 100 ORDER BY sword_name

$this->sword_model->getsword('model, sword_name, cost',
      array('model' => 'Broad, Samurai', 'sword_name' => 'Excalibur'), 'or');

SELECT model, sword_name, cost FROM sword_tb WHERE model = Broad OR model = Samurai OR sword_name = Excalibur ORDER BY sword_name

$this->sword_model->getsword(NULL,
      array('model' => 'Broad, Samurai', 'sword_name' => ['Excalibur', 'Fred']), 'or');

SELECT * FROM sword_tb WHERE model = Broad OR model = Samurai OR sword_name = Excalibur OR sword_name = Fred ORDER BY sword_name

NOTE: I removed the back-tics from the generated queries string because here on SO it looked weird. Rest assured, everything is properly escaped.

If you're worried about speed, I benchmarked the above. The longest time required to build a query statement was 0.0007 second. To build all five queries required a total of 0.0022 seconds - an average of 0.00044 each.

Note, this is time to build the statement. The time to retrieve data is not included because, well... I don't have the data.