Using database connections in PHP classes

First of all it seems that there isn't really much reason for your database class. If you are writing a wrapper over PDO that doesn't add anything to PDO, why not just use PDO directly? And if you do have some functions that extend PDO's functionality, then why not do just that:

class Db extends PDO {
   public function HeyPDOCantDoThisSoImWritingItMyself() {

   }        
}

Moving on to Workorder, that seems to be something of a database model. I'd urge against extending your database class directly, it would make much more sense to interject a model parent class in between:

class Model {
    protected $db;
    protected $tablename;

    public function __construct(Db $db, $tablename) {
        $this->setDatabase($db)
             ->setTablename($tablename);
    }

    public function setDatabase(DB $db) {
        $this->db = $db;

        return $this;
    }

    public function getDatabase() {
        return $this->db;
    }

    public function setTablename($tablename) {
        if(!is_string($tablename) || empty($tablename)) {
            throw new Exception("Table name must be a non empty string!");
        }

        $this->tablename = $tablename;

        return $this;
    }

    public function getTablename() {
        return $this->tablename;
    }        
}

class Workorder extends Model {    
    public function ThisIsAWorkorderSpecificFunction() {
    }    
}

This way you have a solid foundation for all your future models, and you don't have to re-write their common code next time you need a model. There are some things in there that you might be seeing for the first time, let's dissect them:

    $this->setDatabase($db)
         ->setTablename($tablename);

This is called method chaining, and it's just a fancy and perhaps more readable way of structuring your code. It works because both setDatabase() and setTablename() return the object at the end, via return $this;.

    public function __construct(Db $db, $tablename) {

What I've done here is completely forget about static and global, and instead went for dependency injection. There is nothing inherently wrong with using static and global, especially given PHP's procedural tradition, however they do tend to make errors harder to find, it's not always easy to now where stuff broke. Since you are going for an object oriented solution, dependency injection is the simplest solution.

    public function setDatabase(DB $db) {

Here, I'm type hinting that $db should be a Db object, if you pass anything else to it, it will produce an error. Unfortunately PHP doesn't currently support type hinting for scalar types, so for $tablename I have to check, just to make sure:

    public function setTablename($tablename) {
        if(!is_string($tablename) || empty($tablename)) {
            throw new Exception("Table name must be a non empty string!");
        }

If $tablename is not a string or it's an empty string, I throw an exception, as, well there isn't much we can do to solve the problem. Again, this is a failsafe check, that you'll probably never see failing, but better to be safe than sorry.

And since you mention multiple connections, your Db class could easily handle them, however you'd have to give up extending PDO directly:

class Db {
    protected $connections = array();

    public function setConnection(PDO $connection, $name = "default") {
        if(!is_string($name) || empty($name)) {
            throw new Exception("Table name must be a non empty string!");
        }    

        $this->connections[$name] = $connection;

        return $this;
    }

    public function getConnection($name = "default") {
        if(!is_string($name) || empty($name)) {
            throw new Exception("Table name must be a non empty string!");
        }    

        return
            isset($this->connections[$name])
                ? $this->connections[$name]
                : false;
    }    
}