与PDO :: FETCH_CLASS相反

Question

So I've used PDO::FETCH_CLASS to make a new object, filling the properties with values from the columns of the same name in the database along the lines of:

$db = Connection::get();
$sql = $db->prepare("SELECT * FROM table WHERE id = :id");
$sql->bindParam(":id", "1");
$sql->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'table');
$sql->execute();
$newobj = $sql->fetch();

Is there an opposite for inserting an object's properties into their corresponding columns in the table, to save typing a whole load of bindParam() and a long SQL query?

Many thanks

Answer 1

this was a fun one to do

• One caveat is this will take all the public properties in the class and try to use them as part of the query. You could filter them more if you really need to.

We are going to be using what is known as reflection.

This is sort of a double edged sword.

On the one hand we can put this in a base class and extend it with all your objects and it would work just fine for them. If at a later date you add a field to the table, same deal you don't have to change anything, it just works.

On the other hand it takes a small amount of time to process this instead of say having it written as a string. Some of this could be addressed by caching the queries inside protected static properties and by caching the properties themselves ( but not the values )

I will start off by making an Abstract Class. This is a very flexible approach to this problem and it lends it self to being reused - Note: I tested only the Insert method so forgive me if there are any errors in the other parts.

  abstract class BaseObject
  {

    public $id;
    protected static $_DB;

   public function getDB(\PDO $db ){
      if( !self::$_DB ){
          //@todo: connect to Database
      }
      return self::$_DB;
   }

    public function getId(){ return $this->id; }

    public function setId( $id ){ $this->id = $id }

    //returns the records id
    public function save(){
        //if there is no ID then we know it didn't come from the DB
        if( $this->id ) 
            return $this->update();
        else
            return $this->insert();
    }

    // query format = 'INSERT INTO table (id, ... )VALUES(:id, ... )'
    public function insert(){
        $this->validate();

        $db = $this->getDB(); //localize

        $R = new \ReflectionObject( $this );
        $props = (array)$R->getProperties()[0];

        $names = array_keys( $props );

        $sql = 'INSERT INTO '.$this->getTable().' ('.implode(',', $names).' )VALUES( :'.implode(', :', $names).' )';
        $params = array_combine(
            array_map(function($item){
                return ':'.$item;
            }, $names),
            $props
         );

        $stmt =  $db ->prepare( $sql );
        $stmt->execute( $params );

        $this->id = $db->lastInsertId(); //don't forget to update the id
        return $this->id;
    }

    // query format = 'UPDATE table SET prop=:prop, ... WHERE id=:id'
    public function Update(){
        $this->validate();

        $db = $this->getDB(); //localize

        $R = new \ReflectionObject( $this );
        $props = (array)$R->getProperties()[0];
        $names = array_keys( $props );

        $sql = 'UPATE '.$this->getTable().' SET ';
        $set = [];
        $params = [];
        foreach( $props as $name=>$value ){     
            $params[':'.$name] = $value;

            if( $name == 'id' ) continue;
            $set[] = "$name = :$name";
        }

        $sql .= implode(', ', $set).' WHERE id=:id'


        $stmt = $db->prepare( $sql );
        $stmt->execute( $params );

        return $this->_id;
    }

    abstract public function getTable();

    abstract public function vallidate();

  }

Then in your concrete classes you just need to implement the abstract methods, and add the other properties specific to them

  class Dude extends BaseObject
  {
      public $name;

      public function getName(){ return $this->name ; }

      public function setName( $name ){ $this->name = $name }

      public function getTable(){
           return 'dudes';
      }

     public function validate(){
          if( empty( $this->name ) ) throw new \Exception( "Name cannot be empty" );

       //...etc.
     }
  }

One thing I happened to think of that you should be aware of, When loading a class -via- the PDO results, the class's constructor is not called. It's been a while sense I loaded a class this way and there may be a way to force it to call the constructor, or I may be just recalling incorrectly. But it's something worth mentioning.

The reason I mention that is that the abstract class needs a PDO instance, so I went and added the getDB() method. This is just a brief example on how you can cache the DB connection for all the classes, ( I was to lazy to do the actual connection part, sorry )

Personally I use what is called a Singleton for my DB needs so I would just call something like this self::$_DB = DB::getInstance(); there but that's a story for another day.

I would also suggest adding a delete method, so you get that whole CRUD experience all your programmer fiends keep talking about.

One other major improvement I can think of is you could store some of this stuff in static properties, basically cache it after the first time its ran. That would save some on re-processing ( introspection ) of the class multiple times.

Its a bit tricky though and you would want to further break things down. One tip I can give you on that is make sure to use static::$Var in the base class and not self::$Var so you use whats called Late Static Binding . That's basically the tricky part, because you could have descendant classes with totally different stuff. I'm not sure if this is the correct term but it's kind of a scope resolution problem.

But I will leave these last things up to you. This example should point you down the right path ( or at least a path I know works ), and give you some ideas of what is possible.

One last thing is it's perfectly fine to access properties or call methods using strings like this ( assuming they exist of course )

foreach( $props as $name=>$value ){
     //for this we will say $name = 'id'
    $method = "get".ucFirst( $name ); // 'getId'
    $a = $this->$method(); // calls $this->getId()
    $a = $this->$name;  //access property $this->id; 
}

I just thought I would put that out there to give you another way to access the data that you might find useful.

Answer 2

I think you want to do something like this. refer (The only proper) PDO tutorial

$arr = [1,2,3];
$in  = str_repeat('?,', count($arr) - 1) . '?';
$sql = "SELECT * FROM table WHERE foo=? AND column IN ($in) AND bar=? AND baz=?";
$stm = $db->prepare($sql);
$params = array_merge([$foo], $arr, [$bar, $baz]);
$stm->execute($params);
$data = $stm->fetchAll();

this may give you better idea on this, if I have not understood your question properly please let me know.