php class to serve properties of an object - php

Question

I am new to PHP OOP (coded PHP in procedural style for some time now) and I think that I understood the SOLID principles and I understood that an object not necessarely is equal to an entity in a relational database. Anyway I have slight problems to apply this knowledge to this practical situation:
I want to write a class serving/handling product data which is attributes of products (like product name, weight, etc.) but als quantity on stock, open orders, next incoming shipment (with date and quantity being delivered) and so on.
This alone raises questions:
Does the plan to create one class to serve all this data interfere with the single responsibility principle (so is serving the quantity in stock another responsibility than serving the weight of the product)? In other words: Should I rather write an extra class for serving product attributes and another class to serve quantity in stock and another class to serve incoming shipments on this product? To explain: It can be, that external code accessing the object data of this class does not need all these information but just a part of it (e.g. either an attribute of the product or the next incoming shipments, but maybe the external code also needs both).
If I should write two different classes would they be totally seperate or should one extend the other? I personally do not see why one should extend the other as it can always be that only one of these two is needed, so why should I link them together then.
What I know from past experience is that the bottle neck of PHP applications very often is the number of queries you send to the database interface. If I divide everything in different classes, I have several database queries while I would only need two if I have it in one class.
Anyway if I write it in one class, I still have two queries while maybe the outside code needs only data that can be retrieved from one of these two queries. Should I put the two queries in two different methods and let the code outside of the class decide which methods should be executed and therefore decide which parts of the product data are available in the object? (This would be to save on resources and execution time.)
If I want to prevent that the outside code has to decide which methods to call to have the right data available should I better declare the properties to be private and have the magic __get function execute the necessary queries? I myself believe this is a dirty work around and I read somewhere that the magic __get function is rather a type of error handling if an outside code wants to access private properties.
Should I also add data manipulation methods to this class? I could add one for changing the static attributes of a product, but does it make sense to have a method in this class to change the quantity in orders? I think this would rather belong to an "orders" class than to a class of product data, right?
Here is some code snippet to illustriate, what I intend to do (in this case I wrote to serve all data by one class and let the outside code decide which method to call to have the right data available:
<?php
class productdata {
public $productID;
public $productname;
public $weight;
public $deliverytime;
public $deprecated;
public $openorderquantity;
public $stock;
public $opensupplierorders;
public function readproductdatafromDB() {
$db = new Db();
$safe_productID = $db->quote($this->productID);
$rows_get_productdata = $db->select("SELECT ...");
$error = $db -> error();
foreach ($rows_get_productdata as $row_get_productdata) {
$this -> productname = $row_get_productdata["productname"];
$this -> weight = $row_get_productdata["weight"];
$this -> deliverytime = $row_get_productdata["deliverytime"];
$this -> deprecated = $row_get_productdata["deprecated"];
$this -> openorderquantity = $row_get_productdata["openorderquantity"];
$this -> stock = $row_get_productdata["stock"];
}
}
public function readopensupplierordersfromDB () {
$db = new Db();
$safe_productID = $db->quote($this->productID);
$this->opensupplierorders = $db->select("SELECT ...");
$error = $db -> error();
}
} ?>
Please do not care about the DB calls I have a good DB wrapping class, I think.
When calling the class I would do:
<?php
$productdata = new productdata();
$productdata->productID = '123';
$productdata->readproductdatafromDB();
echo "The weight of the product is: " . $productdata->weight;
?>
I hope I am asking the right questions. Thank you very much in advance to help me with this.
Best Regards,
Benedikt.

Answer 1

First principles: design it right and worry about performance/optimisation if and when you encounter problems there.
So, product attributes are seperate from stock attributes, which are seperate but related to order atributes, which are seperate but related to supplier atributes, etc. Thus each type of information should be encapsulated into its own class: and yes this will mirror the noramalised database schema to a great extent.

Answer 2

In your code, you're mainly breaking the Single Responsibility principe. Your class is doing two things: managing the product information and managing your database connection/queries. That's the wrong way to do it.
You'll have a lot of duplicate code this way. Now you only have a Product entity. What if you have 50 of them? You'll have the same code in all 50 classes, not something you'll want to do. Have a look at the Repository pattern, which can help you for database interaction.
The correct way is to seperate these. Create a class for managing the connection and retrieving the data and a class Product, not ProductData, of which objects can be created with the data you receive from the database.
I'd suggest you have a look at some OOP frameworks first. Work with them, try and understand them and you'll understand these concepts a lot better so you can use them in your own projects.
Other than that, have a look at design patterns. The book Head First Design Patterns is an excellent introduction to understand design principles and patterns.