StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
12504807
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
12
CommunityOwnedDate
CreationDate
2012-09-20T00:53:30.507
FavoriteCount
0
LastActivityDate
2012-09-20T00:53:30.507
LastEditDate
2017-05-23T10:27:58.363
LastEditorUserId
-1
OwnerUserId
367456
ParentId
12493927
PostTypeId
2
Score
6
ViewCount
0
LastEditorDisplayName
text
Body
Your question is not very specific, and I have the feeling you're not really aware what your concrete problems are. You've already accept an answer that gives you some code but puts you in the wrong direction as it does not solve your underlying problem and wastes code. The first thing you should know if you want to make use and benefit of the object oriented interface of PHP's mysqli extension is, that the <code>Mysqli</code> class represents the database connection (the "link" as it was named for a procedural approach) already: <pre><code>require('inc/dbc.php'); $dbConnection = new Mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME); </code></pre> That's already it. Sure you might want to use some error handling here: <pre><code>if ($dbConnection->connect_error) { throw new Exception( sprintf('(#%d) %s', $dbConnection->connect_errorno, $dbConnection->connect_error) ); } </code></pre> Throwing exception instead of let's say <code>die('message')</code> is done, because you can easily create an exception handler so that you can display a more useful response to the user from within a central place instead of handling each exceptional error-case where it appears (actually at the place where <code>die</code> would be). You can also log and mail the backtrace so you can fix things more easily. Naturally you do not need to use exceptions, however the rule of thumb is to use <code>die</code> only in scripts you throw away in let's say a week and it does not work well with object oriented design. As you will need this code anyway in all places where you will need your database connection, you can create your own connection object to bring those parts together as they belong together: <pre><code>class DatabaseException extends Exception { } class DatabaseConnection extends Mysqli { public function __construct($host, $user, $password, $database = "", $port = NULL, $socket = NULL) { parent::__construct($host, $user, $password, $database, $port, $socket); $this->throwConnectionExceptionOnConnectionError(); } private function throwConnectionExceptionOnConnectionError() { if (!$this->connect_error) return; $message = sprintf('(%s) %s', $this->connect_errno, $this->connect_error); throw new DatabaseException($message); } } </code></pre> The usage is actually pretty straight forward and very much the same, only the name of the class varies and it's definition needs to be loaded: <pre><code>require('inc/dbc.php'); require('inc/database.php'); $dbConnection = new DatabaseConnection(DB_HOST, DB_USER, DB_PASS, DB_NAME); </code></pre> As written, the connection object already represents your database connection. So every part in your application that needs it, has to ask for it. Let's review your example function: <pre><code>function getOption($id, $db_link) { // $db_link = $this->db_link; $res = mysqli_query($this->db_link,"SELECT * from config where id='1'"); $row = mysqli_fetch_array($res); return $row['option']; } </code></pre> I renamed the function and I commented the first line, even this might be what you want. Actually, if that function would be part of the <code>DatabaseConnection</code> object, it could work like this: <pre><code>class DatabaseConnection extends Mysqli { ... public function getOption($id) { $statement = $this->prepare('SELECT `option` FROM config WHERE id=?'); $statement->bind_param('i', $id); $statement->execute(); $statement->bind_result($option); $statement->fetch(); $statement->close(); return $option; } </code></pre> As this example demonstrates, the database connection is already there. However, this is not advisable. Imagine you not only have options but this and that and such and what not more. You would create one function after the other all in one class. Well for a little application that might even so work right, but imagine more and more. You would get one very large class that is responsible for many things. So it would be bad to do this, even if you can use <code>$this</code> already to prepare the statement. Also take note that you should prepare statements. This has been answered here numerous times, if you're not used to it, read about it, it's worth the lines. There are better ways to not repeat code (DRY: Don't repeat yourself) while stepping into object oriented (you should even already do this with procedural). So as to have this all in one class would be a problem, you instead put it in a class of it's own: <pre><code>class DatabaseModelBase { protected $connection; public function __construct(Connection $connection) { $this->connection = $connection; } protected function prepare($query) { $connection = $this->connection; $statement = $connection->prepare($query); if (!$statement) { throw new DatabaseException( sprintf('(%s) %s', $connection->error, $connection->errno) ); } return $statement; } } class Option extends DatabaseModelBase { public function find($id) { $statement = $this->prepare('SELECT `option` FROM config WHERE id=?'); $statement->bind_param('i', $id); $statement->execute(); $statement->bind_result($option); $statement->fetch(); $statement->close(); return $option; } } </code></pre> This has some extended error handling again, because most often mistakes are made in the SQL query. And as you can see the individual function to fetch some specific data is placed in it's own class. You can use such classes to group the fetching and updating for specific datatypes. Usage in full: <pre><code>$dbConnection = new Connection(DB_HOST, DB_USER, DB_PASS, DB_NAME); $option = new Option($dbConnection); $optionValue = $option->find(1); echo $optionValue; # value for option with ID1 </code></pre> The names of the <code>Option</code> object probably is not well, I tried to keep the example lightweight but also offer some separation. For other scenarious you might want to prefer some different kind how to access the db connection, because it is injected into <code>Option</code> via it's constructor, <code>Option</code> does not deal any longer with the details how the database connection is being created. For example you can make the database connection object more smart only to connect to the database the first time prepare or query is actually used with it. So that requests to your website that do not need a database connection would not needlessly connect to the database. You find more examples in other questions and you might want to learn about dependency injection. Also you always want to keep things apart from each other, so you have some objects that are only lightly connected to each other. <ul> <li><a href="https://stackoverflow.com/questions/10919277/how-to-successfully-rewrite-old-mysql-php-code-with-deprecated-mysql-functions">How to successfully rewrite old mysql-php code with deprecated mysql_* functions?</a></li> <li><a href="https://stackoverflow.com/questions/2030624/dependency-injection-simple-implementation">Dependency Injection simple implementation</a></li> </ul>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. PObuild a mysqli db connection class and other classes use it
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USCommunity
UserOwnerUserId
1. UShakre
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. PObuild a mysqli db connection class and other classes use it
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTAcceptedByOriginator
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.