General purpose PHP/MySQL handler class utilizing PDO

/*
        Description:
                -> Base general purpose PDO MySQL database connection instantiation class.
                -> contains set of common generic database interaction methods.
                -> helper modules can be created for simplifying use of its generic methods,
                   and "plugged in" using the load_helper_module() method.
*/
class db_connection
{
        /* property: connection object instance */
        private $connection;

        /* properties: connection variables */
        private $dbhost; // database host.
        private $dbname; // database name.
        private $dbuser; // database username.
        private $dbpass; // database password.

        /* property: HM -> stores array of helper module objects */
        public $HM;

        public function __construct()
        {
                /* set connection properties */
                $this->dbhost = DB_HOST;
                $this->dbname = DB_NAME;
                $this->dbuser = DB_USER;
                $this->dbpass = DB_PASS;

                /* instantiate connection */
                try
                {
                        $this->connection = new PDO(
                                'mysql:host=' . $this->dbhost . ';dbname=' . $this->dbname,
                                $this->dbuser,
                                $this->dbpass
                        );
                        $this->connection->setAttribute(PDO::ATTR_PERSISTENT, true);
                        $this->connection->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
                        $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                        exit;
                }

                /* prep $this->HM for storing helper modules */
                $this->HM = array();
        }

        public function __destruct()
        {
                $this->HM = null;
                $this->connection = null;
        }

        // method: register_helper()
        //              -> creates a new helper module object with a preferred specified name.
        //              -> $name is the desired name of the helper, $helper is the name of helper class.
        //              -> helper modules contain "wrapper" methods to ease working with the generic
        //                 methods defined here (db_connection)
        public function register_helper($name, $helper)
        {
                if(!isset($this->HM[$name]))
                {
                        $this->HM[$name] = new $helper($this);
                }
        }

        /**********************************/
        /*  TABLE CREATION and REPORTING  */
        /**********************************/

        public function construct_table($table, $fields, $primary)
        {
                $sql = 'CREATE TABLE IF NOT EXISTS `' . $table . '` ( ';

                for($i = 0; $i < count($fields); $i++)
                {
                        $sql .= '`' . $fields[$i][0] . '` ' . $fields[$i][1] . ', ';
                }

                $sql .= 'PRIMARY KEY (`' . $primary . '`) ';

                $sql .= ' )';
                $sql .= 'ENGINE=InnoDB CHARACTER SET=utf8';
                try
                {
                        $this->connection->exec($sql);
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                }
        }

        public function report_table($table)
        {
                $tables_array = array();

                try
                {       // get table names and push to $tables_array
                        $tablequery = $this->connection->query("
                                SELECT
                                        TABLE_NAME
                                FROM
                                        information_schema.TABLES
                                WHERE
                                        TABLE_TYPE = 'BASE TABLE'
                                AND
                                        TABLE_SCHEMA = '$this->dbname'
                        ");
                        while($fetch = $tablequery->fetch())
                        {
                                array_push($tables_array, $fetch['TABLE_NAME']);
                        }
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                }

                if(in_array($table, $tables_array))
                {
                        return true;
                }
                return false;
        }

        public function drop_table($table)
        {
                if($this->report_table($table)){
                        try
                        {
                                $this->connection->exec("DROP TABLE `$table`");
                        }
                        catch(PDOException $e)
                        {
                                jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                        }
                }
        }

        /********************/
        /*  SELECT METHODS  */
        /********************/

        // method: get_row_count -> returns the number of rows based on primary key entries.
        public function fetch_row_count($table, $key)
        {
                if($this->report_table($table)){
                        try{
                                $statement = $this->connection->query("
                                        SELECT COUNT(`$key`)
                                        AS `num`
                                        FROM `$table`
                                ");
                                $fetch = $statement->fetch();
                                return $fetch['num'];
                        }
                        catch(PDOException $e){
                                jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                                return null;
                        }
                }
                return null;
        }

        public function check_duplicate($table, $collumn, $item)
        {
                try
                {
                        $statement = $this->connection->prepare("
                                SELECT COUNT(`$collumn`)
                                AS `dup`
                                FROM `$table`
                                WHERE `$collumn` = :item
                        ");
                        $statement->bindParam(':item', $item);
                        $statement->execute();
                        $fetch = $statement->fetch();

                        if($fetch['dup'] > 0)
                        { // if we have a find..
                                return true;
                        }
                        return false;
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                        return null;
                }
        }

        // public method: fetch_items() -> [ table name | items to get | [ from where | equals this ] ]
        public function fetch_items($table, $items, $where, $values)
        {
                $sql = 'SELECT ';
                // where are we selecting from?
                if(is_array($items))
                {       // are we dealing with an array?
                        for($i = 0; $i < count($items); $i++)
                        {
                                if($i !== (count($items) - 1))
                                {
                                        $sql .= '`' . $items[$i] . '`, ';
                                }
                                else
                                {
                                        $sql .= '`' . $items[$i] . '` ';
                                }
                        }
                }
                else
                {       // if not an array
                        $sql .= '`' . $items . '` ';
                }
                // from which table?
                $sql .= 'FROM `' . $table . '` ';
                // where?
                if(is_array($where))
                {
                        for($i = 0; $i < count($where); $i++)
                        {
                                if($i == 0)
                                {
                                        $sql .= 'WHERE `' . $where[$i] . '` = :item' . $i . ' ';
                                }
                                else
                                {
                                        $sql .= 'AND `' . $where[$i] . '` = :item' . $i . ' ';
                                }
                        }
                }
                else
                {
                        $sql .= 'WHERE `' . $where . '` = :item ';
                }

                try
                {
                        $statement = $this->connection->prepare($sql);
                        if(is_array($where))
                        {
                                for($i = 0; $i < count($where); $i++)
                                {
                                        $statement->bindParam(':item' . $i, $values[$i]);
                                }
                        }
                        else
                        {
                                $statement->bindParam(':item', $values);
                        }
                        $statement->execute();
                        $fetch = $statement->fetch();
                        if(is_array($fetch))
                        {
                                return $fetch;
                        }
                        return null;
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                }
        }

        /********************/
        /*  UPDATE METHODS  */
        /********************/

        public function update_timestamp($table, $update, $where, $values)
        {
                $sql = 'UPDATE `' . $table . '` ';
                $sql .= 'SET `' . $update . '` = NOW() ';
                $sql .= 'WHERE `' . $where . '` = :item ';
                try
                {
                        $statement = $this->connection->prepare($sql);
                        $statement->bindParam(':item', $values);
                        $statement->execute();
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                }
        }

        public function update_fields($table, $updatecols, $updatevals, $wherecols, $wherevals)
        {
                $sql = 'UPDATE `' . $table . '` SET ';

                if(is_array($updatecols))
                {
                        for($i = 0; $i < count($updatecols); $i++)
                        {
                                if($i !== (count($updatecols) - 1))
                                {
                                        $sql .= '`' . $updatecols[$i] . '` = :update' . $i . ', ';
                                }
                                else
                                {
                                        $sql .= '`' . $updatecols[$i] . '` = :update' . $i . ' ';
                                }
                        }
                }
                else
                {
                        $sql .= '`' . $updatecols . '` = :update ';
                }

                if(is_array($wherecols))
                {
                        for($i = 0; $i < count($wherecols); $i++)
                        {
                                if($i == 0)
                                {
                                        $sql .= 'WHERE `' . $wherecols[$i] . '` = :where' . $i . ' ';
                                }
                                else
                                {
                                        $sql .= 'AND `' . $wherecols[$i] . '` = :where' . $i . ' ';
                                }
                        }
                }
                else
                {
                        $sql .= 'WHERE `' . $wherecols . '` = :where ';
                }

                try
                {
                        $statement = $this->connection->prepare($sql);

                        if(is_array($updatecols))
                        {
                                for($i = 0; $i < count($updatecols); $i++)
                                {
                                        $statement->bindParam(':update' . $i, $updatevals[$i]);
                                }
                        }
                        else
                        {
                                $statement->bindParam(':update', $updatevals);
                        }

                        if(is_array($wherecols))
                        {
                                for($i = 0; $i < count($wherecols); $i++)
                                {
                                        $statement->bindParam(':where' . $i, $wherevals[$i]);
                                }
                        }
                        else
                        {
                                $statement->bindParam(':where', $wherevals);
                        }

                        $statement->execute();
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                }
        }

        /********************/
        /*  INSERT METHODS  */
        /********************/

        public function insert_into_table($table, $collumns, $values)
        {
                $sql = 'INSERT INTO `' . $table . '` (';
                for($i = 0; $i < count($collumns); $i++)
                {
                        if($i !== (count($collumns) - 1))
                        {
                                $sql .= '`' . $collumns[$i] . '`, ';
                        }
                        else
                        {
                                $sql .= '`' . $collumns[$i] . '`';
                        }
                }
                $sql .= ') VALUES (';
                for($i = 0; $i < count($values); $i++)
                {
                        if($i !== (count($values) - 1))
                        {
                                $sql .= ':item' . $i . ', ';
                        }
                        else
                        {
                                $sql .= ':item' . $i;
                        }
                }
                $sql .= ')';

                try
                {
                        $statement = $this->connection->prepare($sql);
                        for($i = 0; $i < count($values); $i++)
                        {
                                $statement->bindParam(':item' . $i, $values[$i]);
                        }
                        $statement->execute();
                }
                catch(PDOException $e)
                {
                        jerk_debug('Error In: ' . __METHOD__ , $e->getMessage());
                        return false;
                }
                return true;
        }
}