从静态方法中的另一个类调用非静态方法

Question

I wanna call a non static method from my Database Class in a static method.

Uncaught Error: Call to a member function select() on null in E:\\xampp\\htdocs\\danacrm\\libs\\Setting.php:32

what is my solution?!

This is my Database class : [ path : ../libs/Database.php ]

    class Database extends PDO
    {
        function __construct($DB_TYPE, $DB_HOST, $DB_NAME, $DB_USER, $DB_PASS)
        {
            parent::__construct($DB_TYPE . ':host=' . $DB_HOST . ';dbname=' . $DB_NAME, $DB_USER, $DB_PASS,array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'utf8'"));
        }

        public function select($SQL,$array=array(),$fetch_style=  PDO::FETCH_ASSOC) {

            $query = $this->prepare($SQL);
            foreach ($array as $key => $value) {
                $query->bindvalue(":$key", $value);
            }
            $query->execute();

            return $query->fetchAll($fetch_style);
        }
        public function insert($table, $data) {
            ksort($data);

            $fieldkey = implode('`, `', array_keys($data));
            $fieldvalue = ':' . implode(', :', array_keys($data));

            $query = $this->prepare("INSERT INTO  $table
                  ( `$fieldkey` )
           VALUES ( $fieldvalue )");

            foreach ($data as $key => $value) {
                $query->bindvalue(":$key", $value);
            }

            return $query->execute();

        }

        public function update($table, $data, $where) {
            ksort($data);
            $fieldDetails = "";
            foreach ($data as $key => $value) {
                $fieldDetails .= " `$key`= :$key ,";
            }
            $fieldDetails = rtrim($fieldDetails, ' ,');

            $query = $this->prepare("UPDATE $table  SET $fieldDetails  WHERE $where");


            foreach ($data as $key => $value) {

                $query->bindvalue(":$key", $value);
            }
            if($query->execute())
                return true;

            return false;
        }
        public function delete($table,$where) {
            $query = $this->prepare("DELETE FROM  $table  WHERE $where");
            return   $query->execute();
        }
    }

and my Setting class : [ path : ../libs/setting.php ]

class Setting
{

    protected static $db;

    function __construct()
    {
        self::$db = new Database(DB_TYPE,DB_HOST,DB_NAME,DB_USER,DB_PASS);
    }

    // I wanna use this method in whole of my project
    public static function options($option_name = false)
    {
        if ($option_name) {
            $options = self::$db->select("SELECT * FROM `options` WHERE `option_name` = '$option_name'");
            if(!empty($options[0]))
            {
                return $options[0];
            }
            else
            {
                return false;
            }
        } else {
            $options = self::$db->select("SELECT * FROM `options`");
        }
        return $options;
    }

}

Answer 1

You are doing quite a lot things wrong there.

Don't wrap PDO class

PDO already is a DB acces abstraction. You do not need to abstract the abstraction. You are also doing the prepared statements wrong in your code, which makes your code vulnerable to SQL injections. Please check the linked manual article and pay specific attention to use of bindParam() and bindValue() methods. You could also watch this video (it's uses mysqli in the examples, but the core mechanic is the same), which should explain where to injection vulnerability actually comes from.

Use dependency injection

Your current code relies on the global state. Instead you should inject the PDO instance as a dependency in your Settings service.

In practice it would looks something like this:

class Setting {
    privare $connection;

    public function __construct(PDO $connection) {
        $this->connection = $connection;
    }

    public function options($option_name) {
        // codes here
    }
};

The idea basically is:

$db = new PDO;
$foo = new Foo($db);
$bar = new Bar($db);

This way the both Foo and Bar instance have the same DB connection.

Watching this lecture would be highly recommended.

Answer 2

Based on what Sahil Gulati and Yupik mentioned in the comments, you need first to instantiate the Database class before you can actually call it's methods.

Since static classes doesn't need to be instantiated (can be), it should be noted that all property inside Static classes that needs to be instantiated before usage are called first. One option for this one is to have some initiator function that will set the necessary objects into motion. :)

class Database {
    public function select($sql) {
        //code here
    } 
};

class Setting {
    protected static $db;

    public static function initiate() {
        self::$db = new Database();
    }

    public static function options($option_name) {
        // codes here
    }
};

usage:

Setting::initiate();
Setting::options('some option name');